//! Sets a new mesh
void CAnimatedMeshSceneNode::setMesh(IAnimatedMesh* mesh)
{
if (!mesh)
return; // won't set null mesh
if (Mesh != mesh)
{
if (Mesh)
Mesh->drop();
Mesh = mesh;
// grab the mesh (it's non-null!)
Mesh->grab();
}
// get materials and bounding box
Box = Mesh->getBoundingBox();
IMesh* m = Mesh->getMesh(0,0);
if (m)
{
Materials.clear();
Materials.reallocate(m->getMeshBufferCount());
for (u32 i=0; i<m->getMeshBufferCount(); ++i)
{
IMeshBuffer* mb = m->getMeshBuffer(i);
if (mb)
Materials.push_back(mb->getMaterial());
else
Materials.push_back(video::SMaterial());
}
}
// clean up joint nodes
if (JointsUsed)
{
JointsUsed=false;
checkJoints();
}
// get start and begin time
// setAnimationSpeed(Mesh->getAnimationSpeed());
setFrameLoop(0, Mesh->getFrameCount());
}
void CMeshSceneNode::copyMaterials()
{
Materials.clear();
if (Mesh)
{
video::SMaterial mat;
for (u32 i=0; i<Mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* mb = Mesh->getMeshBuffer(i);
if (mb)
mat = mb->getMaterial();
Materials.push_back(mat);
}
}
}
//! renders the node.
void CInstancedMeshSceneNode::render()
{
if (!IsVisible || !SceneManager->getActiveCamera())
return;
if (!baseMesh || baseMesh->getMeshBuffer(0)->getVertexBuffer(1)->getVertexCount() == 0)
return;
IMeshBuffer* renderBuffer = baseMesh->getMeshBuffer(0);
video::IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
driver->setMaterial(readOnlyMaterial ? material : renderBuffer->getMaterial());
driver->drawMeshBuffer(renderBuffer);
// for debug purposes only:
if (DebugDataVisible)
{
video::SMaterial m;
m.Lighting = false;
driver->setMaterial(m);
if (DebugDataVisible & scene::EDS_BBOX)
driver->draw3DBox(box, video::SColor(255, 255, 255, 255));
if (DebugDataVisible & scene::EDS_BBOX_BUFFERS)
{
const u32 size = instanceNodeArray.size();
for (u32 i = 0; i < size; ++i)
{
core::aabbox3df box = renderBuffer->getBoundingBox();
driver->setTransform(video::ETS_WORLD, instanceNodeArray[i]->getAbsoluteTransformation());
driver->draw3DBox(box, video::SColor(255, 255, 255, 255));
}
}
}
}
//! Sets a new mesh
void CAnimatedMeshSceneNode::setMesh(IAnimatedMesh* mesh)
{
if (!mesh)
return; // won't set null mesh
if (Mesh)
Mesh->drop();
Mesh = mesh;
// get materials and bounding box
Box = Mesh->getBoundingBox();
IMesh* m = Mesh->getMesh(0,0);
if (m)
{
Materials.clear();
video::SMaterial mat;
for (u32 i=0; i<m->getMeshBufferCount(); ++i)
{
IMeshBuffer* mb = m->getMeshBuffer(i);
if (mb)
mat = mb->getMaterial();
Materials.push_back(mat);
}
}
// get start and begin time
setFrameLoop ( 0, Mesh->getFrameCount() );
// grab the mesh
if (Mesh)
Mesh->grab();
}
//! creates the tree
bool COctTreeSceneNode::createTree(IMesh* mesh)
{
if (!mesh)
return false;
MeshName = SceneManager->getMeshCache()->getMeshFilename( mesh );
deleteTree();
u32 beginTime = os::Timer::getRealTime();
u32 nodeCount = 0;
u32 polyCount = 0;
Box = mesh->getBoundingBox();
if (mesh->getMeshBufferCount())
{
vertexType = mesh->getMeshBuffer(0)->getVertexType();
switch(vertexType)
{
case video::EVT_STANDARD:
{
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* b = mesh->getMeshBuffer(i);
if (b->getVertexCount() && b->getIndexCount())
{
Materials.push_back(b->getMaterial());
StdMeshes.push_back(OctTree<video::S3DVertex>::SMeshChunk());
OctTree<video::S3DVertex>::SMeshChunk &nchunk = StdMeshes.getLast();
nchunk.MaterialId = Materials.size() - 1;
u32 v;
nchunk.Vertices.reallocate(b->getVertexCount());
for (v=0; v<b->getVertexCount(); ++v)
nchunk.Vertices.push_back(((video::S3DVertex*)b->getVertices())[v]);
polyCount += b->getIndexCount();
nchunk.Indices.reallocate(b->getIndexCount());
for (v=0; v<b->getIndexCount(); ++v)
nchunk.Indices.push_back(b->getIndices()[v]);
}
}
StdOctTree = new OctTree<video::S3DVertex>(StdMeshes, MinimalPolysPerNode);
nodeCount = StdOctTree->getNodeCount();
}
break;
case video::EVT_2TCOORDS:
{
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* b = mesh->getMeshBuffer(i);
if (b->getVertexCount() && b->getIndexCount())
{
Materials.push_back(b->getMaterial());
LightMapMeshes.push_back(OctTree<video::S3DVertex2TCoords>::SMeshChunk());
OctTree<video::S3DVertex2TCoords>::SMeshChunk& nchunk = LightMapMeshes.getLast();
nchunk.MaterialId = Materials.size() - 1;
u32 v;
nchunk.Vertices.reallocate(b->getVertexCount());
for (v=0; v<b->getVertexCount(); ++v)
nchunk.Vertices.push_back(((video::S3DVertex2TCoords*)b->getVertices())[v]);
polyCount += b->getIndexCount();
nchunk.Indices.reallocate(b->getIndexCount());
for (v=0; v<b->getIndexCount(); ++v)
nchunk.Indices.push_back(b->getIndices()[v]);
}
}
LightMapOctTree = new OctTree<video::S3DVertex2TCoords>(LightMapMeshes, MinimalPolysPerNode);
nodeCount = LightMapOctTree->getNodeCount();
}
break;
case video::EVT_TANGENTS:
{
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* b = mesh->getMeshBuffer(i);
if (b->getVertexCount() && b->getIndexCount())
{
Materials.push_back(b->getMaterial());
TangentsMeshes.push_back(OctTree<video::S3DVertexTangents>::SMeshChunk());
OctTree<video::S3DVertexTangents>::SMeshChunk& nchunk = TangentsMeshes.getLast();
nchunk.MaterialId = Materials.size() - 1;
u32 v;
nchunk.Vertices.reallocate(b->getVertexCount());
for (v=0; v<b->getVertexCount(); ++v)
nchunk.Vertices.push_back(((video::S3DVertexTangents*)b->getVertices())[v]);
polyCount += b->getIndexCount();
nchunk.Indices.reallocate(b->getIndexCount());
for (v=0; v<b->getIndexCount(); ++v)
nchunk.Indices.push_back(b->getIndices()[v]);
}
}
TangentsOctTree = new OctTree<video::S3DVertexTangents>(TangentsMeshes, MinimalPolysPerNode);
nodeCount = TangentsOctTree->getNodeCount();
}
break;
}
}
u32 endTime = os::Timer::getRealTime();
c8 tmp[255];
sprintf(tmp, "Needed %ums to create OctTree SceneNode.(%u nodes, %u polys)",
endTime - beginTime, nodeCount, polyCount/3);
os::Printer::log(tmp, ELL_INFORMATION);
return true;
}
//! writes a mesh
bool COBJMeshWriter::writeMesh(io::IWriteFile* file, scene::IMesh* mesh, s32 flags)
{
if (!file)
return false;
os::Printer::log("Writing mesh", file->getFileName());
// write OBJ MESH header
const core::stringc name(FileSystem->getFileBasename(SceneManager->getMeshCache()->getMeshName(mesh), false)+".mtl");
file->write("# exported by Irrlicht\n",23);
file->write("mtllib ",7);
file->write(name.c_str(),name.size());
file->write("\n\n",2);
// write mesh buffers
core::array<video::SMaterial*> mat;
u32 allVertexCount=1; // count vertices over the whole file
for (u32 i=0; i<mesh->getMeshBufferCount(); ++i)
{
core::stringc num(i+1);
IMeshBuffer* buffer = mesh->getMeshBuffer(i);
if (buffer && buffer->getVertexCount())
{
file->write("g grp", 5);
file->write(num.c_str(), num.size());
file->write("\n",1);
u32 j;
const u32 vertexCount = buffer->getVertexCount();
for (j=0; j<vertexCount; ++j)
{
file->write("v ",2);
getVectorAsStringLine(buffer->getPosition(j), num);
file->write(num.c_str(), num.size());
}
for (j=0; j<vertexCount; ++j)
{
file->write("vt ",3);
getVectorAsStringLine(buffer->getTCoords(j), num);
file->write(num.c_str(), num.size());
}
for (j=0; j<vertexCount; ++j)
{
file->write("vn ",3);
getVectorAsStringLine(buffer->getNormal(j), num);
file->write(num.c_str(), num.size());
}
file->write("usemtl mat",10);
num = "";
for (j=0; j<mat.size(); ++j)
{
if (*mat[j]==buffer->getMaterial())
{
num = core::stringc(j);
break;
}
}
if (num == "")
{
num = core::stringc(mat.size());
mat.push_back(&buffer->getMaterial());
}
file->write(num.c_str(), num.size());
file->write("\n",1);
const u32 indexCount = buffer->getIndexCount();
for (j=0; j<indexCount; j+=3)
{
file->write("f ",2);
num = core::stringc(buffer->getIndices()[j+2]+allVertexCount);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write(" ",1);
num = core::stringc(buffer->getIndices()[j+1]+allVertexCount);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write(" ",1);
num = core::stringc(buffer->getIndices()[j+0]+allVertexCount);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write("/",1);
file->write(num.c_str(), num.size());
file->write(" ",1);
file->write("\n",1);
}
file->write("\n",1);
allVertexCount += vertexCount;
}
}
if (mat.size() == 0)
return true;
file = FileSystem->createAndWriteFile( name );
if (file)
{
os::Printer::log("Writing material", file->getFileName());
file->write("# exported by Irrlicht\n\n",24);
for (u32 i=0; i<mat.size(); ++i)
{
core::stringc num(i);
file->write("newmtl mat",10);
file->write(num.c_str(),num.size());
file->write("\n",1);
getColorAsStringLine(mat[i]->AmbientColor, "Ka", num);
file->write(num.c_str(),num.size());
getColorAsStringLine(mat[i]->DiffuseColor, "Kd", num);
file->write(num.c_str(),num.size());
getColorAsStringLine(mat[i]->SpecularColor, "Ks", num);
file->write(num.c_str(),num.size());
getColorAsStringLine(mat[i]->EmissiveColor, "Ke", num);
file->write(num.c_str(),num.size());
num = core::stringc(mat[i]->Shininess/0.128f);
file->write("Ns ", 3);
file->write(num.c_str(),num.size());
file->write("\n", 1);
if (mat[i]->getTexture(0))
{
file->write("map_Kd ", 7);
file->write(mat[i]->getTexture(0)->getName().getPath().c_str(), mat[i]->getTexture(0)->getName().getPath().size());
file->write("\n",1);
}
file->write("\n",1);
}
file->drop();
}
return true;
}
/* This method has a lot of duplication and overhead. Moreover, the tangents mesh conversion does not really work. I think we need a a proper mesh implementation for octrees, which handle all vertex types internally. Converting all structures to just one vertex type is always problematic.
Thanks to Auria for fixing major parts of this method. */
bool COctreeSceneNode::createTree(IMesh* mesh)
{
if (!mesh)
return false;
MeshName = SceneManager->getMeshCache()->getMeshName(mesh);
mesh->grab();
deleteTree();
Mesh = mesh;
const u32 beginTime = os::Timer::getRealTime();
u32 nodeCount = 0;
u32 polyCount = 0;
u32 i;
Box = mesh->getBoundingBox();
if (mesh->getMeshBufferCount())
{
// check for "larger" buffer types
u32 meshReserve = StdMeshes.size();
Materials.reallocate(Materials.size()+meshReserve);
StdMeshesMatID.reallocate(meshReserve);
for ( i=0; i < mesh->getMeshBufferCount(); ++i)
{
IMeshBuffer* b = mesh->getMeshBuffer(i);
if (b->getVertexBuffer()->getVertexCount() && b->getIndexBuffer()->getIndexCount())
{
Materials.push_back(b->getMaterial());
IMeshBuffer* nchunk = StdMeshes[i];
StdMeshesMatID.push_back(Materials.size() - 1);
if (UseVisibilityAndVBOs)
{
nchunk->setHardwareMappingHint(scene::EHM_STATIC, scene::EBT_VERTEX);
nchunk->setHardwareMappingHint(scene::EHM_DYNAMIC, scene::EBT_INDEX);
}
else
nchunk->setHardwareMappingHint(scene::EHM_STATIC);
SceneManager->getMeshManipulator()->copyVertices(b->getVertexBuffer(), nchunk->getVertexBuffer(), true);
polyCount += b->getIndexBuffer()->getIndexCount();
nchunk->getIndexBuffer()->reallocate(b->getIndexBuffer()->getIndexCount());
for (u32 v=0; v<b->getIndexBuffer()->getIndexCount(); ++v)
nchunk->getIndexBuffer()->addIndex(b->getIndexBuffer()->getIndex(v));
}
}
StdOctree = new Octree(StdMeshes, StdMeshesMatID, MinimalPolysPerNode);
nodeCount = StdOctree->getNodeCount();
}
const u32 endTime = os::Timer::getRealTime();
c8 tmp[255];
sprintf(tmp, "Needed %ums to create Octree SceneNode.(%u nodes, %u polys)",
endTime - beginTime, nodeCount, polyCount/3);
os::Printer::log(tmp, ELL_INFORMATION);
return true;
}
/* This method has a lot of duplication and overhead. Moreover, the tangents mesh conversion does not really work. I think we need a a proper mesh implementation for octrees, which handle all vertex types internally. Converting all structures to just one vertex type is always problematic.
Thanks to Auria for fixing major parts of this method. */
bool COctreeSceneNode::createTree(IMesh* mesh)
{
if (!mesh)
return false;
MeshName = SceneManager->getMeshCache()->getMeshName(mesh);
mesh->grab();
deleteTree();
Mesh = mesh;
const u32 beginTime = os::Timer::getRealTime();
u32 nodeCount = 0;
u32 polyCount = 0;
u32 i;
Box = mesh->getBoundingBox();
if (mesh->getMeshBufferCount())
{
// check for "larger" buffer types
u32 meshReserve = StdMeshes.size();
Materials.reallocate(Materials.size()+meshReserve);
StdMeshesMatID.reallocate(meshReserve);
for ( i=0; i < mesh->getMeshBufferCount(); ++i)
{
const scene::IMeshManipulator* meshManipulator = SceneManager->getMeshManipulator();
IMeshBuffer* meshBuffer = mesh->getMeshBuffer(i);
IMeshBuffer* nchunk = StdMeshes[i];
// copy vertices
video::IVertexDescriptor* srcDescriptor = meshBuffer->getVertexDescriptor();
video::IVertexDescriptor* dstDescriptor = nchunk->getVertexDescriptor();
const u32 vbCount = meshBuffer->getVertexBufferCount();
for (u32 j = 0; j < vbCount; ++j)
meshManipulator->copyVertices(meshBuffer->getVertexBuffer(j), j, srcDescriptor, nchunk->getVertexBuffer(j), j, dstDescriptor, true);
// copy indices
scene::IIndexBuffer* srcIndexBuffer = meshBuffer->getIndexBuffer();
scene::IIndexBuffer* dstIndexBuffer = nchunk->getIndexBuffer();
meshManipulator->copyIndices(srcIndexBuffer, dstIndexBuffer);
// copy material
Materials.push_back(meshBuffer->getMaterial());
StdMeshesMatID.push_back(Materials.size() - 1);
// others
polyCount += dstIndexBuffer->getIndexCount();
if (UseVBOs)
{
if (UseVisibilityAndVBOs)
{
nchunk->setHardwareMappingHint(scene::EHM_STATIC, scene::EBT_VERTEX);
nchunk->setHardwareMappingHint(scene::EHM_DYNAMIC, scene::EBT_INDEX);
}
else
nchunk->setHardwareMappingHint(scene::EHM_STATIC);
}
else
{
nchunk->setHardwareMappingHint(scene::EHM_NEVER);
}
}
StdOctree = new Octree(StdMeshes, StdMeshesMatID, MinimalPolysPerNode);
nodeCount = StdOctree->getNodeCount();
}
const u32 endTime = os::Timer::getRealTime();
c8 tmp[255];
sprintf(tmp, "Needed %ums to create Octree SceneNode.(%u nodes, %u polys)",
endTime - beginTime, nodeCount, polyCount/3);
os::Printer::log(tmp, ELL_INFORMATION);
return true;
}
int main(int, char**){
IrrlichtDevice *device;
//create the irrlicht device //IrrlichtDevice *device = createDevice(video::EDT_OPENGL, core::dimension2d<s32>(1440,900), 32, false, true, true, InputHandler::getInstance()); device = createDevice(video::EDT_OPENGL, core::dimension2d<s32>(800,600), 32, false//shadows ,true, true, InputHandler::getInstance());
if(device==NULL)return 1; //create the irrKlang device // start the sound engine with default parameters
ISoundEngine* soundEngine = createIrrKlangDevice();
//ISound* CurrentPlayingSound = 0;
//ISoundSource* backgroundMusic = soundEngine->addSoundSourceFromFile("../media/sounds/getout.ogg");
//backgroundMusic->setDefaultVolume(0.3f);
if (!soundEngine){
printf("Could not startup irrKlang sound engine\n");
return 0; // error starting up the engine
}
//Play some sound while all this is starting, loop it
//CurrentPlayingSound = soundEngine->play2D("../media/sounds/getout.ogg", true);
//soundEngine->play2D(backgroundMusic);
//set the title of the window
device->setWindowCaption(L"Quake the Can");
//hide the cursor
device->getCursorControl()->setVisible(false);
//get the driver, scene manager, and gui environment objects
video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();
//Add this back in with the return of the Main GUI
gui::IGUIEnvironment* guienv = device->getGUIEnvironment();
driver->setFog(irr::video::SColor(255,25,25,25), true, 0,750, 0, true, true);//set the fog properties
/***Load the map***/ //load the pk3 file containing the .bsp map file into the engine file system device->getFileSystem()->addZipFileArchive("../media/map-20kdm2.pk3");
//get the mesh from the map bsp file
scene::IQ3LevelMesh* mesh = (scene::IQ3LevelMesh*) (smgr->getMesh("maps/20kdm2.bsp"));
//add a scene node for the map
scene::ISceneNode *mapNode = NULL;//scene node representing the level itself
mapNode = smgr->addOctTreeSceneNode(
mesh->getMesh(quake3::E_Q3_MESH_GEOMETRY), 0, -1, 1024);
if(!mesh){throw new std::string("mesh creation error");}
//code i took from an irrlicht tutorial to load in quake 3 shader items
scene::IMesh * additional_mesh = mesh->getMesh ( quake3::E_Q3_MESH_ITEMS );
for ( u32 i = 0; i!= additional_mesh->getMeshBufferCount (); ++i ){
IMeshBuffer *meshBuffer = additional_mesh->getMeshBuffer ( i );
const video::SMaterial &material = meshBuffer->getMaterial();
//! The ShaderIndex is stored in the material parameter
s32 shaderIndex = (s32) material.MaterialTypeParam2;
//the meshbuffer can be rendered without additional support, or it has no shader
const quake3::SShader *shader = mesh->getShader ( shaderIndex );
if( 0 == shader ){throw new std::string("Error loading shaders");}
mapNode->addChild((smgr->addQuake3SceneNode ( meshBuffer, shader )));
}
mesh->releaseMesh ( quake3::E_Q3_MESH_ITEMS );
if(!mapNode)return 1;
//CPTODO: get rid of local constant
mapNode->setPosition(core::vector3df(-1300,-144,-1249));
mapNode->setMaterialFlag(video::EMF_LIGHTING, true);//enable lighting
mapNode->setMaterialType(irr::video::EMT_LIGHTMAP_LIGHTING_M4);//set the material property of the map to blend the lightmap with dynamic lighting
smgr->addSkyDomeSceneNode(driver->getTexture("../media/skydome.jpg"),32,32,1.0f,2.0f); //create the skydome
mapNode->setMaterialFlag(irr::video::EMF_FOG_ENABLE, true);//enable fogging on the map node
//create a triangle selector object for the map for use in creating collisions
irr::scene::ITriangleSelector* selector = NULL;
selector = smgr->createOctTreeTriangleSelector(mesh->getMesh(quake3::E_Q3_MESH_GEOMETRY),//map->getMesh(0),
mapNode,128);
if(!selector)return 1;
mapNode->setTriangleSelector(selector);
{//block containing the game object
//create game HUD object
gameHUD* display = gameHUD::getInstance();
display->setVideoDriver(driver);
//create the game object
irr::scene::ISceneNode* x = smgr->addCubeSceneNode();
x->setPosition(vector3df(-400,-41,-42));
x->setScale(vector3df(45,1,5));
x->setMaterialTexture(0,driver->getTexture("../media/wall.jpg"));
x->setMaterialTexture(1,driver->getTexture("../media/wall.jpg"));
x->setMaterialFlag(video::EMF_FOG_ENABLE, true);
specialWalls.push_back(x);
irr::scene::ISceneNode* x2 = smgr->addCubeSceneNode();
x2->setPosition(vector3df(-400,-41,232));
x2->setScale(vector3df(45,.9,5));
x2->setMaterialTexture(0,driver->getTexture("../media/wall.jpg"));
x2->setMaterialFlag(video::EMF_FOG_ENABLE, true);
specialWalls.push_back(x2);
irr::scene::ISceneNode* x3 = smgr->addCubeSceneNode();
x3->setPosition(vector3df(-603,-41,104));
x3->setScale(vector3df(5,.95,45));
x3->setMaterialTexture(0,driver->getTexture("../media/wall.jpg"));
x3->setMaterialFlag(video::EMF_FOG_ENABLE, true);
specialWalls.push_back(x3);
x3 = smgr->addCubeSceneNode();
x3->setPosition(vector3df(825,-41,104));
x3->setScale(vector3df(5,1.25,45));
x3->setMaterialTexture(0,driver->getTexture("../media/wall.jpg"));
x3->setMaterialFlag(video::EMF_FOG_ENABLE, true);
specialWalls.push_back(x3);
x = smgr->addCubeSceneNode(); x->setPosition(vector3df(-400+1000,-41,-42)); x->setScale(vector3df(45,1.05,5)); x->setMaterialTexture(0,driver->getTexture("../media/wall.jpg")); x->setMaterialTexture(1,driver->getTexture("../media/wall.jpg")); x->setMaterialFlag(video::EMF_FOG_ENABLE, true); specialWalls.push_back(x);
x2 = smgr->addCubeSceneNode(); x2->setPosition(vector3df(-400+1000,-41,232)); x2->setScale(vector3df(45,.95,5)); x2->setMaterialTexture(0,driver->getTexture("../media/wall.jpg")); x2->setMaterialFlag(video::EMF_FOG_ENABLE, true); specialWalls.push_back(x2);
ktcGame game(device, selector, display); /*******************************************************/ /***************GAME UPDATE LOOP************************/ /*******************************************************/ while(device->run()){ //run update on the message handler to send any delayed messges that have passed their time stamp MsgHandler->update(device->getTimer());
game.update(device->getTimer());
//this has been taken out for planning based on menu system
guienv->drawAll();
if(InputHandler::getInstance()->EXIT_MESSAGE)
break;
}
}//scope containing the game
//device->drop();
//soundEngine->drop();
return 0;
}
