void SampleParticles::loadTerrain(const char* path, PxReal xScale, PxReal yScale, PxReal zScale)
{
SampleFramework::SampleAsset* asset = getAsset(terrain_hf, SampleFramework::SampleAsset::ASSET_TEXTURE);
mManagedAssets.push_back(asset);
PX_ASSERT(asset->getType() == SampleFramework::SampleAsset::ASSET_TEXTURE);
SampleFramework::SampleTextureAsset* texAsset = static_cast<SampleFramework::SampleTextureAsset*>(asset);
SampleRenderer::RendererTexture2D* heightfieldTexture = texAsset->getTexture();
// NOTE: Assuming that heightfield texture has B8G8R8A8 format.
if(heightfieldTexture)
{
PxU16 nbColumns = PxU16(heightfieldTexture->getWidth());
PxU16 nbRows = PxU16(heightfieldTexture->getHeight());
PxHeightFieldDesc heightFieldDesc;
heightFieldDesc.nbColumns = nbColumns;
heightFieldDesc.nbRows = nbRows;
PxU32* samplesData = (PxU32*)SAMPLE_ALLOC(sizeof(PxU32) * nbColumns * nbRows);
heightFieldDesc.samples.data = samplesData;
heightFieldDesc.samples.stride = sizeof(PxU32);
heightFieldDesc.convexEdgeThreshold = 0;
PxU8* currentByte = (PxU8*)heightFieldDesc.samples.data;
PxU32 texturePitch = 0;
PxU8* loaderPtr = static_cast<PxU8*>(heightfieldTexture->lockLevel(0, texturePitch));
PxVec3Alloc* verticesA = SAMPLE_NEW(PxVec3Alloc)[nbRows * nbColumns];
PxVec3* vertices = verticesA;
PxReal* UVs = (PxReal*)SAMPLE_ALLOC(sizeof(PxReal) * nbRows * nbColumns * 2);
for (PxU32 row = 0; row < nbRows; row++)
{
for (PxU32 column = 0; column < nbColumns; column++)
{
PxHeightFieldSample* currentSample = (PxHeightFieldSample*)currentByte;
currentSample->height = *loaderPtr;
vertices[row * nbColumns + column] =
PxVec3(PxReal(row) * xScale,
PxReal(currentSample->height * zScale),
PxReal(column) * yScale);
UVs[2 * (row * nbColumns + column)] = (PxReal(row) / PxReal(nbRows)) * 7.0f;
UVs[2 * (row * nbColumns + column) + 1] = (PxReal(column) / PxReal(nbColumns)) * 7.0f;
currentSample->materialIndex0 = 0;
currentSample->materialIndex1 = 0;
currentSample->clearTessFlag();
currentByte += heightFieldDesc.samples.stride;
loaderPtr += 4 * sizeof(PxU8);
}
}
PxHeightField* heightField = getPhysics().createHeightField(heightFieldDesc);
// free allocated memory for heightfield samples description
SAMPLE_FREE(samplesData);
// create shape for heightfield
PxTransform pose(PxVec3(-((PxReal)nbRows*yScale) / 2.0f,
0.0f,
-((PxReal)nbColumns*xScale) / 2.0f),
PxQuat::createIdentity());
PxRigidActor* hf = getPhysics().createRigidStatic(pose);
runtimeAssert(hf, "PxPhysics::createRigidStatic returned NULL\n");
PxShape* shape = hf->createShape(PxHeightFieldGeometry(heightField, PxMeshGeometryFlags(), zScale, xScale, yScale), getDefaultMaterial());
runtimeAssert(shape, "PxRigidActor::createShape returned NULL\n");
shape->setFlag(PxShapeFlag::ePARTICLE_DRAIN, false);
shape->setFlag(PxShapeFlag::eSIMULATION_SHAPE, true);
// add actor to the scene
getActiveScene().addActor(*hf);
mPhysicsActors.push_back(hf);
// create indices and UVs
PxU32* indices = (PxU32*)SAMPLE_ALLOC(sizeof(PxU32) * (nbColumns - 1) * (nbRows - 1) * 3 * 2);
for(int i = 0; i < (nbColumns - 1); ++i)
{
for(int j = 0; j < (nbRows - 1); ++j)
{
// first triangle
indices[6 * (i * (nbRows - 1) + j) + 0] = (i + 1) * nbRows + j;
indices[6 * (i * (nbRows - 1) + j) + 1] = i * nbRows + j;
indices[6 * (i * (nbRows - 1) + j) + 2] = i * nbRows + j + 1;
// second triangle
indices[6 * (i * (nbRows - 1) + j) + 3] = (i + 1) * nbRows + j + 1;
indices[6 * (i * (nbRows - 1) + j) + 4] = (i + 1) * nbRows + j;
indices[6 * (i * (nbRows - 1) + j) + 5] = i * nbRows + j + 1;
}
}
// add mesh to renderer
RAWMesh data;
data.mName = "terrain";
data.mTransform = PxTransform::createIdentity();
data.mNbVerts = nbColumns * nbRows;
data.mVerts = (PxVec3*)vertices;
data.mVertexNormals = NULL;
data.mUVs = UVs;
data.mMaterialID = MATERIAL_HEIGHTFIELD;
data.mNbFaces = (nbColumns - 1) * (nbRows - 1) * 2;
data.mIndices = indices;
RenderMeshActor* hf_mesh = createRenderMeshFromRawMesh(data);
hf_mesh->setPhysicsShape(shape);
SAMPLE_FREE(indices);
SAMPLE_FREE(UVs);
DELETEARRAY(verticesA);
}
else
{
char errMsg[256];
physx::string::sprintf_s(errMsg, 256, "Couldn't load %s\n", path);
fatalError(errMsg);
}
}
PxRigidActor* SampleSubmarine::loadTerrain(const char* name, const PxReal heightScale, const PxReal rowScale, const PxReal columnScale)
{
PxRigidActor* heightFieldActor = NULL;
BmpLoader loader;
if(loader.loadBmp(getSampleMediaFilename(name)))
{
PxU16 nbColumns = PxU16(loader.mWidth), nbRows = PxU16(loader.mHeight);
PxHeightFieldDesc heightFieldDesc;
heightFieldDesc.nbColumns = nbColumns;
heightFieldDesc.nbRows = nbRows;
PxU32* samplesData = (PxU32*)SAMPLE_ALLOC(sizeof(PxU32)*nbColumns * nbRows);
heightFieldDesc.samples.data = samplesData;
heightFieldDesc.samples.stride = sizeof(PxU32);
PxU8* currentByte = (PxU8*)heightFieldDesc.samples.data;
PxU8* loader_ptr = loader.mRGB;
PxVec3Alloc* vertexesA = SAMPLE_NEW(PxVec3Alloc)[nbRows * nbColumns];
PxF32* uvs = (PxF32*)SAMPLE_ALLOC(sizeof(PxF32) * nbRows * nbColumns * 2);
PxVec3* vertexes = vertexesA;
for (PxU32 row = 0; row < nbRows; row++)
{
for (PxU32 column = 0; column < nbColumns; column++)
{
PxHeightFieldSample* currentSample = (PxHeightFieldSample*)currentByte;
currentSample->height = *loader_ptr;
vertexes[row * nbColumns + column] = PxVec3(PxReal(row)*rowScale,
PxReal(currentSample->height * heightScale),
PxReal(column)*columnScale);
uvs[(row * nbColumns + column)*2 + 0] = (float)column/7.0f;
uvs[(row * nbColumns + column)*2 + 1] = (float)row/7.0f;
currentSample->materialIndex0 = 0;
currentSample->materialIndex1 = 0;
currentSample->clearTessFlag();
currentByte += heightFieldDesc.samples.stride;
loader_ptr += 3 * sizeof(PxU8);
}
}
PxHeightField* heightField = getPhysics().createHeightField(heightFieldDesc);
if(!heightField) fatalError("createHeightField failed!");
// create shape for heightfield
PxTransform pose(PxVec3(-((PxReal)nbRows*rowScale) / 2.0f,
0.0f,
-((PxReal)nbColumns*columnScale) / 2.0f),
PxQuat::createIdentity());
heightFieldActor = getPhysics().createRigidStatic(pose);
if(!heightFieldActor) fatalError("createRigidStatic failed!");
PxShape* shape = heightFieldActor->createShape(PxHeightFieldGeometry(heightField, PxMeshGeometryFlags(), heightScale, rowScale, columnScale), getDefaultMaterial());
if(!shape) fatalError("createShape failed!");
// add actor to the scene
getActiveScene().addActor(*heightFieldActor);
// create indices
PxU32* indices = (PxU32*)SAMPLE_ALLOC(sizeof(PxU32)*((nbColumns - 1) * (nbRows - 1) * 3 * 2));
for(int i = 0; i < (nbColumns - 1); ++i)
{
for(int j = 0; j < (nbRows - 1); ++j)
{
// first triangle
indices[6 * (i * (nbRows - 1) + j) + 0] = (i + 1) * nbRows + j;
indices[6 * (i * (nbRows - 1) + j) + 1] = i * nbRows + j;
indices[6 * (i * (nbRows - 1) + j) + 2] = i * nbRows + j + 1;
// second triangle
indices[6 * (i * (nbRows - 1) + j) + 3] = (i + 1) * nbRows + j + 1;
indices[6 * (i * (nbRows - 1) + j) + 4] = (i + 1) * nbRows + j;
indices[6 * (i * (nbRows - 1) + j) + 5] = i * nbRows + j + 1;
}
}
// add mesh to renderer
RAWMesh data;
data.mName = name;
data.mTransform = PxTransform::createIdentity();
data.mNbVerts = nbColumns * nbRows;
data.mVerts = vertexes;
data.mVertexNormals = NULL;
data.mUVs = uvs;
data.mMaterialID = MATERIAL_TERRAIN_MUD;
data.mNbFaces = (nbColumns - 1) * (nbRows - 1) * 2;
data.mIndices = indices;
RenderMeshActor* hf_mesh = createRenderMeshFromRawMesh(data);
if(!hf_mesh) fatalError("createRenderMeshFromRawMesh failed!");
hf_mesh->setPhysicsShape(shape);
shape->setFlag(PxShapeFlag::eVISUALIZATION, false);
SAMPLE_FREE(indices);
SAMPLE_FREE(uvs);
DELETEARRAY(vertexesA);
SAMPLE_FREE(samplesData);
}
return heightFieldActor;
}
