void GuiDecalEditorCtrl::renderScene(const RectI & updateRect)
{
PROFILE_SCOPE( GuiDecalEditorCtrl_renderScene );
GFXTransformSaver saver;
RectI bounds = getBounds();
ColorI hlColor(0,255,0,255);
ColorI regColor(255,0,0,255);
ColorI selColor(0,0,255,255);
ColorI color;
GFXDrawUtil *drawUtil = GFX->getDrawUtil();
GFXStateBlockDesc desc;
desc.setBlend( true );
desc.setZReadWrite( true, false );
// Draw 3D stuff here.
if ( mSELDecal )
{
mGizmo->renderGizmo( mLastCameraQuery.cameraMatrix, mLastCameraQuery.fov );
mSELEdgeVerts.clear();
if ( gDecalManager->clipDecal( mSELDecal, &mSELEdgeVerts ) )
_renderDecalEdge( mSELEdgeVerts, ColorI( 255, 255, 255, 255 ) );
const F32 &decalSize = mSELDecal->mSize;
Point3F boxSize( decalSize, decalSize, decalSize );
MatrixF worldMat( true );
mSELDecal->getWorldMatrix( &worldMat, true );
drawUtil->drawObjectBox( desc, boxSize, mSELDecal->mPosition, worldMat, ColorI( 255, 255, 255, 255 ) );
}
if ( mHLDecal )
{
mHLEdgeVerts.clear();
if ( gDecalManager->clipDecal( mHLDecal, &mHLEdgeVerts ) )
_renderDecalEdge( mHLEdgeVerts, ColorI( 255, 255, 255, 255 ) );
const F32 &decalSize = mHLDecal->mSize;
Point3F boxSize( decalSize, decalSize, decalSize );
MatrixF worldMat( true );
mHLDecal->getWorldMatrix( &worldMat, true );
drawUtil->drawObjectBox( desc, boxSize, mHLDecal->mPosition, worldMat, ColorI( 255, 255, 255, 255 ) );
}
}
void HQWater::update(ICamera* cam)
{
position.x = cam->getPosition()->x;
position.z = cam->getPosition()->z;
position.y = m_waterY;
Vec3 axis;
f32 angle;
Vec3 camDir = Vec3(cam->getViewDirection()->x, 0, cam->getViewDirection()->z);
D3DXVec3Normalize(&camDir, &camDir);
Vec3 planeDir = Vec3(1,0,1);
D3DXVec3Normalize(&planeDir, &planeDir);
D3DXVec3Cross(&axis, &planeDir, &camDir);
angle = acos(D3DXVec3Dot(&planeDir, &camDir));
D3DXMatrixRotationAxis(&rot, &axis, angle);
worldMat(&meshWorld, position);
meshWorld = rot * meshWorld;
position.y = 0;
worldMat(&world, position, rotation);
D3DXMatrixInverse(&invWorld, 0, &world);
boundingBox.setTransform(position);
}
void* Tractor::getVehiclePose()
{
if(m_poseGiven)
return (void*)m_vehiclePose;
m_poseGiven = true;
/*CHASSIS*/
Mat rot;
worldMat(&m_vehiclePose->matChassis, Vec3(m_actor->getGlobalPosition().x, m_actor->getGlobalPosition().y, m_actor->getGlobalPosition().z), Vec3(0, 0, 0));
D3DXMatrixRotationQuaternion(&rot, &D3DXQUATERNION(m_actor->getGlobalOrientationQuat().x, m_actor->getGlobalOrientationQuat().y, m_actor->getGlobalOrientationQuat().z, m_actor->getGlobalOrientationQuat().w));
m_vehiclePose->matChassis = m_vehicleDimms->matChassisRotation * rot * m_vehiclePose->matChassis;
D3DXVec3TransformNormal(&m_forward, &Vec3(1, 0, 0), &rot);
ShapeUserData* sud;
//Wheels
//Front Left wheel
sud = (ShapeUserData*)(m_wheelFrontLeft->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matFrontLeftWheel);
m_vehiclePose->matFrontLeftWheel = m_vehicleDimms->matFrontLeftWheelRotation * m_vehiclePose->matFrontLeftWheel;
//Front Right wheel
sud = (ShapeUserData*)(m_wheelFrontRight->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matFrontRightWheel);
m_vehiclePose->matFrontRightWheel = m_vehicleDimms->matFrontRightWheelRotation * m_vehiclePose->matFrontRightWheel;
//Rear Left wheel
sud = (ShapeUserData*)(m_wheelRearLeft->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matRearLeftWheel);
m_vehiclePose->matRearLeftWheel = m_vehicleDimms->matRearLeftWheelRotation * m_vehiclePose->matRearLeftWheel;
//Rear Right wheel
sud = (ShapeUserData*)(m_wheelRearRight->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matRearRightWheel);
m_vehiclePose->matRearRightWheel = m_vehicleDimms->matRearRightWheelRotation * m_vehiclePose->matRearRightWheel;
return (void*)m_vehiclePose;
}
u32 HQWater::render()
{
if(!m_shader || !m_hmap || !m_hmap2 || !m_dhmap || !m_fresnel || !m_foam || !m_normalMap || !m_detailNormalMap || !mesh || !meshMed || !meshLow)
return 0;
else
{
update(gEngine.renderer->get().camera);
static f32 lastWaterAmp = 0;
if(lastWaterAmp != r_waterAmplitude){ lastWaterAmp = r_waterAmplitude; m_mustUpdateNormalMap = 1; }
m_waterY = 3*r_waterAmplitude;
gEngine.renderer->setReflectionHeight(m_waterY);
if(m_updatedNormalMapType != r_waterOcean)m_mustUpdateNormalMap = m_mustUpdateDetailNormalMap = 1;
if(m_mustUpdateNormalMap || m_mustUpdateDetailNormalMap)
{
gEngine.renderer->disableHDR();
if(m_mustUpdateNormalMap)updateNormalMap();
if(m_mustUpdateDetailNormalMap)updateDetailNormalMap();
gEngine.renderer->enableHDR();
}
Mat g_matInvViewProj;
D3DXMatrixInverse(&g_matInvViewProj, 0, gEngine.renderer->get().camera->getViewProjectionMat());
if(gEngine.renderer->get().type == REND_DEFERRED)
gEngine.renderer->setShader(m_shader->setTech("WaterDeferred"));
else
gEngine.renderer->setShader(m_shader->setTech("Water"));
m_shader->setTex("DEPTHMAP", gEngine.renderer->getMRT()->getRT(2));
m_shader->setF32("m_waterY", m_waterY);
m_shader->setMat("g_matInvViewProj", &g_matInvViewProj);
m_shader->setTex("ReflectionMap", gEngine.renderer->getReflectionTexture()->getColorTexture());
if(gEngine.renderer->get().type == REND_DEFERRED)
m_shader->setTex("RefractionMap", gEngine.renderer->getMRT()->getRT(0));
else
m_shader->setTex("RefractionMap", gEngine.renderer->getBackBuffer(0)->getColorTexture());
m_shader->setTex("HMap", m_normalMap->getColorTexture());
m_shader->setTex("DetailNormalMap", m_detailNormalMap->getColorTexture());
m_shader->setF32("detailNormalMapScale", r_waterDetailNormalMapScale);
m_shader->setTex("Fresnel", m_fresnel);
m_shader->setTex("Foam", m_foam);
m_shader->setF32("Amplitude", r_waterAmplitude);
m_shader->setVec3("g_waterColor", &r_waterColor);
m_shader->setF32("h0coef", r_waterH0coef);
m_shader->setF32("h1coef", r_waterH1coef);
m_shader->setF32("h2coef", r_waterH2coef);
m_shader->setF32("h3coef", r_waterH3coef);
m_shader->setF32("detailNormalMapCoef", r_waterDetailNormalMapCoef);
m_shader->setF32("g_R0", r_waterFresnelR0);
m_shader->setF32("g_refractionStrength", r_waterRefractionStrength);
m_shader->setF32("g_waterSpecularExp", r_waterSpecularExp);
m_shader->setF32("g_hMapTextureSize", g_waterNormalMapSize);
m_shader->setF32("g_hMapTextureTexelSize", 1.0f/(f32)g_waterNormalMapSize);
m_shader->setVec2("half_texel", &Vec2(0.5f/(f32)gEngine.device->getWidth(), 0.5f/(f32)gEngine.device->getHeight()));
m_shader->setF32("g_time", gEngine.kernel->tmr->getFrameTime() * 0.001f);
m_shader->setF32("g_refExp", r_refExp);
if(g_sunLight)
{
m_shader->setVec3("g_sunDir", g_sunLight->getDir());
m_shader->setVec4("g_sunColor", g_sunLight->getColor());
}
else
{
m_shader->setVec3("g_sunDir", &Vec3(0, -1, 0));
m_shader->setVec4("g_sunColor", &Vec4(1,1,1,1));
}
m_shader->setVec4("g_fogParams", &r_fogParams);
m_shader->setVec3("g_fogColor", &r_fogColor);
gEngine.renderer->state.setAlphaBlendEnable(TRUE);
gEngine.renderer->state.setBlendOp(D3DBLENDOP_ADD);
gEngine.renderer->state.setSrcBlend(D3DBLEND_SRCALPHA);
gEngine.renderer->state.setDestBlend(D3DBLEND_INVSRCALPHA);
Mat trans;
position.y = 0;
for(f32 x = 0; x < 9000;)
{
for(f32 y = 0; y < 9000;)
{
if(x >= 3000 || y >= 3000)
{
worldMat(&trans, Vec3(x - 100.0f, -2, y - 100.0f));
worldMat(&meshWorld, position);
meshWorld = trans * rot * meshWorld;
gEngine.renderer->setWorld(&meshWorld);
gEngine.renderer->commitChanges();
meshLow->render();
}
else if(x >= 1000 || y >= 1000)
{
worldMat(&trans, Vec3(x - 100.0f, -1, y - 100.0f));
worldMat(&meshWorld, position);
meshWorld = trans * rot * meshWorld;
gEngine.renderer->setWorld(&meshWorld);
gEngine.renderer->commitChanges();
meshMed->render();
}
else
{
worldMat(&trans, Vec3(x - 100.0f, 0, y - 100.0f));
worldMat(&meshWorld, position);
meshWorld = trans * rot * meshWorld;
gEngine.renderer->setWorld(&meshWorld);
gEngine.renderer->commitChanges();
mesh->render();
}
if(y >= 3000)y+=6000;
else if(y >= 1000)y+=2000;
else y+= 1000;
}
if(x >= 3000)x+=6000;
else if(x >= 1000)x+=2000;
else x+= 1000;
}
return 1;
}
}
VehiclePose* VehicleController::getVehiclePose()
{
if(m_poseGiven)
return m_vehiclePose;
m_poseGiven = true;
Mat backup;
Vec3 wheelPos;
NxWheelContactData dest;
NxShape* cont;
float contactPos;
Vec3 suspensionTravel;
/*CHASSIS*/
Mat rot;
worldMat(&m_vehiclePose->matChassis, Vec3(m_actor->getGlobalPosition().x, m_actor->getGlobalPosition().y, m_actor->getGlobalPosition().z), Vec3(0, 0, 0));
D3DXMatrixRotationQuaternion(&rot, &D3DXQUATERNION(m_actor->getGlobalOrientationQuat().x, m_actor->getGlobalOrientationQuat().y, m_actor->getGlobalOrientationQuat().z, m_actor->getGlobalOrientationQuat().w));
Vec3 cross;
Mat chassisRot;
D3DXVec3Cross(&cross, &Vec3(1, 0, 0), &m_vehicleParams->vecChassisForward);
D3DXMatrixRotationAxis(&chassisRot, &cross, acos(D3DXVec3Dot(&Vec3(1, 0, 0), &m_vehicleParams->vecChassisForward)));
m_vehiclePose->matChassis = chassisRot * rot * m_vehiclePose->matChassis;
D3DXVec3TransformCoord(&m_forward, &Vec3(1, 0, 0), &rot);
D3DXVec3TransformCoord(&m_left, &Vec3(0, 0, -1), &rot);
D3DXVec3Normalize(&m_forward, &m_forward);
D3DXVec3Normalize(&m_left, &m_left);
ShapeUserData* sud;
//Wheels
//Front Left wheel
Mat wheelRot;
D3DXMatrixRotationYawPitchRoll(&wheelRot, m_vehicleParams->vecFrontLeftWheelRotation.y, m_vehicleParams->vecFrontLeftWheelRotation.x, m_vehicleParams->vecFrontLeftWheelRotation.z);
sud = (ShapeUserData*)(m_wheelFrontLeft->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matFrontLeftWheel);
m_vehiclePose->matFrontLeftWheel = wheelRot * m_vehiclePose->matFrontLeftWheel;
wheelPos = getVehicleParams()->posFrontLeftWheel;
D3DXVec3TransformCoord(&wheelPos, &wheelPos, &m_vehiclePose->matChassis);
cont = m_wheelFrontLeft->getContact(dest);
backup = m_vehiclePose->matChassis;
backup._41 = 0;
backup._42 = 0;
backup._43 = 0;
contactPos = dest.contactPosition;
if(!cont)
contactPos = m_wheelFrontLeft->getSuspensionTravel();
else
contactPos -= m_wheelFrontLeft->getRadius();
suspensionTravel = Vec3(0, contactPos, 0);
D3DXVec3TransformCoord(&suspensionTravel, &suspensionTravel, &backup);
//if(dest.contactForce)
wheelPos -= suspensionTravel;
m_vehiclePose->matFrontLeftWheel._41 = wheelPos.x;
m_vehiclePose->matFrontLeftWheel._42 = wheelPos.y;
m_vehiclePose->matFrontLeftWheel._43 = wheelPos.z;
//Front Right wheel
D3DXMatrixRotationYawPitchRoll(&wheelRot, m_vehicleParams->vecFrontRightWheelRotation.y, m_vehicleParams->vecFrontRightWheelRotation.x, m_vehicleParams->vecFrontRightWheelRotation.z);
sud = (ShapeUserData*)(m_wheelFrontRight->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matFrontRightWheel);
m_vehiclePose->matFrontRightWheel = wheelRot * m_vehiclePose->matFrontRightWheel;
wheelPos = getVehicleParams()->posFrontRightWheel;
D3DXVec3TransformCoord(&wheelPos, &wheelPos, &m_vehiclePose->matChassis);
cont = m_wheelFrontRight->getContact(dest);
backup = m_vehiclePose->matChassis;
backup._41 = 0;
backup._42 = 0;
backup._43 = 0;
contactPos = dest.contactPosition;
if(!cont)
contactPos = m_wheelFrontRight->getSuspensionTravel();
else
contactPos -= m_wheelFrontRight->getRadius();
suspensionTravel = Vec3(0, contactPos, 0);
D3DXVec3TransformCoord(&suspensionTravel, &suspensionTravel, &backup);
//if(dest.contactForce)
wheelPos -= suspensionTravel;
m_vehiclePose->matFrontRightWheel._41 = wheelPos.x;
m_vehiclePose->matFrontRightWheel._42 = wheelPos.y;
m_vehiclePose->matFrontRightWheel._43 = wheelPos.z;
//Rear Left wheel
D3DXMatrixRotationYawPitchRoll(&wheelRot, m_vehicleParams->vecRearLeftWheelRotation.y, m_vehicleParams->vecRearLeftWheelRotation.x, m_vehicleParams->vecRearLeftWheelRotation.z);
sud = (ShapeUserData*)(m_wheelRearLeft->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matRearLeftWheel);
m_vehiclePose->matRearLeftWheel = wheelRot * m_vehiclePose->matRearLeftWheel;
wheelPos = getVehicleParams()->posRearLeftWheel;
D3DXVec3TransformCoord(&wheelPos, &wheelPos, &m_vehiclePose->matChassis);
cont = m_wheelRearLeft->getContact(dest);
backup = m_vehiclePose->matChassis;
backup._41 = 0;
backup._42 = 0;
backup._43 = 0;
contactPos = dest.contactPosition;
if(!cont)
contactPos = m_wheelRearLeft->getSuspensionTravel();
else
contactPos -= m_wheelRearLeft->getRadius();
suspensionTravel = Vec3(0, contactPos, 0);
D3DXVec3TransformCoord(&suspensionTravel, &suspensionTravel, &backup);
//if(dest.contactForce)
wheelPos -= suspensionTravel;
m_vehiclePose->matRearLeftWheel._41 = wheelPos.x;
m_vehiclePose->matRearLeftWheel._42 = wheelPos.y;
m_vehiclePose->matRearLeftWheel._43 = wheelPos.z;
//Rear Right wheel
D3DXMatrixRotationYawPitchRoll(&wheelRot, m_vehicleParams->vecRearRightWheelRotation.y, m_vehicleParams->vecRearRightWheelRotation.x, m_vehicleParams->vecRearRightWheelRotation.z);
sud = (ShapeUserData*)(m_wheelRearRight->userData);
sud->wheelShapePose.getColumnMajor44((NxF32*)&m_vehiclePose->matRearRightWheel);
m_vehiclePose->matRearRightWheel = wheelRot * m_vehiclePose->matRearRightWheel;
wheelPos = getVehicleParams()->posRearRightWheel;
D3DXVec3TransformCoord(&wheelPos, &wheelPos, &m_vehiclePose->matChassis);
cont = m_wheelRearRight->getContact(dest);
backup = m_vehiclePose->matChassis;
backup._41 = 0;
backup._42 = 0;
backup._43 = 0;
contactPos = dest.contactPosition;
if(!cont)
contactPos = m_wheelRearRight->getSuspensionTravel();
else
contactPos -= m_wheelRearRight->getRadius();
suspensionTravel = Vec3(0, contactPos, 0);
D3DXVec3TransformCoord(&suspensionTravel, &suspensionTravel, &backup);
//if(dest.contactForce)
wheelPos -= suspensionTravel;
m_vehiclePose->matRearRightWheel._41 = wheelPos.x;
m_vehiclePose->matRearRightWheel._42 = wheelPos.y;
m_vehiclePose->matRearRightWheel._43 = wheelPos.z;
return m_vehiclePose;
}
Terrain::Terrain(TerrainVertex *vertices, LPDIRECT3DTEXTURE9 indTex, u32 secX, u32 secY, u32 sectorSize, u32 hmSize, f32 texHmGeoStep)
{
shader = 0;
m_indexTexture = indTex;
m_colorTexture[0] = 0;
m_colorTexture[1] = 0;
m_colorTexture[2] = 0;
m_colorTexture[3] = 0;
m_vb = 0;
m_ibCenter = 0;
m_ibBorder = 0;
m_vbSize = 0;
m_ibCenterSize = 0;
m_ibBorderSize = 0;
m_indexTexture = 0;
m_borderTopLod = 0;
m_borderLeftLod = 0;
m_borderTopLod = 0;
m_borderBottomLod = 0;
m_top = m_left = m_right = m_bottom = 0;
m_sectorSize = sectorSize;
mesh = 0;
//DEFERRED MAT
material = new Material();
if(g_terrainTexColorMap1.size())material->m_colorMapSplatting[0] = gEngine.resMgr->load<Texture>(g_terrainTexColorMap1);
if(g_terrainTexColorMap2.size())material->m_colorMapSplatting[1] = gEngine.resMgr->load<Texture>(g_terrainTexColorMap2);
if(g_terrainTexColorMap3.size())material->m_colorMapSplatting[2] = gEngine.resMgr->load<Texture>(g_terrainTexColorMap3);
if(g_terrainTexColorMap4.size())material->m_colorMapSplatting[3] = gEngine.resMgr->load<Texture>(g_terrainTexColorMap4);
if(g_terrainTexNormalMap1.size())material->m_normalMapSplatting[0] = gEngine.resMgr->load<Texture>(g_terrainTexNormalMap1);
if(g_terrainTexNormalMap2.size())material->m_normalMapSplatting[1] = gEngine.resMgr->load<Texture>(g_terrainTexNormalMap2);
if(g_terrainTexNormalMap3.size())material->m_normalMapSplatting[2] = gEngine.resMgr->load<Texture>(g_terrainTexNormalMap3);
if(g_terrainTexNormalMap4.size())material->m_normalMapSplatting[3] = gEngine.resMgr->load<Texture>(g_terrainTexNormalMap4);
material->m_type = MT_TERRAIN;
material->m_albedoMap = gEngine.resMgr->load<Texture>("noise.jpg");
material->m_useSpecular = 1.0f;
material->m_splatting = 1;
material->update();
shader = material->m_shader;
Vec3 minbb = Vec3(200000,200000,200000), maxbb = Vec3(-200000,-200000,-200000);
TerrainVertex *v;
WORD *indices;
m_levels = sqrt((f32)sectorSize+1)-1;
if(m_levels>g_terrainMaxLODLevels)
m_levels=g_terrainMaxLODLevels;
m_vb = new LPDIRECT3DVERTEXBUFFER9[m_levels];
m_ibCenter = new LPDIRECT3DINDEXBUFFER9[m_levels];
m_ibBorder = new LPDIRECT3DINDEXBUFFER9[m_levels];
m_vbSize = new u32[m_levels];
m_ibCenterSize = new u32[m_levels];
m_ibBorderSize = new u32[m_levels];
for(u32 level = 0; level < m_levels; level++)
{
u32 lev = pow((f32)2, (i32)level);
u32 lowWidth = (((f32)sectorSize)/(f32)lev)+1;
m_vbSize[level] = (u32)(lowWidth * lowWidth);
gEngine.kernel->addMemUsage("Terrain", m_vbSize[level] * sizeof(TerrainVertex));
if(FAILED(gEngine.device->getDev()->CreateVertexBuffer(m_vbSize[level] * sizeof(TerrainVertex), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &m_vb[level], NULL)))
{ gEngine.kernel->log->prnEx(LT_ERROR, "Terrain", "Could not create vertex buffer for level %u", level); return; }
m_vb[level]->Lock(0, 0, (void**)&v, 0);
u32 count = 0;
for (UINT y = 0; y <= sectorSize; y+=lev){
for (UINT x = 0; x <= sectorSize; x+=lev){
u32 vertIndex = ((secY*sectorSize + y)*(hmSize) + secX*sectorSize + x);
Vec3 pos = vertices[vertIndex].pos;
//if(( (x == 0 || x == (sectorSize)) || (y == 0 || y == (sectorSize)) ) && level > 0)pos.y -= pow(g_terrainLowVBExponentX, (f32)level) * g_terrainLowVBExponent;
if(pos.x > maxbb.x)maxbb.x=pos.x;if(pos.y > maxbb.y)maxbb.y=pos.y;if(pos.z > maxbb.z)maxbb.z=pos.z;
if(pos.x < minbb.x)minbb.x=pos.x;if(pos.y < minbb.y)minbb.y=pos.y;if(pos.z < minbb.z)minbb.z=pos.z;
v[count] = vertices[vertIndex];
//v[count].texCoord = Vec2((float)(pos.x)/(hmSize*texHmGeoStep), (float)(pos.z)/(hmSize*texHmGeoStep));
v[count].texCoord = Vec2((f32)x/(f32)sectorSize,(f32)y/(f32)sectorSize);
count++;
}
}
u32 centerWidth = ((sectorSize/lev)-2)?((sectorSize/lev)-2):((sectorSize/lev)-1);
m_ibCenterSize[level] = (centerWidth * centerWidth * 3 * 2);
gEngine.kernel->addMemUsage("Terrain", m_ibCenterSize[level] * sizeof(WORD));
if(FAILED(gEngine.device->getDev()->CreateIndexBuffer(m_ibCenterSize[level] * sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_ibCenter[level], NULL)))
{ gEngine.kernel->log->prnEx(LT_ERROR, "Terrain", "Could not create center index buffer for level %u", level); return; }
m_ibBorderSize[level] = (sectorSize/lev)*5*3 + (sectorSize/lev-1)*4*3;
gEngine.kernel->addMemUsage("Terrain", m_ibBorderSize[level] * sizeof(WORD));
if(FAILED(gEngine.device->getDev()->CreateIndexBuffer(m_ibBorderSize[level] * sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_ibBorder[level], NULL)))
{ gEngine.kernel->log->prnEx(LT_ERROR, "Terrain", "Could not create border index buffer for level %u", level); return; }
m_ibCenter[level]->Lock(0, 0, (void**)&indices, 0);
count = 0;
WORD vIndex = 0;
for (UINT z = 1; z < (sectorSize)/lev - 1; z++){
for (UINT x = 1; x < (sectorSize)/lev - 1; x++){
vIndex = z * lowWidth + x;
// first triangle
indices[count++] = vIndex + 1; indices[count++] = vIndex; indices[count++] = vIndex + lowWidth;
// second triangle
indices[count++] = vIndex + 1; indices[count++] = vIndex + lowWidth; indices[count++] = vIndex + lowWidth + 1;
}
}
m_vb[level]->Unlock();
m_ibCenter[level]->Unlock();
}
position = Vec3(0,0,0);
boundingBox = BoundingBox(minbb, maxbb);
boundingBox.setTransform(position);
worldMat(&world, position);
m_borderTopLod = new u32[m_levels];
m_borderLeftLod = new u32[m_levels];
m_borderRightLod = new u32[m_levels];
m_borderBottomLod = new u32[m_levels];
for(u32 i = 0; i < m_levels; i++)
{
m_borderTopLod[i] = 999;
m_borderLeftLod[i] = 999;
m_borderRightLod[i] = 999;
m_borderBottomLod[i] = 999;
}
m_lod = 0;
m_lodGeo = 0;
gEngine.kernel->addMemUsage("Terrain", sizeof(this));
}
