void WorkspaceWidget::showDialog() { NewMaterialDialog *newMaterial = new NewMaterialDialog(this); newMaterial->show(); MaterialManager *matMgr = MaterialManager::getSingletonPtr(); Ogre::LogManager::getSingleton().logMessage("Working dir: " + matMgr->getWorkDir().toStdString()); }
void SceneLabel::updateFromLabel() { MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager(); if(texture) materialManager->deleteTexture(texture); texture = materialManager->createTextureFromImage(label, materialManager->clampDefault, materialManager->mipmapsDefault); if(material) { localShaderOptions->clearTexture("diffuse"); localShaderOptions->addTexture("diffuse", texture); } delete mesh; mesh = new Mesh(Mesh::QUAD_MESH); mesh->createVPlane(label->getWidth()*scale,label->getHeight()*scale); bBox.x = label->getWidth()*scale; bBox.y = label->getHeight()*scale; bBox.z = 0; if(useVertexBuffer) CoreServices::getInstance()->getRenderer()->createVertexBufferForMesh(mesh); // TODO: resize it here bBoxRadius = label->getWidth()*scale; }
//---------------------------------------------------------------------------- GraphicsRoot::~GraphicsRoot () { MaterialManager *mi = MaterialManager::GetSingletonPtr(); if (mi) { mi->Terminate(); delete0(mi); MaterialManager::Set(0); } }
void MeshWithoutIndexDataTests::setUp() { LogManager::getSingleton().createLog("MeshWithoutIndexDataTests.log", true); OGRE_NEW ResourceGroupManager(); OGRE_NEW LodStrategyManager(); mBufMgr = OGRE_NEW DefaultHardwareBufferManager(); mMeshMgr = OGRE_NEW MeshManager(); archiveMgr = OGRE_NEW ArchiveManager(); archiveMgr->addArchiveFactory(OGRE_NEW FileSystemArchiveFactory()); MaterialManager* matMgr = OGRE_NEW MaterialManager(); matMgr->initialise(); }
Geometry* SceneLoader::LoadGeometry(QDomElement element) { Geometry* geom = GeometryPool::Get()->GetGeometry(_geometryName, _geometryIdx); if (geom) { return geom; } if (element.nodeName() != QString ("geometry")) { printf ("ceXMLDataLoader::LoadGeometry: Illegal data format: '%s' != 'geometry'\n", element.nodeName().toStdString().c_str()); fflush (stdout); return 0; } geom = new Geometry (); QDomElement staticElement = element.firstChildElement("staticmesh"); if (!staticElement.isNull()) { ceMesh* mesh = LoadMesh (staticElement); if (!mesh) { geom->Release(); return 0; } iStaticMesh* staticMesh = _engine->GetDevice()->CreateStaticMesh(); staticMesh->SetMesh(mesh); geom->SetMesh(staticMesh); geom->SetMetaMesh(MT_Static, staticElement.firstChildElement("mesh").attribute("filename")); } MaterialManager* matMgr = Session::Get()->GetMaterialManager(); QDomElement materialElement = element.firstChildElement("material"); Material* mat = 0; if (!materialElement.isNull()) { mat = matMgr->GetMaterial(materialElement.text()); } if (!mat) { mat = matMgr->GetDefaultMaterial(); } geom->SetMetaMaterial(mat); GeometryPool::Get()->Set(_geometryName, _geometryIdx, geom); return geom; }
Texture* MdlFileImport::loadTexture( mstudiotexture_t& texDesc , uint8* data ) { int texArea = texDesc.height * texDesc.width; uint8* pal = data + texArea; std::vector< uint8 > texData( texArea * 4 ); uint32* pColor = (uint32*) &texData[0]; for( int i = 0 ; i < texArea ; ++i ) { uint8* palC = pal + 3 * data[i]; pColor[i] = Color::toARGB( palC[0] , palC[1], palC[2] , 255 ); } MaterialManager* manager = mScene->getWorld()->_getMaterialManager(); Texture* texture = manager->createTexture2D( texDesc.name , CF_TEX_FMT_ARGB32 , &texData[0] , texDesc.width , texDesc.height ); return texture; }
void SetTexturePack (ceTexturePack* pack) { for (unsigned rp=0; rp<RP_Count; rp++) { for (unsigned ts=0; ts<TS_Count; ts++) { iTexture* txt = pack->GetTexture((ceRenderPass)rp, (ceTextureStage)ts); _textures[rp][ts] = _manager->FindTexture(txt); } } }
void ImpostorTexture::renderTextures(bool force) { #ifdef IMPOSTOR_FILE_SAVE TexturePtr renderTexture; #else TexturePtr renderTexture(texture); //if we're not using a file image we need to set up a resource loader, so that the texture is regenerated if it's ever unloaded (such as switching between fullscreen and the desktop in win32) loader = std::auto_ptr<ImpostorTextureResourceLoader>(new ImpostorTextureResourceLoader(*this)); #endif RenderTexture *renderTarget; Camera *renderCamera; Viewport *renderViewport; SceneNode *camNode; //Set up RTT texture uint32 textureSize = ImpostorPage::impostorResolution; if (renderTexture.isNull()) { renderTexture = TextureManager::getSingleton().createManual(getUniqueID("ImpostorTexture"), "Impostors", TEX_TYPE_2D, textureSize * IMPOSTOR_YAW_ANGLES, textureSize * IMPOSTOR_PITCH_ANGLES, 0, PF_A8R8G8B8, TU_RENDERTARGET, loader.get()); } renderTexture->setNumMipmaps(MIP_UNLIMITED); //Set up render target renderTarget = renderTexture->getBuffer()->getRenderTarget(); renderTarget->setAutoUpdated(false); //Set up camera camNode = sceneMgr->getSceneNode("ImpostorPage::cameraNode"); renderCamera = sceneMgr->createCamera(getUniqueID("ImpostorCam")); camNode->attachObject(renderCamera); renderCamera->setLodBias(1000.0f); renderViewport = renderTarget->addViewport(renderCamera); renderViewport->setOverlaysEnabled(false); renderViewport->setClearEveryFrame(true); renderViewport->setShadowsEnabled(false); renderViewport->setBackgroundColour(ImpostorPage::impostorBackgroundColor); //Set up scene node SceneNode* node = sceneMgr->getSceneNode("ImpostorPage::renderNode"); Ogre::SceneNode* oldSceneNode = entity->getParentSceneNode(); if (oldSceneNode) { oldSceneNode->detachObject(entity); } node->attachObject(entity); node->setPosition(-entityCenter); //Set up camera FOV const Real objDist = entityRadius * 100; const Real nearDist = objDist - (entityRadius + 1); const Real farDist = objDist + (entityRadius + 1); renderCamera->setAspectRatio(1.0f); renderCamera->setFOVy(Math::ATan(entityDiameter / objDist)); renderCamera->setNearClipDistance(nearDist); renderCamera->setFarClipDistance(farDist); //Disable mipmapping (without this, masked textures look bad) MaterialManager *mm = MaterialManager::getSingletonPtr(); FilterOptions oldMinFilter = mm->getDefaultTextureFiltering(FT_MIN); FilterOptions oldMagFilter = mm->getDefaultTextureFiltering(FT_MAG); FilterOptions oldMipFilter = mm->getDefaultTextureFiltering(FT_MIP); mm->setDefaultTextureFiltering(FO_POINT, FO_LINEAR, FO_NONE); //Disable fog FogMode oldFogMode = sceneMgr->getFogMode(); ColourValue oldFogColor = sceneMgr->getFogColour(); Real oldFogDensity = sceneMgr->getFogDensity(); Real oldFogStart = sceneMgr->getFogStart(); Real oldFogEnd = sceneMgr->getFogEnd(); sceneMgr->setFog(Ogre::FOG_EXP2, Ogre::ColourValue(0,0,0,0), 0.0f, 0.0f, 0.0f); //Ember change //We need to disable all lightning and render it full bright Ogre::ColourValue oldAmbientColour = sceneMgr->getAmbientLight(); sceneMgr->setAmbientLight(ColourValue::White); std::vector<Ogre::MovableObject*> lightStore; Ogre::SceneManager::MovableObjectIterator lightIterator = sceneMgr->getMovableObjectIterator(Ogre::LightFactory::FACTORY_TYPE_NAME); while (lightIterator.hasMoreElements()) { Ogre::MovableObject* light = lightIterator.getNext(); if (light) { if (light->getVisible()) { lightStore.push_back(light); light->setVisible(false); } } } // Get current status of the queue mode Ogre::SceneManager::SpecialCaseRenderQueueMode OldSpecialCaseRenderQueueMode = sceneMgr->getSpecialCaseRenderQueueMode(); //Only render the entity sceneMgr->setSpecialCaseRenderQueueMode(Ogre::SceneManager::SCRQM_INCLUDE); sceneMgr->addSpecialCaseRenderQueue(group->geom->getRenderQueue() + 1); uint8 oldRenderQueueGroup = entity->getRenderQueueGroup(); entity->setRenderQueueGroup(group->geom->getRenderQueue() + 1); bool oldVisible = entity->getVisible(); entity->setVisible(true); float oldMaxDistance = entity->getRenderingDistance(); entity->setRenderingDistance(0); bool needsRegen = true; #ifdef IMPOSTOR_FILE_SAVE //Calculate the filename hash used to uniquely identity this render String strKey = entityKey; char key[32] = {0}; uint32 i = 0; for (String::const_iterator it = entityKey.begin(); it != entityKey.end(); ++it) { key[i] ^= *it; i = (i+1) % sizeof(key); } for (i = 0; i < sizeof(key); ++i) key[i] = (key[i] % 26) + 'A'; String tempdir = this->group->geom->getTempdir(); ResourceGroupManager::getSingleton().addResourceLocation(tempdir, "FileSystem", "BinFolder"); String fileNamePNG = "Impostor." + String(key, sizeof(key)) + '.' + StringConverter::toString(textureSize) + ".png"; String fileNameDDS = "Impostor." + String(key, sizeof(key)) + '.' + StringConverter::toString(textureSize) + ".dds"; //Attempt to load the pre-render file if allowed needsRegen = force; if (!needsRegen){ try{ texture = TextureManager::getSingleton().load(fileNameDDS, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED); } catch (...){ try{ texture = TextureManager::getSingleton().load(fileNamePNG, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED); } catch (...){ needsRegen = true; } } } #endif if (needsRegen){ //If this has not been pre-rendered, do so now const float xDivFactor = 1.0f / IMPOSTOR_YAW_ANGLES; const float yDivFactor = 1.0f / IMPOSTOR_PITCH_ANGLES; for (int o = 0; o < IMPOSTOR_PITCH_ANGLES; ++o){ //4 pitch angle renders #ifdef IMPOSTOR_RENDER_ABOVE_ONLY Radian pitch = Degree((90.0f * o) * yDivFactor); //0, 22.5, 45, 67.5 #else Radian pitch = Degree((180.0f * o) * yDivFactor - 90.0f); #endif for (int i = 0; i < IMPOSTOR_YAW_ANGLES; ++i){ //8 yaw angle renders Radian yaw = Degree((360.0f * i) * xDivFactor); //0, 45, 90, 135, 180, 225, 270, 315 //Position camera camNode->setPosition(0, 0, 0); camNode->setOrientation(Quaternion(yaw, Vector3::UNIT_Y) * Quaternion(-pitch, Vector3::UNIT_X)); camNode->translate(Vector3(0, 0, objDist), Node::TS_LOCAL); //Render the impostor renderViewport->setDimensions((float)(i) * xDivFactor, (float)(o) * yDivFactor, xDivFactor, yDivFactor); renderTarget->update(); } } #ifdef IMPOSTOR_FILE_SAVE //Save RTT to file with respecting the temp dir renderTarget->writeContentsToFile(tempdir + fileNamePNG); //Load the render into the appropriate texture view texture = TextureManager::getSingleton().load(fileNamePNG, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED); #else texture = renderTexture; #endif } entity->setVisible(oldVisible); entity->setRenderQueueGroup(oldRenderQueueGroup); entity->setRenderingDistance(oldMaxDistance); sceneMgr->removeSpecialCaseRenderQueue(group->geom->getRenderQueue() + 1); // Restore original state sceneMgr->setSpecialCaseRenderQueueMode(OldSpecialCaseRenderQueueMode); //Re-enable mipmapping mm->setDefaultTextureFiltering(oldMinFilter, oldMagFilter, oldMipFilter); //Re-enable fog sceneMgr->setFog(oldFogMode, oldFogColor, oldFogDensity, oldFogStart, oldFogEnd); //Re-enable both scene lightning and disabled individual lights sceneMgr->setAmbientLight(oldAmbientColour); for (std::vector<Ogre::MovableObject*>::const_iterator I = lightStore.begin(); I != lightStore.end(); ++I) { (*I)->setVisible(true); } //Delete camera renderTarget->removeViewport(0); renderCamera->getSceneManager()->destroyCamera(renderCamera); //Delete scene node node->detachAllObjects(); if (oldSceneNode) { oldSceneNode->attachObject(entity); } #ifdef IMPOSTOR_FILE_SAVE //Delete RTT texture assert(!renderTexture.isNull()); String texName2(renderTexture->getName()); renderTexture.setNull(); if (TextureManager::getSingletonPtr()) TextureManager::getSingleton().remove(texName2); #endif }
void LevelManager::loadLevel(Level* lvl) { printf("STARTING TO LOAD LEVEL \n" ); std::cout << "Entities::start " << cg::Registry::instance()->size() << "\n"; _currentLevel = lvl; _currentClues = 0; static_cast<Scene*>(cg::Registry::instance()->get("Scene"))->reset(); MaterialManager* materialManager = dynamic_cast<MaterialManager*>(cg::Registry::instance()->get("MaterialManager")); TextureManager* textureManager = dynamic_cast<TextureManager*>(cg::Registry::instance()->get("TextureManager")); materialManager->clear(); std::list<Material*>::iterator matit; for(matit = lvl->getMaterials()->begin(); matit != lvl->getMaterials()->end(); matit++) { materialManager->add(*matit); } textureManager->clear(); std::list<Texture*>::iterator texit; textureManager->addMap(lvl->getMapTex()); for(texit = lvl->getTextures()->begin(); texit != lvl->getTextures()->end(); texit++) { textureManager->add(*texit); } printf("LEVEL MANAGER: REMOVING PREVIOUS ENTITIES\n"); //clearing old ones (if there are any) cg::View* v1 = static_cast<cg::View*>(cg::Registry::instance()->get("view1")); std::list<std::string>::iterator entitiesit; for(entitiesit = _currentEntities->begin(); entitiesit != _currentEntities->end(); entitiesit++) { v1->unlinkEntity(*entitiesit); cg::Registry::instance()->remove(*entitiesit); } std::cout << "Entities::after_unlink " << cg::Registry::instance()->size() << "\n"; DebugManager* dm = static_cast<DebugManager*>(cg::Registry::instance()->get("DebugManager")); std::cout << "Debugmanager::Before " << dm->getListsSize() << "\n"; printf("LEVEL MANAGER: REMOVING DEBUG LISTENERS\n"); //removing everything registered for Debug (Ninja is always there) //DebugManager* dm = static_cast<DebugManager*>(cg::Registry::instance()->get("DebugManager")); dm->dispose(); dm->disableDebug(); std::cout << "Debugmanager::After " << dm->getListsSize() << "\n"; CollisionManager* cm = static_cast<CollisionManager*>(cg::Registry::instance()->get("CollisionManager")); std::cout << "Collision::Before " << cm->getListsSize() << "\n"; printf("LEVEL MANAGER: REMOVING COLLISION LISTENERS\n"); //removing everything except Ninja from Collisions //CollisionManager* cm = static_cast<CollisionManager*>(cg::Registry::instance()->get("CollisionManager")); cm->dispose(); std::cout << "Collision::After " << cm->getListsSize() << "\n"; std::cout << "Entities::after_managers " << cg::Registry::instance()->size() << "\n"; _currentEntities->clear(); std::cout << "Entities::after_clean_entities " << cg::Registry::instance()->size() << "\n"; printf("LEVEL MANAGER: STARTING TO LOAD HEIGHT MAP\n"); ImageLoaderHeightMap* ilhm = static_cast<ImageLoaderHeightMap*>(cg::Registry::instance()->get("mappedterrain")); if(ilhm != NULL) ilhm->setHeightMap(LEVEL_PATH + _currentLevel->getHeightMap()); else { ilhm = new ImageLoaderHeightMap("mappedterrain", LEVEL_PATH + _currentLevel->getHeightMap()); cg::Registry::instance()->add(ilhm); } std::cout << "Entities::after_heightmap " << cg::Registry::instance()->size() << "\n"; printf("LEVEL MANAGER: STARTING TO LOAD ITEM MAP\n"); ImageLoaderItemMap* ilim = static_cast<ImageLoaderItemMap*>(cg::Registry::instance()->get("mappeditems")); if(ilim != NULL) ilim->setItemMap(LEVEL_PATH + _currentLevel->getHeightMap(), LEVEL_PATH + _currentLevel->getItemMap()); else { ilim = new ImageLoaderItemMap("mappeditems", LEVEL_PATH + _currentLevel->getHeightMap(), LEVEL_PATH + _currentLevel->getItemMap()); cg::Registry::instance()->add(ilim); } for(entitiesit = _currentEntities->begin(); entitiesit != _currentEntities->end(); entitiesit++) { cg::Registry::instance()->get(*entitiesit)->init(); } //reset ninja position printf("LEVEL MANAGER: RESETING NINJA POSITION\n"); Ninja* ninja = dynamic_cast<Ninja*>(cg::Registry::instance()->get("Ninja")); ninja->reset(); static_cast<Camera*>(cg::Registry::instance()->get("Camera"))->mainCamera(); std::cout << "Entities::after_itemmap " << cg::Registry::instance()->size() << "\n"; std::cout << "Debugmanager::After " << dm->getListsSize() << "\n"; std::cout << "Collision::After " << cm->getListsSize() << "\n"; printf("LEVEL LOADED\n"); }
void RenderState::enter() { OgreFramework* framework = OgreFramework::getSingletonPtr(); framework->_viewport->setVisibilityMask(RF_MAIN); //framework->_log->logMessage("Entering RenderState..."); _sceneMgr = framework->_root->createSceneManager(ST_GENERIC, "RenderSceneMgr"); _sceneMgr->setAmbientLight(Ogre::ColourValue(0.7f, 0.7f, 0.7f)); _sceneMgr->addRenderQueueListener(framework->_overlaySystem); /////////////////// Setup Ray queries (unused) _rsq = _sceneMgr->createRayQuery(Ray()); _rsq->setQueryMask(OGRE_HEAD_MASK); ////////////////// Setup Camera _camera = _sceneMgr->createCamera("GameCamera"); _camera->setPosition(Vector3(5, 60, 60)); _camera->lookAt(Vector3(5, 20, 0)); _camera->setNearClipDistance(5); Real vpWidth = Real(framework->_viewport->getActualWidth()); Real vpHeight = Real(framework->_viewport->getActualHeight()); _camera->setAspectRatio(vpWidth / vpHeight); framework->_viewport->setCamera(_camera); _currentObject = 0; ////////////////// Setup GUI buildGUI(); ////////////////// Setup Scene createScene(); ////////////////// Create render textures // PixelFormat format = PF_A8B8G8R8; PixelFormat format = PF_FLOAT16_RGBA; float rtWidth = vpWidth; float rtHeight = vpHeight; if (rayPositions.create("rayPos", rtWidth, rtHeight, format, _camera, _sceneMgr)) { std::cout << "Error creating ray positions texture\n"; } if (rayDirections.create("rayDir", rtWidth, rtHeight, format, _camera, _sceneMgr)) { std::cout << "Error creating ray directions texture\n"; } rayPositions.setupThumbnail(0.74, 0.99, -0.74, -0.99); rayPositions.showThumbnail(); rayDirections.setupThumbnail(0.45, 0.7, -0.74, -0.99); rayDirections.showThumbnail(); ////////////////// Setup parameters for ray materials MaterialManager* matMgr = MaterialManager::getSingletonPtr(); MaterialPtr rayDirMat = matMgr->getByName("BoundingCubesDirections"); GpuProgramParametersSharedPtr fragParameters; fragParameters = rayDirMat->getTechnique(0)->getPass(0)->getFragmentProgramParameters(); float rt_width_inv = 1.0 / rtWidth; float rt_height_inv = 1.0 / rtHeight; try { fragParameters->setNamedConstant("width_inv", rt_width_inv); fragParameters->setNamedConstant("height_inv", rt_height_inv); } catch (Exception e) {} float width_inv = 1.0 / vpWidth; float height_inv = 1.0 / vpHeight; fragParameters = breadMat->getTechnique(0)->getPass(0)->getFragmentProgramParameters(); try { fragParameters->setNamedConstant("width_inv", width_inv); fragParameters->setNamedConstant("height_inv", height_inv); } catch (Exception e) {} ////////////////// Setup shadow params _sceneMgr->setShadowFarDistance(100); _sceneMgr->setShadowTextureCount(2); _sceneMgr->setShadowTextureSelfShadow(true); _sceneMgr->setShadowCasterRenderBackFaces(false); _sceneMgr->setShadowTextureCasterMaterial("DepthShadowmap/Caster/Bread"); _sceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED); _sceneMgr->setShadowTextureConfig( 0, 2048, 2048, PF_FLOAT32_R ); tableEntity->getSubEntity(0)->getMaterial()->setReceiveShadows(true); tableEntity->getSubEntity(0)->setMaterialName("DepthShadowmap/Receiver/Float", "General"); breadEntity->getSubEntity(0)->getMaterial()->setReceiveShadows(true); breadEntity->setCastShadows(true); }
void WFLoader::parseMaterialFile( const char *line ) { /* Variables */ char tempStr[20] = "\0"; MaterialManager *matMngrPtr = NULL; MaterialData matData; float r, g, b; /* Code */ matMngrPtr = MaterialManager::getInstance(); if( strlen( line ) > 0 ) { if( line[ 0 ] == 'n' ) { sscanf( line, "%s", tempStr ); /* Material name */ if( strcmp( tempStr, "newmtl" ) == 0 ) { sscanf( line, "%*s %s", m_CurrentMatName ); matMngrPtr->addMaterial( m_CurrentMatName, matData ); } } else if( line[ 0 ] == 'N' ) { switch( line[ 1 ] ) { case 's': /* Specular exponent ( shininess ) */ sscanf( line, "%*s %f", &r ); /* Even though Color4f is used, only the value of r gets saved into the Material values */ matMngrPtr->setValue( m_CurrentMatName, MaterialManager::MAT_SHININESS, Color4f( r, 0.0, 0.0, 1.0 ) ); break; } } /* Reflectivity information */ else if( line[ 0 ] == 'K' ) { switch( line[ 1 ] ) //if( line[ 1 ] == 'a' ) { case 'a': /* Ambient */ sscanf( line, "%*s %f %f %f", &r, &g, &b ); matMngrPtr->setValue( m_CurrentMatName, MaterialManager::MAT_AMBIENT, Color4f( r, g, b, 1.0 ) ); break; case 'd': /* Diffuse */ sscanf( line, "%*s %f %f %f", &r, &g, &b ); matMngrPtr->setValue( m_CurrentMatName, MaterialManager::MAT_DIFFUSE, Color4f( r, g, b, 1.0 ) ); break; case 's': /* Specular */ sscanf( line, "%*s %f %f %f", &r, &g, &b ); matMngrPtr->setValue( m_CurrentMatName, MaterialManager::MAT_SPECULAR, Color4f( r, g, b, 1.0 ) ); break; } } } }
void UIRect::loadTexture(String fileName) { MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager(); texture = materialManager->createTextureFromFile(fileName, materialManager->clampDefault, false); }
int main(int argc, char** argv ){ if( argc != 8 ) { std::cout << " usage: print_materials compact.xml x0 y0 z0 x1 y1 z1 " << std::endl << " -> prints the materials on a straight line between the two given points ( unit is cm) " << std::endl ; exit(1) ; } std::string inFile = argv[1] ; std::stringstream sstr ; sstr << argv[2] << " " << argv[3] << " " << argv[4] << " " << argv[5] << " " << argv[6] << " " << argv[7] ; double x0,y0,z0,x1,y1,z1 ; sstr >> x0 ; sstr >> y0 ; sstr >> z0 ; sstr >> x1 ; sstr >> y1 ; sstr >> z1 ; LCDD& lcdd = LCDD::getInstance(); lcdd.fromCompact( inFile ); Vector3D p0( x0, y0, z0 ) ; Vector3D p1( x1, y1, z1 ) ; MaterialManager matMgr ; const MaterialVec& materials = matMgr.materialsBetween( p0 , p1 ) ; std::cout << std::endl << " ####### materials between the two points : " << p0 << "*cm and " << p1 << "*cm : " << std::endl ; double sum_x0 = 0 ; double sum_lambda = 0 ; double path_length = 0 ; for( unsigned i=0,n=materials.size();i<n;++i){ Material mat = materials[i].first ; double length = materials[i].second ; double nx0 = length / mat.radLength() ; sum_x0 += nx0 ; double nLambda = length / mat.intLength() ; sum_lambda += nLambda ; path_length += length ; std::cout << " " << mat << " thickness: " << length << " path_length:" << path_length << " integrated_X0: " << sum_x0 << " integrated_lambda: " << sum_lambda << std::endl ; } std::cout << "############################################################################### " << std::endl << std::endl ; const MaterialData& avMat = matMgr.createAveragedMaterial( materials ) ; std::cout << " averaged Material : " << " Z: " << avMat.Z() << " A: " << avMat.A() << " densitiy: " << avMat.density() << " radiationLength: " << avMat.radiationLength() << " interactionLength: " << avMat.interactionLength() << std::endl << std::endl ; std::cout << " Total length : " << path_length / dd4hep::mm << " mm " << std::endl ; std::cout << " Integrated radiation lengths : " << path_length / avMat.radiationLength() << " X0 " << std::endl ; std::cout << " Integrated interaction lengths : " << path_length / avMat.interactionLength() << " lambda " << std::endl ; std::cout << "############################################################################### " << std::endl << std::endl ; return 0; }
bool ObjModel::loadMTLFile(const char* fileName) { cout << "Loading material file: " << fileName << endl; FILE* fp; string* modelPath = getCvarAddress_S("r_modelPath"); string canonicalPath = *modelPath + "obj/" + fileName; cout << "From file path: " << canonicalPath << endl; if( !(fp=fopen(canonicalPath.c_str(), "r")) ) { error = "OBJ Materials file not found"; Con_print("Obj: File not found - %s", canonicalPath.c_str()); return false; } MaterialManager* tm = getMaterialManager(); material_t* mat; while( !feof(fp) ) { char in[MAX_OBJ_LINE_LEN]; fgets(in, MAX_OBJ_LINE_LEN, fp); char incpy[MAX_OBJ_LINE_LEN]; #ifdef OBJMATDEBUG cout << "MAT Line: " << in << endl; #endif strcpy(incpy, in); // if its a comment or whitespace skip it if( in[0] == '#' || in[0] == ' ' || in[0] == '\n' || in[0] == '\r' || in[0] == '\t') continue; else { // otherwise we need to process some data char* token = strtok(in, WHITESPACE); if( token == NULL ) break; if( !strcmp(token, "newmtl") ) { material_t* newmat = new material_t; initializeMaterial(newmat); token = strtok(NULL, WHITESPACE); if( !tm->hasMaterial(token) ) { tm->addMaterial(token, newmat); mat = newmat; #ifdef OBJMATDEBUG cout << "New material created: " << token << endl; #endif } else { #ifdef OBJMATDEBUG cout << "MTL Error: Material redefinition: " << token << endl; #endif } } else if( !strcmp(token, "Ns") ) { sscanf(incpy, "Ns %f", &mat->Ns); } else if( !strcmp(token, "Ka") ) { sscanf(incpy, "Ka %f %f %f", &mat->Ka[0], &mat->Ka[1], &mat->Ka[2]); } else if( !strcmp(token, "Kd") ) { sscanf(incpy, "Kd %f %f %f", &mat->Kd[0], &mat->Kd[1], &mat->Kd[2]); } else if( !strcmp(token, "Ks") ) { sscanf(incpy, "Ks %f %f %f", &mat->Ks[0], &mat->Ks[1],& mat->Ks[2]); } else if( !strcmp(token, "Ni") ) { sscanf(incpy, "Ni %f", &mat->Ni); } else if( !strcmp(token, "d") ) { sscanf(incpy, "d %f", &mat->d); } else if( !strcmp(token, "illum") ) { sscanf(incpy, "illum %d", &mat->illum); } else if( !strcmp(token, "map_Kd") ) { token = strtok(NULL, WHITESPACE); strcpy(mat->map_Kd, token); #ifdef OBJMATDEBUG cout << "Loading texture: " << mat->map_Kd << endl; #endif getMaterialManager()->loadBitmap(mat->map_Kd); } } } fclose(fp); return true; }
void SceneMesh::loadTextureFromImage(Image *image) { MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager(); texture = materialManager->createTextureFromImage(image, materialManager->clampDefault, materialManager->mipmapsDefault); }
void GodRaysManager::_createMaterials(const HydraxComponent& HC) { Ogre::String VertexProgramData, FragmentProgramData; Ogre::GpuProgramParametersSharedPtr VP_Parameters, FP_Parameters; Ogre::String EntryPoints[2] = {"main_vp", "main_fp"}; Ogre::String GpuProgramsData[2]; Ogre::String GpuProgramNames[2]; MaterialManager *mMaterialManager = mHydrax->getMaterialManager(); int NumberOfDepthChannels = 0; Ogre::String GB[2] = {"0, 1, 0", "0, 0, 1"}; if (_isComponent(HC, HYDRAX_COMPONENT_CAUSTICS)) { NumberOfDepthChannels++; } // God Rays material VertexProgramData = ""; FragmentProgramData = ""; // Vertex program switch (mHydrax->getShaderMode()) { case MaterialManager::SM_HLSL: case MaterialManager::SM_CG: { VertexProgramData += Ogre::String( "void main_vp(\n") + // IN "float4 iPosition : POSITION,\n" + // OUT "out float4 oPosition : POSITION,\n"; if (mObjectsIntersections) { VertexProgramData += Ogre::String( "out float3 oPosition_ : TEXCOORD0,\n") + "out float4 oProjUV : TEXCOORD1,\n" + // UNIFORM "uniform float4x4 uWorld,\n" + "uniform float4x4 uTexViewProj,\n"; } VertexProgramData += Ogre::String( "uniform float4x4 uWorldViewProj)\n") + "{\n" + "oPosition = mul(uWorldViewProj, iPosition);\n"; if (mObjectsIntersections) { VertexProgramData += Ogre::String( "float4 wPos = mul(uWorld, iPosition);\n")+ "oPosition_ = wPos.xyz;\n"+ "oProjUV = mul(uTexViewProj, wPos);\n"; } VertexProgramData += "}\n"; } break; case MaterialManager::SM_GLSL: {} break; } // Fragment program switch (mHydrax->getShaderMode()) { case MaterialManager::SM_HLSL: case MaterialManager::SM_CG: { if (mObjectsIntersections) FragmentProgramData += Ogre::String( "void main_fp(\n") + // IN "float3 iPosition : TEXCOORD0,\n" + "float4 iProjUV : TEXCOORD1,\n" + // OUT "out float4 oColor : COLOR,\n" + // UNIFORM "uniform float3 uLightPosition,\n"+ "uniform float uLightFarClipDistance,\n" + "uniform sampler2D uDepthMap : register(s0))\n" + "{\n" + "iProjUV = iProjUV / iProjUV.w;\n"+ "float Depth = tex2D(uDepthMap, iProjUV.xy).r;\n"+ "if (Depth < saturate( length(iPosition-uLightPosition) / uLightFarClipDistance ))\n"+ "{\n"+ "oColor = float4(0,0,0,1);\n"+ "}\n"+ "else\n"+ "{\n"+ "oColor = float4(float3(" + GB[NumberOfDepthChannels] + ") * 0.1, 1);\n"+ "}\n"+ "}\n"; else FragmentProgramData += Ogre::String( "void main_fp(\n") + // OUT "out float4 oColor : COLOR)\n" + "{\n" + "oColor = float4(float3(" + GB[NumberOfDepthChannels] + ") * 0.1, 1);\n"+ "}\n"; } break; case MaterialManager::SM_GLSL: {} break; } // Build our material mMaterials[0] = Ogre::MaterialManager::getSingleton(). create(_def_GodRays_Material_Name, HYDRAX_RESOURCE_GROUP); Ogre::Pass *GR_Technique0_Pass0 = mMaterials[0]->getTechnique(0)->getPass(0); GR_Technique0_Pass0->setLightingEnabled(false); GR_Technique0_Pass0->setCullingMode(Ogre::CULL_NONE); GR_Technique0_Pass0->setDepthWriteEnabled(false); GR_Technique0_Pass0->setDepthCheckEnabled(mObjectsIntersections); GR_Technique0_Pass0->setSceneBlending(Ogre::SBT_ADD); GpuProgramsData[0] = VertexProgramData; GpuProgramsData[1] = FragmentProgramData; GpuProgramNames[0] = _def_GodRays_Shader_VP_Name; GpuProgramNames[1] = _def_GodRays_Shader_FP_Name; mMaterialManager->fillGpuProgramsToPass(GR_Technique0_Pass0, GpuProgramNames, mHydrax->getShaderMode(), EntryPoints, GpuProgramsData); VP_Parameters = GR_Technique0_Pass0->getVertexProgramParameters(); FP_Parameters = GR_Technique0_Pass0->getFragmentProgramParameters(); VP_Parameters->setNamedAutoConstant("uWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX); if (!mObjectsIntersections) { return; } Ogre::Matrix4 TexViewProj = PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE * mProjectorCamera->getProjectionMatrixWithRSDepth() * mProjectorCamera->getViewMatrix(); VP_Parameters->setNamedAutoConstant("uWorld", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX); VP_Parameters->setNamedConstant("uTexViewProj", TexViewProj); FP_Parameters->setNamedConstant("uLightPosition", mProjectorSN->getPosition()); FP_Parameters->setNamedConstant("uLightFarClipDistance", mProjectorCamera->getFarClipDistance()); GR_Technique0_Pass0->createTextureUnitState(_def_GodRays_Depth_Map)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); GR_Technique0_Pass0->getTextureUnitState(0)->setTextureName(_def_GodRays_Depth_Map); // Depth material VertexProgramData = ""; FragmentProgramData = ""; // Vertex program switch (mHydrax->getShaderMode()) { case MaterialManager::SM_HLSL: case MaterialManager::SM_CG: { VertexProgramData += Ogre::String( "void main_vp(\n") + // IN "float4 iPosition : POSITION,\n" + "float2 iUV : TEXCOORD0,\n" + // OUT "out float4 oPosition : POSITION,\n" + "out float3 oPosition_ : TEXCOORD0,\n" + // UNIFORM "uniform float4x4 uWorld,\n" + "uniform float4x4 uWorldViewProj)\n" + "{\n" + "oPosition = mul(uWorldViewProj, iPosition);\n"+ "float4 wPos = mul(uWorld, iPosition);\n"+ "oPosition_ = wPos.xyz;\n"+ "}\n"; } break; case MaterialManager::SM_GLSL: {} break; } // Fragment program switch (mHydrax->getShaderMode()) { case MaterialManager::SM_HLSL: case MaterialManager::SM_CG: { FragmentProgramData += Ogre::String( "void main_fp(\n") + // IN "float3 iPosition : TEXCOORD0,\n" + // OUT "out float4 oColor : COLOR,\n" + // UNIFORM "uniform float3 uLightPosition,\n" + "uniform float uLightFarClipDistance)\n" + "{\n" + "float depth = saturate( length(iPosition-uLightPosition) / uLightFarClipDistance );\n"+ "oColor = float4(depth, 0, 0, 0);\n"+ "}\n"; } break; case MaterialManager::SM_GLSL: {} break; } // Build our material mMaterials[1] = Ogre::MaterialManager::getSingleton(). create(_def_GodRaysDepth_Material_Name, HYDRAX_RESOURCE_GROUP); Ogre::Pass *GRD_Technique0_Pass0 = mMaterials[1]->getTechnique(0)->getPass(0); mMaterials[1]->getTechnique(0)->setSchemeName("HydraxGodRaysDepth"); GRD_Technique0_Pass0->setLightingEnabled(false); GRD_Technique0_Pass0->setCullingMode(Ogre::CULL_NONE); GpuProgramsData[0] = VertexProgramData; GpuProgramsData[1] = FragmentProgramData; GpuProgramNames[0] = _def_GodRaysDepth_Shader_VP_Name; GpuProgramNames[1] = _def_GodRaysDepth_Shader_FP_Name; mMaterialManager->fillGpuProgramsToPass(GRD_Technique0_Pass0, GpuProgramNames, mHydrax->getShaderMode(), EntryPoints, GpuProgramsData); VP_Parameters = GRD_Technique0_Pass0->getVertexProgramParameters(); FP_Parameters = GRD_Technique0_Pass0->getFragmentProgramParameters(); VP_Parameters->setNamedAutoConstant("uWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX); VP_Parameters->setNamedAutoConstant("uWorld", Ogre::GpuProgramParameters::ACT_WORLD_MATRIX); FP_Parameters->setNamedConstant("uLightPosition", mProjectorSN->getPosition()); FP_Parameters->setNamedConstant("uLightFarClipDistance", mProjectorCamera->getFarClipDistance()); }
//Loads the MD2 model MD2Model* MD2Model::load(const char* filename) { Vec3f xyzMin; Vec3f xyzMax; ifstream input; input.open(filename, istream::binary); Con_print("****MD2LOAD:START****"); char buffer[64]; input.read(buffer, 4); //Should be "IPD2", if this is an MD2 file if (buffer[0] != 'I' || buffer[1] != 'D' || buffer[2] != 'P' || buffer[3] != '2') { Con_print("MD2 Error: Wrong MD2 Version Found!"); return NULL; } if (readInt(input) != 8) { //The version number Con_print("MD2 Error: Wrong MD2 Version Number Found!"); return NULL; } int textureWidth = readInt(input); //The width of the textures int textureHeight = readInt(input); //The height of the textures readInt(input); //The number of bytes per frame int numTextures = readInt(input); //The number of textures if (numTextures != 1) { Con_print("MD2 Error: No Textures Found!"); return NULL; } int numVertices = readInt(input); //The number of vertices int numTexCoords = readInt(input); //The number of texture coordinates int numTriangles = readInt(input); //The number of triangles readInt(input); //The number of OpenGL commands int numFrames = readInt(input); //The number of frames //Offsets (number of bytes after the beginning of the file to the beginning //of where certain data appear) int textureOffset = readInt(input); //The offset to the textures int texCoordOffset = readInt(input); //The offset to the texture coordinates int triangleOffset = readInt(input); //The offset to the triangles int frameOffset = readInt(input); //The offset to the frames readInt(input); //The offset to the OpenGL commands readInt(input); //The offset to the end of the file MD2Model* model = new MD2Model(); MaterialManager* matsMgr = getMaterialManager(); //Load the texture input.seekg(textureOffset, ios_base::beg); input.read(buffer, 64); // FIXME // Hack to get the md2 models with pcx textures to load bmp version instead string s = buffer; s = s.substr(0, s.find_last_of(".")); s = s + ".bmp"; strcpy(buffer, s.c_str()); // END FIXME //////////////////////// if (strlen(buffer) < 5 || strcmp(buffer + strlen(buffer) - 4, ".bmp") != 0 ) { Con_print("MD2 Error: Couldn't parse texture name: %s", buffer); // Set texture not found because we can't load the texture that was set model->textureId = matsMgr->getGLTexID("not-found.bmp"); } else { if( !matsMgr->hasMaterial(buffer) ) matsMgr->loadBitmap(buffer); model->textureId = matsMgr->getGLTexID(buffer); } //Load the texture coordinates input.seekg(texCoordOffset, ios_base::beg); model->texCoords = new MD2TexCoord[numTexCoords]; for(int i = 0; i < numTexCoords; i++) { MD2TexCoord* texCoord = model->texCoords + i; texCoord->texCoordX = (float)readShort(input) / textureWidth; texCoord->texCoordY = 1 - (float)readShort(input) / textureHeight; } //Load the triangles input.seekg(triangleOffset, ios_base::beg); model->triangles = new MD2Triangle[numTriangles]; model->numTriangles = numTriangles; for(int i = 0; i < numTriangles; i++) { MD2Triangle* triangle = model->triangles + i; for(int j = 0; j < 3; j++) { triangle->vertices[j] = readUShort(input); } for(int j = 0; j < 3; j++) { triangle->texCoords[j] = readUShort(input); } } //Load the frames input.seekg(frameOffset, ios_base::beg); model->frames = new MD2Frame[numFrames]; model->numFrames = numFrames; for(int i = 0; i < numFrames; i++) { MD2Frame* frame = model->frames + i; frame->vertices = new MD2Vertex[numVertices]; Vec3f scale = readVec3f(input); Vec3f translation = readVec3f(input); input.read(frame->name, 16); for(int j = 0; j < numVertices; j++) { MD2Vertex* vertex = frame->vertices + j; input.read(buffer, 3); Vec3f v((unsigned char)buffer[0], (unsigned char)buffer[1], (unsigned char)buffer[2]); vertex->pos = translation + Vec3f(scale[0] * v[0], scale[1] * v[1], scale[2] * v[2]); // added to get dimensions of model at load time model->doDimensionCheck(vertex->pos); // end dimension add input.read(buffer, 1); int normalIndex = (int)((unsigned char)buffer[0]); vertex->normal = Vec3f(NORMALS[3 * normalIndex], NORMALS[3 * normalIndex + 1], NORMALS[3 * normalIndex + 2]); } } model->startFrame = 0; model->endFrame = numFrames - 1; Con_print("numFrames: %d", numFrames ); Con_print("****MD2LOAD:FINISH****"); Con_print("MD2 Dimensions: %.3f x %.3f x %.3f", model->xRadius*2, model->yRadius*2, model->zRadius*2); return model; }
void SceneMesh::loadTexture(const String& fileName) { MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager(); texture = materialManager->createTextureFromFile(fileName, materialManager->clampDefault, materialManager->mipmapsDefault); ownsTexture = false; // Texture is owned by material manager, not mesh. }
void display() { Core::init(512,512); Core::getInstance()->initImageRendering(); Camera * cam = new Camera(); cam->setPosition(Vector4I(0,-8,-8,1)); cam->setDirection(Vector4I(0,-1,-1,0),Vector4I(0,1,0,0)); cam->setFovDeg(30,30); cam->flush(); MaterialManager * materials = new MaterialManager("/home/rulk/src/raytracer-wsp/StingRay/src/material/" ,"/home/rulk/src/raytracer-wsp/StingRay/src/material/"); materials->loadFile("basic.material"); materials->compile(); Material * mat = materials->getMaterial("simpleColor"); Material * mat1 = materials->getMaterial("complexColor"); std::cout<<mat<<std::endl; RenderableManager * renderables = new RenderableManager(); Sphere * sphere = new Sphere(mat,Fvec4(2,0,-8,1),1); Sphere * sphere1 = new Sphere(mat1,Fvec4(-2,0,-8,1),1); Sphere * sphere2 = new Sphere(mat1,Fvec4(0,2,-8,1),1); ManualMesh manual; TriMesh *themesh = TriMesh::read("/home/rulk/src/raytracer-wsp/StingRay/cube.obj"); if (!themesh) THROW(0,"No such mesh..."); themesh->need_normals(); themesh->need_tstrips(); themesh->need_bsphere(); int offset = 0,len = 0,pIndex; manual.begin(mat); bool needdub = false; for(int i=0;i<themesh->tstrips.size();i++) { if( i >= offset+len) { offset = i+1; len = themesh->tstrips[i]; //manual.beginStrip(); if(i != 0) { manual.duplicateLast(); needdub = true; } continue; } pIndex = themesh->tstrips[i]; manual.position(themesh->vertices[pIndex][0],themesh->vertices[pIndex][1],themesh->vertices[pIndex][2]); if(needdub) { manual.duplicateLast(); needdub = false; } } manual.normal(Fvec4(0,1,0,0)); std::cout<<"Size:"<<themesh->tstrips.size()<<std::endl; TriangelMesh * mesh = manual.getTriangelMesh(); /*SphereStream * spheres = new SphereStream(1,STREAM_READ); spheres->put(Vector4I(2,0,-8,1),1,Vector3I(0,0,1)); spheres->flush(); */ // renderables->registerRendarable(sphere); // renderables->registerRendarable(sphere1); // renderables->registerRendarable(sphere2); renderables->registerRendarable(mesh); MaterialKernel * kernel = new MaterialKernel("/home/rulk/src/raytracer-wsp/StingRay/cl/sphere_tracer.cl"); kernel->setMaterialManager(materials); kernel->setRenderableManager(renderables); kernel->compileKernel(); kernel->setCamera(cam); size_t global_item_size = 512*512; // Process the entire lists size_t local_item_size = 512; kernel->run(Core::getInstance()->getQue(),&global_item_size,&local_item_size); //streamC.sync(); Core::getInstance()->dumpImage("out.png"); Core::getInstance()->flushQue(); Core::getInstance()->finishQue(); delete kernel; Core::destroy(); cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!! return ; }
void SceneMesh::loadTexture(const String& fileName) { MaterialManager *materialManager = CoreServices::getInstance()->getMaterialManager(); texture = materialManager->createTextureFromFile(fileName, materialManager->clampDefault, materialManager->mipmapsDefault); }
Resource *TextureResourceLoader::loadResource(const String &path, ResourcePool *targetPool) { MaterialManager *materialManager = Services()->getMaterialManager(); Texture *texture = materialManager->createTextureFromFile(path, materialManager->clampDefault, materialManager->mipmapsDefault); return texture; }
void MeshSerializerTests::setUp() { errorFactor = 0.05; OGRE_DELETE LogManager::getSingletonPtr(); mLogManager = OGRE_NEW LogManager(); mLogManager->createLog("MeshWithoutIndexDataTests.log", false); mLogManager->setLogDetail(LL_LOW); mFSLayer = OGRE_NEW_T(Ogre::FileSystemLayer, Ogre::MEMCATEGORY_GENERAL)(OGRE_VERSION_NAME); OGRE_NEW ResourceGroupManager(); OGRE_NEW LodStrategyManager(); OGRE_NEW DefaultHardwareBufferManager(); OGRE_NEW MeshManager(); OGRE_NEW SkeletonManager(); ArchiveManager* archiveMgr = OGRE_NEW ArchiveManager(); archiveMgr->addArchiveFactory(OGRE_NEW FileSystemArchiveFactory()); MaterialManager* matMgr = OGRE_NEW MaterialManager(); matMgr->initialise(); // Load resource paths from config file ConfigFile cf; String resourcesPath; #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_WIN32 resourcesPath = mFSLayer->getConfigFilePath("resources.cfg"); #else resourcesPath = mFSLayer->getConfigFilePath("bin/resources.cfg"); #endif // Go through all sections & settings in the file cf.load(resourcesPath); ConfigFile::SectionIterator seci = cf.getSectionIterator(); String secName, typeName, archName; while (seci.hasMoreElements()) { secName = seci.peekNextKey(); ConfigFile::SettingsMultiMap* settings = seci.getNext(); ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; if (typeName == "FileSystem") { ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName); } } } mMesh = MeshManager::getSingleton().load("knot.mesh", ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME); getResourceFullPath(mMesh, mMeshFullPath); if (!copyFile(mMeshFullPath + ".bak", mMeshFullPath)) { // If there is no backup, create one. copyFile(mMeshFullPath, mMeshFullPath + ".bak"); } mSkeletonFullPath = ""; mSkeleton = SkeletonManager::getSingleton().load("jaiqua.skeleton", "Popular").staticCast<Skeleton>(); getResourceFullPath(mSkeleton, mSkeletonFullPath); if (!copyFile(mSkeletonFullPath + ".bak", mSkeletonFullPath)) { // If there is no backup, create one. copyFile(mSkeletonFullPath, mSkeletonFullPath + ".bak"); } mMesh->reload(); #ifdef OGRE_BUILD_COMPONENT_MESHLODGENERATOR { MeshLodGenerator().generateAutoconfiguredLodLevels(mMesh); } #endif /* ifdef OGRE_BUILD_COMPONENT_MESHLODGENERATOR */ mOrigMesh = mMesh->clone(mMesh->getName() + ".orig.mesh", mMesh->getGroup()); }
void FbxRender::CreateMaterials(MaterialManager& materialMgr) { std::vector<StandardMaterial> materialsVector; int defaultIdx = 0; // Try to use a default texture, // when we are unable to load a texture. for (unsigned int i = 0; i < materialMgr.GetTextureResource().size(); i++) { if (materialMgr.GetTextureResource()[i].name == "Default") { defaultIdx = i; break; } } for (unsigned int matIdx = 0; matIdx < m_fbxLoader.m_MaterialList.size(); matIdx++) { StandardMaterial material; // Use reinterpret_cast to load data for a material type. StandardMaterial* pConveter = reinterpret_cast<StandardMaterial*>(m_fbxLoader.m_MaterialList[matIdx].rawData); unsigned int texIdx = pConveter->albedoMapIdx; if (texIdx < m_fbxLoader.m_TextureList.size()) { ComPtr<ID3D12Resource> Texture; std::string path = m_fbxLoader.m_TextureList[texIdx].name; if (path.size() > 10) { bool repeatTexture = false; // Search the textures in the material manager. for (unsigned int i = 0; i < materialMgr.GetTextureResource().size(); i++) { if (materialMgr.GetTextureResource()[i].name == path) { repeatTexture = true; texIdx = i; break; } } // Create a new texture resource, if we don't find the same one in the material manager. if (!repeatTexture) { HRESULT hr = CreateWICTextureFromFileEx(g_d3dObjects->GetD3DDevice(), std::wstring(path.begin(), path.end()).c_str(), 0, 0, 0, 0, 0, &Texture); materialMgr.AddResource(Texture, path); texIdx = materialMgr.GetTextureResource().size() - 1; } } else { // This filename is invalid. texIdx = defaultIdx; } } else { // No any texture in the FBX model. texIdx = defaultIdx; } // Store the material data into this manager. material.albedoColor = pConveter->albedoColor; material.specularColor = pConveter->specularColor; material.albedoMapIdx = texIdx; materialsVector.push_back(material); } if (materialsVector.size()) { // Create a material buffer. ComPtr<ID3D12Resource> materialBuffer; CD3DX12_HEAP_PROPERTIES heapProperty(D3D12_HEAP_TYPE_UPLOAD); D3D12_RESOURCE_DESC resourceDesc; ZeroMemory(&resourceDesc, sizeof(resourceDesc)); resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; resourceDesc.Alignment = 0; resourceDesc.SampleDesc.Count = 1; resourceDesc.SampleDesc.Quality = 0; resourceDesc.MipLevels = 1; resourceDesc.Format = DXGI_FORMAT_UNKNOWN; resourceDesc.DepthOrArraySize = 1; resourceDesc.Height = 1; resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; resourceDesc.Width = sizeof(materialsVector[0])*materialsVector.size(); ThrowIfFailed(g_d3dObjects->GetD3DDevice()->CreateCommittedResource(&heapProperty, D3D12_HEAP_FLAG_NONE, &resourceDesc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(materialBuffer.GetAddressOf()))); void* mapped = nullptr; materialBuffer->Map(0, nullptr, &mapped); memcpy(mapped, &materialsVector[0], sizeof(materialsVector[0])*materialsVector.size()); materialBuffer->Unmap(0, nullptr); materialMgr.UpdateMaterialBuffer(materialBuffer, materialsVector.size(), sizeof(materialsVector[0])); } }