Hello, comme j'ai déjà posté auparavant des screens, je pense qu'il est temps pour moi de vous offrir mon mini code source (A améliorer !!!!)
Je vous serais donc super reconnaissant de pas venir ici dans le seul but de pomper et donc de refiler vos modifs pour l'améliorer et en faire un moteur de terrain digne de se nom 
.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 | #ifndef _CTerrain #define _CTerrain #include <irrlicht.h> using namespace irr; //#pragma comment(lib, "Irrlicht.lib") class CTerrain : public scene::ISceneNode { public: const enum TerrainQuality {High=1,Medium=2,Low=4,ExtraLow=8}; CTerrain::CTerrain(c8* HeightmapFile,TerrainQuality Quality,f32 ScaleTexture,scene::ISceneNode* parent,scene::ISceneManager* smgr,s32 id); CTerrain::~CTerrain(); void setColorTexture(c8* FileName); void setDetailTexture(c8* FileName); void SetTextureSplat(u32 NumTex,c8* FileName); void setDebugMode(bool Enable); void setRenderDistance(f32 Distance); void ActivateSplattingTextures(scene::ISceneManager* smgr,f32 Height,f32 Fog,video::SColorf FogColor); scene::IMesh* getMesh(); f32 getHeight(f32 x,f32 z); virtual void setMaterialType(const video::E_MATERIAL_TYPE Mat); virtual void OnRegisterSceneNode(); virtual void render(); virtual const core::aabbox3d<f32>& getBoundingBox() const; virtual video::SMaterial& getMaterial(u32 i); virtual void setPosition(const core::vector3df &Pos); virtual void setScale(const core::vector3df &Scale); u32 getMaterialCount(); private: core::aabbox3d<f32> Box; video::SMaterial Material; scene::SMeshBufferLightMap** CTTileBuffer; void calculateNormals ( scene::SMeshBufferLightMap* pMeshBuffer,s32 Size); bool Debug; f32 RenderDistance; scene::SMesh* TerrainMesh; u16 NbsTiles; }; class MyShaderCallBack : public video::IShaderConstantSetCallBack { public: scene::ISceneManager* smgr; f32 Height,Fog; video::SColorf FogColor; void setSplatScene(scene::ISceneManager* scene,f32 height,f32 fog,video::SColorf fogColor) { smgr=scene; Height = height; Fog = fog; FogColor = fogColor; } virtual void OnSetConstants(video::IMaterialRendererServices* services, s32 userData) { video::IVideoDriver* driver = services->getVideoDriver(); core::matrix4 worldViewProj; worldViewProj = driver->getTransform(video::ETS_PROJECTION); worldViewProj *= driver->getTransform(video::ETS_VIEW); worldViewProj *= driver->getTransform(video::ETS_WORLD); if (driver->getDriverType() == video::EDT_OPENGL) { worldViewProj = worldViewProj.getTransposed(); int var; var = 0; services->setPixelShaderConstant("texgrass", reinterpret_cast<f32*>(&var), 1); var = 1; services->setPixelShaderConstant("texrock", reinterpret_cast<f32*>(&var), 1); var = 2; services->setPixelShaderConstant("texsnow", reinterpret_cast<f32*>(&var), 1); var = 3; services->setPixelShaderConstant("texdetail", reinterpret_cast<f32*>(&var), 1); } services->setVertexShaderConstant("mWorldViewProj",worldViewProj.pointer(),16); services->setVertexShaderConstant("TerrainHeight",reinterpret_cast<f32*>(&Height),1); services->setVertexShaderConstant("FogDistance",reinterpret_cast<f32*>(&Fog),1); core::vector3df pos = smgr->getActiveCamera()->getPosition(); services->setVertexShaderConstant("cameraPos", reinterpret_cast<f32*>(&pos), 3); core::matrix4 world = driver->getTransform(video::ETS_WORLD); services->setVertexShaderConstant("mWorld",world.pointer(),16); services->setPixelShaderConstant("fog",reinterpret_cast<f32*>(&FogColor),4); } }; #endif |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 | #include <CTerrain.h> #include <irrlicht.h> using namespace irr; CTerrain::CTerrain(c8* HeightmapFile,TerrainQuality Quality,f32 ScaleTexture,scene::ISceneNode* parent,scene::ISceneManager* smgr,s32 id): scene::ISceneNode(parent, smgr, id) { //Test if the number of quality is correct if(Quality != 1 && Quality != 2 && Quality != 4 && Quality != 8) { //if not force to medium quality Quality = Medium; } //Set the Debug to false Debug=false; //Get the Heightmap video::IImage *Heightmap = SceneManager->getVideoDriver()->createImageFromFile(HeightmapFile); //Get dimension of heightmap u16 Size = Heightmap->getDimension().Width; //Set the size of Tiles for Terrain s32 SizeOfTiles = 0; //Switch Size for calculate the Size of Tile switch(Size) { case 64: SizeOfTiles=(Size/4)+1; NbsTiles = 4*4; break; case 128 : SizeOfTiles=(Size/8)+1; NbsTiles = 8*8; break; case 256 : SizeOfTiles=(Size/16)+1; NbsTiles = 16*16; break; case 512 : SizeOfTiles=(Size/16)+1; NbsTiles = 16*16; break; case 768 : SizeOfTiles=(Size/24)+1; NbsTiles = 24*24; break; case 1024: SizeOfTiles=(Size/32)+1; NbsTiles = 32*32; break; case 2048: SizeOfTiles=(Size/32)+1; NbsTiles = 32*32; break; default: SizeOfTiles=(Size/16)+1; NbsTiles = 16*16; break; } //Create the Mesh for the Terrain Mesh TerrainMesh = new scene::SMesh(); //Calculate the quality factor u32 SOTiles = irr::core::ceil32((f32)SizeOfTiles/(f32)Quality); //Init the array of MeshBuffer CTTileBuffer=new scene::SMeshBufferLightMap* [NbsTiles]; //Start the loop to create Buffers u32 TileX=0,TileZ=0; for (u32 i =0;i < NbsTiles;++i) { CTTileBuffer[i]=new scene::SMeshBufferLightMap(); CTTileBuffer[i]->Vertices.set_used(SizeOfTiles*SizeOfTiles); CTTileBuffer[i]->Indices.set_used(SizeOfTiles*SizeOfTiles*6); const f32 tdSize = 1.0f/(f32)(Size-1); u32 Index=0; u16 NbsIndices=0,NbsVertices=0; for(u32 x=TileX;x<(TileX+SizeOfTiles);x+=Quality) { for (u32 z=TileZ;z<(TileZ+SizeOfTiles);z+=Quality) { if (NbsVertices < (SOTiles*SOTiles)-SOTiles-1) { Index = NbsVertices; u32 TestValue = ( (((x-TileX)/Quality)+1) * ((z-TileZ)/Quality) + ((x-TileX)/Quality) ); if (Index != TestValue || (x-TileX==0 && z < TileZ+SizeOfTiles-Quality)) { CTTileBuffer[i]->Indices[NbsIndices++]=Index; CTTileBuffer[i]->Indices[NbsIndices++]=Index+1; CTTileBuffer[i]->Indices[NbsIndices++]=Index+SOTiles+1; CTTileBuffer[i]->Indices[NbsIndices++]=Index; CTTileBuffer[i]->Indices[NbsIndices++]=Index+SOTiles+1; CTTileBuffer[i]->Indices[NbsIndices++]=Index+SOTiles; } } video::S3DVertex2TCoords vertex; vertex.Normal = core::vector3df(0,1,0); vertex.Pos.X = (f32)x; video::SColor pixelColor(Heightmap->getPixel(x,z)); vertex.Pos.Y = (f32) pixelColor.getLuminance()/10.0f; vertex.Pos.Z = (f32)z; vertex.TCoords = core::vector2d<f32>( (f32)(x*tdSize), (f32)(z*tdSize)); vertex.TCoords2 = core::vector2d<f32>( (f32)(x*tdSize), (f32)(z*tdSize))*ScaleTexture; CTTileBuffer[i]->Vertices[NbsVertices]=vertex; NbsVertices++; } } CTTileBuffer[i]->Material.Lighting = true; //CTTileBuffer[i]->Material.Wireframe = true; CTTileBuffer[i]->Material.BackfaceCulling = true; CTTileBuffer[i]->Material.GouraudShading=true; CTTileBuffer[i]->Material.FogEnable=false; CTTileBuffer[i]->Material.DiffuseColor=video::SColor(255,255,255,255); CTTileBuffer[i]->Material.AmbientColor=video::SColor(255,255,255,255); CTTileBuffer[i]->Material.EmissiveColor=video::SColor(255,255,255,255); CTTileBuffer[i]->Vertices.set_used(NbsVertices); CTTileBuffer[i]->Indices.set_used(NbsIndices); for(s32 j = 0; j < ((Quality+1)/2); j++) { for(u32 index = 2; index < (SOTiles * SOTiles - 2); index++) { //A[i] = (1/8)*(A[i-2] + 2*A[i-1] + 2*A[i] + 2*A[i+1] + A[i+2]); CTTileBuffer[i]->Vertices[index].Pos.Y += (1/8)* (CTTileBuffer[i]->Vertices[index-2].Pos.Y + 2*CTTileBuffer[i]->Vertices[index-1].Pos.Y + 2*CTTileBuffer[i]->Vertices[index].Pos.Y + 2*CTTileBuffer[i]->Vertices[index+1].Pos.Y + CTTileBuffer[i]->Vertices[index+2].Pos.Y); } } for(s32 k = 0; k < ((Quality+1)/2); k++) { for(u32 index = SOTiles; index < (SOTiles * (SOTiles - 1)); index++) { CTTileBuffer[i]->Vertices[index].Pos.Y = (CTTileBuffer[i]->Vertices[index - SOTiles].Pos.Y + CTTileBuffer[i]->Vertices[index + SOTiles].Pos.Y ) / 2.0f; } } //Calculate the normals calculateNormals(CTTileBuffer[i],SOTiles); //Recalculate the bounding box CTTileBuffer[i]->recalculateBoundingBox(); //Add the buffer to the Terrain Mesh TerrainMesh->addMeshBuffer(CTTileBuffer[i]); TileX+=SizeOfTiles-1; if(TileX >= Size) { TileX=0; TileZ+=SizeOfTiles-1; if(TileZ >= Size) { TileZ=0; } } } AutomaticCullingState = scene::EAC_OFF; Heightmap->drop(); } CTerrain::~CTerrain() { for(u32 i=0;i<NbsTiles;++i) { if (CTerrain::CTTileBuffer[i] != NULL) { CTerrain::CTTileBuffer[i]->drop(); } } delete [] CTerrain::CTTileBuffer; if(CTerrain::TerrainMesh != NULL) { CTerrain::TerrainMesh->drop(); } } void CTerrain::OnRegisterSceneNode() { if (IsVisible) SceneManager->registerNodeForRendering(this); ISceneNode::OnRegisterSceneNode(); } void CTerrain::render() { scene::ICameraSceneNode* cam = SceneManager->getActiveCamera(); const scene::SViewFrustum* frustum = cam->getViewFrustum(); video::IVideoDriver* Driver = SceneManager->getVideoDriver(); core::vector3df Pos = cam->getPosition(); cam->updateAbsolutePosition(); Pos.Y=0.0f; for (u32 i=0;i<NbsTiles;i++) { if (CTTileBuffer[i] != NULL) { Driver->setTransform(video::ETS_WORLD,AbsoluteTransformation); //DEBUG HERE if(Debug==true) { video::SMaterial Mat; Mat.AmbientColor = video::SColor(255,255,255,255); Mat.DiffuseColor = video::SColor(255,255,255,255); Mat.EmissiveColor = video::SColor(255,0,255,0); Driver->setMaterial(Mat); Driver->draw3DBox(CTTileBuffer[i]->getBoundingBox(),video::SColor(255,255,255,255)); } if( frustum->getBoundingBox().intersectsWithBox(CTTileBuffer[i]->getBoundingBox())==true) { f64 ActualDistance = CTTileBuffer[i]->BoundingBox.getCenter().getDistanceFrom(Pos); if(ActualDistance < RenderDistance) { Driver->setMaterial(video::SMaterial(CTTileBuffer[i]->Material)); Driver->drawIndexedTriangleList(&CTTileBuffer[i]->Vertices[0],CTTileBuffer[i]->getVertexCount(),&CTTileBuffer[i]->Indices[0], CTTileBuffer[i]->getIndexCount()/3 ); //Driver->drawMeshBuffer(CTTileBuffer[i]); } } } } } void CTerrain::setPosition(const core::vector3df &Pos) { for (u32 i=0;i<NbsTiles;i++) { if (CTTileBuffer[i] != NULL) { for (u32 j=0;j<CTTileBuffer[i]->getVertexCount();++j) { CTTileBuffer[i]->Vertices[j].Pos+=Pos; } CTTileBuffer[i]->recalculateBoundingBox(); } } } void CTerrain::setScale(const core::vector3df &Scale) { for (u32 i=0;i<NbsTiles;i++) { if (CTTileBuffer[i] != NULL) { for (u32 j=0;j<CTTileBuffer[i]->getVertexCount();++j) { CTTileBuffer[i]->Vertices[j].Pos*=Scale; } CTTileBuffer[i]->recalculateBoundingBox(); } } } const core::aabbox3d<f32>& CTerrain::getBoundingBox() const { return Box; } u32 CTerrain::getMaterialCount() { return 1; } video::SMaterial& CTerrain::getMaterial(u32 i) { return Material; } void CTerrain::ActivateSplattingTextures(scene::ISceneManager* smgr,f32 Height,f32 Fog,video::SColorf FogColor) { video::IVideoDriver* driver = smgr->getVideoDriver(); s32 newMaterialType1 = 0; video::IGPUProgrammingServices* gpu = smgr->getVideoDriver()->getGPUProgrammingServices(); if (driver->getDriverType() != video::EDT_OPENGL) { //Merci à DeusXL pour son shader  c8 ShaderFileName[] = "texgrass" "texrock" "texsnow" "texdetail" "mWorldViewProj" "TerrainHeight" "FogDistance" "cameraPos" "mWorld" "fog" "float4x4 mWorldViewProj;n" "float4x4 mWorld;n" "float3 cameraPos;n" "float TerrainHeight;n" "float FogDistance;n" "struct VS_OUTPUTn" "{n" "float4 Position : POSITION;n" "float4 Diffuse : COLOR0;n" "float2 TexCoord1 : TEXCOORD1;n" "};n" "VS_OUTPUT vertexMain( in float4 vPosition : POSITION,in float3 vNormal : NORMAL,float2 texCoord1 : TEXCOORD1)n" "{n" "VS_OUTPUT Output;n" "Output.Position = mul(vPosition, mWorldViewProj);n" "float4 position = mul(vPosition, mWorld);n" "float dist = sqrt ( pow(position.x - cameraPos.x, 2.0f) +n" "pow(position.y - cameraPos.y, 2.0f) +n" "pow(position.z - cameraPos.z, 2.0f));n" "Output.Diffuse = float4(vPosition.y / TerrainHeight, dist / FogDistance, 0.0f, 0.0f);n" "Output.TexCoord1 = texCoord1;n" "return Output;n" "}n" "struct PS_OUTPUTn" "{n" "float4 RGBColor : COLOR0;n" "};n" "sampler2D tex[4];n" "float4 fog;n" "PS_OUTPUT pixelMain( float2 TexCoord1 : TEXCOORD1,float4 Position : POSITION,float4 Diffuse : COLOR0 )n" "{n" "PS_OUTPUT Output;n" "float heightpercent = Diffuse.x;n" "float dist = Diffuse.y;n" "float4 grasscolor = tex2D(tex[0], TexCoord1 * 5.0f) * pow((1.0f - heightpercent), 4.0f);n" "float4 rockcolor = tex2D(tex[1], TexCoord1 * 5.0f) * pow((1.0f - abs(0.5f - heightpercent)), 4.0f);n"; if (gpu) { MyShaderCallBack* mc = new MyShaderCallBack(); mc->setSplatScene(smgr,Height,Fog,FogColor); newMaterialType1 = gpu->addHighLevelShaderMaterial( ShaderFileName, "float4 snowcolor = tex2D(tex[2], TexCoord1 * 5.0f) * pow(heightpercent,4.0f);n", video::EVST_VS_2_0, ShaderFileName, "float4 detailcolor = tex2D(tex[3], TexCoord1 * 5.0f) * pow((1.0f - abs(0.7f - heightpercent)), 4.0f);n", video::EPST_PS_2_0, mc, video::EMT_SOLID,0); mc->drop(); } } else { c8 ShaderFragment[] = "Output.RGBColor = (grasscolor + rockcolor + snowcolor + detailcolor);n"//n" "if (dist >= 0.5f)n"struct VS_OUTPUT {n"{n"vec4 Position;n"Output.RGBColor *= (1.0f - (dist-0.5f));n"vec4 Diffuse;n"Output.RGBColor += (fog * (dist-0.5f));n"vec2 TexCoord1;n"}n"};n"return Output;n"struct PS_OUTPUT {n"}n"vec4 RGBColor;n"vertexMain"};n"pixelMain"// Structure definitionsn" "//n" "//n" "// Global variable definitionsn" " " " " "//n" " "PS_OUTPUT pixelMain( in vec2 TexCoord1, in vec4 Position, in vec4 Diffuse );n" "//n" " "// Function declarationsn" " " " " " " "//n" " "uniform vec4 fog;n" "uniform sampler2D texgrass,texrock,texsnow,texdetail;n" "//n" " "// Function definitionsn" " " " "//n" " "PS_OUTPUT pixelMain( in vec2 TexCoord1, in vec4 Position, in vec4 Diffuse ) {n" "float heightpercent;n" "float dist;n" "vec4 grasscolor;n" "vec4 rockcolor;n" "vec4 snowcolor;n" "vec4 detailcolor;n" "PS_OUTPUT Output;n" "heightpercent = Diffuse.x ;n" "dist = Diffuse.y ;n" "grasscolor = (texture2D( texgrass, (TexCoord1 * 5.00000)) * pow( (1.00000 - heightpercent), 4.00000));n" "rockcolor = (texture2D( texrock, (TexCoord1 * 5.00000)) * pow( (1.00000 - abs( (0.500000 - heightpercent) )), 4.00000));n"//n" "snowcolor = (texture2D( texsnow, (TexCoord1 * 5.00000)) * pow( heightpercent, 4.00000));n"void main() {n"detailcolor = (texture2D( texdetail, (TexCoord1 * 5.00000)) * pow( (1.00000 - abs( (0.700000 - heightpercent) )), 4.00000));n"PS_OUTPUT xlat_retVal;n"Output.RGBColor = (((grasscolor + rockcolor) + snowcolor) + detailcolor);n"xlat_retVal = pixelMain( vec2(gl_TexCoord[1]), vec4(gl_FragCoord), vec4(gl_Color));n"if ( (dist >= 0.500000) ){n"gl_FragData[0] = vec4( xlat_retVal.RGBColor);n"Output.RGBColor *= (1.00000 - (dist - 0.500000));n"}n"Output.RGBColor += (fog * (dist - 0.500000));n"// Translator's entry pointn" "}n"//n" "return Output;n" "}n" "//n" " "// Structure definitionsn" " " " " " " " " " "; c8 ShaderVertex[]= "//n" "//n" "uniform float FogDistance;n"struct VS_OUTPUT {n"uniform float TerrainHeight;n"vec4 Position;n"uniform vec3 cameraPos;n"vec4 Diffuse;n"uniform mat4 mWorld;n"vec2 TexCoord1;n"uniform mat4 mWorldViewProj;n"};n"// Global variable definitionsn" "struct PS_OUTPUT {n"//n" "vec4 RGBColor;n" "};n"//n" "// Function declarationsn" "VS_OUTPUT vertexMain( in vec4 vPosition, in vec3 vNormal, in vec2 texCoord1 ) {n"//n" "VS_OUTPUT Output;n" "vec4 position;n" "float dist;n" "Output.Position = ( vPosition * mWorldViewProj );n" "position = ( vPosition * mWorld );n" "dist = sqrt( ((pow( (position.x - cameraPos.x ), 2.00000) + pow( (position.y - cameraPos.y ), 2.00000)) + pow( (position.z - cameraPos.z ), 2.00000)) );n"//n" "Output.Diffuse = vec4( (vPosition.y / TerrainHeight), (dist / FogDistance), 0.000000, 0.000000);n"VS_OUTPUT vertexMain( in vec4 vPosition, in vec3 vNormal, in vec2 texCoord1 );n"Output.TexCoord1 = texCoord1;n"// Function definitionsn" "return Output;n"//n" "}n" "//n" " "// Translator's entry pointn" " " " " " " " " " " " " " "; if (gpu) { MyShaderCallBack* mc = new MyShaderCallBack(); mc->setSplatScene(smgr,Height,Fog,FogColor); newMaterialType1 = gpu->addHighLevelShaderMaterial( ShaderVertex, " ", video::EVST_VS_1_1, ShaderFragment, " ", video::EPST_PS_1_1, mc, video::EMT_SOLID,0); mc->drop(); } } setMaterialType((video::E_MATERIAL_TYPE)newMaterialType1); } void CTerrain::setColorTexture(c8* FileName) { for (u32 i=0;i<NbsTiles;++i) { if (CTTileBuffer[i] != NULL) { CTTileBuffer[i]->Material.MaterialType = video::EMT_SOLID; CTTileBuffer[i]->Material.Textures[0] = SceneManager->getVideoDriver()->getTexture(FileName); } } } void CTerrain::setDetailTexture(c8* FileName) { for (u32 i=0;i<NbsTiles;++i) { if (CTTileBuffer[i] != NULL) { CTTileBuffer[i]->Material.MaterialType = video::EMT_DETAIL_MAP; CTTileBuffer[i]->Material.Textures[1] = SceneManager->getVideoDriver()->getTexture(FileName); } } } void CTerrain::SetTextureSplat(u32 NumTex,c8* FileName) { for (u32 i=0;i<NbsTiles;++i) { if (CTTileBuffer[i] != NULL) { CTTileBuffer[i]->Material.Textures[NumTex] = SceneManager->getVideoDriver()->getTexture(FileName); } } } void CTerrain::setDebugMode(bool Enable) { Debug=Enable; } void CTerrain::setRenderDistance(f32 Distance) { RenderDistance = Distance; } void CTerrain::setMaterialType(video::E_MATERIAL_TYPE Mat) { for (u32 i=0;i < NbsTiles;++i) { if (CTTileBuffer[i] != NULL) { CTTileBuffer[i]->Material.MaterialType = Mat; } } } scene::IMesh* CTerrain::getMesh() { return (scene::IMesh*)TerrainMesh; } f32 CTerrain::getHeight(f32 x,f32 z) { scene::SMeshBufferLightMap* TempBuffer=NULL; f32 ValueReturn = 0.0f; for (u32 i=0;i < NbsTiles;++i) { if (CTTileBuffer[i] != NULL) { core::vector3df Vec(x,CTTileBuffer[i]->getBoundingBox().getCenter().Y,z); if(CTTileBuffer[i]->getBoundingBox().isPointInside(Vec)) { TempBuffer=CTTileBuffer[i]; break; } } } if(TempBuffer != NULL) { //n" scene::SMesh* Mesh=new scene::SMesh(); Mesh->addMeshBuffer(TempBuffer); scene::ITriangleSelector* selector= SceneManager->createTriangleSelector((scene::IMesh*)Mesh,this); this->setTriangleSelector(selector); core::line3d<f32> line; line.start = core::vector3d<f32>(x,-200000,z); line.end = core::vector3d<f32>(x,200000,z); core::vector3df intersection; core::triangle3df tri; if (SceneManager->getSceneCollisionManager()->getCollisionPoint(line, selector, intersection,tri)) { ValueReturn = intersection.Y; } selector->drop(); Mesh->drop(); } else { ValueReturn=-999999.999f; } return ValueReturn; } //Si le TempBuffer renvoi différent de null, on se situ dans un tile void CTerrain::calculateNormals ( scene::SMeshBufferLightMap* pMeshBuffer,s32 Size) { s32 count; //Take from the irrlicht source code core::vector3df a, b, c, t; for (s32 x=0; x<Size; ++x) for (s32 z=0; z<Size; ++z) { count = 0; core::vector3df normal; //s32 Size = 4; if (x>0 && z>0) { a = pMeshBuffer->Vertices[(x-1)*Size+z-1].Pos; b = pMeshBuffer->Vertices[(x-1)*Size+z].Pos; c = pMeshBuffer->Vertices[x*Size+z].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; a = pMeshBuffer->Vertices[(x-1)*Size+z-1].Pos; b = pMeshBuffer->Vertices[x*Size+z-1].Pos; c = pMeshBuffer->Vertices[x*Size+z].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; count += 2; } // top left if (x>0 && z<Size-1) { a = pMeshBuffer->Vertices[(x-1)*Size+z].Pos; b = pMeshBuffer->Vertices[(x-1)*Size+z+1].Pos; c = pMeshBuffer->Vertices[x*Size+z+1].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; a = pMeshBuffer->Vertices[(x-1)*Size+z].Pos; b = pMeshBuffer->Vertices[x*Size+z+1].Pos; c = pMeshBuffer->Vertices[x*Size+z].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; count += 2; } // top right if (x<Size-1 && z<Size-1) { a = pMeshBuffer->Vertices[x*Size+z+1].Pos; b = pMeshBuffer->Vertices[x*Size+z+1].Pos; c = pMeshBuffer->Vertices[(x+1)*Size+z+1].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; a = pMeshBuffer->Vertices[x*Size+z+1].Pos; b = pMeshBuffer->Vertices[(x+1)*Size+z+1].Pos; c = pMeshBuffer->Vertices[(x+1)*Size+z].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; count += 2; } // bottom right if (x<Size-1 && z>0) { a = pMeshBuffer->Vertices[x*Size+z-1].Pos; b = pMeshBuffer->Vertices[x*Size+z].Pos; c = pMeshBuffer->Vertices[(x+1)*Size+z].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; a = pMeshBuffer->Vertices[x*Size+z-1].Pos; b = pMeshBuffer->Vertices[(x+1)*Size+z].Pos; c = pMeshBuffer->Vertices[(x+1)*Size+z-1].Pos; b -= a; c -= a; t = b.crossProduct ( c ); t.normalize ( ); normal += t; count += 2; } if ( count != 0 ) { normal.normalize ( ); } else { normal.set( 0.0f, 1.0f, 0.0f ); } pMeshBuffer->Vertices[x * Size + z].Normal = normal; } } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | #include <CTerrain.h> CTerrain* Terrain=new CTerrain("texgrass",CTerrain::Medium,10,smgr->getRootSceneNode(),smgr,0); Terrain->setScale(core::vector3df(30,50,30)); //La distance de rendu, plus elle sera élevée plus ça va ramer.... Terrain->setRenderDistance(5000.0f); //Terrain->setDebugMode(true); //ici ça ralenti le bazard mais ça peut être utile Terrain->setPosition(core::vector3df(-3840,0,-3840)); //Simili texture splatting on est pas obligé de l'utiliser, voir plus bas Terrain->ActivateSplattingTextures(smgr,600.0f,3000.0f,video::SColorf(0.0f,0.5f,0.8f,1.0f)); Terrain->SetTextureSplat(0,"texrock"); Terrain->SetTextureSplat(1,"texsnow"); Terrain->SetTextureSplat(2,"texdetail"); Terrain->SetTextureSplat(3,"mWorldViewProj"); //Texturage normal Voilà, ici on peut utiliser ça mais perso j'aime pas //Terrain->setColorTexture("Media/Colormap.jpg"); //Terrain->setDetailTexture("Media/Detail.jpg"); |
Voilou j'espère sincèrement que vous l'amliorerez et nous en ferez profiter car si je m'apperçois que ça se limite à la pompe....bein vous pourrez dire adieu à des code de se genre....
@++
[Edit] Ne fonctionne qu'avec des Heightmaps de 64,128,256,512,768,1024,2048 et pas d'autre taille.
Hors ligne
Très bonne lib
Reste à espérer qu'elle évoluera comme tu l'as dit
Je m'en vais tester
Hors ligne
salut, content d'avoir de tes nouvelles (de toi et de ton moteur de terrain)
a bientot 
Dernière modification par Jerry Kan (03-07-2007 12:21:56)
Hors ligne
Merci
J'ai testé en speed, et ca a l'air nickel.
Pour ce qui est des modifications, ce sera pas pour tout de suite du moins pour moi (vu que je comprend quasiment rien à la plupart des concepts)
Je vois que tu es un peu amère par le manque de partage de connaissance (du moins pour la communauté Fr de Irrlicht)
Comme je suis incapable de présenter une quelconque routine sur Irrlicht. Je peux juste vous fournir ce petit logiciel qui j'espère pourra servir à certain : http://forum.irrlicht.fr/viewtopic.php?pid=2536#p2536
Voilà en tout cas, encore merci pour tes sources, cela me sera très utile.
Hors ligne
Copland :
Je vous serais donc super reconnaissant de pas venir ici dans le seul but de pomper et donc de refiler vos modifs pour l'améliorer et en faire un moteur de terrain digne de se nom
Au fait, si tu veux empecher la pompe sans participation, il te suffit de préciser que ton code est sous licence GPL stricte (allé la v3 tant qu'a faire)
pour cela il te faut faire 1 copier coller de l'intitulé de la licence en entete de chaque fichier, et si tu fait un zip, tu rajoute un fichier LICENCE.txt avec le texte de la GPL (v3 ! v3 !)
l'entete de chaque fichier :
/* * (C) 1998-2007 by TON NOM ICI + adresse mail * *************************************************************************** * This program is free software; you can redistribute it and/or modify it * * under the terms of the GNU General Public License as published by the * * Free Software Foundation; either version 2 of the License, or (at your * * option) any later version. * * * * This program is distributed in the hope that it will be useful, but * * WITHOUT ANY WARRANTY; without the implied warranty of MERCHANTABILITY * * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * * for more details. * * * * You should have received a copy of the GNU General Public License along * * with this program; if not, write to the Free Software Foundation, Inc., * * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * *************************************************************************** */
Dernière modification par Jerry Kan (03-07-2007 18:44:01)
Hors ligne
J'essaye de voir, mais je n'arrive pas a compilé 
CTerrain.h : No such file or directory
Alors qu'il est bien rangé...
Une idée ?
(J'utilise Irrlicht 1.2, de ce fait, a tu une vieille version, même pas forcément fini ^^
Sinon, je vais faire la conversion, mais je suis pas sur que sa marche)
a+
w
Dernière modification par Willikus (03-07-2007 21:13:45)
Hors ligne
Hello, pour la license je vais y réfléchir, sinon willikus il ne s'agit probablement que d'un problème d'include dans ton projet car j'ai testé se code sous windows et linux avec différent ide sans aucun problèmes .
Hors ligne
Super boulot Copland. Merci de partager tes sources
En vue de préparer un futur projet je suis en train de bosser sur un editeur de spline et sur la creation de nouveaux Animator de type spline. J'ai presque terminé et je mettrais a disposition tres bientot mes travaux (déja à moitié disponible sur le forum officiel d'irrlicht).
Je comptais par la suite enchainer avec un nouveau moteur de terrain car l'actuel est plutot anecdotique. Compte tenu que le tient est plutot bien avancé et m'a l'air de bien tourner je vais reprendre tes sources et compte sur moi pour te faire part des ameliorations.
Dernière modification par Ikam (04-07-2007 10:38:58)
Hors ligne
Merci par avance monsieur Ikam .
Sinon pour confirmer, après 2/3 mini modif, ça marche nickel sous Irrlicht 1.2.
Ce qui fait que ça fonctionne sur Irrlicht 1.2,1.3 et SVN ainsi que sous les IDE suivants : Code::Blocks,DevCPP,VC++.
Y'a vraiment pas grand chose à modifier dans le code, donc ceux qui sont sous la 1.2 pourront l'utiliser également, par contre je le déconseille car chez moi la 1.3 est un poil plus rapide.
Pour terminer, je pense qu'il faudrait optimiser le code au niveau de la charge en ram, je pensais à des zones de chargement mais dans le cadre de mon projet ça pose le problème d'un cour lag donc je l'ai pas fait.
Ensuite, il faudrait programmer une vrai méthode GetHeight, là c'est de la bidouille à deux balles,idem je l'ai pas codé car j'utilise un moteur de physique pour les collisions.
Voilou @++
Hors ligne
C'est très bien. C'est comme ça que le TerrainSceneNode devrait être dans le Irrlicht officiel.
Ceci dit en passant, en OPENGL j'ai de meilleurs FPS avec ton node qu'avec l'autre (sans splatting et à distance max de rendu égales). Heureusement que l'autre bénéficie d'un système de LOD super techno post moderne censé améliorer les performances, tu parles. En plus le LOD modifie les contours du terrain c'est immonde. Donc bravo Copland.
Je n'ai pas réussi à faire marcher le ITriangleSelector dessus mais c'est pas grave je m'en sers jamais (système perso de collision et gravité).
Pour faire des trous de bombes donc déformer le terrain avec getHeight/setHeight il faudrait déterminer sur quel tile le vertex est situé, puis modifier sa valeur par
CTTileBuffer[i]->Vertices[j].Height=newHeight;
C'est ça?
Hors ligne
Hello,
Merci pour les compliments ça fait plaisir même si le code n'est pas parfait .
Sinon pour répondre à ta question ça serai un truc du genre :
CTTileBuffer[i]->Vertices[j].Pos.Y = NewHeight;
Sinon pour le triangle selector, si tu dois t'en servir programme le directement dans la classe elle même, pour ça regarde la méthode GetHeight() y'a une technique {optimisé par rapport à la position de la camera active} pour ne pas saturer le rendu.
Voilou @++
Hors ligne
Salut !
J'ai commencé a attaqué ton code, ça rend vraiment bien, mais l'histoire du selector c'est assez gênant...
Je n'es pas vraiment compris "la méthode GetHeight() y'a une technique {optimisé par rapport à la position de la camera active} pour ne pas saturer le rendu."
Tu dit qu'il faut faire une fonction qui renvoi le triangleSelector d'apres la position ?
(Ca me bloque car ça empeche la gestion de la nage, du saut et ton systeme est pas tres réaliste pour des monté importante [tu monte plus vite quand l'angle est plus grand])
Mais par contre, la map est superbe et accepte bcp mieux des grande echelle sans trop abimé le rendu (j'ai doublé le rendue par rapport a avant et je n'ai plus de cran)
Encore bravo en tt cas
EDIT :
Je vient de trouver une methode mais on perd + de 50% des perfs (110FPS -> 49FPS)
scene::ITriangleSelector* selectormap = smgr->createTriangleSelector(Terrain->getMesh(),Terrain); Terrain->setTriangleSelector(selectormap); selectormap->drop(); scene::IMetaTriangleSelector* metaSelector = smgr->createMetaTriangleSelector(); metaSelector->addTriangleSelector(selectormap); scene::ISceneNodeAnimatorCollisionResponse* choc = smgr->createCollisionResponseAnimator(metaSelector, camera, core::vector3df(45,75,45), core::vector3df(0,-15,0), core::vector3df(0,50,0)); camera->addAnimator(choc); choc->drop();
Enfin, je suppose que pas mal de monde savait faire ça mais c'est tous ce que j'ai réussi a faire
a+
w
Dernière modification par Willikus (15-07-2007 17:03:13)
Hors ligne
Salut,
De toute façon tu as tout interret à utiliser un moteur de physique ou un moteur de collisions externe, car ceux d'irrlicht sont extrènement lent...Donc si tu te sers d'un moteur de terrain pour gagner quelques fps mais les reperdre sur des collisions, je n'en vois pas vraiment l'interret.
Enfin tu fais comme tu veux .
[edit]
Dans la méthode GetHeight pas très précise, je test les buffers du terrain pour voir au dessus de quel "tile" on se situ, et à se moment là je creais un triangle selector uniquement pour se tile, je fais mon calcul et je le vire, comme ça on perd beaucoup moins de fps, c'est ça l'optimisation par rapport à la position.
(Ca me bloque car ça empeche la gestion de la nage, du saut et ton systeme est pas tres réaliste pour des monté importante [tu monte plus vite quand l'angle est plus grand])
Ca c'est faux, ma méthode se contente de suivre le terrain au polygone pret donc le getheight est super précis quand il échou pas car par moment irrlicht perd les pédales est passe à travers le triangle et par conséquent renvoi une valeur érroné.
Hors ligne
En mettant le rendu en
High : 20 FPS
Medium : 49 FPS
Low : 120 FPS
En low, moi ca marche pas trop mal
Ca c'est faux, ma méthode se contente de suivre le terrain au polygone pret donc le getheight est super précis quand il échou pas car par moment irrlicht perd les pédales est passe à travers le triangle et par conséquent renvoi une valeur érroné.
Ce n'est pas le fonctionnement que je critique
Ton truc, si j'ai bien compris, calcule la position Y pour le X et Z. Donc, cette façon passe n'importe quel pente...
Enfin... je pense que ton truc c'est parfaitement adapté pour un A-RPG, un peu moins pour un FPS... mais Irrlicht n'est pas très bon dans les deux
Je persiste a dire que c'est un tres bon rendu !
(Je vais essayé un peu de physique : un conseil sur le moteur ? ODE ?)
a+
w
Hors ligne
Yop si t'a jamais tripoté Ode, je te souhaite bien du courage car il est vraiment pas évident à parramétrer, cependant je code mon projet avec, donc si besoin je pourrai t'aider à se niveau là.
Sinon je te conseillerai plustot Newton ou pourquoi pas Bullet que je ne connais pas mais j'en entend beaucoup de bien partout.
Hors ligne
Salut !
Je vais regardé les differentes choses qu'ils proposent.
Merci de ton aide en tt cas
a+
w
Hors ligne
de mon coté j'ai été séduit par OPAL qui est vraiment tres sympa,
c'est une couche d'abstraction sur ODE qui rends le dev beaucoup plus facile, helas la version est encore 0.8 je crois
Hors ligne
Salut, un snippet que j'ai posté ce week-end sur le forum officiel, pour avoir gravité et collision avec le sol. Marche du feu de dieu avec ta classe.
La seule différence: ton getHeight() retourne -999999.999f si on n'a rien sous les pieds, alors que le getHeight du node officiel retourne -999999.9f Je pense qu'il faudrait aussi retourner cette valeur, bref simplement enlever les deux dernières décimales.
// Quelque part:
f32 Gravity = 0.3f; // 0 = pas de gravité
f32 HeightAboveGround=10.f;
// Dans le main loop:
env->drawAll();
if (Gravity)
{
vector3df pos = camera->getPosition();
float Y = terrain->getHeight(pos.X, pos.Z);
//if (Y != -999999.9f) // no ground under, do nothing
if (Y != -999999.999f)
{
pos.Y -= Gravity;
Y += HeightAboveGround;
if (pos.Y > Y) camera->setPosition(pos);
else camera->setPosition(vector3df(pos.X, Y, pos.Z));
}
}
driver->endScene();On peut l'optimiser en ajoutant if (isMoving) pour pas recalculer si on bouge pas.
C'est moins complet qu'un moteur physique mais les FPS restent.
Ca serait encore mieux niveau performances si le TriangleSelector était créé dans le constructeur plutôt qu'à chaque frame, en passant un bool au constructeur par exemple. La classe pourrait garder un pointeur en protected et le détruire dans le destructeur.
A présent je me demande comment appliquer le fog sur le terrain avec le "texturage normal" ...
Dernière modification par katsankat (16-07-2007 14:10:19)
Hors ligne
coucou
Comme je te l'ai deja dit Copland, j'ai commencé à retouché à ta classe pour y apporter quelques modifs. Je voulais juste faire un recapitulatif de ce j'ai touché et ce que je suis en train de faire dessus.
Concernant les ameliorations ou les bugs ca serait bein de mettre a jour cette liste pour voir ce qu'il y a à faire ou pour y apporter des idées.
Donc si vous avez des bugs ou des commentaires, ceux ci sont les bienvenues, pour essayer d'ameliorer en commun ce petit systeme de terrain bien sympathique que copland nous a gracieusement offert
bugs:
- Corrigé ! Lors de setposition sur CTerrain si Y est <> 0 avec une valeur +- RenderDIstance le rendu ne se fait pas
- En cours ! Sur les extremités du terrain sur les bord X et Z la hauteur chute à 0
- Corrigé ! Sur les extremités du terrain sur les bord X et Z la hauteur chute à 0 : necessite desormais d'employer des map de taille 2^N+1 (257*257, 513*513, etc...)
- Corrigé ! la generation du terrain est inversée par raport à la heightmap
- Corrigé ! la texture couleur du terrain est inversée par raport à la colormap
Ameliorations:
- OK ! optimisation du rendu par calcul de la distance de rendu au carré
- OK ! optimisation du rendu en sortant de la boucle l'appel sur Driver->setTransform(...)
- OK ! optimisation du rendu en sortant de la boucle l'appel à Driver->setMaterial(...)
- OK ! modification du mode debug pour l'utiliser facon irrlicht (DebugDataVisible)
- OK ! ajout en debug du rendu de la bounding box du terain mesh + recalcul de cette bounding box lors de setposition et setscale
- OK ! ajout en debug du rendu du terrain en mode wireframe
- En cours ! arrangement general du code et ajout de commentaires
- En cours ! externalisation du shader
- En cours ! mettre le nommage des elements de la structure quality facon irrlicht
- En cours ! ajouter une option pour activer le fog en mode de texturage normal
- En cours ! charger une heightmap de type RAW
- OK ! mettre le nommage des elements de la structure quality facon irrlicht (stuct renommée E_TERRAIN_QUALITY)
Extensions :
- En cours ! Creation d'une nouvelle classe pour permettre un systeme de chargement de plusieurs terrain par zonez et permettre le rendu sur plusieurs terrains à la fois
Ameliorations eventuelles :
- possibilité de charger une heightmap deja préchargé dans un type de fichier mesh plutot qu e depuis une heightmap pour ameliorer la vitesse de chargement d'un terrain
- ameliorer le rendu pour un affichage de l'horizon du terrain plus linéaire (supprimer l'effet d'apparition bloc par bloc)
- ajouter un algorithme d'optimisation sur le rendu du terrain
- creer un systeme de generation automatique de terrain, pour un terrain infini
Dernière modification par Ikam (24-07-2007 17:08:45)
Hors ligne
Salut, avec mon programme, le code de Copland bug, voici une banal copie de mon mail, jamais reçu :
"
Salut !
J'ai remarqué un "bug" sur ton rendue de terrain, des "facette" s'affiche avec des points noirs et parfois (sous certain angle) on voit des segments entre les facettes.
As tu deja vu ces bug (ou c ma CG qui fait des items) ?
probleme du png ?
a+
w
"
Cela est peut etres du a d'autre chose dans mon programme mais si vous avez des idées (utilisation du code pour Irrlicht 1.2 avec un puissant scale (80,200,80).
Voila
a+
w
Hors ligne
salut,
Quelle taille de heightmap tu utilises ?
Et je présume que se bug apparait en Directx et pas en openGl c'est ça ?
Hors ligne
Salut,
Bon désolé pour ce poste j'avais dit des betises.
Par contre j'ai 3 questions (en rapport avec ma betise lol)
1 - A quoi sert l'attribut Material?
2 - Pourquoi la méthode getMaterialCount ne retourne pas le nombre de tile (soit le nombre de material réellement utilisé)
3 - Pourquoi la méthode getMaterial (u32 i) ne retourne pas CTTileBuffer[i]->Material?
Je pense que en faisant cela, on pourrait utilisé ensuite un truc genre terrain->SetMaterialFlag(flag,true) non?
Merci
Voila a+
Dernière modification par ZeroZero (23-07-2007 15:54:29)
Hors ligne
salut,
Quelle taille de heightmap tu utilises ?
Et je présume que se bug apparait en Directx et pas en openGl c'est ça ? (big_smile)
Salut !
-256*256 (je commence par petit ^^)
-OpenGL 2.1.0 avec une 8800GTS
C'est possible que ce soit l'histoire de .png qui foute le chantier car ça passe tres mal (mes png change de couleur selon l'angle) : le dirt.png qui dérange ? (j'essairai de le changer)
a+
w
Hors ligne
j'ai remarquer qu'en utilisant une map de taille classique (256*256, 512*512 etc...) au niveau du rendu du terrain sur les bords la hauteur du terrain chute à 0 donnant l'impression d'un mur sur les bords. Probleme genant si l'on veux coller 2 terrains cote a cote.
En fait selon l'algorithme pour generer le terrain il manque les informations de hauteur pour une rangée de pixel sur le bords x et une autre le bord z,
j'ai essayé de modifier la generation du terrain mais je retombe toujours sur le meme probleme soit il manque carrement une colone de CTTileBuffer soit y'a une rangée de pixel de trop ou de moins etc.., j'ai meme essayé de recalculer la hauteur de ces rangée de pixels mais c'est de la bidouille et ca fait des cracks entre 2 terrains.
bref y'a toujours un decalage et qui semble etre normal du fait que si la largeur d'un terrain est 256 unité il faudra 257 vertex pour la representer et comme notre image n'en a que 256 par coté le 257 eme prend la valeur 0 par defaut.
Du coup il semble que charger une image avec une rangé de pixel suplementaire sur les bords x et z (257*257, 513*513 etc..) soit la solution la plus simple à mettre en oeuvre (avec une legere modif du code).
J'ai aussi rajouté du code pour charger une image de type RAW qui elles sont deja de type taille 257*257 etc... et la ca marche bien aussi
Y'a il une meilleure solution ?
Dernière modification par Ikam (24-07-2007 00:30:24)
Hors ligne
bon le fait est qu'il manque une rangée pixel sur chaque bord et d'apres ce que j'ai trouvé sur les heightmap et sur le net, le mieux est d'utiliser des heightmaps de taille 2^N+1 soit du genre 257*257 plutot que 256*256.
j'ai adpater le code pour accepter ces nouveaux formats et ca marche nikel, j'en ai profiter aussi pour corriger 2 autres bugs en rapport avec le meme probleme decrit ICI
Bugs :
- Corrigé ! Sur les extremités du terrain sur les bord X et Z la hauteur chute à 0 : necessite desormais d'employer des map de taille 2^N+1 (257*257, 513*513, etc...)
- Corrigé ! la forme du terrain est inversée par raport à la heightmap
- Corrigé ! la texture couleur du terrain est inversée par raport à la colormap
je crois qu'il y a un autre bug mais celui ci lié au shader, j'ai pas vraiment eu le temps de tester plus mais il m'est arrivé des voir les textures clignotés suite à un mouvement de camera... a suivre
Dernière modification par Ikam (24-07-2007 17:18:21)
Hors ligne
