00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 #include <cstdlib>
00044 #include <cstdio>
00045
00046 #include <OSGConfig.h>
00047
00048 #include "OSGTiledQuadTreeTerrain.h"
00049 #include "OSGQuadTreeTerrain.h"
00050 #include "OSGRenderAction.h"
00051 #include "OSGImage.h"
00052 #include "OSGChunkMaterial.h"
00053
00054 OSG_USING_NAMESPACE
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069 void TiledQuadTreeTerrain::initMethod(InitPhase ePhase)
00070 {
00071 Inherited::initMethod(ePhase);
00072
00073 if(ePhase == TypeObject::SystemPost)
00074 {
00075 RenderAction::registerEnterDefault(
00076 getClassType(),
00077 reinterpret_cast<Action::Callback>(
00078 &TiledQuadTreeTerrain::renderEnter));
00079 }
00080 }
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092 TiledQuadTreeTerrain::TiledQuadTreeTerrain(void) :
00093 Inherited()
00094 {
00095 }
00096
00097 TiledQuadTreeTerrain::TiledQuadTreeTerrain(
00098 const TiledQuadTreeTerrain &source) :
00099
00100 Inherited(source)
00101 {
00102 }
00103
00104 TiledQuadTreeTerrain::~TiledQuadTreeTerrain(void)
00105 {
00106 }
00107
00108
00109
00110 inline MaterialPtr cloneMaterial(const MaterialPtr &mat)
00111 {
00112 #if 0
00113
00114 for(MFStateChunkPtr::const_iterator it = m->getChunks().begin();
00115 it != m->getChunks().end();
00116 ++it)
00117 {
00118 clone->addChunk(*it);
00119 }
00120 #endif
00121
00122 ChunkMaterialPtr m = dynamic_cast<ChunkMaterialPtr>(mat);
00123 ChunkMaterialPtr clone = NULL;
00124
00125 if(m != NULL)
00126 {
00127 clone = dynamic_cast<ChunkMaterialPtr>(m->shallowCopy());
00128 }
00129
00130 return clone;
00131 }
00132
00133
00134 void TiledQuadTreeTerrain::changed(ConstFieldMaskArg whichField,
00135 UInt32 origin,
00136 BitVector details)
00137 {
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148 if((whichField & HeightTilesFieldMask) && getMFHeightTiles()->size() > 0)
00149 {
00150 if(getParents()[0] != NullFC)
00151 {
00152 NodePtr pParent = dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00153
00154 while(pParent->getNChildren() > 0)
00155 {
00156 pParent->subChild(0u);
00157 }
00158
00159 Real32 step =
00160 (getHeightTiles(0)->getWidth()-1)*getVertexSpacing();
00161
00162 Real32 tstepx = 1.0f/getSizeX();
00163 Real32 tstepy = 1.0f/getSizeY();
00164
00165 UInt32 i, j;
00166
00167 const UInt32 roi = getSizeROI()+getSizeROI()+1;
00168
00169
00170 for(j=0; j<roi; ++j)
00171 {
00172 for(i=0; i<roi; ++i)
00173 {
00174 QuadTreeTerrainPtr terrain = QuadTreeTerrain::create();
00175
00176 terrain->setVertexSpacing(getVertexSpacing());
00177 terrain->setHeightScale (getHeightScale());
00178 terrain->setGeoMorphing (getGeoMorphing());
00179 terrain->setDetail (getDetail());
00180 terrain->setBorderDetail (1);
00181 terrain->setEyePointValid(true);
00182 terrain->setUpdateTerrain(getUpdateTerrain());
00183 terrain->setPerPixelLighting(getPerPixelLighting());
00184
00185 NodePtr node = Node::create();
00186
00187 addRef(node);
00188
00189 node->setCore(terrain);
00190
00191
00192
00193 if (i < getSizeX() && j < getSizeY())
00194 {
00195 terrain->setHeightData(getHeightTiles(j*getSizeX()+i));
00196 terrain->setOriginX(i*step);
00197 terrain->setOriginY(j*step);
00198 node->setTravMask(TypeTraits<UInt32>::BitsSet);
00199 }
00200 else
00201 {
00202 node->setTravMask(0);
00203 }
00204
00205 pParent->addChild(node);
00206 }
00207 }
00208 }
00209 setCurrentX(getSizeROI());
00210 setCurrentY(getSizeROI());
00211 }
00212
00213 if(((whichField & MaterialFieldMask) ||
00214 (whichField & PerPixelLightingFieldMask)))
00215 {
00216 Real32 tstepx = 1.0f/getSizeX();
00217 Real32 tstepy = 1.0f/getSizeY();
00218 UInt32 i, j;
00219 const UInt32 roi = getSizeROI()+getSizeROI()+1;
00220 for(j=0; j<roi; ++j)
00221 {
00222 for(i=0; i<roi; ++i)
00223 {
00224 NodePtr pParent = dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00225
00226 NodePtr node = pParent->getChild(j*roi+i);
00227
00228 QuadTreeTerrainPtr terrain =
00229 dynamic_cast<QuadTreeTerrainPtr>(node->getCore());
00230
00231 if (terrain == NullFC)
00232 {
00233 continue;
00234 }
00235
00236 if(getMaterial() == NullFC)
00237 {
00238 if(getHeightTextures().size() > j*getSizeX()+i &&
00239 i < getSizeX() && j < getSizeY())
00240 {
00241 terrain->setMaterial(
00242 getHeightTextures(j*getSizeX()+i));
00243 }
00244 }
00245 else
00246 {
00247 MaterialPtr mat = cloneMaterial(getMaterial());
00248 terrain->setMaterial(mat);
00249 terrain->setOriginTexX(i*tstepx);
00250 terrain->setOriginTexY(j*tstepy);
00251 terrain->setTexSpacing (tstepx);
00252 terrain->setTexYSpacing(tstepy);
00253 }
00254
00255 terrain->setPerPixelLighting(getPerPixelLighting());
00256 }
00257 }
00258 }
00259
00260 if((whichField & GeoMorphingFieldMask))
00261 {
00262 const UInt32 roi = getSizeROI()+getSizeROI()+1;
00263 const UInt32 roi2 = roi*roi;
00264
00265 for(UInt32 i=0; i<roi2; ++i)
00266 {
00267 NodePtr pParent = dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00268
00269 NodePtr node = pParent->getChild(i);
00270
00271 QuadTreeTerrainPtr terrain =
00272 dynamic_cast<QuadTreeTerrainPtr>(node->getCore());
00273
00274 if(terrain == NullFC)
00275 {
00276 continue;
00277 }
00278
00279 terrain->setGeoMorphing(getGeoMorphing());
00280 }
00281 }
00282
00283 if((whichField & DetailFieldMask))
00284 {
00285 const UInt32 roi = getSizeROI()+getSizeROI()+1;
00286 const UInt32 roi2 = roi*roi;
00287
00288 for (UInt32 i=0; i<roi2; ++i)
00289 {
00290 NodePtr pParent = dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00291
00292 NodePtr node = pParent->getChild(i);
00293
00294 QuadTreeTerrainPtr terrain =
00295 dynamic_cast<QuadTreeTerrainPtr>(node->getCore());
00296
00297 if(terrain == NullFC)
00298 {
00299 continue;
00300 }
00301
00302 terrain->setDetail(getDetail());
00303 }
00304 }
00305 Inherited::changed(whichField, origin, details);
00306 }
00307
00308 inline void reorderChilds (const NodePtr& parent, NodePtr order[], Int32 num)
00309 {
00310 Int32 num2 = num*num;
00311
00312 for(Int32 i=0; i<num2; ++i)
00313 {
00314 parent->addChild(order[i]);
00315 }
00316 }
00317 inline void subAllChilds (const NodePtr& parent, NodePtr order[], Int32 num)
00318 {
00319
00320 while (parent->getNChildren() > 0)
00321 {
00322 parent->subChild(0u);
00323 }
00324 }
00325
00326 inline void caseChilds_n1n1(const NodePtr& parent, NodePtr order[], Int32 num)
00327 {
00328 Int32 num2 = num*num-num;
00329 Int32 i, j, k;
00330
00331 for (i=0, k=0; i<num; ++i, ++k)
00332 {
00333 order[k] = parent->getChild(num2+i);
00334 }
00335 for(i=0; i<num-1; ++i)
00336 {
00337 order[k] = parent->getChild(i*num+num-1);
00338
00339 for(j=0, ++k; j<num-1; ++j, ++k)
00340 {
00341 order[k] = parent->getChild(i*num+j);
00342 }
00343 }
00344 subAllChilds(parent, order, num);
00345 }
00346
00347 inline void caseChilds_n10 (const NodePtr& parent, NodePtr order[], Int32 num)
00348 {
00349 Int32 num2 = num*num-num;
00350 Int32 i, j, k;
00351
00352 for(i=0, k=0; i<num; ++i)
00353 {
00354 order[k] = parent->getChild(i*num+num-1);
00355
00356 for(j=0, ++k; j<num-1; ++j, ++k)
00357 {
00358 order[k] = parent->getChild(i*num+j);
00359 }
00360 }
00361 subAllChilds(parent, order, num);
00362 }
00363
00364 inline void caseChilds_n1p1 (const NodePtr& parent, NodePtr order[], Int32 num)
00365 {
00366 Int32 num2 = num*num-num;
00367 Int32 i, j, k;
00368
00369 for(i=1, k=0; i<num; ++i)
00370 {
00371 order[k] = parent->getChild(i*num+num-1);
00372
00373 for(j=0, ++k; j<num-1; ++j, ++k)
00374 {
00375 order[k] = parent->getChild(i*num+j);
00376 }
00377 }
00378
00379 for(i=0; i<num; ++i, ++k)
00380 {
00381 order[k] = parent->getChild(i);
00382 }
00383 subAllChilds(parent, order, num);
00384 }
00385
00386 inline void caseChilds_0n1 (const NodePtr& parent, NodePtr order[], Int32 num)
00387 {
00388 Int32 num2 = num*num-num;
00389 Int32 i, j, k;
00390
00391 for(i=0, k=0; i<num; ++i, ++k)
00392 {
00393 order[k] = parent->getChild(num2+i);
00394 }
00395
00396 for(i=0; i<num-1; ++i)
00397 {
00398 for(j=0; j<num; ++j, ++k)
00399 {
00400 order[k] = parent->getChild(i*num+j);
00401 }
00402 }
00403 subAllChilds(parent, order, num);
00404 }
00405
00406 inline void caseChilds_0p1 (const NodePtr& parent, NodePtr order[], Int32 num)
00407 {
00408 Int32 num2 = num*num-num;
00409 Int32 i, j, k;
00410
00411 for(i=1, k=0; i<num; ++i)
00412 {
00413 for(j=0; j<num; ++j, ++k)
00414 {
00415 order[k] = parent->getChild(i*num+j);
00416 }
00417 }
00418
00419 for(i=0; i<num; ++i, ++k)
00420 {
00421 order[k] = parent->getChild(i);
00422 }
00423
00424 subAllChilds(parent, order, num);
00425 }
00426
00427 inline void caseChilds_p1n1 (const NodePtr& parent, NodePtr order[], Int32 num)
00428 {
00429 Int32 num2 = num*num-num;
00430 Int32 i, j, k;
00431
00432 for(i=0, k=0; i<num; ++i, ++k)
00433 {
00434 order[k] = parent->getChild(num2+i);
00435 }
00436
00437 for(i=0; i<num-1; ++i, ++k)
00438 {
00439 for(j=1; j<num; ++j, ++k)
00440 {
00441 order[k] = parent->getChild(i*num+j);
00442 }
00443 order[k] = parent->getChild(i*num);
00444 }
00445 subAllChilds(parent, order, num);
00446 }
00447 inline void caseChilds_p10 (const NodePtr& parent, NodePtr order[], Int32 num)
00448 {
00449 Int32 num2 = num*num-num;
00450 Int32 i, j, k;
00451
00452 for(i=0, k=0; i<num; ++i, ++k)
00453 {
00454 for(j=1; j<num; ++j, ++k)
00455 {
00456 order[k] = parent->getChild(i*num+j);
00457 }
00458 order[k] = parent->getChild(i*num);
00459 }
00460 subAllChilds(parent, order, num);
00461 }
00462 inline void caseChilds_p1p1 (const NodePtr& parent, NodePtr order[], Int32 num)
00463 {
00464 Int32 num2 = num*num-num;
00465 Int32 i, j, k;
00466
00467 for(i=1, k=0; i<num; ++i, ++k)
00468 {
00469 for(j=1; j<num; ++j, ++k)
00470 {
00471 order[k] = parent->getChild(i*num+j);
00472 }
00473 order[k] = parent->getChild(i*num);
00474 }
00475
00476 for(i=0; i<num; ++i, ++k)
00477 {
00478 order[k] = parent->getChild(i);
00479 }
00480 subAllChilds(parent, order, num);
00481 }
00482
00483 Action::ResultE TiledQuadTreeTerrain::renderEnter (Action* action)
00484 {
00485 NodePtr node;
00486 QuadTreeTerrainPtr core;
00487
00488 RenderAction* da = dynamic_cast<RenderAction*>(action);
00489
00490 if(da != NULL && getUpdate() && getSizeX() > 0 && getSizeY() > 0)
00491 {
00492 const FrustumVolume& frustum = da->getFrustum();
00493
00494 Matrix camera = da->getCameraToWorld();
00495 Matrix toworld = da->top_matrix();
00496
00497 toworld.invert();
00498 camera.multLeft(toworld);
00499
00500
00501 Real32 step = (getHeightTiles(0)->getWidth()-1)*getVertexSpacing();
00502 Real32 tstepx = 1.0f/getSizeX();
00503 Real32 tstepy = 1.0f/getSizeY();
00504
00505
00506 Pnt3f eyePoint(camera[3][0], camera[3][1], camera[3][2]);
00507
00508
00509 const Int32 roi = getSizeROI()+getSizeROI()+1;
00510 const Int32 roi2 = roi*roi;
00511
00512 for(UInt32 i=0; i<roi2; ++i)
00513 {
00514 NodePtr pParent = dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00515 node = pParent->getChild(i);
00516
00517 core = dynamic_cast<QuadTreeTerrainPtr>(node->getCore());
00518
00519 core->setEyePoint(eyePoint);
00520 core->setUpdateTerrain(getUpdateTerrain());
00521 }
00522
00523
00524 Int32 x = Int32((eyePoint[0])/step);
00525 Int32 y = Int32((eyePoint[2])/step);
00526
00527 x = osgMax(x, 0);
00528 x = osgMin(x, Int32(getSizeX()-1));
00529 y = osgMax(y, 0);
00530 y = osgMin(y, Int32(getSizeY()-1));
00531
00532
00533 if(x != getCurrentX() || y != getCurrentY())
00534 {
00535 if(x < getCurrentX()-1)
00536 {
00537 x = getCurrentX()-1;
00538 }
00539 else if(x > getCurrentX()+1)
00540 {
00541 x = getCurrentX()+1;
00542 }
00543
00544 if(y < getCurrentY()-1)
00545 {
00546 y = getCurrentY()-1;
00547 }
00548 else if (y > getCurrentY()+1)
00549 {
00550 y = getCurrentY()+1;
00551 }
00552 SNOTICE << "current ("
00553 << getCurrentX() << ","
00554 << getCurrentY() << ")->("
00555 << x << ","
00556 << y << ")"
00557 << std::endl;
00558
00559 Int32 i, j;
00560
00561 NodePtr order[49];
00562
00563 assert(roi*roi <= 49);
00564
00565 switch (x - getCurrentX())
00566 {
00567 case -1:
00568 switch (y - getCurrentY())
00569 {
00570 case -1:
00571 {
00572 NodePtr pParent =
00573 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00574
00575 caseChilds_n1n1(pParent, order, roi);
00576
00577 for(i=-getSizeROI(); i<=getSizeROI(); ++i)
00578 {
00579 node = order[i+getSizeROI()];
00580 if(y-getSizeROI() >= 0 &&
00581 x+i >= 0 &&
00582 x+i < getSizeX())
00583 {
00584 node->setTravMask(
00585 TypeTraits<UInt32>::BitsSet);
00586 core =
00587 dynamic_cast<QuadTreeTerrainPtr>(
00588 node->getCore());
00589
00590 core->setHeightData(
00591 getHeightTiles((y-getSizeROI())*
00592 getSizeX() + x+i));
00593
00594 if(getMaterial() == NullFC)
00595 {
00596 core->setMaterial(
00597 getHeightTextures((y-getSizeROI())*
00598 getSizeX() + x+i));
00599 }
00600 else
00601 {
00602 core->setOriginTexX((x+i)*tstepx);
00603 core->setOriginTexY((y-getSizeROI())*
00604 tstepy);
00605 }
00606
00607 core->setOriginX((x+i)*step);
00608 core->setOriginY((y-getSizeROI())*step);
00609 }
00610 else
00611 {
00612 node->setTravMask(0);
00613 }
00614 }
00615
00616 for(i=-getSizeROI()+1; i<=getSizeROI(); ++i)
00617 {
00618 node = order[(i+getSizeROI())*roi];
00619
00620 if(x-getSizeROI() >= 0 &&
00621 y+i >= 0 &&
00622 y+i < getSizeY())
00623 {
00624 node->setTravMask(
00625 TypeTraits<UInt32>::BitsSet);
00626 core =
00627 dynamic_cast<QuadTreeTerrainPtr>(
00628 node->getCore());
00629
00630 core->setHeightData(
00631 getHeightTiles((y+i)*
00632 getSizeX() +
00633 (x-getSizeROI())));
00634
00635 if(getMaterial() == NullFC)
00636 {
00637 core->setMaterial(
00638 getHeightTextures((y+i)*
00639 getSizeX() +
00640 x-getSizeROI()));
00641 }
00642 else
00643 {
00644 core->setOriginTexX((x-getSizeROI())*
00645 tstepx);
00646
00647 core->setOriginTexY((y+i)*tstepy);
00648 }
00649
00650 core->setOriginX((x-getSizeROI())*step);
00651 core->setOriginY((y+i)*step);
00652 }
00653 else
00654 {
00655 node->setTravMask(0);
00656 }
00657 }
00658 reorderChilds(pParent, order, roi);
00659 break;
00660 }
00661 case 0:
00662 {
00663 NodePtr pParent =
00664 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00665
00666 caseChilds_n10(pParent, order, roi);
00667
00668 for(i=-getSizeROI(); i<=getSizeROI(); ++i)
00669 {
00670 node = order[(i+getSizeROI())*roi];
00671
00672 if(x-getSizeROI() >= 0 &&
00673 y+i >= 0 &&
00674 y+i < getSizeY())
00675 {
00676 node->setTravMask(
00677 TypeTraits<UInt32>::BitsSet);
00678 core =
00679 dynamic_cast<QuadTreeTerrainPtr>(
00680 node->getCore());
00681
00682 core->setHeightData(
00683 getHeightTiles((y+i)*
00684 getSizeX() +
00685 x-getSizeROI()));
00686
00687 if(getMaterial() == NullFC)
00688 {
00689 core->setMaterial(
00690 getHeightTextures((y+i)*
00691 getSizeX() +
00692 x-getSizeROI()));
00693 }
00694 else
00695 {
00696 core->setOriginTexX((x-getSizeROI())*
00697 tstepx);
00698 core->setOriginTexY((y+i)*tstepy);
00699 }
00700
00701 core->setOriginX((x-getSizeROI())*step);
00702 core->setOriginY((y+i)*step);
00703 }
00704 else
00705 {
00706 node->setTravMask(0);
00707 }
00708 }
00709 reorderChilds(pParent, order, roi);
00710 break;
00711 }
00712
00713 case 1:
00714 {
00715 NodePtr pParent =
00716 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00717
00718 caseChilds_n1p1(pParent, order, roi);
00719
00720 for(i=-getSizeROI(); i<getSizeROI(); ++i)
00721 {
00722 node = order[(i+getSizeROI())*roi];
00723
00724 if(x-getSizeROI() >= 0 &&
00725 y+i >= 0 &&
00726 y+i < getSizeY())
00727 {
00728 node->setTravMask(
00729 TypeTraits<UInt32>::BitsSet);
00730 core =
00731 dynamic_cast<QuadTreeTerrainPtr>(
00732 node->getCore());
00733
00734 core->setHeightData(
00735 getHeightTiles((y+i)*
00736 getSizeX() +
00737 x-getSizeROI()));
00738
00739 if(getMaterial() == NullFC)
00740 {
00741 core->setMaterial(
00742 getHeightTextures((y+i)*
00743 getSizeX() +
00744 x-getSizeROI()));
00745 }
00746 else
00747 {
00748 core->setOriginTexX((x-getSizeROI())*
00749 tstepx);
00750 core->setOriginTexY((y+i)*tstepy);
00751 }
00752
00753 core->setOriginX((x-getSizeROI())*step);
00754 core->setOriginY((y+i)*step);
00755 }
00756 else
00757 {
00758 node->setTravMask(0);
00759 }
00760 }
00761
00762 for(j=-getSizeROI(); j<=getSizeROI(); ++j)
00763 {
00764 node = order[roi2-roi+j+getSizeROI()];
00765
00766 if(x+j >= 0 &&
00767 x+j < getSizeX() &&
00768 y+getSizeROI() < getSizeY())
00769 {
00770 node->setTravMask(
00771 TypeTraits<UInt32>::BitsSet);
00772 core =
00773 dynamic_cast<QuadTreeTerrainPtr>(
00774 node->getCore());
00775
00776 core->setHeightData(
00777 getHeightTiles((y+getSizeROI())*
00778 getSizeX() +
00779 x+j));
00780
00781 if(getMaterial() == NullFC)
00782 {
00783 core->setMaterial(
00784 getHeightTextures((y+
00785 getSizeROI())*
00786 getSizeX() + x+j));
00787 }
00788 else
00789 {
00790 core->setOriginTexX((x+j)*tstepx);
00791 core->setOriginTexY((y+getSizeROI())*
00792 tstepy);
00793 }
00794
00795 core->setOriginX((x+j)*step);
00796 core->setOriginY((y+getSizeROI())*step);
00797 }
00798 else
00799 {
00800 node->setTravMask(0);
00801 }
00802 }
00803 reorderChilds(pParent, order, roi);
00804 break;
00805 }
00806 }
00807 break;
00808
00809 case 0:
00810 switch (y - getCurrentY())
00811 {
00812 case -1:
00813 {
00814 NodePtr pParent =
00815 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00816
00817 caseChilds_0n1(pParent, order, roi);
00818
00819 for(i=-getSizeROI(); i<=getSizeROI(); ++i)
00820 {
00821 node = order[i+getSizeROI()];
00822
00823 if (x+i >= 0 &&
00824 x+i < getSizeX() &&
00825 y-getSizeROI() >= 0)
00826 {
00827 node->setTravMask(
00828 TypeTraits<UInt32>::BitsSet);
00829 core =
00830 dynamic_cast<QuadTreeTerrainPtr>(
00831 node->getCore());
00832
00833 core->setHeightData(
00834 getHeightTiles((y-getSizeROI())*
00835 getSizeX() + x+i));
00836
00837 if(getMaterial() == NullFC)
00838 {
00839 core->setMaterial(
00840 getHeightTextures((y-getSizeROI())*
00841 getSizeX() + x+i));
00842 }
00843 else
00844 {
00845 core->setOriginTexX((x+i)*tstepx);
00846 core->setOriginTexY((y-getSizeROI())*
00847 tstepy);
00848 }
00849
00850 core->setOriginX((x+i)*step);
00851 core->setOriginY((y-getSizeROI())*step);
00852 }
00853 else
00854 {
00855 node->setTravMask(0);
00856 }
00857 }
00858 reorderChilds(pParent, order, roi);
00859 break;
00860 }
00861 case 1:
00862 {
00863 NodePtr pParent =
00864 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00865
00866 caseChilds_0p1(pParent, order, roi);
00867
00868 for(i=-getSizeROI(); i<=getSizeROI(); ++i)
00869 {
00870 node = order[roi2-roi+(i+getSizeROI())];
00871 if(x+i >= 0 &&
00872 x+i < getSizeX() &&
00873 y+getSizeROI() < getSizeY())
00874 {
00875 node->setTravMask(
00876 TypeTraits<UInt32>::BitsSet);
00877 core =
00878 dynamic_cast<QuadTreeTerrainPtr>(
00879 node->getCore());
00880
00881 core->setHeightData(
00882 getHeightTiles((y+getSizeROI())*
00883 getSizeX() + x+i));
00884
00885 if(getMaterial() == NullFC)
00886 {
00887 core->setMaterial(
00888 getHeightTextures((y+getSizeROI())*
00889 getSizeX() + x+i));
00890 }
00891 else
00892 {
00893 core->setOriginTexX((x+i)*tstepx);
00894 core->setOriginTexY((y+getSizeROI())*
00895 tstepy);
00896 }
00897 core->setOriginX((x+i)*step);
00898 core->setOriginY((y+getSizeROI())*step);
00899 }
00900 else
00901 {
00902 node->setTravMask(0);
00903 }
00904 }
00905 reorderChilds(pParent, order, roi);
00906 break;
00907 }
00908 }
00909 break;
00910 case +1:
00911 switch (y - getCurrentY())
00912 {
00913 case -1:
00914 {
00915 NodePtr pParent =
00916 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
00917
00918 caseChilds_p1n1(pParent, order, roi);
00919
00920 for(i=-getSizeROI(); i<=getSizeROI(); ++i)
00921 {
00922 node = order[i+getSizeROI()];
00923
00924 if(x+i >= 0 &&
00925 x+i < getSizeX() &&
00926 y-getSizeROI() >= 0)
00927 {
00928 node->setTravMask(
00929 TypeTraits<UInt32>::BitsSet);
00930 core =
00931 dynamic_cast<QuadTreeTerrainPtr>(
00932 node->getCore());
00933
00934 core->setHeightData(
00935 getHeightTiles((y-getSizeROI())*
00936 getSizeX() + x+i));
00937
00938 if(getMaterial() == NullFC)
00939 {
00940 core->setMaterial(
00941 getHeightTextures((y-getSizeROI())*
00942 getSizeX() + x+i));
00943 }
00944 else
00945 {
00946 core->setOriginTexX((x+i)*tstepx);
00947 core->setOriginTexY((y-getSizeROI())*
00948 tstepy);
00949 }
00950
00951 core->setOriginX((x+i)*step);
00952 core->setOriginY((y-getSizeROI())*step);
00953 }
00954 else
00955 {
00956 node->setTravMask(0);
00957 }
00958 }
00959
00960 for(i=-getSizeROI()+1; i<=getSizeROI(); ++i)
00961 {
00962 node = order[(i+getSizeROI())*roi+(roi-1)];
00963
00964 if(x+getSizeROI() < getSizeX() &&
00965 y+i >= 0 &&
00966 y+i < getSizeY())
00967 {
00968 node->setTravMask(
00969 TypeTraits<UInt32>::BitsSet);
00970 core =
00971 dynamic_cast<QuadTreeTerrainPtr>(
00972 node->getCore());
00973
00974 core->setHeightData(
00975 getHeightTiles((y+i)*getSizeX() +
00976 (x+getSizeROI())));
00977
00978 if(getMaterial() == NullFC)
00979 {
00980 core->setMaterial(
00981 getHeightTextures((y+i)*
00982 getSizeX() +
00983 x+getSizeROI()));
00984 }
00985 else
00986 {
00987 core->setOriginTexX((x+getSizeROI())*
00988 tstepx);
00989 core->setOriginTexY((y+i)*tstepy);
00990 }
00991
00992 core->setOriginX((x+getSizeROI())*step);
00993 core->setOriginY((y+i)*step);
00994 }
00995 else
00996 {
00997 node->setTravMask(0);
00998 }
00999 }
01000 reorderChilds(pParent, order, roi);
01001 break;
01002 }
01003 case 0:
01004 {
01005 NodePtr pParent =
01006 dynamic_cast<NodePtr>(getParents()[0].getCPtr());
01007
01008 caseChilds_p10(pParent, order, roi);
01009
01010 for(i=-getSizeROI(); i<=getSizeROI(); ++i)
01011 {
01012 node = order[(i+getSizeROI())*roi+roi-1];
01013
01014 if(x+getSizeROI() < 