// ----------------------------------------------------------------------------
CMeshBuffer<S3DVertex2TCoords>* Terrain::build(path p)
{
IrrlichtDevice* device = Editor::getEditor()->getDevice();
CMeshBuffer<S3DVertex2TCoords>* mb = new CMeshBuffer<S3DVertex2TCoords>();
mb->Vertices.reallocate(m_mesh.vertex_count);
mb->Indices.reallocate(m_mesh.quad_count * 6);
for (u32 i = 0; i < m_mesh.vertex_count; i++)
mb->Vertices.push_back(m_mesh.vertices[i]);
for (u32 i = 0; i < m_mesh.quad_count * 6; i++)
mb->Indices.push_back(m_mesh.indices[i]);
mb->recalculateBoundingBox();
mb->Material = m_material;
ITexture* texture = m_material.getTexture(1);
IImage* image = device->getVideoDriver()->createImage(texture, position2di(0, 0),
texture->getSize());
stringc name = p + "/splatt.png";
device->getVideoDriver()->writeImageToFile(image, name.c_str());
image->drop();
return mb;
} // build
void CMeshEntity::Render(CShader* shader, const mat4f &view, const mat4f &projection)
{
assert ( shader != NULL );
//send modelViewprojection matrix to the current shader
if(shader->matprojviewmodel != -1 )
{
mat4f mat = projection * view * m_mTransformationMatrix;
glUniformMatrix4fv(shader->matprojviewmodel, 1, GL_FALSE, &mat[0]);
}
//send model matrix if the shader needs
if(shader->matmodel != -1 )
{
glUniformMatrix4fv(shader->matmodel, 1, GL_FALSE, &m_mTransformationMatrix[0]);
}
//this part can be merged with a renderer class
//get the mesh buffer
CMeshBuffer* buffer = m_pMesh->GetMeshBuffer();
//go through all groups in the mesh buffer
for(uint32 g = 0; g < buffer->GroupsCount(); ++g)
{
//render each group
CMeshGroup* grp = buffer->GroupAtIndex(g);
//get corresponding material for each group
CMaterial* material = buffer->MaterialForGroup(grp);
//the following code can be merged with a renderer class
//map material to shader context, this can be merged in a renderer class, where the renderer go through all material properties and set the appropriate GL state and shader uniform, for ex, bump texture, detail texture, (diffuse, ambient, specular properties ), face culling, depth write, transparent materials (blending) etc...
if(material != NULL )
{
if( material->diffuseTexture != NULL && shader->texture0 != -1)
{
material->diffuseTexture->ActivateAndBind(GL_TEXTURE0);
//shader->SetUniform1i("texture0", 0, shader->texture0);
//or
glUniform1i(shader->texture0, 0);
}
}
//enable vertex array object (vao)
grp->MapToGPU(0);
//perform GL draw for each group
glDrawElements(grp->GetDrawingMode(), grp->GetIndices().size(), GL_UNSIGNED_SHORT, 0);
}
}
void CGeometryTool::quad(CMeshBuffer& meshBuffer, real x1, real y1, real x2, real y2, real x3, real y3, real x4, real y4)
{
CBuffer<QVector3D>& vertices = meshBuffer.positionsBuffer();
CBuffer<QVector3D>& normals = meshBuffer.normalsBuffer();
vertices << QVector3D(x1, y1, -0.05f);
vertices << QVector3D(x2, y2, -0.05f);
vertices << QVector3D(x4, y4, -0.05f);
vertices << QVector3D(x3, y3, -0.05f);
vertices << QVector3D(x4, y4, -0.05f);
vertices << QVector3D(x2, y2, -0.05f);
QVector3D n = QVector3D::normal
(QVector3D(x2 - x1, y2 - y1, 0.0f), QVector3D(x4 - x1, y4 - y1, 0.0f));
normals << n;
normals << n;
normals << n;
normals << n;
normals << n;
normals << n;
vertices << QVector3D(x4, y4, 0.05f);
vertices << QVector3D(x2, y2, 0.05f);
vertices << QVector3D(x1, y1, 0.05f);
vertices << QVector3D(x2, y2, 0.05f);
vertices << QVector3D(x4, y4, 0.05f);
vertices << QVector3D(x3, y3, 0.05f);
n = QVector3D::normal
(QVector3D(x2 - x4, y2 - y4, 0.0f), QVector3D(x1 - x4, y1 - y4, 0.0f));
normals << n;
normals << n;
normals << n;
normals << n;
normals << n;
normals << n;
}
void CGeometryTool::extrude(CMeshBuffer& meshBuffer, real x1, real y1, real x2, real y2)
{
CBuffer<QVector3D>& vertices = meshBuffer.positionsBuffer();
CBuffer<QVector3D>& normals = meshBuffer.normalsBuffer();
vertices << QVector3D(x1, y1, +0.05f);
vertices << QVector3D(x2, y2, +0.05f);
vertices << QVector3D(x1, y1, -0.05f);
vertices << QVector3D(x2, y2, -0.05f);
vertices << QVector3D(x1, y1, -0.05f);
vertices << QVector3D(x2, y2, +0.05f);
QVector3D n = QVector3D::normal
(QVector3D(x2 - x1, y2 - y1, 0.0f), QVector3D(0.0f, 0.0f, -0.1f));
normals << n;
normals << n;
normals << n;
normals << n;
normals << n;
normals << n;
}
void CSMFMeshFileLoader::loadLimb(io::IReadFile* file, SMesh* mesh, const core::matrix4 &parentTransformation)
{
core::matrix4 transformation;
// limb transformation
core::vector3df translate, rotate, scale;
io::BinaryFile::read(file, translate);
io::BinaryFile::read(file, rotate);
io::BinaryFile::read(file, scale);
transformation.setTranslation(translate);
transformation.setRotationDegrees(rotate);
transformation.setScale(scale);
transformation = parentTransformation * transformation;
core::stringc textureName, textureGroupName;
// texture information
io::BinaryFile::read(file, textureGroupName);
io::BinaryFile::read(file, textureName);
// attempt to load texture using known formats
video::ITexture* texture = 0;
const c8* extensions[] = {".jpg", ".png", ".tga", ".bmp", 0};
for (const c8 **ext = extensions; !texture && *ext; ++ext)
{
texture = getMeshTextureLoader() ? getMeshTextureLoader()->getTexture(textureName + *ext) : NULL;
if (texture)
{
textureName = textureName + *ext;
break;
}
}
// find the correct mesh buffer
u32 i;
for (i=0; i<mesh->MeshBuffers.size(); ++i)
if (mesh->MeshBuffers[i]->getMaterial().TextureLayer[0].Texture == texture)
break;
// create mesh buffer if none was found
if (i == mesh->MeshBuffers.size())
{
CMeshBuffer<video::S3DVertex>* mb = new CMeshBuffer<video::S3DVertex>();
mb->Material.TextureLayer[0].Texture = texture;
// horribly hacky way to do this, maybe it's in the flags?
if (core::hasFileExtension(textureName, "tga", "png"))
mb->Material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
else
mb->Material.MaterialType = video::EMT_SOLID;
mesh->MeshBuffers.push_back(mb);
}
CMeshBuffer<video::S3DVertex>* mb = (CMeshBuffer<video::S3DVertex>*)mesh->MeshBuffers[i];
u16 vertexCount, firstVertex = mb->getVertexCount();
io::BinaryFile::read(file, vertexCount);
mb->Vertices.reallocate(mb->Vertices.size() + vertexCount);
// add vertices and set positions
for (i=0; i<vertexCount; ++i)
{
core::vector3df pos;
io::BinaryFile::read(file, pos);
transformation.transformVect(pos);
video::S3DVertex vert;
vert.Color = 0xFFFFFFFF;
vert.Pos = pos;
mb->Vertices.push_back(vert);
}
// set vertex normals
for (i=0; i < vertexCount; ++i)
{
core::vector3df normal;
io::BinaryFile::read(file, normal);
transformation.rotateVect(normal);
mb->Vertices[firstVertex + i].Normal = normal;
}
// set texture coordinates
for (i=0; i < vertexCount; ++i)
{
core::vector2df tcoords;
io::BinaryFile::read(file, tcoords);
mb->Vertices[firstVertex + i].TCoords = tcoords;
}
// triangles
u32 triangleCount;
// vertexCount used as temporary
io::BinaryFile::read(file, vertexCount);
triangleCount=3*vertexCount;
mb->Indices.reallocate(mb->Indices.size() + triangleCount);
for (i=0; i < triangleCount; ++i)
{
u16 index;
io::BinaryFile::read(file, index);
mb->Indices.push_back(firstVertex + index);
}
// read limbs
s32 limbCount;
io::BinaryFile::read(file, limbCount);
for (s32 l=0; l < limbCount; ++l)
loadLimb(file, mesh, transformation);
}
//! creates/loads an animated mesh from the file.
//! \return Pointer to the created mesh. Returns 0 if loading failed.
//! If you no longer need the mesh, you should call IAnimatedMesh::drop().
//! See IReferenceCounted::drop() for more information.
IAnimatedMesh* COCTLoader::createMesh(io::IReadFile* file)
{
if (!file)
return 0;
octHeader header;
file->read(&header, sizeof(octHeader));
octVert * verts = new octVert[header.numVerts];
octFace * faces = new octFace[header.numFaces];
octTexture * textures = new octTexture[header.numTextures];
octLightmap * lightmaps = new octLightmap[header.numLightmaps];
octLight * lights = new octLight[header.numLights];
file->read(verts, sizeof(octVert) * header.numVerts);
file->read(faces, sizeof(octFace) * header.numFaces);
//TODO: Make sure id is in the legal range for Textures and Lightmaps
u32 i;
for (i = 0; i < header.numTextures; i++) {
octTexture t;
file->read(&t, sizeof(octTexture));
textures[t.id] = t;
}
for (i = 0; i < header.numLightmaps; i++) {
octLightmap t;
file->read(&t, sizeof(octLightmap));
lightmaps[t.id] = t;
}
file->read(lights, sizeof(octLight) * header.numLights);
//TODO: Now read in my extended OCT header (flexible lightmaps and vertex normals)
// This is the method Nikolaus Gebhardt used in the Q3 loader -- create a
// meshbuffer for every possible combination of lightmap and texture including
// a "null" texture and "null" lightmap. Ones that end up with nothing in them
// will be removed later.
SMesh * Mesh = new SMesh();
for (i=0; i<(header.numTextures+1) * (header.numLightmaps+1); ++i)
{
CMeshBuffer<video::S3DVertex2TCoords>* buffer = new CMeshBuffer<video::S3DVertex2TCoords>(SceneManager->getVideoDriver()->getVertexDescriptor(1));
buffer->Material.MaterialType = video::EMT_LIGHTMAP;
buffer->Material.Lighting = false;
Mesh->addMeshBuffer(buffer);
buffer->drop();
}
// Build the mesh buffers
for (i = 0; i < header.numFaces; i++)
{
if (faces[i].numVerts < 3)
continue;
const f32* const a = verts[faces[i].firstVert].pos;
const f32* const b = verts[faces[i].firstVert+1].pos;
const f32* const c = verts[faces[i].firstVert+2].pos;
const core::vector3df normal =
core::plane3df(core::vector3df(a[0],a[1],a[2]), core::vector3df(b[0],c[1],c[2]), core::vector3df(c[0],c[1],c[2])).Normal;
const u32 textureID = core::min_(s32(faces[i].textureID), s32(header.numTextures - 1)) + 1;
const u32 lightmapID = core::min_(s32(faces[i].lightmapID),s32(header.numLightmaps - 1)) + 1;
CMeshBuffer<video::S3DVertex2TCoords>* meshBuffer = (CMeshBuffer<video::S3DVertex2TCoords>*)Mesh->getMeshBuffer(lightmapID * (header.numTextures + 1) + textureID);
const u32 base = meshBuffer->getVertexBuffer()->getVertexCount();
// Add this face's verts
u32 v;
for (v = 0; v < faces[i].numVerts; ++v)
{
octVert * vv = &verts[faces[i].firstVert + v];
video::S3DVertex2TCoords vert;
vert.Pos.set(vv->pos[0], vv->pos[1], vv->pos[2]);
vert.Color = video::SColor(0,255,255,255);
vert.Normal.set(normal);
if (textureID == 0)
{
// No texture -- just a lightmap. Thus, use lightmap coords for texture 1.
// (the actual texture will be swapped later)
vert.TCoords.set(vv->lc[0], vv->lc[1]);
}
else
{
vert.TCoords.set(vv->tc[0], vv->tc[1]);
vert.TCoords2.set(vv->lc[0], vv->lc[1]);
}
meshBuffer->getVertexBuffer()->addVertex(&vert);
}
// Now add the indices
// This weird loop turns convex polygons into triangle strips.
// I do it this way instead of a simple fan because it usually looks a lot better in wireframe, for example.
// High, Low
u32 h = faces[i].numVerts - 1;
u32 l = 0;
for (v = 0; v < faces[i].numVerts - 2; ++v)
{
const u32 center = (v & 1)? h - 1: l + 1;
meshBuffer->getIndexBuffer()->addIndex(base + h);
meshBuffer->getIndexBuffer()->addIndex(base + l);
meshBuffer->getIndexBuffer()->addIndex(base + center);
if (v & 1)
--h;
else
++l;
}
}
// load textures
core::array<video::ITexture*> tex;
tex.reallocate(header.numTextures + 1);
tex.push_back(0);
const core::stringc relpath = FileSystem->getFileDir(file->getFileName())+"/";
for (i = 1; i < (header.numTextures + 1); i++)
{
core::stringc path(textures[i-1].fileName);
path.replace('\\','/');
if (FileSystem->existFile(path))
tex.push_back(SceneManager->getVideoDriver()->getTexture(path));
else
// try to read in the relative path of the OCT file
tex.push_back(SceneManager->getVideoDriver()->getTexture( (relpath + path) ));
}
// prepare lightmaps
core::array<video::ITexture*> lig;
lig.set_used(header.numLightmaps + 1);
lig[0] = 0;
const u32 lightmapWidth = 128;
const u32 lightmapHeight = 128;
const core::dimension2d<u32> lmapsize(lightmapWidth, lightmapHeight);
bool oldMipMapState = SceneManager->getVideoDriver()->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
SceneManager->getVideoDriver()->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
video::IImage* tmpImage = SceneManager->getVideoDriver()->createImage(video::ECF_R8G8B8, lmapsize);
for (i = 1; i < (header.numLightmaps + 1); ++i)
{
core::stringc lightmapname = file->getFileName();
lightmapname += ".lightmap.";
lightmapname += (int)i;
const octLightmap* lm = &lightmaps[i-1];
for (u32 x=0; x<lightmapWidth; ++x)
{
for (u32 y=0; y<lightmapHeight; ++y)
{
tmpImage->setPixel(x, y,
video::SColor(255,
lm->data[x][y][2],
lm->data[x][y][1],
lm->data[x][y][0]));
}
}
lig[i] = SceneManager->getVideoDriver()->addTexture(lightmapname.c_str(), tmpImage);
}
tmpImage->drop();
SceneManager->getVideoDriver()->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, oldMipMapState);
// Free stuff
delete [] verts;
delete [] faces;
delete [] textures;
delete [] lightmaps;
delete [] lights;
// attach materials
for (i = 0; i < header.numLightmaps + 1; i++)
{
for (u32 j = 0; j < header.numTextures + 1; j++)
{
u32 mb = i * (header.numTextures + 1) + j;
CMeshBuffer<video::S3DVertex2TCoords> * meshBuffer = (CMeshBuffer<video::S3DVertex2TCoords>*)Mesh->getMeshBuffer(mb);
meshBuffer->Material.setTexture(0, tex[j]);
meshBuffer->Material.setTexture(1, lig[i]);
if (meshBuffer->Material.getTexture(0) == 0)
{
// This material has no texture, so we'll just show the lightmap if there is one.
// We swapped the texture coordinates earlier.
meshBuffer->Material.setTexture(0, meshBuffer->Material.getTexture(1));
meshBuffer->Material.setTexture(1, 0);
}
if (meshBuffer->Material.getTexture(1) == 0)
{
// If there is only one texture, it should be solid and lit.
// Among other things, this way you can preview OCT lights.
meshBuffer->Material.MaterialType = video::EMT_SOLID;
meshBuffer->Material.Lighting = true;
}
}
}
// delete all buffers without geometry in it.
i = 0;
while(i < Mesh->MeshBuffers.size())
{
if (Mesh->MeshBuffers[i]->getVertexBuffer()->getVertexCount() == 0 ||
Mesh->MeshBuffers[i]->getIndexBuffer()->getIndexCount() == 0 ||
Mesh->MeshBuffers[i]->getMaterial().getTexture(0) == 0)
{
// Meshbuffer is empty -- drop it
Mesh->MeshBuffers[i]->drop();
Mesh->MeshBuffers.erase(i);
}
else
{
++i;
}
}
// create bounding box
for (i = 0; i < Mesh->MeshBuffers.size(); ++i)
{
Mesh->MeshBuffers[i]->recalculateBoundingBox();
}
Mesh->recalculateBoundingBox();
// Set up an animated mesh to hold the mesh
SAnimatedMesh* AMesh = new SAnimatedMesh();
AMesh->Type = EAMT_OCT;
AMesh->addMesh(Mesh);
AMesh->recalculateBoundingBox();
Mesh->drop();
return AMesh;
}
IAnimatedMesh* CMY3DMeshFileLoader::createMesh(io::IReadFile* file)
{
MaterialEntry.clear();
MeshBufferEntry.clear();
ChildNodes.clear();
// working directory (from which we load the scene)
core::stringc filepath = FileSystem->getFileDir(file->getFileName());
if (filepath==".")
filepath="";
else
filepath.append("/");
// read file into memory
SMyFileHeader fileHeader;
file->read(&fileHeader, sizeof(SMyFileHeader));
#ifdef __BIG_ENDIAN__
fileHeader.MyId = os::Byteswap::byteswap(fileHeader.MyId);
fileHeader.Ver = os::Byteswap::byteswap(fileHeader.Ver);
#endif
if (fileHeader.MyId!=MY3D_ID || fileHeader.Ver!=MY3D_VER)
{
os::Printer::log("Bad MY3D file header, loading failed!", ELL_ERROR);
return 0;
}
u16 id;
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
if (id!=MY3D_SCENE_HEADER_ID)
{
os::Printer::log("Cannot find MY3D_SCENE_HEADER_ID, loading failed!", ELL_ERROR);
return 0;
}
SMySceneHeader sceneHeader;
file->read(&sceneHeader, sizeof(SMySceneHeader));
#ifdef __BIG_ENDIAN__
sceneHeader.MaterialCount = os::Byteswap::byteswap(sceneHeader.MaterialCount);
sceneHeader.MeshCount = os::Byteswap::byteswap(sceneHeader.MeshCount);
#endif
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
if (id!=MY3D_MAT_LIST_ID)
{
os::Printer::log("Can not find MY3D_MAT_LIST_ID, loading failed!", ELL_ERROR);
return 0;
}
core::stringc texturePath =
SceneManager->getParameters()->getAttributeAsString(MY3D_TEXTURE_PATH);
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
c8 namebuf[256];
for (s32 m=0; m<sceneHeader.MaterialCount; ++m)
{
if (id != MY3D_MAT_HEADER_ID)
{
os::Printer::log("Cannot find MY3D_MAT_HEADER_ID, loading failed!", ELL_ERROR);
return 0;
}
// read material header
MaterialEntry.push_back(SMyMaterialEntry());
SMyMaterialEntry& me=MaterialEntry.getLast();
file->read(&(me.Header), sizeof(SMyMaterialHeader));
// read next identificator
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
bool gotLightMap=false, gotMainMap=false;
for (u32 t=0; t<me.Header.TextureCount; ++t)
{
if (id==MY3D_TEX_FNAME_ID)
file->read(namebuf, 256);
else
{
me.Texture2 = readEmbeddedLightmap(file, namebuf);
if (!me.Texture2)
return 0;
gotLightMap = true;
}
const core::stringc name(namebuf);
const s32 pos = name.findLast('.');
const core::stringc LightingMapStr = "LightingMap";
const s32 ls = LightingMapStr.size();
const bool isSubString = (LightingMapStr == name.subString(core::max_(0, (pos - ls)), ls));
if ((isSubString || (name[pos-1]=='m' &&
name[pos-2]=='l' && name[pos-3]=='_')) &&
!gotLightMap)
{
const bool oldMipMapState = SceneManager->getVideoDriver()->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
SceneManager->getVideoDriver()->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
me.Texture2FileName = texturePath.size() ? texturePath : filepath;
me.Texture2FileName.append("Lightmaps/");
me.Texture2FileName.append(name);
if (name.size())
me.Texture2 = SceneManager->getVideoDriver()->getTexture(me.Texture2FileName);
me.MaterialType = video::EMT_LIGHTMAP_M2;
gotLightMap = true;
SceneManager->getVideoDriver()->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, oldMipMapState);
}
else
if (!gotLightMap && gotMainMap)
{
me.Texture2FileName = texturePath.size() ? texturePath : filepath;
me.Texture2FileName.append(name);
if (name.size())
me.Texture2 = SceneManager->getVideoDriver()->getTexture(me.Texture2FileName);
me.MaterialType = video::EMT_REFLECTION_2_LAYER;
}
else
if (!gotMainMap && !gotLightMap)
{
me.Texture1FileName = filepath;
me.Texture1FileName.append(name);
if (name.size())
me.Texture1 = SceneManager->getVideoDriver()->getTexture(me.Texture1FileName);
gotMainMap = true;
me.MaterialType = video::EMT_SOLID;
}
else
if (gotLightMap)
{
me.MaterialType = video::EMT_LIGHTMAP_M2;
}
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
}
// override material types based on their names
if (!strncmp(me.Header.Name, "AlphaChannel-", 13))
me.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
else
if (!strncmp(me.Header.Name, "SphereMap-", 10))
me.MaterialType = video::EMT_SPHERE_MAP;
}
// loading meshes
if (id!=MY3D_MESH_LIST_ID)
{
os::Printer::log("Can not find MY3D_MESH_LIST_ID, loading failed!", ELL_ERROR);
return 0;
}
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
for (s32 mesh_id=0; mesh_id<sceneHeader.MeshCount; mesh_id++)
{
// Warning!!! In some cases MY3D exporter uncorrectly calculates
// MeshCount (it's a problem, has to be solved) thats why
// i added this code line
if (id!=MY3D_MESH_HEADER_ID)
break;
if (id!=MY3D_MESH_HEADER_ID)
{
os::Printer::log("Can not find MY3D_MESH_HEADER_ID, loading failed!", ELL_ERROR);
return 0;
}
SMyMeshHeader meshHeader;
file->read(&meshHeader, sizeof(SMyMeshHeader));
core::array <SMyVertex> Vertex;
core::array <SMyFace> Face;
core::array <SMyTVertex> TVertex1, TVertex2;
core::array <SMyFace> TFace1, TFace2;
s32 vertsNum=0;
s32 facesNum=0;
// vertices
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
if (id!=MY3D_VERTS_ID)
{
os::Printer::log("Can not find MY3D_VERTS_ID, loading failed!", ELL_ERROR);
return 0;
}
file->read(&vertsNum, sizeof(vertsNum));
Vertex.set_used(vertsNum);
file->read(Vertex.pointer(), sizeof(SMyVertex)*vertsNum);
// faces
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
if (id!=MY3D_FACES_ID)
{
os::Printer::log("Can not find MY3D_FACES_ID, loading failed!", ELL_ERROR);
return 0;
}
file->read(&facesNum, sizeof(facesNum));
Face.set_used(facesNum);
file->read(Face.pointer(), sizeof(SMyFace)*facesNum);
// reading texture channels
for (s32 tex=0; tex<(s32)meshHeader.TChannelCnt; tex++)
{
// Max 2 texture channels allowed (but in format .my3d can be more)
s32 tVertsNum=0, tFacesNum=0;
// reading texture coords
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
if (id!=MY3D_TVERTS_ID)
{
core::stringc msg="Can not find MY3D_TVERTS_ID (";
msg.append(core::stringc(tex));
msg.append("texture channel), loading failed!");
os::Printer::log(msg.c_str(), ELL_ERROR);
return 0;
}
file->read(&tVertsNum, sizeof(tVertsNum));
if (tex==0)
{
// 1st texture channel
TVertex1.set_used(tVertsNum);
file->read(TVertex1.pointer(), sizeof(SMyTVertex)*tVertsNum);
}
else
if (tex==1)
{
// 2nd texture channel
TVertex2.set_used(tVertsNum);
file->read(TVertex2.pointer(), sizeof(SMyTVertex)*tVertsNum);
}
else
{
// skip other texture channels
file->seek(file->getPos()+sizeof(SMyTVertex)*tVertsNum);
}
// reading texture faces
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
if (id!=MY3D_TFACES_ID)
{
core::stringc msg="Can not find MY3D_TFACES_ID (";
msg.append(core::stringc(tex));
msg.append("texture channel), loading failed!");
os::Printer::log(msg.c_str(), ELL_ERROR);
return 0;
}
file->read(&tFacesNum, sizeof(tFacesNum));
if (tex==0)
{
// 1st texture channel
TFace1.set_used(tFacesNum);
file->read(TFace1.pointer(), sizeof(SMyFace)*tFacesNum);
}
else if (tex==1)
{
// 2nd texture channel
TFace2.set_used(tFacesNum);
file->read(TFace2.pointer(), sizeof(SMyFace)*tFacesNum);
}
else
{
// skip other texture channels
file->seek(file->getPos()+sizeof(SMyFace)*tFacesNum);
}
}
// trying to find material
SMyMaterialEntry* matEnt = getMaterialEntryByIndex(meshHeader.MatIndex);
// creating geometry for the mesh
// trying to find mesh buffer for this material
CMeshBuffer<video::S3DVertex2TCoords>* buffer = getMeshBufferByMaterialIndex(meshHeader.MatIndex);
if (!buffer ||
(buffer->getVertexBuffer()->getVertexCount()+vertsNum) > SceneManager->getVideoDriver()->getMaximalPrimitiveCount())
{
// creating new mesh buffer for this material
buffer = new CMeshBuffer<video::S3DVertex2TCoords>(SceneManager->getVideoDriver()->getVertexDescriptor(1));
buffer->Material.MaterialType = video::EMT_LIGHTMAP_M2; // EMT_LIGHTMAP_M4 also possible
buffer->Material.Wireframe = false;
buffer->Material.Lighting = false;
if (matEnt)
{
buffer->Material.MaterialType = matEnt->MaterialType;
if (buffer->Material.MaterialType == video::EMT_REFLECTION_2_LAYER)
{
buffer->Material.Lighting = true;
buffer->Material.setTexture(1, matEnt->Texture1);
buffer->Material.setTexture(0, matEnt->Texture2);
}
else
{
buffer->Material.setTexture(0, matEnt->Texture1);
buffer->Material.setTexture(1, matEnt->Texture2);
}
if (buffer->Material.MaterialType == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
{
buffer->Material.BackfaceCulling = true;
buffer->Material.Lighting = true;
}
else
if (buffer->Material.MaterialType == video::EMT_SPHERE_MAP)
{
buffer->Material.Lighting = true;
}
buffer->Material.AmbientColor = video::SColor(
matEnt->Header.AmbientColor.A, matEnt->Header.AmbientColor.R,
matEnt->Header.AmbientColor.G, matEnt->Header.AmbientColor.B
);
buffer->Material.DiffuseColor = video::SColor(
matEnt->Header.DiffuseColor.A, matEnt->Header.DiffuseColor.R,
matEnt->Header.DiffuseColor.G, matEnt->Header.DiffuseColor.B
);
buffer->Material.EmissiveColor = video::SColor(
matEnt->Header.EmissiveColor.A, matEnt->Header.EmissiveColor.R,
matEnt->Header.EmissiveColor.G, matEnt->Header.EmissiveColor.B
);
buffer->Material.SpecularColor = video::SColor(
matEnt->Header.SpecularColor.A, matEnt->Header.SpecularColor.R,
matEnt->Header.SpecularColor.G, matEnt->Header.SpecularColor.B
);
}
else
{
buffer->Material.setTexture(0, 0);
buffer->Material.setTexture(1, 0);
buffer->Material.AmbientColor = video::SColor(255, 255, 255, 255);
buffer->Material.DiffuseColor = video::SColor(255, 255, 255, 255);
buffer->Material.EmissiveColor = video::SColor(0, 0, 0, 0);
buffer->Material.SpecularColor = video::SColor(0, 0, 0, 0);
}
if (matEnt && matEnt->Header.Transparency!=0)
{
if (buffer->Material.MaterialType == video::EMT_REFLECTION_2_LAYER )
{
buffer->Material.MaterialType = video::EMT_TRANSPARENT_REFLECTION_2_LAYER;
buffer->Material.Lighting = true;
buffer->Material.BackfaceCulling = true;
}
else
{
buffer->Material.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
buffer->Material.Lighting = false;
buffer->Material.BackfaceCulling = false;
}
}
else if (
!buffer->Material.getTexture(1) &&
buffer->Material.MaterialType != video::EMT_TRANSPARENT_ALPHA_CHANNEL &&
buffer->Material.MaterialType != video::EMT_SPHERE_MAP)
{
buffer->Material.MaterialType = video::EMT_SOLID;
buffer->Material.Lighting = true;
}
MeshBufferEntry.push_back(
SMyMeshBufferEntry(meshHeader.MatIndex, buffer));
}
video::S3DVertex2TCoords VertexA, VertexB, VertexC;
// vertices (A, B, C) color
video::SColor vert_color;
if (matEnt &&
(buffer->Material.MaterialType == video::EMT_TRANSPARENT_VERTEX_ALPHA ||
buffer->Material.MaterialType == video::EMT_TRANSPARENT_REFLECTION_2_LAYER))
{
video::SColor color(
matEnt->Header.DiffuseColor.A, matEnt->Header.DiffuseColor.R,
matEnt->Header.DiffuseColor.G, matEnt->Header.DiffuseColor.B);
vert_color = color.getInterpolated(video::SColor(0,0,0,0),
1-matEnt->Header.Transparency);
}
else
{
vert_color = buffer->Material.DiffuseColor;
}
VertexA.Color = VertexB.Color = VertexC.Color = vert_color;
if (buffer->Material.MaterialType == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
{
buffer->getIndexBuffer()->reallocate(buffer->getIndexBuffer()->getIndexCount()+6*facesNum);
buffer->getVertexBuffer()->reallocate(buffer->getVertexBuffer()->getVertexCount()+6*facesNum);
}
else
{
buffer->getIndexBuffer()->reallocate(buffer->getIndexBuffer()->getIndexCount()+3*facesNum);
buffer->getVertexBuffer()->reallocate(buffer->getVertexBuffer()->getVertexCount()+3*facesNum);
}
for (int f=0; f<facesNum; f++)
{
// vertex A
VertexA.Pos.X = Vertex[Face[f].C].Coord.X;
VertexA.Pos.Y = Vertex[Face[f].C].Coord.Y;
VertexA.Pos.Z = Vertex[Face[f].C].Coord.Z;
VertexA.Normal.X = Vertex[Face[f].C].Normal.X;
VertexA.Normal.Y = Vertex[Face[f].C].Normal.Y;
VertexA.Normal.Z = Vertex[Face[f].C].Normal.Z;
if (meshHeader.TChannelCnt>0)
{
VertexA.TCoords.X = TVertex1[TFace1[f].C].TCoord.X;
VertexA.TCoords.Y = TVertex1[TFace1[f].C].TCoord.Y;
}
if (meshHeader.TChannelCnt>1)
{
VertexA.TCoords2.X = TVertex2[TFace2[f].C].TCoord.X;
VertexA.TCoords2.Y = TVertex2[TFace2[f].C].TCoord.Y;
}
// vertex B
VertexB.Pos.X = Vertex[Face[f].B].Coord.X;
VertexB.Pos.Y = Vertex[Face[f].B].Coord.Y;
VertexB.Pos.Z = Vertex[Face[f].B].Coord.Z;
VertexB.Normal.X = Vertex[Face[f].B].Normal.X;
VertexB.Normal.Y = Vertex[Face[f].B].Normal.Y;
VertexB.Normal.Z = Vertex[Face[f].B].Normal.Z;
if (meshHeader.TChannelCnt>0)
{
VertexB.TCoords.X = TVertex1[TFace1[f].B].TCoord.X;
VertexB.TCoords.Y = TVertex1[TFace1[f].B].TCoord.Y;
}
if (meshHeader.TChannelCnt>1)
{
VertexB.TCoords2.X = TVertex2[TFace2[f].B].TCoord.X;
VertexB.TCoords2.Y = TVertex2[TFace2[f].B].TCoord.Y;
}
// vertex C
VertexC.Pos.X = Vertex[Face[f].A].Coord.X;
VertexC.Pos.Y = Vertex[Face[f].A].Coord.Y;
VertexC.Pos.Z = Vertex[Face[f].A].Coord.Z;
VertexC.Normal.X = Vertex[Face[f].A].Normal.X;
VertexC.Normal.Y = Vertex[Face[f].A].Normal.Y;
VertexC.Normal.Z = Vertex[Face[f].A].Normal.Z;
if (meshHeader.TChannelCnt>0)
{
VertexC.TCoords.X = TVertex1[TFace1[f].A].TCoord.X;
VertexC.TCoords.Y = TVertex1[TFace1[f].A].TCoord.Y;
}
if (meshHeader.TChannelCnt>1)
{
VertexC.TCoords2.X = TVertex2[TFace2[f].A].TCoord.X;
VertexC.TCoords2.Y = TVertex2[TFace2[f].A].TCoord.Y;
}
// store 3d data in mesh buffer
buffer->getIndexBuffer()->addIndex(buffer->getVertexBuffer()->getVertexCount());
buffer->getVertexBuffer()->addVertex(&VertexA);
buffer->getIndexBuffer()->addIndex(buffer->getVertexBuffer()->getVertexCount());
buffer->getVertexBuffer()->addVertex(&VertexB);
buffer->getIndexBuffer()->addIndex(buffer->getVertexBuffer()->getVertexCount());
buffer->getVertexBuffer()->addVertex(&VertexC);
//*****************************************************************
// !!!!!! W A R N I N G !!!!!!!
//*****************************************************************
// For materials with alpha channel we duplicate all faces.
// This has be done for proper lighting calculation of the back faces.
// So you must remember this while you creating your models !!!!!
//*****************************************************************
// !!!!!! W A R N I N G !!!!!!!
//*****************************************************************
if (buffer->Material.MaterialType == video::EMT_TRANSPARENT_ALPHA_CHANNEL)
{
VertexA.Normal = core::vector3df(-VertexA.Normal.X, -VertexA.Normal.Y, -VertexA.Normal.Z);
VertexB.Normal = core::vector3df(-VertexB.Normal.X, -VertexB.Normal.Y, -VertexB.Normal.Z);
VertexC.Normal = core::vector3df(-VertexC.Normal.X, -VertexC.Normal.Y, -VertexC.Normal.Z);
buffer->getIndexBuffer()->addIndex(buffer->getVertexBuffer()->getVertexCount());
buffer->getVertexBuffer()->addVertex(&VertexC);
buffer->getIndexBuffer()->addIndex(buffer->getVertexBuffer()->getVertexCount());
buffer->getVertexBuffer()->addVertex(&VertexB);
buffer->getIndexBuffer()->addIndex(buffer->getVertexBuffer()->getVertexCount());
buffer->getVertexBuffer()->addVertex(&VertexA);
}
}
file->read(&id, sizeof(id));
#ifdef __BIG_ENDIAN__
id = os::Byteswap::byteswap(id);
#endif
}
// creating mesh
SMesh* mesh = new SMesh();
for (u32 num=0; num<MeshBufferEntry.size(); ++num)
{
CMeshBuffer<video::S3DVertex2TCoords>* buffer = MeshBufferEntry[num].MeshBuffer;
if (!buffer)
continue;
mesh->addMeshBuffer(buffer);
buffer->recalculateBoundingBox();
buffer->drop();
}
mesh->recalculateBoundingBox();
if (id != MY3D_FILE_END_ID)
os::Printer::log("Loading finished, but can not find MY3D_FILE_END_ID token.", ELL_WARNING);
SAnimatedMesh* am = new SAnimatedMesh();
am->addMesh(mesh);
mesh->drop();
am->recalculateBoundingBox();
return am;
}