iMesh*
iResLoader::loadMesh(dString* filePath) {
CL_THROW_IF_NIL(filePath);
dData* meshData = dData::dataWithContentsOfFile(filePath);
const dByte* meshBytes = (const dByte*)meshData->bytes();
iSMeshHeader* h = (iSMeshHeader*)meshBytes;
assert(dSwapLittleIntToHost(h->tag) == kiMeshSignature);
assert(dSwapLittleIntToHost(h->headerLength) +
dSwapLittleIntToHost(h->ibDataSize) +
dSwapLittleIntToHost(h->vbDataSize) +
dSwapLittleIntToHost(h->meshPartsDataSize) == meshData->length());
meshBytes += dSwapLittleIntToHost(h->headerLength);
dobj_ptr<dData> ibData(dData::alloc()->initWithBytes(meshBytes, h->ibDataSize));
dobj_ptr<iIndexBuffer> ib(iIndexBuffer::alloc()->initWithDataAndType(ibData.get(), kiEDataType_UnsignedShort));
meshBytes += dSwapLittleIntToHost(h->ibDataSize);
dobj_ptr<dData> vbData(dData::alloc()->initWithBytes(meshBytes, h->vbDataSize));
dobj_ptr<iVertexBuffer> vb(iVertexBuffer::alloc()->initWithDataAndFVF(vbData.get(), (iEFVF)dSwapLittleIntToHost(h->fvf)));
meshBytes += dSwapLittleIntToHost(h->vbDataSize);
dobj_ptr<dData> mpData(dData::alloc()->initWithBytes(meshBytes, h->meshPartsDataSize));
const dByte* mpPtr = (const dByte*)mpData->bytes();
dUInteger dataLength = 0;
dobj_ptr<dDictT<iMeshPart*, dString*> > parts((dDictT<iMeshPart*, dString*>*)
dDictT<iMeshPart*, dString*>::alloc()->init());
while (dataLength < h->meshPartsDataSize) {
iSMeshPartInfo* partInfo = (iSMeshPartInfo*)mpPtr;
dobj_ptr<iMeshPart> part(iMeshPart::alloc()->initWithParams(ib.get(), kiEDrawMode_Triangles, partInfo->first, partInfo->count));
mpPtr += sizeof(iSMeshPartInfo);
dataLength += sizeof(iSMeshPartInfo);
dobj_ptr<dString> name(dString::alloc()->initWithCharacters((TCHAR*)mpPtr, partInfo->nameLength));
mpPtr += partInfo->nameLength * sizeof(TCHAR);
dataLength += partInfo->nameLength * sizeof(TCHAR);
parts->setObjectForKey(part.get(), name.get());
}
return iMesh::meshWithVertexBufferAndParts(vb.get(), parts.get());
}
void ColladaMeshFactory::DecodeInstance(RevModel** aModel,FCDGeometry* aGeometry,FCDGeometryInstance* aGeometryInstance,FCDocument* aColladaDocument,bool aHasBoneWeightsFlag,FCDController* aController,FCDControllerInstance* aControllerInstance)
{
FCDGeometryMesh* mesh=aGeometry->GetMesh();
if (!mesh->IsTriangles()) FCDGeometryPolygonsTools::Triangulate(mesh);
FCDGeometrySource* positionSource=mesh->FindSourceByType(FUDaeGeometryInput::POSITION);
FCDGeometrySource* normalSource=mesh->FindSourceByType(FUDaeGeometryInput::NORMAL);
FCDGeometrySource* geoTangentSource=mesh->FindSourceByType(FUDaeGeometryInput::GEOTANGENT);
FCDGeometrySource* texTangentSource=mesh->FindSourceByType(FUDaeGeometryInput::TEXTANGENT);
FCDGeometrySource* colorSource=mesh->FindSourceByType(FUDaeGeometryInput::COLOR);
FCDGeometrySource* textureCordinatesSource=mesh->FindSourceByType(FUDaeGeometryInput::TEXCOORD);
FCDGeometrySource* geoBiNormalSource=mesh->FindSourceByType(FUDaeGeometryInput::GEOBINORMAL);
FCDGeometrySource* texBiNormalSource=mesh->FindSourceByType(FUDaeGeometryInput::TEXBINORMAL);
assert(positionSource);
int elementCount=0;
int totalStride;
int positionStride;
int normalStride;
int colorStride;
int textureCordinatesStride;
int tangentStride;
RevInputData data;
if(positionSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
//(*aModel)->AddModelInputElement(element);
positionStride=elementCount;
data.myElements.push_back( element );
elementCount+=12;
}
if(aHasBoneWeightsFlag)
{
D3D11_INPUT_ELEMENT_DESC element={ "WEIGHTS", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
elementCount+=4;
D3D11_INPUT_ELEMENT_DESC element2={ "BONES", 0, DXGI_FORMAT_R8G8B8A8_UINT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element2 );
elementCount+=4;
}
if(normalSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
normalStride=elementCount;
elementCount+=12;
}
if(colorSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
colorStride=elementCount;
elementCount+=16;
}
if(textureCordinatesSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
textureCordinatesStride=elementCount;
elementCount+=8;
}
//assert(((geoTangentSource!=NULL) && (texTangentSource!=NULL))==false);
if(geoTangentSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
tangentStride=elementCount;
elementCount+=12;
}
if(texTangentSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
tangentStride=elementCount;
elementCount+=12;
}
if(geoBiNormalSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "BINORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
tangentStride=elementCount;
elementCount+=12;
}
if(texBiNormalSource!=NULL)
{
D3D11_INPUT_ELEMENT_DESC element= { "BINORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, elementCount, D3D11_INPUT_PER_VERTEX_DATA, 0 };
data.myElements.push_back( element );
tangentStride=elementCount;
elementCount+=12;
}
for( auto element : data.myElements )
{
data.m_instancedElements.push_back( element );
}
D3D11_INPUT_ELEMENT_DESC elementOne = { "WORLD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 0, D3D11_INPUT_PER_INSTANCE_DATA, 1 };
D3D11_INPUT_ELEMENT_DESC elementTwo = { "WORLD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 16, D3D11_INPUT_PER_INSTANCE_DATA, 1 };
D3D11_INPUT_ELEMENT_DESC elementThree = { "WORLD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 32, D3D11_INPUT_PER_INSTANCE_DATA, 1 };
data.m_instancedElements.push_back( elementOne );
data.m_instancedElements.push_back( elementTwo );
data.m_instancedElements.push_back( elementThree );
totalStride=elementCount;
RevVertexDataNormal vbData( 0 );
DetermineVertexType( vbData, data );
// vbData.mySize = vbData.myStride * vbData.myNrOfVertexes;
// vbData.myVertexData = new char[ vbData.mySize ];
RevIndexData indexData;
GenerateMeshDatafromPolygonsFull(aModel,indexData,vbData,data,aGeometryInstance,mesh, aColladaDocument, aHasBoneWeightsFlag, aController, aControllerInstance );
}
RevModel* RevModelFactory::CreateBox(float width, float height, float depth, const CU::Vector4f& color)
{
//
// Create the vertices.
//
RevVertexDataNormal vbData(24);
vbData.myStride = sizeof( RevVertexPosCol );
vbData.mySize = vbData.myStride * vbData.myNrOfVertexes;
vbData.myVertexData = new char[ vbData.mySize ];
float w2 = 0.5f*width;
float h2 = 0.5f*height;
float d2 = 0.5f*depth;
RevVertexPosCol vP[24];
// Fill in the front face vertex data.
vP[0].myPos = CU::Vector3f(-w2, -h2, -d2);
vP[1].myPos = CU::Vector3f(-w2, +h2, -d2);
vP[2].myPos = CU::Vector3f(+w2, +h2, -d2);
vP[3].myPos= CU::Vector3f(+w2, -h2, -d2);
// Fill in the back face vertex data.
vP[4].myPos = CU::Vector3f(-w2, -h2, +d2);
vP[5].myPos = CU::Vector3f(+w2, -h2, +d2);
vP[6].myPos = CU::Vector3f(+w2, +h2, +d2);
vP[7].myPos = CU::Vector3f(-w2, +h2, +d2);
// Fill in the top face vertex data.
vP[8].myPos = CU::Vector3f(-w2, +h2, -d2);
vP[9].myPos = CU::Vector3f(-w2, +h2, +d2);
vP[10].myPos = CU::Vector3f(+w2, +h2, +d2);
vP[11].myPos = CU::Vector3f(+w2, +h2, -d2);
// Fill in the bottom face vertex data.
vP[12].myPos = CU::Vector3f(-w2, -h2, -d2);
vP[13].myPos = CU::Vector3f(+w2, -h2, -d2);
vP[14].myPos = CU::Vector3f(+w2, -h2, +d2);
vP[15].myPos = CU::Vector3f(-w2, -h2, +d2);
// Fill in the left face vertex data.
vP[16].myPos = CU::Vector3f(-w2, -h2, +d2);
vP[17].myPos = CU::Vector3f(-w2, +h2, +d2);
vP[18].myPos = CU::Vector3f(-w2, +h2, -d2);
vP[19].myPos = CU::Vector3f(-w2, -h2, -d2);
// Fill in the right face vertex data.
vP[20].myPos = CU::Vector3f(+w2, -h2, -d2);
vP[21].myPos = CU::Vector3f(+w2, +h2, -d2);
vP[22].myPos = CU::Vector3f(+w2, +h2, +d2);
vP[23].myPos = CU::Vector3f(+w2, -h2, +d2);
for (auto vIndex = 0; vIndex < 24; vIndex++)
{
vP[vIndex].myColor = color;
}
memcpy(vbData.myVertexData, &vP[0], sizeof(RevVertexPosCol)* 24);
//
// Create the indices.
//
RevIndexData ibData;
ibData.myNrOfIndexes = 36;
ibData.mySize = sizeof( UINT ) * ibData.myNrOfIndexes;
ibData.myFormat = DXGI_FORMAT_R32_UINT;
UINT* indexData = new UINT[ ibData.myNrOfIndexes ];
ibData.myIndexData = new char[ ibData.mySize ];
// Fill in the front face index data
indexData[0] = 0; indexData[1] = 1; indexData[2] = 2;
indexData[3] = 0; indexData[4] = 2; indexData[5] = 3;
// FindexDatall indexDatan the back face indexDatandex data
indexData[6] = 4; indexData[7] = 5; indexData[8] = 6;
indexData[9] = 4; indexData[10] = 6; indexData[11] = 7;
// FindexDatall indexDatan the top face indexDatandex data
indexData[12] = 8; indexData[13] = 9; indexData[14] = 10;
indexData[15] = 8; indexData[16] = 10; indexData[17] = 11;
// FindexDatall indexDatan the bottom face indexDatandex data
indexData[18] = 12; indexData[19] = 13; indexData[20] = 14;
indexData[21] = 12; indexData[22] = 14; indexData[23] = 15;
// FindexDatall indexDatan the left face indexDatandex data
indexData[24] = 16; indexData[25] = 17; indexData[26] = 18;
indexData[27] = 16; indexData[28] = 18; indexData[29] = 19;
// FindexDatall indexDatan the rindexDataght face indexDatandex data
indexData[30] = 20; indexData[31] = 21; indexData[32] = 22;
indexData[33] = 20; indexData[34] = 22; indexData[35] = 23;
memcpy( &ibData.myIndexData, &indexData[0], ibData.mySize );
RevInputData data;
for(int i = 0; i < ARRAYSIZE( VertexPosColLayout ); i++ )
{
data.myElements.push_back( VertexPosColLayout[i] );
}
RevModelRenderEssentials essentials( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );
essentials.myVertexStart = 0;
essentials.myIndexStart = 0;
essentials.myIndexCount = ibData.myNrOfIndexes;
RevModel* model = new RevModel( );
model->InitShader( "Shaders\\Object_PosCol.txt" );
model->Init( vbData, ibData, data, essentials );
m_createdModels.push_back(model);
return model;
}
RevModel* RevModelFactory::GetSphereSliceDefered( )
{
RevModel* model = new RevModel();
model->InitShader( "Shaders\\Fullscreen.txt" );
model->SetIsNullObjectFlag(false);
const int VertexSize=12;
const int PolygonSize = VertexSize-1;
float theta = -90.0f * (3.14157f / 180.0f);
float phi = 0.0f;
std::vector< RevVertexPos > vertexes;
for (int i = 0; i < VertexSize; i++)
{
phi = 0;
for (int j = 0; j < VertexSize; j++)
{
RevVertexPos vertex;
vertex.myPos = CU::Vector3f(
(float)cos(theta) * (float)cos(phi),
(float)cos(theta) * (float)sin(phi),
(float)sin(theta) );
vertexes.push_back( vertex );
phi +=((360.0f) / (float)PolygonSize) * (DirectX::XM_PI / 180.0f);
}
theta += ((180.0f / (float)PolygonSize)* (DirectX::XM_PI / 180.0f));
}
RevVertexDataNormal vbData( vertexes.size() );
vbData.myStride = sizeof( RevVertexPos );
vbData.mySize = vbData.myStride * vbData.myNrOfVertexes;
vbData.myVertexData = new char[ vbData.mySize ];
std::vector< UINT> indicies;
indicies.reserve(PolygonSize * PolygonSize * 6);
int indiceCount=0;
for (int i = 0; i < PolygonSize; i++)
{
for (int j = 0; j < PolygonSize; j++)
{
indicies.push_back((UINT)((i + 1) * VertexSize + j));
indicies.push_back((UINT)(i * VertexSize + j + 1));
indicies.push_back((UINT)(i * VertexSize + j));
indicies.push_back((UINT)((i + 1) * VertexSize + (j))) ;
indicies.push_back((UINT)((i + 1) * VertexSize + (j + 1)));
indicies.push_back((UINT)(i * VertexSize + (j + 1)));
indiceCount += 6;
}
}
// for(int i = 0; i < vertexes.size(); i++)
// {
// RevVertexPos v;
// memcpy( &v, &vertexes[i], vbData.myStride );
// memcpy( &vbData.myVertexData[ offset ], &v, vbData.myStride );
// offset += vbData.myStride;
// }
memcpy(&vbData.myVertexData[0], &vertexes[0], vbData.mySize);
RevIndexData ibData;
ibData.myNrOfIndexes = indicies.size();
ibData.mySize = sizeof(UINT) * indicies.size();
ibData.myFormat = DXGI_FORMAT_R32_UINT;
ibData.myIndexData = new char[ibData.mySize];
memcpy(&ibData.myIndexData[0], &indicies[0], ibData.mySize);
RevInputData data;
const int nElements = ARRAYSIZE( VertexPosLayout );
for(int i = 0; i < nElements; i++ )
{
data.myElements.push_back( VertexPosLayout[i] );
}
data.m_effectTech = RevEffect::_PBL_POINT_LIGHT;
RevModelRenderEssentials essentials( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
essentials.myVertexStart = 0;
essentials.myIndexStart = 0;
essentials.myIndexCount = ibData.myNrOfIndexes;
essentials.myIndexCount = indicies.size();
model->Init( vbData, ibData, data, essentials );
m_createdModels.push_back(model);
return model;
}
