?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Show bonus/malus timer text if available
[ryzomcore.git] / nel / src / 3d / patch_render.cpp
blobde5d0b4ec2b2e235768c42432dbc27279db9b2d9
1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17 #include "std3d.h"
18
19
20 #include "nel/3d/patch.h"
21 #include "nel/3d/tessellation.h"
22 #include "nel/3d/bezier_patch.h"
23 #include "nel/3d/zone.h"
24 #include "nel/3d/landscape.h"
25 #include "nel/3d/landscape_profile.h"
26 #include "nel/3d/patchdlm_context.h"
27 #include "nel/3d/debug_vb.h"
28
29 #include "nel/misc/vector.h"
30 #include "nel/misc/common.h"
31
32 using namespace std;
33 using namespace NLMISC;
34
35 #ifdef DEBUG_NEW
36 #define new DEBUG_NEW
37 #endif
38
39 namespace NL3D
40 {
41
42
43 // ***************************************************************************
44 // ***************************************************************************
45 // Patch Texture computation.
46 // ***************************************************************************
47 // ***************************************************************************
48
49
50 // ***************************************************************************
51 void CPatch::computeNewFar(const NLMISC::CBSphere &patchSphere, sint &newFar0, sint &newFar1)
52 {
53 // Classify the patch.
54 //========================
55 float r= (CLandscapeGlobals::RefineCenter-patchSphere.Center).norm() - patchSphere.Radius;
56 float rr=0.0;
57 if(r<CLandscapeGlobals::TileDistNear)
58 rr= r-CLandscapeGlobals::TileDistNear, newFar0= 0;
59 else if(r<CLandscapeGlobals::Far0Dist)
60 rr= r-CLandscapeGlobals::Far0Dist, newFar0= 1;
61 else if(r<CLandscapeGlobals::Far1Dist)
62 rr= r-CLandscapeGlobals::Far1Dist, newFar0= 2;
63 else
64 newFar0= 3;
65 // Transition with the next level.
66 newFar1=0;
67 if(newFar0<3 && rr>-(CLandscapeGlobals::FarTransition+2*patchSphere.Radius))
68 {
69 newFar1= newFar0+1;
70 }
71
72
73 // Update Texture Info.
74 //========================
75 if(newFar0!=Far0 || newFar1!=Far1)
76 {
77 // Backup old pass0
78 CPatchRdrPass *oldPass0=_PatchRdrPassFar0;
79 CPatchRdrPass *oldPass1=_PatchRdrPassFar1;
80
81 // Checks
82 if (oldPass0==NULL)
83 nlassert (Far0<=0);
84 if (oldPass1==NULL)
85 nlassert (Far1<=0);
86
87 float oldFar0UScale=Far0UScale;
88 float oldFar0VScale=Far0VScale;
89 float oldFar0UBias=Far0UBias;
90 float oldFar0VBias=Far0VBias;
91 uint8 oldFlags=Flags;
92
93
94 // Don't delete the pass0 if the new newFar1 will use it
95 if ((newFar1==Far0)&&(Far0>0))
96 _PatchRdrPassFar0=NULL;
97
98 // Don't delete the pass1 if the new newFar0 will use it
99 if ((newFar0==Far1)&&(Far1>0))
100 _PatchRdrPassFar1=NULL;
101
102 // Pass0 have changed ?
103 if (newFar0!=Far0)
104 {
105 // Compute / get the texture Far.
106 if(newFar0>0)
107 {
108 // Free the old pass, don't used any more
109 if (_PatchRdrPassFar0)
110 Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar0, Far0);
111
112 // Can we use the old pass1 ?
113 if (newFar0==Far1)
114 {
115 // Yes, recycle it!
116 _PatchRdrPassFar0=oldPass1;
117
118 // Copy uv coordinates
119 Far0UScale=Far1UScale;
120 Far0VScale=Far1VScale;
121 Far0UBias=Far1UBias;
122 Far0VBias=Far1VBias;
123
124 // Copy rotation flag
125 Flags&=~NL_PATCH_FAR0_ROTATED; // erase it
126 if (Flags&NL_PATCH_FAR1_ROTATED)
127 Flags|=NL_PATCH_FAR0_ROTATED; // copy it
128 }
129 else // get a new render pass
130 {
131 // Rotation boolean
132 bool bRot;
133 _PatchRdrPassFar0=Zone->Landscape->getFarRenderPass(this, newFar0, Far0UScale, Far0VScale, Far0UBias, Far0VBias, bRot);
134
135 // Flags is set if the far texture is rotated of 90deg to the left
136 if (bRot)
137 Flags|=NL_PATCH_FAR0_ROTATED;
138 else
139 Flags&=~NL_PATCH_FAR0_ROTATED;
140 }
141 }
142 else // no more far pass0
143 {
144 if (_PatchRdrPassFar0)
145 {
146 Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar0, Far0);
147 _PatchRdrPassFar0=NULL;
148 }
149 }
150 }
151
152 // Pass1 have changed ?
153 if (newFar1!=Far1)
154 {
155 // Now let's go with pass1
156 if(newFar1>0)
157 {
158 // Delete the pass1 if not used any more
159 if (_PatchRdrPassFar1)
160 Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar1, Far1);
161
162 // Can we use the old pass1 ?
163 if (newFar1==Far0)
164 {
165 // Yes, recycle it!
166 _PatchRdrPassFar1= oldPass0;
167 nlassert (_PatchRdrPassFar1);
168
169 // Copy uv coordinates
170 Far1UScale=oldFar0UScale;
171 Far1VScale=oldFar0VScale;
172 Far1UBias=oldFar0UBias;
173 Far1VBias=oldFar0VBias;
174
175 // Copy rotation flag
176 Flags&=~NL_PATCH_FAR1_ROTATED; // erase it
177 if (oldFlags&NL_PATCH_FAR0_ROTATED)
178 Flags|=NL_PATCH_FAR1_ROTATED; // copy it
179 }
180 else // get a new render pass
181 {
182 // Rotation boolean
183 bool bRot;
184 _PatchRdrPassFar1=Zone->Landscape->getFarRenderPass(this, newFar1, Far1UScale, Far1VScale, Far1UBias, Far1VBias, bRot);
185 nlassert (_PatchRdrPassFar1);
186
187 // Flags is set if the far texture is rotated of 90deg to the left
188 if (bRot)
189 Flags|=NL_PATCH_FAR1_ROTATED;
190 else
191 Flags&=~NL_PATCH_FAR1_ROTATED;
192 }
193
194 // Compute info for transition.
195 float farDist = 0.f;
196 switch(newFar1)
197 {
198 case 1: farDist= CLandscapeGlobals::TileDistNear; break;
199 case 2: farDist= CLandscapeGlobals::Far0Dist; break;
200 case 3: farDist= CLandscapeGlobals::Far1Dist; break;
201 default: nlstop;
202 };
203 TransitionSqrMin= sqr(farDist-CLandscapeGlobals::FarTransition);
204 OOTransitionSqrDelta= 1.0f/(sqr(farDist)-TransitionSqrMin);
205 }
206 else // no more far pass1
207 {
208 if (_PatchRdrPassFar1)
209 {
210 Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar1, Far1);
211 _PatchRdrPassFar1=NULL;
212 }
213 }
214 }
215
216 }
217
218 // Don't copy Far0 and Far1.
219 }
220
221
222 // ***************************************************************************
223 void CPatch::updateTextureFarOnly(const NLMISC::CBSphere &patchSphere)
224 {
225 sint newFar0,newFar1;
226 // compute new Far0 and new Far1.
227 computeNewFar(patchSphere, newFar0, newFar1);
228
229 // Far change.
230 //------------------
231 // Set new far values
232 Far0= newFar0;
233 Far1= newFar1;
234 }
235
236
237
238 // ***************************************************************************
239 // ***************************************************************************
240 // Patch / Face rendering.
241 // ***************************************************************************
242 // ***************************************************************************
243
244
245 // ***************************************************************************
246 void CPatch::preRender(const NLMISC::CBSphere &patchSphere)
247 {
248 // 0. Classify the patch, and update TextureInfo.
249 //=======================
250 sint newFar0,newFar1;
251 // compute new Far0 and new Far1.
252 computeNewFar(patchSphere, newFar0, newFar1);
253
254
255 // 2. Update vertices in VB
256 //========================
257 sint oldFar0= Far0, oldFar1= Far1;
258
259 // Test if go in or go out tileMode.
260 bool changeTileMode;
261 // this is true if a change is made, and if old or current is in TileMode.
262 changeTileMode= (newFar0!=oldFar0) && (newFar0==0 || oldFar0==0);
263 // Or this is true if Far0 / Far1 was invalid before.
264 changeTileMode= changeTileMode || oldFar0==-1 || oldFar1==-1;
265
266 // Pre VB change.
267 //------------------
268 // In this case, major change: delete all VB, then recreate after.
269 if(changeTileMode)
270 {
271 // delete the old VB (NB: isRenderClipped()==false here).
272 // NB: Far0 and Far1 are still unmodified, so deleteVB() will do the good job.
273 deleteVBAndFaceVector();
274 }
275 else
276 {
277 // minor change: Far0 UV, or Far1.
278 // Far0 UV: do nothing here.
279 // If change in Far1, must delete Far1
280 if(newFar1!=oldFar1)
281 {
282 // NB: Far1 is still unmodified, so deleteVB() will do the good job.
283 deleteVBAndFaceVectorFar1Only();
284 }
285 }
286
287 // Far change.
288 //------------------
289 // Set new far values
290 Far0= newFar0;
291 Far1= newFar1;
292
293
294 // Post VB change.
295 //------------------
296 if(changeTileMode)
297 {
298 // major change: recreate all the VB.
299 allocateVBAndFaceVector();
300 // Then try to refill if possible.
301 fillVB();
302 }
303 else
304 {
305 // minor change: Far0 UV, or Far1.
306 // If change in Far0
307 if(newFar0!=oldFar0)
308 {
309 // Then must recompute VB with good UVs.
310 // An optimisation is to check if UVs had really change (see UScale ...)
311 // but the case they don't change is very rare: 1/16.
312 fillVBFar0Only();
313 }
314
315 // If change in Far1, must allcoate and recompute UVs.
316 if(newFar1!=oldFar1)
317 {
318 allocateVBAndFaceVectorFar1Only();
319 // try to fill if no reallocation problem
320 fillVBFar1Only();
321 }
322 }
323
324
325 // 3. Append patch to renderList.
326 //=====================
327 // This patch is visible. So if good far, append.
328 if(Far0>0)
329 {
330 _PatchRdrPassFar0->appendRdrPatchFar0(this);
331 }
332 // Same for Far1.
333 if(Far1>0)
334 {
335 _PatchRdrPassFar1->appendRdrPatchFar1(this);
336 }
337
338
339 // 4. Clip tess blocks.
340 //=====================
341 // If we are in Tile/FarTransition
342 bool doClipFar= Far0==0 && Far1==1;
343 // Parse all TessBlocks.
344 uint nTessBlock= TessBlocks.size();
345 CTessBlock *pTessBlock= nTessBlock>0? &TessBlocks[0]: NULL ;
346 for(; nTessBlock>0; pTessBlock++, nTessBlock--)
347 {
348 CTessBlock &tblock= *pTessBlock;
349
350 // bkup the old result for clipping
351 bool oldVisibleFar0= tblock.visibleFar0();
352 bool oldVisibleTile= tblock.visibleTile();
353 bool oldVisibleFar1= tblock.visibleFar1();
354
355 // If this TessBlock is empty, do not need to clip
356 if(tblock.FaceTileMaterialRefCount==0)
357 {
358 // Simply force the clip.
359 tblock.forceClip();
360 }
361 else
362 {
363 // clip the tessBlock.
364 tblock.resetClip();
365 tblock.clip();
366 // If we are in Tile/FarTransition
367 if(doClipFar)
368 tblock.clipFar(CLandscapeGlobals::RefineCenter, CLandscapeGlobals::TileDistNear, CLandscapeGlobals::FarTransition);
369
370 // If TileMode, and if tile visible
371 if(Far0==0 && tblock.visibleTile() )
372 {
373 // Append all tiles (if any) to the renderPass list!
374 for(uint j=0;j<NL3D_TESSBLOCK_TILESIZE; j++)
375 {
376 // If tile exist
377 if(tblock.RdrTileRoot[j])
378 // add it to the renderList
379 tblock.RdrTileRoot[j]->appendTileToEachRenderPass(NumRenderableFaces);
380 }
381 }
382 }
383
384 // If change of clip in tessBlock, must update the tessBlock
385 if( Far0> 0 && oldVisibleFar0 != tblock.visibleFar0() )
386 {
387 if( tblock.visibleFar0() )
388 {
389 // allocate
390 updateFar0VBAlloc(tblock.FarVertexList, true);
391 // fill only if possible.
392 if(!CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs())
393 fillFar0VertexListVB(tblock.FarVertexList);
394 // rebuild triangles index list.
395 tblock.refillFaceVectorFar0();
396 }
397 else
398 {
399 // delete
400 updateFar0VBAlloc(tblock.FarVertexList, false);
401 }
402 }
403 if( Far0==0 && oldVisibleTile != tblock.visibleTile() )
404 {
405 if( tblock.visibleTile() )
406 {
407 // allocate
408 updateTileVBAlloc(tblock.NearVertexList, true);
409 // fill only if possible.
410 if(!CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs())
411 fillTileVertexListVB(tblock.NearVertexList);
412 // rebuild triangles index list.
413 tblock.refillFaceVectorTile();
414 }
415 else
416 {
417 // delete
418 updateTileVBAlloc(tblock.NearVertexList, false);
419 }
420 }
421 if( Far1> 0 && oldVisibleFar1 != tblock.visibleFar1() )
422 {
423 if( tblock.visibleFar1() )
424 {
425 // allocate
426 updateFar1VBAlloc(tblock.FarVertexList, true);
427 // fill only if possible.
428 if(!CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs())
429 fillFar1VertexListVB(tblock.FarVertexList);
430 // rebuild triangles index list.
431 tblock.refillFaceVectorFar1();
432 }
433 else
434 {
435 // delete
436 updateFar1VBAlloc(tblock.FarVertexList, false);
437 }
438 }
439 }
440
441 }
442
443
444 // Special profiling.
445 #ifdef NL3D_PROFILE_LAND
446 #define NL3D_PROFILE_LAND_ADD_FACE_VECTOR(_x, _fv) \
447 if(_fv) \
448 { \
449 NL3D_PROFILE_LAND_ADD(_x, *_fv); \
450 }
451 #else
452 #define NL3D_PROFILE_LAND_ADD_FACE_VECTOR(_x, _fv)
453 #endif
454
455
456 // ***************************************************************************
457 static inline void renderFaceVector(TLandscapeIndexType *fv)
458 {
459 /*
460 Remind that structure of fv is:
461 uint32 NumTri
462 uint32 index0Tri0
463 uint32 index1Tri0
464 uint32 index2Tri0
465 uint32 index0Tri1
466 uint32 index1Tri1
467 .....
468 */
469
470 // If not NULL (ie not empty).
471 if(fv)
472 {
473 // TestYoyo: Bench.
474 /*
475 extern uint TEMP_NRFV;
476 extern uint TEMP_NRFVTri;
477 extern float TEMP_NRFVMeanTri;
478 extern float TEMP_NRFVDeltaTri;
479 TEMP_NRFV++;
480 TEMP_NRFVTri+= *fv;
481 TEMP_NRFVDeltaTri+= sqr(*fv-TEMP_NRFVMeanTri);
482 */
483
484 // here we have NumTri>0, because fv!=NULL.
485
486 // making lot of render() is slower than copy a block, and render it.
487 //CLandscapeGlobals::PatchCurrentDriver->renderSimpleTriangles(fv+1, *fv);
488 CHECK_IBA_RANGE(CLandscapeGlobals::PassTriArrayIBA, NL3D_LandscapeGlobals_PassTriCurPtr, *fv*3 * sizeof(uint32));
489 #if defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM)
490 #ifndef NL_LANDSCAPE_INDEX16
491 __asm
492 {
493 mov ebx, fv
494 mov edi, NL3D_LandscapeGlobals_PassTriCurPtr
495
496 mov edx, NL3D_LandscapeGlobals_PassNTri
497 xor eax, eax // Avoid AGI stall.
498
499 mov ecx, [ebx]
500 lea esi, [ebx+4]
501
502 mov eax, ecx // eax= bkup NumTris
503 lea ecx, [ecx + ecx*2] // ecx= nTriIndex= NumTris*3
504
505 // copy tri indices
506 rep movsd
507
508 add edx, eax // edx= NL3D_LandscapeGlobals_PassNTri + NumTri;
509
510 // NL3D_LandscapeGlobals_PassTriCurPtr= edi= new ptr after copy
511 mov NL3D_LandscapeGlobals_PassTriCurPtr, edi
512 mov NL3D_LandscapeGlobals_PassNTri, edx
513 }
514 #else
515 __asm
516 {
517 mov ebx, fv
518 mov edi, NL3D_LandscapeGlobals_PassTriCurPtr
519
520 mov edx, NL3D_LandscapeGlobals_PassNTri
521 xor eax, eax // Avoid AGI stall.
522
523 movzx ecx, word ptr [ebx]
524 lea esi, [ebx+2]
525
526 mov eax, ecx // eax= bkup NumTris
527 lea ecx, [ecx + ecx*2] // ecx= nTriIndex= NumTris*3
528
529 test ecx, 1
530 jne odd_number
531 shr ecx, 1
532 // for alignment, first copy a single word
533 movsw
534 dec ecx
535 rep movsd
536 movsw
537 jmp even_number_done
538 odd_number:
539 shr ecx, 1
540 // for alignment, first copy a single word
541 movsw
542 rep movsd
543 even_number_done:
544
545 add edx, eax // edx= NL3D_LandscapeGlobals_PassNTri + NumTri;
546
547 // NL3D_LandscapeGlobals_PassTriCurPtr= edi= new ptr after copy
548 mov NL3D_LandscapeGlobals_PassTriCurPtr, edi
549 mov NL3D_LandscapeGlobals_PassNTri, edx
550 }
551 #endif
552 #else
553 uint nTriIndex= *fv*3;
554 // Fill and increment the array.
555 #ifndef NL_LANDSCAPE_INDEX16
556 memcpy( NL3D_LandscapeGlobals_PassTriCurPtr, fv+1, nTriIndex * sizeof(uint32) );
557 NL3D_LandscapeGlobals_PassTriCurPtr= (uint32*)NL3D_LandscapeGlobals_PassTriCurPtr + nTriIndex;
558 #else
559 memcpy( NL3D_LandscapeGlobals_PassTriCurPtr, fv+1, nTriIndex * sizeof(uint16) );
560 NL3D_LandscapeGlobals_PassTriCurPtr= (uint16*)NL3D_LandscapeGlobals_PassTriCurPtr + nTriIndex;
561 #endif
562 NL3D_LandscapeGlobals_PassNTri+= *fv;
563 #endif
564 }
565 }
566
567
568 // ***************************************************************************
569 void CPatch::renderFar0()
570 {
571 NL3D_PROFILE_LAND_ADD(ProfNPatchRdrFar0, 1);
572
573 #ifdef NL_DEBUG
574 // Must be visible, and must be called only if the RdrPass is enabled.
575 nlassert(!isRenderClipped() && _PatchRdrPassFar0);
576 #endif
577
578 // Render tris of MasterBlock.
579 renderFaceVector(MasterBlock.Far0FaceVector);
580 // profile
581 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar0, MasterBlock.Far0FaceVector);
582
583 // Render tris of TessBlocks.
584 uint nTessBlock= TessBlocks.size();
585 CTessBlock *pTessBlock= nTessBlock>0? &TessBlocks[0]: NULL ;
586 for(; nTessBlock>0; pTessBlock++, nTessBlock--)
587 {
588 CTessBlock &tblock= *pTessBlock;
589 // if block visible, render
590 if( tblock.visibleFar0() )
591 {
592 renderFaceVector(tblock.Far0FaceVector);
593 // profile
594 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar0, tblock.Far0FaceVector);
595 }
596 }
597 }
598
599
600 // ***************************************************************************
601 void CPatch::renderFar1()
602 {
603 NL3D_PROFILE_LAND_ADD(ProfNPatchRdrFar1, 1);
604
605 #ifdef NL_DEBUG
606 // Must be visible, and must be called only if the RdrPass is enabled.
607 nlassert(!isRenderClipped() && _PatchRdrPassFar1);
608 #endif
609
610 // Render tris of MasterBlock.
611 renderFaceVector(MasterBlock.Far1FaceVector);
612 // profile.
613 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar1, MasterBlock.Far1FaceVector);
614
615 // Render tris of TessBlocks.
616 uint nTessBlock= TessBlocks.size();
617 CTessBlock *pTessBlock= nTessBlock>0? &TessBlocks[0]: NULL ;
618 for(; nTessBlock>0; pTessBlock++, nTessBlock--)
619 {
620 CTessBlock &tblock= *pTessBlock;
621 // if block visible, render
622 if( tblock.visibleFar1() )
623 {
624 renderFaceVector(tblock.Far1FaceVector);
625 // profile.
626 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar1, tblock.Far1FaceVector);
627 }
628 }
629 }
630
631
632 // ***************************************************************************
633 void CTileMaterial::renderTile(uint pass)
634 {
635 // because precisely inserted in preRender(), and correctly tested, this tile is to be rendered,
636 // If the pass is enabled.
637 if(Pass[pass].PatchRdrPass)
638 {
639 // render tris of the good faceList.
640 renderFaceVector(TileFaceVectors[pass]);
641
642 // profile.
643 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrTile[pass], TileFaceVectors[pass]);
644 }
645 }
646
647 // ***************************************************************************
648 void CTileMaterial::renderTilePassRGB0()
649 {
650 // because precisely inserted in preRender(), and correctly tested, this tile is to be rendered,
651 // this pass must be enabled!
652 nlassert(Pass[NL3D_TILE_PASS_RGB0].PatchRdrPass);
653 // render tris of the good faceList.
654 renderFaceVector(TileFaceVectors[NL3D_TILE_PASS_RGB0]);
655
656 // profile.
657 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrTile[NL3D_TILE_PASS_RGB0], TileFaceVectors[NL3D_TILE_PASS_RGB0]);
658 }
659
660 // ***************************************************************************
661 void CTileMaterial::renderTilePassLightmap()
662 {
663 // because precisely inserted in preRender(), and correctly tested, this tile is to be rendered,
664 // this pass must be enabled!
665 nlassert(Pass[NL3D_TILE_PASS_LIGHTMAP].PatchRdrPass);
666 // render tris of the good faceList, ie the one of PassRGB0, because vertices are reused.
667 renderFaceVector(TileFaceVectors[NL3D_TILE_PASS_RGB0]);
668
669 // profile.
670 NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrTile[NL3D_TILE_PASS_LIGHTMAP], TileFaceVectors[NL3D_TILE_PASS_RGB0]);
671 }
672
673
674 // ***************************************************************************
675 // ***************************************************************************
676 // FaceVector Allocation
677 // ***************************************************************************
678 // ***************************************************************************
679
680
681 // ***************************************************************************
682 void CPatch::createFaceVectorFar1()
683 {
684 if(Far1>0)
685 {
686 // Create the face for all TessBlocks.
687 MasterBlock.createFaceVectorFar1(getLandscape()->_FaceVectorManager);
688 for(uint i=0; i<TessBlocks.size(); i++)
689 TessBlocks[i].createFaceVectorFar1(getLandscape()->_FaceVectorManager);
690 }
691 }
692 // ***************************************************************************
693 void CPatch::deleteFaceVectorFar1()
694 {
695 if(Far1>0)
696 {
697 // delete the face for all TessBlocks.
698 MasterBlock.deleteFaceVectorFar1(getLandscape()->_FaceVectorManager);
699 for(uint i=0; i<TessBlocks.size(); i++)
700 TessBlocks[i].deleteFaceVectorFar1(getLandscape()->_FaceVectorManager);
701 }
702 }
703 // ***************************************************************************
704 void CPatch::createFaceVectorFar0OrTile()
705 {
706 // If Far Mode.
707 if(Far0>0)
708 {
709 // Create the face for all TessBlocks.
710 MasterBlock.createFaceVectorFar0(getLandscape()->_FaceVectorManager);
711 for(uint i=0; i<TessBlocks.size(); i++)
712 TessBlocks[i].createFaceVectorFar0(getLandscape()->_FaceVectorManager);
713 }
714 // Or If Tile Mode.
715 else if(Far0==0)
716 {
717 // Create the face for all TessBlocks.
718 // No tiles in MasterBlock!
719 for(uint i=0; i<TessBlocks.size(); i++)
720 TessBlocks[i].createFaceVectorTile(getLandscape()->_FaceVectorManager);
721 }
722 }
723 // ***************************************************************************
724 void CPatch::deleteFaceVectorFar0OrTile()
725 {
726 // If Far Mode.
727 if(Far0>0)
728 {
729 // delete the face for all TessBlocks.
730 MasterBlock.deleteFaceVectorFar0(getLandscape()->_FaceVectorManager);
731 for(uint i=0; i<TessBlocks.size(); i++)
732 TessBlocks[i].deleteFaceVectorFar0(getLandscape()->_FaceVectorManager);
733 }
734 // Or If Tile Mode.
735 else if(Far0==0)
736 {
737 // delete the face for all TessBlocks.
738 // No tiles in MasterBlock!
739 for(uint i=0; i<TessBlocks.size(); i++)
740 TessBlocks[i].deleteFaceVectorTile(getLandscape()->_FaceVectorManager);
741 }
742 }
743
744
745 // ***************************************************************************
746 void CPatch::recreateTessBlockFaceVector(CTessBlock &block)
747 {
748 // Do it Only if patch is visible.
749 if(!isRenderClipped())
750 {
751 // Far0.
752 // If Far Mode.
753 if(Far0>0)
754 {
755 // Create the face for this TessBlock only.
756 block.createFaceVectorFar0(getLandscape()->_FaceVectorManager);
757 }
758 // Or If Tile Mode.
759 else if(Far0==0)
760 {
761 // No tiles in MasterBlock! So no need to call createFaceVectorTile(), if this block is the MasterBlock.
762 if(&block != &MasterBlock)
763 block.createFaceVectorTile(getLandscape()->_FaceVectorManager);
764 }
765
766 // Far1.
767 if(Far1>0)
768 {
769 // Create the face for this TessBlock only.
770 block.createFaceVectorFar1(getLandscape()->_FaceVectorManager);
771 }
772 }
773
774 }
775
776
777 // ***************************************************************************
778 // ***************************************************************************
779 // VB Allocation
780 // ***************************************************************************
781 // ***************************************************************************
782
783
784 // ***************************************************************************
785 void CPatch::updateFar0VBAlloc(CTessList<CTessFarVertex> &vertList, bool alloc)
786 {
787 // Traverse the vertList.
788 CTessFarVertex *pVert;
789 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
790 {
791 if(alloc)
792 pVert->Index0= CLandscapeGlobals::CurrentFar0VBAllocator->allocateVertex();
793 else
794 CLandscapeGlobals::CurrentFar0VBAllocator->deleteVertex(pVert->Index0);
795 }
796 }
797
798
799 // ***************************************************************************
800 void CPatch::updateFar1VBAlloc(CTessList<CTessFarVertex> &vertList, bool alloc)
801 {
802 // Traverse the vertList.
803 CTessFarVertex *pVert;
804 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
805 {
806 if(alloc)
807 pVert->Index1= CLandscapeGlobals::CurrentFar1VBAllocator->allocateVertex();
808 else
809 CLandscapeGlobals::CurrentFar1VBAllocator->deleteVertex(pVert->Index1);
810 }
811 }
812
813
814 // ***************************************************************************
815 void CPatch::updateTileVBAlloc(CTessList<CTessNearVertex> &vertList, bool alloc)
816 {
817 // Traverse the vertList.
818 CTessNearVertex *pVert;
819 for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next)
820 {
821 if(alloc)
822 pVert->Index= CLandscapeGlobals::CurrentTileVBAllocator->allocateVertex();
823 else
824 CLandscapeGlobals::CurrentTileVBAllocator->deleteVertex(pVert->Index);
825 }
826 }
827
828
829 // ***************************************************************************
830 void CPatch::updateVBAlloc(bool alloc)
831 {
832 // update Far0.
833 //=======
834 if(Far0>0)
835 {
836 // alloc Far0 VB.
837 updateFar0VBAlloc(MasterBlock.FarVertexList, alloc);
838 for(sint i=0; i<(sint)TessBlocks.size(); i++)
839 {
840 CTessBlock &tblock= TessBlocks[i];
841 // need update VB only if tessBlock is visible.
842 if( tblock.visibleFar0() )
843 updateFar0VBAlloc(tblock.FarVertexList, alloc);
844 }
845 }
846 else if (Far0==0)
847 {
848 // alloc Tile VB.
849 // No Tiles in MasterBlock!!
850 // Traverse the TessBlocks to add vertices.
851 for(sint i=0; i<(sint)TessBlocks.size(); i++)
852 {
853 CTessBlock &tblock= TessBlocks[i];
854 // Add the vertices.
855 // need update VB only if tessBlock is visible.
856 if( tblock.visibleTile() )
857 updateTileVBAlloc(tblock.NearVertexList, alloc);
858 }
859 }
860
861 // update Far1.
862 //=======
863 if(Far1>0)
864 {
865 // alloc VB.
866 updateFar1VBAlloc(MasterBlock.FarVertexList, alloc);
867 for(sint i=0; i<(sint)TessBlocks.size(); i++)
868 {
869 CTessBlock &tblock= TessBlocks[i];
870 // need update VB only if tessBlock is visible.
871 if( tblock.visibleFar1() )
872 updateFar1VBAlloc(tblock.FarVertexList, alloc);
873 }
874 }
875 }
876
877 // ***************************************************************************
878 void CPatch::deleteVBAndFaceVector()
879 {
880 updateVBAlloc(false);
881 deleteFaceVectorFar1();
882 deleteFaceVectorFar0OrTile();
883 }
884
885 // ***************************************************************************
886 void CPatch::allocateVBAndFaceVector()
887 {
888 updateVBAlloc(true);
889 createFaceVectorFar1();
890 createFaceVectorFar0OrTile();
891 }
892
893
894 // ***************************************************************************
895 void CPatch::deleteVBAndFaceVectorFar1Only()
896 {
897 if(Far1>0)
898 {
899 // alloc VB.
900 updateFar1VBAlloc(MasterBlock.FarVertexList, false);
901 for(sint i=0; i<(sint)TessBlocks.size(); i++)
902 {
903 CTessBlock &tblock= TessBlocks[i];
904 // need update VB only if tessBlock is visible.
905 if( tblock.visibleFar1() )
906 updateFar1VBAlloc(tblock.FarVertexList, false);
907 }
908 }
909
910 deleteFaceVectorFar1();
911 }
912
913 // ***************************************************************************
914 void CPatch::allocateVBAndFaceVectorFar1Only()
915 {
916 if(Far1>0)
917 {
918 // alloc VB.
919 updateFar1VBAlloc(MasterBlock.FarVertexList, true);
920 for(sint i=0; i<(sint)TessBlocks.size(); i++)
921 {
922 CTessBlock &tblock= TessBlocks[i];
923 // need update VB only if tessBlock is visible.
924 if( tblock.visibleFar1() )
925 updateFar1VBAlloc(tblock.FarVertexList, true);
926 }
927 }
928
929 createFaceVectorFar1();
930 }
931
932
933 // ***************************************************************************
934 void CPatch::debugAllocationMarkIndicesFarList(CTessList<CTessFarVertex> &vertList, uint marker)
935 {
936 // Traverse the vertList.
937 CTessFarVertex *pVert;
938 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
939 {
940 pVert->Index0= marker;
941 pVert->Index1= marker;
942 }
943 }
944
945 void CPatch::debugAllocationMarkIndicesNearList(CTessList<CTessNearVertex> &vertList, uint marker)
946 {
947 // Traverse the vertList.
948 CTessNearVertex *pVert;
949 for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next)
950 {
951 pVert->Index= marker;
952 }
953 }
954
955 void CPatch::debugAllocationMarkIndices(uint marker)
956 {
957 sint i;
958
959 // Do it For Far.
960 debugAllocationMarkIndicesFarList(MasterBlock.FarVertexList, marker);
961 for(i=0; i<(sint)TessBlocks.size(); i++)
962 {
963 CTessBlock &tblock= TessBlocks[i];
964 debugAllocationMarkIndicesFarList(tblock.FarVertexList, marker);
965 }
966 // Do it For Near.
967 // No Tiles in MasterBlock!!
968 for(i=0; i<(sint)TessBlocks.size(); i++)
969 {
970 CTessBlock &tblock= TessBlocks[i];
971 debugAllocationMarkIndicesNearList(tblock.NearVertexList, marker);
972 }
973
974 }
975
976
977
978 // ***************************************************************************
979 // ***************************************************************************
980 // VB Filling.
981 // ***************************************************************************
982 // ***************************************************************************
983
984
985 // ***************************************************************************
986 // NB: need to be inlined only for fillFar0VB() in this file.
987 inline void CPatch::fillFar0VertexVB(CTessFarVertex *pVert)
988 {
989 // The Buffers must have been locked
990 nlassert(CLandscapeGlobals::CurrentFar0VBAllocator);
991 nlassert(CLandscapeGlobals::CurrentFar0VBAllocator->bufferLocked());
992 // VBInfo must be OK.
993 nlassert(!CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs());
994
995 static uint8 *CurVBPtr;
996 // Compute/build the new vertex.
997 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer;
998 CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize;
999
1000 // NB: the filling order of data is important, for AGP write combiners.
1001
1002 // compute Uvs.
1003 static CUV uv;
1004 CParamCoord pc= pVert->PCoord;
1005 if (Flags&NL_PATCH_FAR0_ROTATED)
1006 {
1007 uv.U= pc.getT()* Far0UScale + Far0UBias;
1008 uv.V= (1.f-pc.getS())* Far0VScale + Far0VBias;
1009 }
1010 else
1011 {
1012 uv.U= pc.getS()* Far0UScale + Far0UBias;
1013 uv.V= pc.getT()* Far0VScale + Far0VBias;
1014 }
1015
1016 // compute Dynamic lightmap Uv.
1017 static CUV uvDLM;
1018 if(_DLMContext) // (NB: Suppose BTB kill this test).
1019 {
1020 // compute UV with DLM context info.
1021 uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias;
1022 uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias;
1023 }
1024 else
1025 {
1026 // just set UV so the vertex point to a black pixel (see CTextureDLM).
1027 uvDLM.U= 1;
1028 uvDLM.V= 1;
1029 }
1030
1031 // If not VertexProgram (NB: Suppose BTB kill this test).
1032 if( !CLandscapeGlobals::VertexProgramEnabled )
1033 {
1034 // Set Pos. Set it local to the current center of landscape
1035 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr, sizeof(CVector));
1036 *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition;
1037 // Set Uvs.
1038 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff0, sizeof(CUV));
1039 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff0)= uv;
1040 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1, sizeof(CUV));
1041 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM;
1042 }
1043 else
1044 {
1045 // Else must setup Vertex program inputs
1046 // v[0]== StartPos.
1047 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr, sizeof(CVector));
1048 *(CVector*)CurVBPtr= pVert->Src->StartPos;
1049 // v[8]== Tex0
1050 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff0, sizeof(CUV));
1051 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff0)= uv;
1052 // v[9]== Tex1
1053 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1, sizeof(CUV));
1054 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM;
1055
1056 // v[10]== GeomInfo.
1057 static CUV geomInfo;
1058 geomInfo.U= pVert->Src->MaxFaceSize * CLandscapeGlobals::OORefineThreshold;
1059 geomInfo.V= pVert->Src->MaxNearLimit;
1060 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.GeomInfoOff, sizeof(CUV));
1061 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.GeomInfoOff)= geomInfo;
1062
1063 // v[11]== EndPos - StartPos
1064 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.DeltaPosOff, sizeof(CVector))
1065 *(CVector*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.DeltaPosOff)=
1066 pVert->Src->EndPos - pVert->Src->StartPos;
1067 }
1068 }
1069 // ***************************************************************************
1070 // NB: need to be inlined only for fillFar1VB() in this file.
1071 inline void CPatch::fillFar1VertexVB(CTessFarVertex *pVert)
1072 {
1073 // The Buffers must have been locked
1074 nlassert(CLandscapeGlobals::CurrentFar1VBAllocator);
1075 nlassert(CLandscapeGlobals::CurrentFar1VBAllocator->bufferLocked());
1076 // VBInfo must be OK.
1077 nlassert(!CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs());
1078
1079 static uint8 *CurVBPtr;
1080 // Compute/build the new vertex.
1081 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer;
1082 CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize;
1083
1084 // NB: the filling order of data is important, for AGP write combiners.
1085
1086 // compute Uvs.
1087 static CUV uv;
1088 CParamCoord pc= pVert->PCoord;
1089 if (Flags&NL_PATCH_FAR1_ROTATED)
1090 {
1091 uv.U= pc.getT()* Far1UScale + Far1UBias;
1092 uv.V= (1.f-pc.getS())* Far1VScale + Far1VBias;
1093 }
1094 else
1095 {
1096 uv.U= pc.getS()* Far1UScale + Far1UBias;
1097 uv.V= pc.getT()* Far1VScale + Far1VBias;
1098 }
1099
1100 // compute Dynamic lightmap Uv.
1101 static CUV uvDLM;
1102 if(_DLMContext) // (NB: Suppose BTB kill this test).
1103 {
1104 // compute UV with DLM context info.
1105 uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias;
1106 uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias;
1107 }
1108 else
1109 {
1110 // just set UV so the vertex point to a black pixel (see CTextureDLM).
1111 uvDLM.U= 1;
1112 uvDLM.V= 1;
1113 }
1114
1115 // If not VertexProgram (NB: Suppose BTB kill this test).
1116 if( !CLandscapeGlobals::VertexProgramEnabled )
1117 {
1118 // Set Pos. Set it local to the current center of landscape
1119 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr, sizeof(CVector));
1120 *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition;
1121 // Set Uvs.
1122 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff0, sizeof(CUV));
1123 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff0)= uv;
1124 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1, sizeof(CUV));
1125 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM;
1126 // Set default color.
1127 static CRGBA col(255,255,255,255);
1128 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.ColorOff, sizeof(CRGBA));
1129 *(CRGBA*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.ColorOff)= col;
1130 }
1131 else
1132 {
1133 // Else must setup Vertex program inputs
1134 // v[0]== StartPos.
1135 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr, sizeof(CVector));
1136 *(CVector*)CurVBPtr= pVert->Src->StartPos;
1137 // v[8]== Tex0
1138 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff0, sizeof(CUV));
1139 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff0)= uv;
1140 // v[9]== Tex1
1141 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1, sizeof(CUV));
1142 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM;
1143
1144 // v[10]== GeomInfo.
1145 static CUV geomInfo;
1146 geomInfo.U= pVert->Src->MaxFaceSize * CLandscapeGlobals::OORefineThreshold;
1147 geomInfo.V= pVert->Src->MaxNearLimit;
1148 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.GeomInfoOff, sizeof(CUV));
1149 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.GeomInfoOff)= geomInfo;
1150
1151 // v[11]== EndPos - StartPos
1152 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.DeltaPosOff, sizeof(CVector))
1153 *(CVector*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.DeltaPosOff)=
1154 pVert->Src->EndPos - pVert->Src->StartPos;
1155
1156 // v[12]== Alpha information
1157 // Hopefully, fillVBFar1Only() is called each Time the Far1 change, in preRender().
1158 // So TransitionSqrMin and OOTransitionSqrDelta in CPath are valid.
1159 geomInfo.U= TransitionSqrMin;
1160 geomInfo.V= OOTransitionSqrDelta;
1161 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.AlphaInfoOff, sizeof(CUV))
1162 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.AlphaInfoOff)= geomInfo;
1163
1164 }
1165 }
1166 // ***************************************************************************
1167 // NB: need to be inlined only for fillTileVB() in this file.
1168 inline void CPatch::fillTileVertexVB(CTessNearVertex *pVert)
1169 {
1170 // The Buffers must have been locked
1171 nlassert(CLandscapeGlobals::CurrentTileVBAllocator);
1172 nlassert(CLandscapeGlobals::CurrentTileVBAllocator->bufferLocked());
1173 // VBInfo must be OK.
1174 nlassert(!CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs());
1175
1176 static uint8 *CurVBPtr;
1177 // Compute/build the new vertex.
1178 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentTileVBInfo.VertexCoordPointer;
1179 CurVBPtr+= pVert->Index * CLandscapeGlobals::CurrentTileVBInfo.VertexSize;
1180
1181
1182 // NB: the filling order of data is important, for AGP write combiners.
1183
1184 // If not VertexProgram (NB: Suppose BTB kill this test).
1185 if( !CLandscapeGlobals::VertexProgramEnabled )
1186 {
1187 // Set Pos. Set it local to the current center of landscape
1188 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr, sizeof(CVector))
1189 *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition;
1190 // Set Uvs.
1191 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff0, sizeof(CUV))
1192 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff0)= pVert->PUv0;
1193 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff1, sizeof(CUV))
1194 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff1)= pVert->PUv1;
1195 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff2, sizeof(CUV))
1196 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff2)= pVert->PUv2;
1197 }
1198 else
1199 {
1200 // Else must setup Vertex program inputs
1201 // v[0]== StartPos.
1202 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr, sizeof(CVector))
1203 *(CVector*)CurVBPtr= pVert->Src->StartPos;
1204 // v[8]== Tex0
1205 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff0, sizeof(CUV))
1206 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff0)= pVert->PUv0;
1207 // v[9]== Tex1
1208 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff1, sizeof(CUV))
1209 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff1)= pVert->PUv1;
1210 // v[12]== Tex2
1211 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff2, sizeof(CUV))
1212 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff2)= pVert->PUv2;
1213
1214 // v[10]== GeomInfo.
1215 static CUV geomInfo;
1216 geomInfo.U= pVert->Src->MaxFaceSize * CLandscapeGlobals::OORefineThreshold;
1217 geomInfo.V= pVert->Src->MaxNearLimit;
1218 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.GeomInfoOff, sizeof(CUV))
1219 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.GeomInfoOff)= geomInfo;
1220
1221 // v[11]== EndPos - StartPos
1222 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.DeltaPosOff, sizeof(CVector))
1223 *(CVector*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.DeltaPosOff)=
1224 pVert->Src->EndPos - pVert->Src->StartPos;
1225 }
1226 }
1227
1228
1229 // ***************************************************************************
1230 void CPatch::fillFar0VertexListVB(CTessList<CTessFarVertex> &vertList)
1231 {
1232 // Traverse the vertList.
1233 CTessFarVertex *pVert;
1234 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1235 {
1236 fillFar0VertexVB(pVert);
1237 }
1238 }
1239
1240
1241 // ***************************************************************************
1242 void CPatch::fillFar1VertexListVB(CTessList<CTessFarVertex> &vertList)
1243 {
1244 // Traverse the vertList.
1245 CTessFarVertex *pVert;
1246 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1247 {
1248 fillFar1VertexVB(pVert);
1249 }
1250 }
1251
1252
1253 // ***************************************************************************
1254 void CPatch::fillTileVertexListVB(CTessList<CTessNearVertex> &vertList)
1255 {
1256 // Traverse the vertList.
1257 CTessNearVertex *pVert;
1258 for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next)
1259 {
1260 fillTileVertexVB(pVert);
1261 }
1262 }
1263
1264
1265
1266 // ***************************************************************************
1267 void CPatch::fillVB()
1268 {
1269 // Fill Far0.
1270 //=======
1271 // fill only if no reallcoation occurs
1272 if(Far0>0 && !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() )
1273 {
1274 // Fill Far0 VB.
1275 fillFar0VertexListVB(MasterBlock.FarVertexList);
1276 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1277 {
1278 CTessBlock &tblock= TessBlocks[i];
1279 // fill only if tblock visible.
1280 if( tblock.visibleFar0() )
1281 fillFar0VertexListVB(tblock.FarVertexList);
1282 }
1283 }
1284 else if(Far0==0 && !CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs() )
1285 {
1286 // Fill Tile VB.
1287 // No Tiles in MasterBlock!!
1288 // Traverse the TessBlocks to add vertices.
1289 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1290 {
1291 CTessBlock &tblock= TessBlocks[i];
1292 // fill only if tblock visible.
1293 if( tblock.visibleTile() )
1294 fillTileVertexListVB(tblock.NearVertexList);
1295 }
1296 }
1297
1298 // Fill Far1.
1299 //=======
1300 if(Far1>0 && !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() )
1301 {
1302 // Fill VB.
1303 fillFar1VertexListVB(MasterBlock.FarVertexList);
1304 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1305 {
1306 CTessBlock &tblock= TessBlocks[i];
1307 // fill only if tblock visible.
1308 if( tblock.visibleFar1() )
1309 fillFar1VertexListVB(tblock.FarVertexList);
1310 }
1311 }
1312
1313 }
1314
1315
1316 // ***************************************************************************
1317 void CPatch::fillVBIfVisible()
1318 {
1319 if(isRenderClipped()==false)
1320 fillVB();
1321 }
1322
1323
1324 // ***************************************************************************
1325 void CPatch::fillVBFar0Only()
1326 {
1327 if(Far0>0 && !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() )
1328 {
1329 // Fill Far0 VB.
1330 fillFar0VertexListVB(MasterBlock.FarVertexList);
1331 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1332 {
1333 CTessBlock &tblock= TessBlocks[i];
1334 // fill only if tblock visible.
1335 if( tblock.visibleFar0() )
1336 fillFar0VertexListVB(tblock.FarVertexList);
1337 }
1338 }
1339 }
1340
1341
1342 // ***************************************************************************
1343 void CPatch::fillVBFar1Only()
1344 {
1345 if(Far1>0 && !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() )
1346 {
1347 // Fill VB.
1348 fillFar1VertexListVB(MasterBlock.FarVertexList);
1349 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1350 {
1351 CTessBlock &tblock= TessBlocks[i];
1352 // fill only if tblock visible.
1353 if( tblock.visibleFar1() )
1354 fillFar1VertexListVB(tblock.FarVertexList);
1355 }
1356 }
1357 }
1358
1359 // ***************************************************************************
1360 // ***************************************************************************
1361 // VB Software Geomorph / Alpha.
1362 // ***************************************************************************
1363 // ***************************************************************************
1364
1365
1366 // ***************************************************************************
1367 void CPatch::computeGeomorphVertexList(CTessList<CTessFarVertex> &vertList)
1368 {
1369 // Traverse the vertList.
1370 CTessFarVertex *pVert;
1371 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1372 {
1373 // compute geomorph.
1374 pVert->Src->computeGeomPos();
1375 }
1376 }
1377
1378
1379 // ***************************************************************************
1380 void CPatch::computeGeomorphFar0VertexListVB(CTessList<CTessFarVertex> &vertList)
1381 {
1382 // Traverse the vertList.
1383 CTessFarVertex *pVert;
1384 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1385 {
1386 static uint8 *CurVBPtr;
1387 // Compute/build the new vertex.
1388 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer;
1389 CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize;
1390
1391 // Set Geomorphed Position. Set it local to the current center of landscape
1392 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr, sizeof(CVector))
1393 *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition;
1394 }
1395 }
1396
1397
1398 // ***************************************************************************
1399 void CPatch::computeGeomorphAlphaFar1VertexListVB(CTessList<CTessFarVertex> &vertList)
1400 {
1401 // Traverse the vertList.
1402 CTessFarVertex *pVert;
1403 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1404 {
1405 static uint8 *CurVBPtr;
1406 // Compute/build the new vertex.
1407 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer;
1408 CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize;
1409
1410 // NB: the filling order of data is important, for AGP write combiners.
1411
1412 // Set Geomorphed Position. Set it local to the current center of landscape
1413 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr, sizeof(CVector))
1414 *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition;
1415
1416 // Set Alpha color.
1417 static CRGBA col(255,255,255,255);
1418 // For Far1, use alpha fro transition.
1419 // Prefer Use Pos, because of caching. So little difference between Soft and VertexProgram mode.
1420 float f= (pVert->Src->Pos - CLandscapeGlobals::RefineCenter).sqrnorm();
1421 f= (f-TransitionSqrMin) * OOTransitionSqrDelta;
1422 clamp(f,0,1);
1423 col.A= (uint8)(f*255);
1424 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.ColorOff, sizeof(CRGBA))
1425 *(CRGBA*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.ColorOff)= col;
1426 }
1427 }
1428
1429
1430 // ***************************************************************************
1431 void CPatch::computeGeomorphTileVertexListVB(CTessList<CTessNearVertex> &vertList)
1432 {
1433 // Traverse the vertList.
1434 CTessNearVertex *pVert;
1435 for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next)
1436 {
1437 static uint8 *CurVBPtr;
1438 // Compute/build the new vertex.
1439 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentTileVBInfo.VertexCoordPointer;
1440 CurVBPtr+= pVert->Index * CLandscapeGlobals::CurrentTileVBInfo.VertexSize;
1441
1442 // Set Geomorphed Position. Set it local to the current center of landscape
1443 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentTileVBInfo.Accessor, CurVBPtr, sizeof(CVector))
1444 *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition;
1445 }
1446 }
1447
1448
1449
1450 // ***************************************************************************
1451 void CPatch::computeSoftwareGeomorphAndAlpha()
1452 {
1453 if(isRenderClipped())
1454 return;
1455
1456 // Compute Geomorph.
1457 //=======
1458 // Need only to fill CTessVertex, so do it only for FarVertices
1459 // Hence Geomorph is done twice on edges of patches!!.
1460 // If not too near for precise, fast compute of geomorph.
1461 if( TessBlocks.empty() )
1462 {
1463 // Just update all vertices of master block.
1464 computeGeomorphVertexList(MasterBlock.FarVertexList);
1465 }
1466 else
1467 {
1468 // update all vertices of master block.
1469 computeGeomorphVertexList(MasterBlock.FarVertexList);
1470 // update vertices of others block.
1471 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1472 {
1473 CTessBlock &tblock= TessBlocks[i];
1474 // Precise Clip.
1475 if(!tblock.getClipped())
1476 {
1477 // compute the geomorph of the vertices in the tessblock.
1478 computeGeomorphVertexList(tblock.FarVertexList);
1479 }
1480 }
1481 }
1482
1483
1484 // Fill Far0.
1485 //=======
1486 if(Far0>0)
1487 {
1488 // Fill Far0 VB.
1489 computeGeomorphFar0VertexListVB(MasterBlock.FarVertexList);
1490 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1491 {
1492 CTessBlock &tblock= TessBlocks[i];
1493 // Precise Clip.
1494 if( tblock.visibleFar0() )
1495 computeGeomorphFar0VertexListVB(tblock.FarVertexList);
1496 }
1497 }
1498 else if(Far0==0)
1499 {
1500 // Fill Tile VB.
1501 // No Tiles in MasterBlock!!
1502 // Traverse the TessBlocks to compute vertices.
1503 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1504 {
1505 CTessBlock &tblock= TessBlocks[i];
1506 // Precise Clip.
1507 if( tblock.visibleTile() )
1508 computeGeomorphTileVertexListVB(tblock.NearVertexList);
1509 }
1510 }
1511
1512 // Fill Far1.
1513 //=======
1514 if(Far1>0)
1515 {
1516 // Fill VB.
1517 computeGeomorphAlphaFar1VertexListVB(MasterBlock.FarVertexList);
1518 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1519 {
1520 CTessBlock &tblock= TessBlocks[i];
1521 // Precise Clip.
1522 if( tblock.visibleFar1() )
1523 computeGeomorphAlphaFar1VertexListVB(tblock.FarVertexList);
1524 }
1525 }
1526 }
1527
1528
1529 // ***************************************************************************
1530 // ***************************************************************************
1531 // VB clip Allocate/Filling.
1532 // ***************************************************************************
1533 // ***************************************************************************
1534
1535
1536 // ***************************************************************************
1537 void CPatch::updateClipPatchVB(bool renderClipped)
1538 {
1539 // If now the patch is invisible
1540 if(renderClipped)
1541 {
1542 // Then delete vertices.
1543 deleteVBAndFaceVector();
1544
1545 // Now, all vertices in VB are deleted.
1546 // Force clip state of all TessBlocks, so no allocation will be done on Vertices in VB.
1547 if(!TessBlocks.empty())
1548 {
1549 for(uint i=0; i<TessBlocks.size();i++)
1550 {
1551 CTessBlock &tblock= TessBlocks[i];
1552 tblock.forceClip();
1553 }
1554 }
1555 }
1556 else
1557 {
1558 // else allocate / fill them.
1559 allocateVBAndFaceVector();
1560 // NB: fillVB() test if any reallocation occurs.
1561 fillVB();
1562 }
1563 }
1564
1565
1566 // ***************************************************************************
1567 // ***************************************************************************
1568 // VB refine Allocate/Filling.
1569 // ***************************************************************************
1570 // ***************************************************************************
1571
1572
1573
1574 // ***************************************************************************
1575 void CPatch::checkCreateVertexVBFar(CTessFarVertex *pVert)
1576 {
1577 nlassert(pVert);
1578 // If visible, and Far0 in !Tile Mode, allocate.
1579 // NB: must test Far0>0 because vertices are reallocated in preRender() if a change of Far occurs.
1580 if(!isRenderClipped() && Far0>0 && pVert->OwnerBlock->visibleFar0() )
1581 {
1582 pVert->Index0= CLandscapeGlobals::CurrentFar0VBAllocator->allocateVertex();
1583 }
1584
1585 // Idem for Far1
1586 if(!isRenderClipped() && Far1>0 && pVert->OwnerBlock->visibleFar1())
1587 {
1588 pVert->Index1= CLandscapeGlobals::CurrentFar1VBAllocator->allocateVertex();
1589 }
1590
1591 }
1592
1593
1594 // ***************************************************************************
1595 void CPatch::checkFillVertexVBFar(CTessFarVertex *pVert)
1596 {
1597 nlassert(pVert);
1598 // If visible, and Far0 in !Tile Mode, try to fill.
1599 // NB: must test Far0>0 because vertices are reallocated in preRender() if a change of Far occurs.
1600 if(!isRenderClipped() && Far0>0 && pVert->OwnerBlock->visibleFar0())
1601 {
1602 if( !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() )
1603 fillFar0VertexVB(pVert);
1604 }
1605
1606 // Idem for Far1
1607 if(!isRenderClipped() && Far1>0 && pVert->OwnerBlock->visibleFar1())
1608 {
1609 if( !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() )
1610 fillFar1VertexVB(pVert);
1611 }
1612 }
1613
1614
1615 // ***************************************************************************
1616 void CPatch::checkCreateVertexVBNear(CTessNearVertex *pVert)
1617 {
1618 nlassert(pVert);
1619 // If visible, and Far0 in Tile Mode, allocate.
1620 // NB: must test Far0==0 because vertices are reallocated in preRender() if a change of Far occurs.
1621 if(!isRenderClipped() && Far0==0 && pVert->OwnerBlock->visibleTile())
1622 {
1623 pVert->Index= CLandscapeGlobals::CurrentTileVBAllocator->allocateVertex();
1624 }
1625 }
1626
1627
1628 // ***************************************************************************
1629 void CPatch::checkFillVertexVBNear(CTessNearVertex *pVert)
1630 {
1631 nlassert(pVert);
1632 // If visible, and Far0 in Tile Mode, try to fill.
1633 // NB: must test Far0==0 because vertices are reallocated in preRender() if a change of Far occurs.
1634 if(!isRenderClipped()&& Far0==0 && pVert->OwnerBlock->visibleTile() )
1635 {
1636 // try to fill.
1637 if( !CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs() )
1638 fillTileVertexVB(pVert);
1639 }
1640 }
1641
1642
1643 // ***************************************************************************
1644 void CPatch::checkDeleteVertexVBFar(CTessFarVertex *pVert)
1645 {
1646 nlassert(pVert);
1647 // If visible, and Far0 in !Tile Mode, ok, the vertex exist in VB, so delete.
1648 // NB: must test Far0>0 because vertices are deleted in preRender() if a change of Far occurs.
1649 if(!isRenderClipped() && Far0>0 && pVert->OwnerBlock->visibleFar0() )
1650 {
1651 CLandscapeGlobals::CurrentFar0VBAllocator->deleteVertex(pVert->Index0);
1652 }
1653
1654 // Idem for Far1
1655 if(!isRenderClipped() && Far1>0 && pVert->OwnerBlock->visibleFar1() )
1656 {
1657 CLandscapeGlobals::CurrentFar1VBAllocator->deleteVertex(pVert->Index1);
1658 }
1659 }
1660
1661 // ***************************************************************************
1662 void CPatch::checkDeleteVertexVBNear(CTessNearVertex *pVert)
1663 {
1664 nlassert(pVert);
1665 // If visible, and Far0 in Tile Mode, ok, the vertex exist in VB, so delete.
1666 // NB: must test Far0==0 because vertices are deleted in preRender() if a change of Far occurs.
1667 if(!isRenderClipped() && Far0==0 && pVert->OwnerBlock->visibleTile() )
1668 {
1669 CLandscapeGlobals::CurrentTileVBAllocator->deleteVertex(pVert->Index);
1670 }
1671 }
1672
1673
1674 // ***************************************************************************
1675 // ***************************************************************************
1676 // VB DLM Filling
1677 // ***************************************************************************
1678 // ***************************************************************************
1679
1680
1681 // ***************************************************************************
1682 void CPatch::fillFar0DLMUvOnlyVertexListVB(CTessList<CTessFarVertex> &vertList)
1683 {
1684 // The Buffers must have been locked
1685 nlassert(CLandscapeGlobals::CurrentFar0VBAllocator);
1686 nlassert(CLandscapeGlobals::CurrentFar0VBAllocator->bufferLocked());
1687 // VBInfo must be OK.
1688 nlassert(!CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs());
1689
1690 static uint8 *CurVBPtr;
1691 static CUV uvDLM;
1692
1693 // If the DLMContext exist
1694 if(_DLMContext)
1695 {
1696 // Traverse the vertList, to compute new uvDLM
1697 CTessFarVertex *pVert;
1698 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1699 {
1700 // Compute/build the new vertex.
1701 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer;
1702 CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize;
1703
1704 // compute Uvs.
1705 CParamCoord pc= pVert->PCoord;
1706
1707 // compute Dynamic lightmap Uv with DLM context info.
1708 uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias;
1709 uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias;
1710
1711 // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change).
1712 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1, sizeof(CUV))
1713 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM;
1714 }
1715 }
1716 // else, reset all Uvs
1717 else
1718 {
1719 // just set UV so the vertex point to a black pixel (see CTextureDLM).
1720 uvDLM.U= 1;
1721 uvDLM.V= 1;
1722
1723 // Traverse the vertList, to reset uv
1724 CTessFarVertex *pVert;
1725 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1726 {
1727 // Compute/build the new vertex.
1728 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer;
1729 CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize;
1730
1731 // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change).
1732 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar0VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1, sizeof(CUV))
1733 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM;
1734 }
1735 }
1736 }
1737
1738 // ***************************************************************************
1739 void CPatch::fillFar1DLMUvOnlyVertexListVB(CTessList<CTessFarVertex> &vertList)
1740 {
1741 // The Buffers must have been locked
1742 nlassert(CLandscapeGlobals::CurrentFar1VBAllocator);
1743 nlassert(CLandscapeGlobals::CurrentFar1VBAllocator->bufferLocked());
1744 // VBInfo must be OK.
1745 nlassert(!CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs());
1746
1747 static uint8 *CurVBPtr;
1748 static CUV uvDLM;
1749
1750 // If the DLMContext exist
1751 if(_DLMContext)
1752 {
1753 // Traverse the vertList, to compute new uvDLM
1754 CTessFarVertex *pVert;
1755 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1756 {
1757 // Compute/build the new vertex.
1758 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer;
1759 CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize;
1760
1761 // compute Uvs.
1762 CParamCoord pc= pVert->PCoord;
1763
1764 // compute Dynamic lightmap Uv with DLM context info.
1765 uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias;
1766 uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias;
1767
1768 // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change).
1769 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1, sizeof(CUV))
1770 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM;
1771 }
1772 }
1773 // else, reset all Uvs
1774 else
1775 {
1776 // just set UV so the vertex point to a black pixel (see CTextureDLM).
1777 uvDLM.U= 1;
1778 uvDLM.V= 1;
1779
1780 // Traverse the vertList, to reset uv
1781 CTessFarVertex *pVert;
1782 for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next)
1783 {
1784 // Compute/build the new vertex.
1785 CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer;
1786 CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize;
1787
1788 // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change).
1789 CHECK_VBA_RANGE(CLandscapeGlobals::CurrentFar1VBInfo.Accessor, CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1, sizeof(CUV))
1790 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM;
1791 }
1792 }
1793 }
1794
1795
1796 // ***************************************************************************
1797 void CPatch::fillVBFarsDLMUvOnly()
1798 {
1799 // Do it for Far0.
1800 if(Far0>0 && !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() )
1801 {
1802 // Fill Far0 VB.
1803 fillFar0DLMUvOnlyVertexListVB(MasterBlock.FarVertexList);
1804 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1805 {
1806 CTessBlock &tblock= TessBlocks[i];
1807 // fill only if tblock visible.
1808 if( tblock.visibleFar0() )
1809 fillFar0DLMUvOnlyVertexListVB(tblock.FarVertexList);
1810 }
1811 }
1812
1813 // Do it for Far1.
1814 if(Far1>0 && !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() )
1815 {
1816 // Fill VB.
1817 fillFar1DLMUvOnlyVertexListVB(MasterBlock.FarVertexList);
1818 for(sint i=0; i<(sint)TessBlocks.size(); i++)
1819 {
1820 CTessBlock &tblock= TessBlocks[i];
1821 // fill only if tblock visible.
1822 if( tblock.visibleFar1() )
1823 fillFar1DLMUvOnlyVertexListVB(tblock.FarVertexList);
1824 }
1825 }
1826 }
1827
1828
1829
1830 } // NL3D