c5751993 |
1 | // Created on: 2014-03-31 |
2 | // Created by: Danila ULYANOV |
3 | // Copyright (c) 2014 OPEN CASCADE SAS |
4 | // |
5 | // This file is part of Open CASCADE Technology software library. |
6 | // |
0a36ca0a |
7 | // This library is free software; you can redistribute it and/or modify it under |
8 | // the terms of the GNU Lesser General Public License version 2.1 as published |
c5751993 |
9 | // by the Free Software Foundation, with special exception defined in the file |
10 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
11 | // distribution for complete text of the license and disclaimer of any warranty. |
12 | // |
13 | // Alternatively, this file may be used under the terms of Open CASCADE |
14 | // commercial license or contractual agreement. |
15 | |
16 | #include <OpenGl_Layer.hxx> |
a1954302 |
17 | |
18 | #include <OpenGl_BVHTreeSelector.hxx> |
19 | #include <OpenGl_Structure.hxx> |
7c3ef2f7 |
20 | #include <OpenGl_ShaderManager.hxx> |
a1954302 |
21 | #include <OpenGl_View.hxx> |
550f3b8b |
22 | #include <OpenGl_Workspace.hxx> |
c04c30b3 |
23 | #include <Graphic3d_GraphicDriver.hxx> |
c5751993 |
24 | |
f5b72419 |
25 | IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Layer, Standard_Transient) |
26 | |
a1954302 |
27 | // ======================================================================= |
825aa485 |
28 | // function : OpenGl_Layer |
a1954302 |
29 | // purpose : |
30 | // ======================================================================= |
f5b72419 |
31 | OpenGl_Layer::OpenGl_Layer (const Standard_Integer theNbPriorities, |
32 | const Handle(Select3D_BVHBuilder3d)& theBuilder) |
50d06d8f |
33 | : myArray (0, theNbPriorities - 1), |
34 | myNbStructures (0), |
f5b72419 |
35 | myBVHPrimitivesTrsfPers (theBuilder), |
a1954302 |
36 | myBVHIsLeftChildQueuedFirst (Standard_True), |
2b8832bb |
37 | myIsBVHPrimitivesNeedsReset (Standard_False), |
38 | myIsCulled (Standard_False) |
c5751993 |
39 | { |
50d06d8f |
40 | myIsBoundingBoxNeedsReset[0] = myIsBoundingBoxNeedsReset[1] = true; |
c5751993 |
41 | } |
42 | |
a1954302 |
43 | // ======================================================================= |
44 | // function : ~OpenGl_Layer |
45 | // purpose : |
46 | // ======================================================================= |
47 | OpenGl_Layer::~OpenGl_Layer() |
48 | { |
49 | // |
50 | } |
51 | |
52 | // ======================================================================= |
53 | // function : Add |
54 | // purpose : |
55 | // ======================================================================= |
56 | void OpenGl_Layer::Add (const OpenGl_Structure* theStruct, |
57 | const Standard_Integer thePriority, |
58 | Standard_Boolean isForChangePriority) |
59 | { |
60 | const Standard_Integer anIndex = Min (Max (thePriority, 0), myArray.Length() - 1); |
61 | if (theStruct == NULL) |
62 | { |
63 | return; |
64 | } |
65 | |
9f112210 |
66 | myArray (anIndex).Add (theStruct); |
a1954302 |
67 | if (theStruct->IsAlwaysRendered()) |
68 | { |
69 | theStruct->MarkAsNotCulled(); |
3fe9ce0e |
70 | if (!isForChangePriority) |
71 | { |
72 | myAlwaysRenderedMap.Add (theStruct); |
73 | } |
a1954302 |
74 | } |
75 | else if (!isForChangePriority) |
76 | { |
778cd667 |
77 | if (theStruct->TransformPersistence().IsNull()) |
825aa485 |
78 | { |
79 | myBVHPrimitives.Add (theStruct); |
80 | } |
81 | else |
82 | { |
83 | myBVHPrimitivesTrsfPers.Add (theStruct); |
84 | } |
a1954302 |
85 | } |
86 | ++myNbStructures; |
87 | } |
88 | |
89 | // ======================================================================= |
90 | // function : Remove |
91 | // purpose : |
92 | // ======================================================================= |
93 | bool OpenGl_Layer::Remove (const OpenGl_Structure* theStruct, |
94 | Standard_Integer& thePriority, |
95 | Standard_Boolean isForChangePriority) |
96 | { |
97 | if (theStruct == NULL) |
98 | { |
99 | thePriority = -1; |
100 | return false; |
101 | } |
102 | |
103 | const Standard_Integer aNbPriorities = myArray.Length(); |
104 | for (Standard_Integer aPriorityIter = 0; aPriorityIter < aNbPriorities; ++aPriorityIter) |
105 | { |
9f112210 |
106 | OpenGl_IndexedMapOfStructure& aStructures = myArray (aPriorityIter); |
107 | |
108 | const Standard_Integer anIndex = aStructures.FindIndex (theStruct); |
109 | if (anIndex != 0) |
a1954302 |
110 | { |
9f112210 |
111 | aStructures.Swap (anIndex, aStructures.Size()); |
112 | aStructures.RemoveLast(); |
113 | |
3fe9ce0e |
114 | if (!isForChangePriority) |
a1954302 |
115 | { |
ef9a9362 |
116 | Standard_Boolean isAlwaysRend = theStruct->IsAlwaysRendered(); |
117 | if (!isAlwaysRend) |
825aa485 |
118 | { |
ef9a9362 |
119 | if (!myBVHPrimitives.Remove (theStruct)) |
3fe9ce0e |
120 | { |
ef9a9362 |
121 | if (!myBVHPrimitivesTrsfPers.Remove (theStruct)) |
122 | { |
123 | isAlwaysRend = Standard_True; |
124 | } |
3fe9ce0e |
125 | } |
126 | } |
ef9a9362 |
127 | if (isAlwaysRend) |
3fe9ce0e |
128 | { |
ef9a9362 |
129 | const Standard_Integer anIndex2 = myAlwaysRenderedMap.FindIndex (theStruct); |
130 | if (anIndex2 != 0) |
3fe9ce0e |
131 | { |
ef9a9362 |
132 | myAlwaysRenderedMap.Swap (myAlwaysRenderedMap.Size(), anIndex2); |
133 | myAlwaysRenderedMap.RemoveLast(); |
3fe9ce0e |
134 | } |
825aa485 |
135 | } |
a1954302 |
136 | } |
9f112210 |
137 | --myNbStructures; |
138 | thePriority = aPriorityIter; |
139 | return true; |
a1954302 |
140 | } |
141 | } |
142 | |
143 | thePriority = -1; |
144 | return false; |
145 | } |
146 | |
147 | // ======================================================================= |
148 | // function : InvalidateBVHData |
149 | // purpose : |
150 | // ======================================================================= |
2b8832bb |
151 | void OpenGl_Layer::InvalidateBVHData() |
a1954302 |
152 | { |
153 | myIsBVHPrimitivesNeedsReset = Standard_True; |
154 | } |
155 | |
3fe9ce0e |
156 | //! Calculate a finite bounding box of infinite object as its middle point. |
7c3ef2f7 |
157 | inline Graphic3d_BndBox3d centerOfinfiniteBndBox (const Graphic3d_BndBox3d& theBndBox) |
3fe9ce0e |
158 | { |
159 | // bounding borders of infinite line has been calculated as own point in center of this line |
7c3ef2f7 |
160 | const Graphic3d_Vec3d aDiagVec = theBndBox.CornerMax() - theBndBox.CornerMin(); |
161 | return aDiagVec.SquareModulus() >= 500000.0 * 500000.0 |
162 | ? Graphic3d_BndBox3d ((theBndBox.CornerMin() + theBndBox.CornerMax()) * 0.5) |
163 | : Graphic3d_BndBox3d(); |
3fe9ce0e |
164 | } |
165 | |
166 | //! Return true if at least one vertex coordinate out of float range. |
7c3ef2f7 |
167 | inline bool isInfiniteBndBox (const Graphic3d_BndBox3d& theBndBox) |
3fe9ce0e |
168 | { |
169 | return Abs (theBndBox.CornerMax().x()) >= ShortRealLast() |
170 | || Abs (theBndBox.CornerMax().y()) >= ShortRealLast() |
171 | || Abs (theBndBox.CornerMax().z()) >= ShortRealLast() |
172 | || Abs (theBndBox.CornerMin().x()) >= ShortRealLast() |
173 | || Abs (theBndBox.CornerMin().y()) >= ShortRealLast() |
174 | || Abs (theBndBox.CornerMin().z()) >= ShortRealLast(); |
175 | } |
176 | |
a1954302 |
177 | // ======================================================================= |
50d06d8f |
178 | // function : BoundingBox |
179 | // purpose : |
180 | // ======================================================================= |
7c3ef2f7 |
181 | Bnd_Box OpenGl_Layer::BoundingBox (const Standard_Integer theViewId, |
182 | const Handle(Graphic3d_Camera)& theCamera, |
183 | const Standard_Integer theWindowWidth, |
184 | const Standard_Integer theWindowHeight, |
185 | const Standard_Boolean theToIncludeAuxiliary) const |
50d06d8f |
186 | { |
150ed3d5 |
187 | updateBVH(); |
188 | |
3fe9ce0e |
189 | const Standard_Integer aBoxId = !theToIncludeAuxiliary ? 0 : 1; |
7c3ef2f7 |
190 | const Graphic3d_Mat4d& aProjectionMat = theCamera->ProjectionMatrix(); |
191 | const Graphic3d_Mat4d& aWorldViewMat = theCamera->OrientationMatrix(); |
50d06d8f |
192 | if (myIsBoundingBoxNeedsReset[aBoxId]) |
193 | { |
194 | // Recompute layer bounding box |
7c3ef2f7 |
195 | myBoundingBox[aBoxId].SetVoid(); |
50d06d8f |
196 | |
7c3ef2f7 |
197 | for (OpenGl_ArrayOfIndexedMapOfStructure::Iterator aMapIter (myArray); aMapIter.More(); aMapIter.Next()) |
50d06d8f |
198 | { |
7c3ef2f7 |
199 | const OpenGl_IndexedMapOfStructure& aStructures = aMapIter.Value(); |
200 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
50d06d8f |
201 | { |
7c3ef2f7 |
202 | const OpenGl_Structure* aStructure = aStructIter.Value(); |
3fe9ce0e |
203 | if (!aStructure->IsVisible (theViewId)) |
50d06d8f |
204 | { |
205 | continue; |
206 | } |
207 | |
208 | // "FitAll" operation ignores object with transform persistence parameter |
209 | // but adds transform persistence point in a bounding box of layer (only zoom pers. objects). |
778cd667 |
210 | if (!aStructure->TransformPersistence().IsNull()) |
50d06d8f |
211 | { |
3fe9ce0e |
212 | if (!theToIncludeAuxiliary |
778cd667 |
213 | && aStructure->TransformPersistence()->IsZoomOrRotate()) |
50d06d8f |
214 | { |
778cd667 |
215 | const gp_Pnt anAnchor = aStructure->TransformPersistence()->AnchorPoint(); |
7c3ef2f7 |
216 | myBoundingBox[aBoxId].Add (anAnchor); |
50d06d8f |
217 | continue; |
218 | } |
219 | // Panning and 2d persistence apply changes to projection or/and its translation components. |
220 | // It makes them incompatible with z-fitting algorithm. Ignored by now. |
3fe9ce0e |
221 | else if (!theToIncludeAuxiliary |
778cd667 |
222 | || aStructure->TransformPersistence()->IsTrihedronOr2d()) |
50d06d8f |
223 | { |
224 | continue; |
225 | } |
226 | } |
227 | |
7c3ef2f7 |
228 | Graphic3d_BndBox3d aBox = aStructure->BoundingBox(); |
3fe9ce0e |
229 | if (!aBox.IsValid()) |
230 | { |
231 | continue; |
232 | } |
50d06d8f |
233 | |
234 | if (aStructure->IsInfinite |
3fe9ce0e |
235 | && !theToIncludeAuxiliary) |
50d06d8f |
236 | { |
3fe9ce0e |
237 | // include center of infinite object |
238 | aBox = centerOfinfiniteBndBox (aBox); |
50d06d8f |
239 | } |
240 | |
778cd667 |
241 | if (!aStructure->TransformPersistence().IsNull()) |
50d06d8f |
242 | { |
778cd667 |
243 | aStructure->TransformPersistence()->Apply (theCamera, aProjectionMat, aWorldViewMat, theWindowWidth, theWindowHeight, aBox); |
50d06d8f |
244 | } |
245 | |
3fe9ce0e |
246 | // skip too big boxes to prevent float overflow at camera parameters calculation |
7c3ef2f7 |
247 | if (aBox.IsValid() |
248 | && !isInfiniteBndBox (aBox)) |
50d06d8f |
249 | { |
7c3ef2f7 |
250 | myBoundingBox[aBoxId].Add (gp_Pnt (aBox.CornerMin().x(), aBox.CornerMin().y(), aBox.CornerMin().z())); |
251 | myBoundingBox[aBoxId].Add (gp_Pnt (aBox.CornerMax().x(), aBox.CornerMax().y(), aBox.CornerMax().z())); |
50d06d8f |
252 | } |
50d06d8f |
253 | } |
254 | } |
255 | |
256 | myIsBoundingBoxNeedsReset[aBoxId] = false; |
257 | } |
258 | |
7c3ef2f7 |
259 | Bnd_Box aResBox = myBoundingBox[aBoxId]; |
3fe9ce0e |
260 | if (!theToIncludeAuxiliary |
261 | || myAlwaysRenderedMap.IsEmpty()) |
262 | { |
7c3ef2f7 |
263 | return aResBox; |
3fe9ce0e |
264 | } |
265 | |
266 | // add transformation-persistent objects which depend on camera position (and thus can not be cached) for operations like Z-fit |
3fe9ce0e |
267 | for (NCollection_IndexedMap<const OpenGl_Structure*>::Iterator aStructIter (myAlwaysRenderedMap); aStructIter.More(); aStructIter.Next()) |
268 | { |
269 | const OpenGl_Structure* aStructure = aStructIter.Value(); |
270 | if (!aStructure->IsVisible (theViewId)) |
271 | { |
272 | continue; |
273 | } |
778cd667 |
274 | else if (aStructure->TransformPersistence().IsNull() |
275 | || !aStructure->TransformPersistence()->IsTrihedronOr2d()) |
3fe9ce0e |
276 | { |
277 | continue; |
278 | } |
279 | |
7c3ef2f7 |
280 | Graphic3d_BndBox3d aBox = aStructure->BoundingBox(); |
3fe9ce0e |
281 | if (!aBox.IsValid()) |
282 | { |
283 | continue; |
284 | } |
285 | |
778cd667 |
286 | aStructure->TransformPersistence()->Apply (theCamera, aProjectionMat, aWorldViewMat, theWindowWidth, theWindowHeight, aBox); |
7c3ef2f7 |
287 | if (aBox.IsValid() |
288 | && !isInfiniteBndBox (aBox)) |
3fe9ce0e |
289 | { |
7c3ef2f7 |
290 | aResBox.Add (gp_Pnt (aBox.CornerMin().x(), aBox.CornerMin().y(), aBox.CornerMin().z())); |
291 | aResBox.Add (gp_Pnt (aBox.CornerMax().x(), aBox.CornerMax().y(), aBox.CornerMax().z())); |
3fe9ce0e |
292 | } |
293 | } |
294 | |
295 | return aResBox; |
50d06d8f |
296 | } |
297 | |
298 | // ======================================================================= |
299 | // function : considerZoomPersistenceObjects |
300 | // purpose : |
301 | // ======================================================================= |
302 | Standard_Real OpenGl_Layer::considerZoomPersistenceObjects (const Standard_Integer theViewId, |
303 | const Handle(Graphic3d_Camera)& theCamera, |
304 | Standard_Integer theWindowWidth, |
3fe9ce0e |
305 | Standard_Integer theWindowHeight) const |
50d06d8f |
306 | { |
307 | if (NbOfTransformPersistenceObjects() == 0) |
308 | { |
309 | return 1.0; |
310 | } |
311 | |
7c3ef2f7 |
312 | const Graphic3d_Mat4d& aProjectionMat = theCamera->ProjectionMatrix(); |
313 | const Graphic3d_Mat4d& aWorldViewMat = theCamera->OrientationMatrix(); |
50d06d8f |
314 | Standard_Real aMaxCoef = -std::numeric_limits<double>::max(); |
315 | |
7c3ef2f7 |
316 | for (OpenGl_ArrayOfIndexedMapOfStructure::Iterator aMapIter (myArray); aMapIter.More(); aMapIter.Next()) |
50d06d8f |
317 | { |
7c3ef2f7 |
318 | const OpenGl_IndexedMapOfStructure& aStructures = aMapIter.Value(); |
319 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
50d06d8f |
320 | { |
7c3ef2f7 |
321 | const OpenGl_Structure* aStructure = aStructIter.Value(); |
3fe9ce0e |
322 | if (!aStructure->IsVisible (theViewId) |
778cd667 |
323 | || aStructure->TransformPersistence().IsNull() |
324 | || !aStructure->TransformPersistence()->IsZoomOrRotate()) |
50d06d8f |
325 | { |
326 | continue; |
327 | } |
328 | |
7c3ef2f7 |
329 | Graphic3d_BndBox3d aBox = aStructure->BoundingBox(); |
3fe9ce0e |
330 | if (!aBox.IsValid()) |
50d06d8f |
331 | { |
332 | continue; |
333 | } |
334 | |
778cd667 |
335 | aStructure->TransformPersistence()->Apply (theCamera, aProjectionMat, aWorldViewMat, theWindowWidth, theWindowHeight, aBox); |
50d06d8f |
336 | |
7c3ef2f7 |
337 | const BVH_Vec3d& aCornerMin = aBox.CornerMin(); |
338 | const BVH_Vec3d& aCornerMax = aBox.CornerMax(); |
50d06d8f |
339 | const Standard_Integer aNbOfPoints = 8; |
340 | const gp_Pnt aPoints[aNbOfPoints] = { gp_Pnt (aCornerMin.x(), aCornerMin.y(), aCornerMin.z()), |
341 | gp_Pnt (aCornerMin.x(), aCornerMin.y(), aCornerMax.z()), |
342 | gp_Pnt (aCornerMin.x(), aCornerMax.y(), aCornerMin.z()), |
343 | gp_Pnt (aCornerMin.x(), aCornerMax.y(), aCornerMax.z()), |
344 | gp_Pnt (aCornerMax.x(), aCornerMin.y(), aCornerMin.z()), |
345 | gp_Pnt (aCornerMax.x(), aCornerMin.y(), aCornerMax.z()), |
346 | gp_Pnt (aCornerMax.x(), aCornerMax.y(), aCornerMin.z()), |
347 | gp_Pnt (aCornerMax.x(), aCornerMax.y(), aCornerMax.z()) }; |
348 | gp_Pnt aConvertedPoints[aNbOfPoints]; |
349 | Standard_Real aConvertedMinX = std::numeric_limits<double>::max(); |
350 | Standard_Real aConvertedMaxX = -std::numeric_limits<double>::max(); |
351 | Standard_Real aConvertedMinY = std::numeric_limits<double>::max(); |
352 | Standard_Real aConvertedMaxY = -std::numeric_limits<double>::max(); |
353 | for (Standard_Integer anIdx = 0; anIdx < aNbOfPoints; ++anIdx) |
354 | { |
355 | aConvertedPoints[anIdx] = theCamera->Project (aPoints[anIdx]); |
356 | |
357 | aConvertedMinX = Min (aConvertedMinX, aConvertedPoints[anIdx].X()); |
358 | aConvertedMaxX = Max (aConvertedMaxX, aConvertedPoints[anIdx].X()); |
359 | |
360 | aConvertedMinY = Min (aConvertedMinY, aConvertedPoints[anIdx].Y()); |
361 | aConvertedMaxY = Max (aConvertedMaxY, aConvertedPoints[anIdx].Y()); |
362 | } |
363 | |
364 | const Standard_Boolean isBigObject = (Abs (aConvertedMaxX - aConvertedMinX) > 2.0) // width of zoom pers. object greater than width of window |
365 | || (Abs (aConvertedMaxY - aConvertedMinY) > 2.0); // height of zoom pers. object greater than height of window |
366 | const Standard_Boolean isAlreadyInScreen = (aConvertedMinX > -1.0 && aConvertedMinX < 1.0) |
367 | && (aConvertedMaxX > -1.0 && aConvertedMaxX < 1.0) |
368 | && (aConvertedMinY > -1.0 && aConvertedMinY < 1.0) |
369 | && (aConvertedMaxY > -1.0 && aConvertedMaxY < 1.0); |
370 | if (isBigObject || isAlreadyInScreen) |
371 | { |
372 | continue; |
373 | } |
374 | |
778cd667 |
375 | const gp_Pnt aTPPoint = aStructure->TransformPersistence()->AnchorPoint(); |
50d06d8f |
376 | gp_Pnt aConvertedTPPoint = theCamera->Project (aTPPoint); |
377 | aConvertedTPPoint.SetZ (0.0); |
378 | |
379 | if (aConvertedTPPoint.Coord().Modulus() < Precision::Confusion()) |
380 | { |
381 | continue; |
382 | } |
383 | |
384 | Standard_Real aShiftX = 0.0; |
385 | if (aConvertedMinX < -1.0) |
386 | { |
387 | aShiftX = ((aConvertedMaxX < -1.0) ? (-(1.0 + aConvertedMaxX) + (aConvertedMaxX - aConvertedMinX)) : -(1.0 + aConvertedMinX)); |
388 | } |
389 | else if (aConvertedMaxX > 1.0) |
390 | { |
391 | aShiftX = ((aConvertedMinX > 1.0) ? ((aConvertedMinX - 1.0) + (aConvertedMaxX - aConvertedMinX)) : (aConvertedMaxX - 1.0)); |
392 | } |
393 | |
394 | Standard_Real aShiftY = 0.0; |
395 | if (aConvertedMinY < -1.0) |
396 | { |
397 | aShiftY = ((aConvertedMaxY < -1.0) ? (-(1.0 + aConvertedMaxY) + (aConvertedMaxY - aConvertedMinY)) : -(1.0 + aConvertedMinY)); |
398 | } |
399 | else if (aConvertedMaxY > 1.0) |
400 | { |
401 | aShiftY = ((aConvertedMinY > 1.0) ? ((aConvertedMinY - 1.0) + (aConvertedMaxY - aConvertedMinY)) : (aConvertedMaxY - 1.0)); |
402 | } |
403 | |
404 | const Standard_Real aDifX = Abs (aConvertedTPPoint.X()) - aShiftX; |
405 | const Standard_Real aDifY = Abs (aConvertedTPPoint.Y()) - aShiftY; |
406 | if (aDifX > Precision::Confusion()) |
407 | { |
408 | aMaxCoef = Max (aMaxCoef, Abs (aConvertedTPPoint.X()) / aDifX); |
409 | } |
410 | if (aDifY > Precision::Confusion()) |
411 | { |
412 | aMaxCoef = Max (aMaxCoef, Abs (aConvertedTPPoint.Y()) / aDifY); |
413 | } |
414 | } |
415 | } |
416 | |
417 | return (aMaxCoef > 0.0) ? aMaxCoef : 1.0; |
418 | } |
419 | |
420 | // ======================================================================= |
a1954302 |
421 | // function : renderAll |
422 | // purpose : |
423 | // ======================================================================= |
424 | void OpenGl_Layer::renderAll (const Handle(OpenGl_Workspace)& theWorkspace) const |
425 | { |
7c3ef2f7 |
426 | const Standard_Integer aViewId = theWorkspace->View()->Identification(); |
427 | for (OpenGl_ArrayOfIndexedMapOfStructure::Iterator aMapIter (myArray); aMapIter.More(); aMapIter.Next()) |
a1954302 |
428 | { |
7c3ef2f7 |
429 | const OpenGl_IndexedMapOfStructure& aStructures = aMapIter.Value(); |
430 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
a1954302 |
431 | { |
7c3ef2f7 |
432 | const OpenGl_Structure* aStruct = aStructIter.Value(); |
2b8832bb |
433 | if (aStruct->IsCulled() |
434 | || !aStruct->IsVisible (aViewId)) |
a272ed94 |
435 | { |
436 | continue; |
437 | } |
a1954302 |
438 | |
439 | aStruct->Render (theWorkspace); |
440 | } |
441 | } |
442 | } |
443 | |
444 | // ======================================================================= |
3fe9ce0e |
445 | // function : updateBVH |
a1954302 |
446 | // purpose : |
447 | // ======================================================================= |
3fe9ce0e |
448 | void OpenGl_Layer::updateBVH() const |
a1954302 |
449 | { |
3fe9ce0e |
450 | if (!myIsBVHPrimitivesNeedsReset) |
451 | { |
452 | return; |
453 | } |
454 | |
455 | myBVHPrimitives.Clear(); |
456 | myBVHPrimitivesTrsfPers.Clear(); |
150ed3d5 |
457 | myAlwaysRenderedMap.Clear(); |
3fe9ce0e |
458 | myIsBVHPrimitivesNeedsReset = Standard_False; |
7c3ef2f7 |
459 | for (OpenGl_ArrayOfIndexedMapOfStructure::Iterator aMapIter (myArray); aMapIter.More(); aMapIter.Next()) |
a1954302 |
460 | { |
7c3ef2f7 |
461 | const OpenGl_IndexedMapOfStructure& aStructures = aMapIter.Value(); |
462 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
825aa485 |
463 | { |
3fe9ce0e |
464 | const OpenGl_Structure* aStruct = aStructIter.Value(); |
465 | if (aStruct->IsAlwaysRendered()) |
825aa485 |
466 | { |
150ed3d5 |
467 | aStruct->MarkAsNotCulled(); |
468 | myAlwaysRenderedMap.Add (aStruct); |
3fe9ce0e |
469 | } |
778cd667 |
470 | else if (aStruct->TransformPersistence().IsNull()) |
3fe9ce0e |
471 | { |
472 | myBVHPrimitives.Add (aStruct); |
473 | } |
474 | else |
475 | { |
476 | myBVHPrimitivesTrsfPers.Add (aStruct); |
825aa485 |
477 | } |
478 | } |
a1954302 |
479 | } |
3fe9ce0e |
480 | } |
481 | |
482 | // ======================================================================= |
2b8832bb |
483 | // function : UpdateCulling |
3fe9ce0e |
484 | // purpose : |
485 | // ======================================================================= |
2b8832bb |
486 | void OpenGl_Layer::UpdateCulling (const OpenGl_BVHTreeSelector& theSelector, |
487 | const Standard_Boolean theToTraverse) |
3fe9ce0e |
488 | { |
489 | updateBVH(); |
a1954302 |
490 | |
2b8832bb |
491 | myIsCulled = false; |
7c3ef2f7 |
492 | for (OpenGl_ArrayOfIndexedMapOfStructure::Iterator aMapIter (myArray); aMapIter.More(); aMapIter.Next()) |
a1954302 |
493 | { |
7c3ef2f7 |
494 | const OpenGl_IndexedMapOfStructure& aStructures = aMapIter.Value(); |
495 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
a1954302 |
496 | { |
7c3ef2f7 |
497 | const OpenGl_Structure* aStruct = aStructIter.Value(); |
2b8832bb |
498 | aStruct->SetCulled (theToTraverse); |
a1954302 |
499 | } |
500 | } |
a1954302 |
501 | |
2b8832bb |
502 | if (!theToTraverse) |
503 | { |
504 | return; |
505 | } |
506 | if (myBVHPrimitives .Size() == 0 |
507 | && myBVHPrimitivesTrsfPers.Size() == 0) |
508 | { |
509 | return; |
510 | } |
511 | |
512 | myIsCulled = myAlwaysRenderedMap.IsEmpty(); |
513 | OpenGl_BVHTreeSelector::CullingContext aCullCtx; |
514 | theSelector.SetCullingDistance(aCullCtx, myLayerSettings.CullingDistance()); |
515 | theSelector.SetCullingSize (aCullCtx, myLayerSettings.CullingSize()); |
825aa485 |
516 | for (Standard_Integer aBVHTreeIdx = 0; aBVHTreeIdx < 2; ++aBVHTreeIdx) |
a1954302 |
517 | { |
825aa485 |
518 | const Standard_Boolean isTrsfPers = aBVHTreeIdx == 1; |
2b8832bb |
519 | opencascade::handle<BVH_Tree<Standard_Real, 3> > aBVHTree; |
825aa485 |
520 | if (isTrsfPers) |
a1954302 |
521 | { |
825aa485 |
522 | if (myBVHPrimitivesTrsfPers.Size() == 0) |
825aa485 |
523 | continue; |
97f937cc |
524 | |
7c3ef2f7 |
525 | const OpenGl_Mat4d& aProjection = theSelector.ProjectionMatrix(); |
526 | const OpenGl_Mat4d& aWorldView = theSelector.WorldViewMatrix(); |
825aa485 |
527 | const Graphic3d_WorldViewProjState& aWVPState = theSelector.WorldViewProjState(); |
91d96372 |
528 | const Standard_Integer aViewportWidth = theSelector.ViewportWidth(); |
529 | const Standard_Integer aViewportHeight = theSelector.ViewportHeight(); |
530 | |
3fe9ce0e |
531 | aBVHTree = myBVHPrimitivesTrsfPers.BVH (theSelector.Camera(), aProjection, aWorldView, aViewportWidth, aViewportHeight, aWVPState); |
825aa485 |
532 | } |
533 | else |
534 | { |
535 | if (myBVHPrimitives.Size() == 0) |
825aa485 |
536 | continue; |
97f937cc |
537 | |
825aa485 |
538 | aBVHTree = myBVHPrimitives.BVH(); |
539 | } |
540 | |
2b8832bb |
541 | if (theSelector.IsCulled (aCullCtx, aBVHTree->MinPoint (0), aBVHTree->MaxPoint (0))) |
825aa485 |
542 | { |
543 | continue; |
544 | } |
545 | |
2b8832bb |
546 | myIsCulled = false; |
f5b72419 |
547 | Standard_Integer aStack[BVH_Constants_MaxTreeDepth]; |
825aa485 |
548 | Standard_Integer aHead = -1; |
2b8832bb |
549 | Standard_Integer aNode = 0; // a root node |
825aa485 |
550 | for (;;) |
551 | { |
552 | if (!aBVHTree->IsOuter (aNode)) |
a1954302 |
553 | { |
f2474958 |
554 | const Standard_Integer aLeftChildIdx = aBVHTree->Child<0> (aNode); |
555 | const Standard_Integer aRightChildIdx = aBVHTree->Child<1> (aNode); |
2b8832bb |
556 | const Standard_Boolean isLeftChildIn = !theSelector.IsCulled (aCullCtx, aBVHTree->MinPoint (aLeftChildIdx), aBVHTree->MaxPoint (aLeftChildIdx)); |
557 | const Standard_Boolean isRightChildIn = !theSelector.IsCulled (aCullCtx, aBVHTree->MinPoint (aRightChildIdx), aBVHTree->MaxPoint (aRightChildIdx)); |
825aa485 |
558 | if (isLeftChildIn |
559 | && isRightChildIn) |
560 | { |
561 | aNode = myBVHIsLeftChildQueuedFirst ? aLeftChildIdx : aRightChildIdx; |
562 | aStack[++aHead] = myBVHIsLeftChildQueuedFirst ? aRightChildIdx : aLeftChildIdx; |
563 | myBVHIsLeftChildQueuedFirst = !myBVHIsLeftChildQueuedFirst; |
564 | } |
565 | else if (isLeftChildIn |
566 | || isRightChildIn) |
567 | { |
568 | aNode = isLeftChildIn ? aLeftChildIdx : aRightChildIdx; |
569 | } |
570 | else |
571 | { |
572 | if (aHead < 0) |
573 | { |
574 | break; |
575 | } |
576 | |
577 | aNode = aStack[aHead--]; |
578 | } |
a1954302 |
579 | } |
580 | else |
581 | { |
825aa485 |
582 | Standard_Integer aIdx = aBVHTree->BegPrimitive (aNode); |
4ecf34cc |
583 | const OpenGl_Structure* aStruct = isTrsfPers |
584 | ? myBVHPrimitivesTrsfPers.GetStructureById (aIdx) |
585 | : myBVHPrimitives.GetStructureById (aIdx); |
825aa485 |
586 | aStruct->MarkAsNotCulled(); |
a1954302 |
587 | if (aHead < 0) |
588 | { |
825aa485 |
589 | break; |
a1954302 |
590 | } |
591 | |
14a35e5d |
592 | aNode = aStack[aHead--]; |
a1954302 |
593 | } |
594 | } |
a1954302 |
595 | } |
596 | } |
597 | |
598 | // ======================================================================= |
599 | // function : Append |
600 | // purpose : |
601 | // ======================================================================= |
602 | Standard_Boolean OpenGl_Layer::Append (const OpenGl_Layer& theOther) |
603 | { |
604 | // the source priority list shouldn't have more priorities |
605 | const Standard_Integer aNbPriorities = theOther.NbPriorities(); |
606 | if (aNbPriorities > NbPriorities()) |
607 | { |
608 | return Standard_False; |
609 | } |
610 | |
611 | // add all structures to destination priority list |
612 | for (Standard_Integer aPriorityIter = 0; aPriorityIter < aNbPriorities; ++aPriorityIter) |
613 | { |
9f112210 |
614 | const OpenGl_IndexedMapOfStructure& aStructures = theOther.myArray (aPriorityIter); |
7c3ef2f7 |
615 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
a1954302 |
616 | { |
7c3ef2f7 |
617 | Add (aStructIter.Value(), aPriorityIter); |
a1954302 |
618 | } |
619 | } |
620 | |
621 | return Standard_True; |
622 | } |
623 | |
7c3ef2f7 |
624 | //======================================================================= |
625 | //function : SetLayerSettings |
626 | //purpose : |
627 | //======================================================================= |
628 | void OpenGl_Layer::SetLayerSettings (const Graphic3d_ZLayerSettings& theSettings) |
629 | { |
630 | const Standard_Boolean toUpdateTrsf = !myLayerSettings.Origin().IsEqual (theSettings.Origin(), gp::Resolution()); |
631 | myLayerSettings = theSettings; |
632 | if (toUpdateTrsf) |
633 | { |
634 | for (OpenGl_ArrayOfIndexedMapOfStructure::Iterator aMapIter (myArray); aMapIter.More(); aMapIter.Next()) |
635 | { |
636 | OpenGl_IndexedMapOfStructure& aStructures = aMapIter.ChangeValue(); |
637 | for (OpenGl_IndexedMapOfStructure::Iterator aStructIter (aStructures); aStructIter.More(); aStructIter.Next()) |
638 | { |
639 | OpenGl_Structure* aStructure = const_cast<OpenGl_Structure*> (aStructIter.Value()); |
640 | aStructure->updateLayerTransformation(); |
641 | } |
642 | } |
643 | } |
644 | } |
645 | |
c5751993 |
646 | //======================================================================= |
647 | //function : Render |
a1954302 |
648 | //purpose : |
c5751993 |
649 | //======================================================================= |
a1954302 |
650 | void OpenGl_Layer::Render (const Handle(OpenGl_Workspace)& theWorkspace, |
651 | const OpenGl_GlobalLayerSettings& theDefaultSettings) const |
c5751993 |
652 | { |
7c3ef2f7 |
653 | const Graphic3d_PolygonOffset anAppliedOffsetParams = theWorkspace->AppliedPolygonOffset(); |
b3eab8ef |
654 | // myLayerSettings.ToClearDepth() is handled outside |
eae454e3 |
655 | |
c5751993 |
656 | // handle depth test |
7c3ef2f7 |
657 | if (myLayerSettings.ToEnableDepthTest()) |
c5751993 |
658 | { |
550f3b8b |
659 | // assuming depth test is enabled by default |
660 | glDepthFunc (theDefaultSettings.DepthFunc); |
c5751993 |
661 | } |
662 | else |
663 | { |
664 | glDepthFunc (GL_ALWAYS); |
665 | } |
eae454e3 |
666 | |
83da37b1 |
667 | // save environment texture |
cc8cbabe |
668 | Handle(OpenGl_TextureSet) anEnvironmentTexture = theWorkspace->EnvironmentTexture(); |
7c3ef2f7 |
669 | if (!myLayerSettings.UseEnvironmentTexture()) |
83da37b1 |
670 | { |
cc8cbabe |
671 | theWorkspace->SetEnvironmentTexture (Handle(OpenGl_TextureSet)()); |
83da37b1 |
672 | } |
673 | |
c5751993 |
674 | // handle depth offset |
7c3ef2f7 |
675 | theWorkspace->SetPolygonOffset (myLayerSettings.PolygonOffset()); |
c5751993 |
676 | |
677 | // handle depth write |
a1073ae2 |
678 | theWorkspace->UseDepthWrite() = myLayerSettings.ToEnableDepthWrite() && theDefaultSettings.DepthMask == GL_TRUE; |
eae454e3 |
679 | glDepthMask (theWorkspace->UseDepthWrite() ? GL_TRUE : GL_FALSE); |
c5751993 |
680 | |
7c3ef2f7 |
681 | const Standard_Boolean hasLocalCS = !myLayerSettings.OriginTransformation().IsNull(); |
682 | const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext(); |
992ed6b3 |
683 | const Handle(OpenGl_ShaderManager)& aManager = aCtx->ShaderManager(); |
684 | Handle(Graphic3d_LightSet) aLightsBack = aManager->LightSourceState().LightSources(); |
685 | const bool hasOwnLights = aCtx->ColorMask() && !myLayerSettings.Lights().IsNull() && myLayerSettings.Lights() != aLightsBack; |
686 | if (hasOwnLights) |
687 | { |
688 | myLayerSettings.Lights()->UpdateRevision(); |
689 | aManager->UpdateLightSourceStateTo (myLayerSettings.Lights()); |
690 | } |
691 | |
7c3ef2f7 |
692 | const Handle(Graphic3d_Camera)& aWorldCamera = theWorkspace->View()->Camera(); |
7c3ef2f7 |
693 | if (hasLocalCS) |
694 | { |
695 | // Apply local camera transformation. |
696 | // The vertex position is computed by the following formula in GLSL program: |
697 | // gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex; |
698 | // where: |
699 | // occProjectionMatrix - matrix defining orthographic/perspective/stereographic projection |
700 | // occWorldViewMatrix - world-view matrix defining Camera position and orientation |
701 | // occModelWorldMatrix - model-world matrix defining Object transformation from local coordinate system to the world coordinate system |
702 | // occVertex - input vertex position |
703 | // |
704 | // Since double precision is quite expensive on modern GPUs, and not available on old hardware, |
705 | // all these values are passed with single float precision to the shader. |
706 | // As result, single precision become insufficient for handling objects far from the world origin. |
707 | // |
708 | // Several approaches can be used to solve precision issues: |
709 | // - [Broute force] migrate to double precision for all matrices and vertex position. |
710 | // This is too expensive for most hardware. |
711 | // - Store only translation part with double precision and pass it to GLSL program. |
712 | // This requires modified GLSL programs for computing transformation |
713 | // and extra packing mechanism for hardware not supporting double precision natively. |
714 | // This solution is less expensive then previous one. |
715 | // - Move translation part of occModelWorldMatrix into occWorldViewMatrix. |
716 | // The main idea here is that while moving Camera towards the object, |
717 | // Camera translation part and Object translation part will compensate each other |
718 | // to fit into single float precision. |
719 | // But this operation should be performed with double precision - this is why we are moving |
720 | // translation part of occModelWorldMatrix to occWorldViewMatrix. |
721 | // |
722 | // All approaches might be useful in different scenarios, but for the moment we consider the last one as main scenario. |
723 | // Here we do the trick: |
724 | // - OpenGl_Layer defines the Local Origin, which is expected to be the center of objects stored within it. |
725 | // This Local Origin is included into occWorldViewMatrix during rendering. |
726 | // - OpenGl_Structure defines Object local transformation occModelWorldMatrix with subtracted Local Origin of the Layer. |
727 | // This means that Object itself should be defined within either Local Transformation equal or near to Local Origin of the Layer. |
728 | theWorkspace->View()->SetLocalOrigin (myLayerSettings.Origin()); |
729 | |
730 | NCollection_Mat4<Standard_Real> aWorldView = aWorldCamera->OrientationMatrix(); |
731 | Graphic3d_TransformUtils::Translate (aWorldView, myLayerSettings.Origin().X(), myLayerSettings.Origin().Y(), myLayerSettings.Origin().Z()); |
732 | |
733 | NCollection_Mat4<Standard_ShortReal> aWorldViewF; |
734 | aWorldViewF.ConvertFrom (aWorldView); |
735 | aCtx->WorldViewState.SetCurrent (aWorldViewF); |
736 | aCtx->ShaderManager()->UpdateClippingState(); |
737 | aCtx->ShaderManager()->UpdateLightSourceState(); |
738 | } |
739 | |
c5751993 |
740 | // render priority list |
2b8832bb |
741 | renderAll (theWorkspace); |
550f3b8b |
742 | |
992ed6b3 |
743 | if (hasOwnLights) |
744 | { |
745 | aManager->UpdateLightSourceStateTo (aLightsBack); |
746 | } |
7c3ef2f7 |
747 | if (hasLocalCS) |
748 | { |
749 | aCtx->ShaderManager()->RevertClippingState(); |
750 | aCtx->ShaderManager()->UpdateLightSourceState(); |
751 | |
752 | aCtx->WorldViewState.SetCurrent (aWorldCamera->OrientationMatrixF()); |
753 | theWorkspace->View() ->SetLocalOrigin (gp_XYZ (0.0, 0.0, 0.0)); |
754 | } |
755 | |
550f3b8b |
756 | // always restore polygon offset between layers rendering |
b6472664 |
757 | theWorkspace->SetPolygonOffset (anAppliedOffsetParams); |
83da37b1 |
758 | |
759 | // restore environment texture |
7c3ef2f7 |
760 | if (!myLayerSettings.UseEnvironmentTexture()) |
83da37b1 |
761 | { |
762 | theWorkspace->SetEnvironmentTexture (anEnvironmentTexture); |
763 | } |
c5751993 |
764 | } |