//------------------------------------------------------ void MaterialService::prepareMaterialInstance(MaterialPtr &mat, unsigned int idx, int tag) { if (tag < 0) // Should not be here if the polygon is sky textured OPDE_EXCEPT("Non-instanced material instance requested"); mat->setReceiveShadows(true); Ogre::StringStream lightmapName; lightmapName << "@lightmap" << tag; Pass *shadPass = mat->getTechnique(0)->getPass(0); if (shadPass->getNumTextureUnitStates() <= 1) { // Lightmap texture is added here TextureUnitState *tex = shadPass->createTextureUnitState(); tex->setTexture(mLightService->getAtlasTexture(tag)); // Blend tex->setColourOperation(LBO_MODULATE); // Use 2nd texture co-ordinate set tex->setTextureCoordSet(1); // Clamp tex->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); // Switch filtering off to see lmap pixels: TFO_NONE tex->setTextureFiltering(TFO_BILINEAR); } else { // There is a definition of the lightmapping pass already, we only // update that definition TextureUnitState *tex = shadPass->getTextureUnitState(1); tex->setTextureName(lightmapName.str()); tex->setTextureCoordSet(1); } }
void Game::parseCmdLine(const mkString& cmd_line) { std::vector<mkString> tokens; extractTokens(cmd_line, tokens); for (size_t i = 0; i < tokens.size(); ++i) { const mkString& token = tokens[i]; const mkString* next_token_ptr = (i < tokens.size() - 1) ? &tokens[i+1] : NULL; if (token == "-freelook") m_startWithFreelook = true; else if (token == "-disable_shadows") m_disableShadows = true; else if (token == "-level") { CHK_ARG("-level"); m_levelName = *next_token_ptr; ++i; } else { Ogre::StringStream ss; ss << "Unrecognized command line parameter '" << token << "'"; MessageBoxA(NULL, ss.str().c_str(), NULL, MB_OK); } } }
//-------------------------------------------------------------------------- bool CompositorDemo_FrameListener::keyPressed (const OIS::KeyEvent &e) { // give 'quitting' priority if (e.key == OIS::KC_ESCAPE) { mQuit = true; return false; } if (e.key == OIS::KC_V) mMain->getRenderWindow()->getViewport(0)->setBackgroundColour(Ogre::ColourValue(0,1,0)); if (e.key == OIS::KC_SYSRQ ) { Ogre::StringStream ss; ss << "screenshot_" << ++mNumScreenShots << ".png"; mMain->getRenderWindow()->writeContentsToFile(ss.str()); mDebugText = "Saved: " + ss.str(); //mTimeUntilNextToggle = 0.5; } // do event injection CEGUI::System& cegui = CEGUI::System::getSingleton(); cegui.injectKeyDown(e.key); cegui.injectChar(e.text); return true; }
Ogre::String OgreBuilding::getUniqueObjectName() { /* Generate unique alias for naming Ogre entities */ static int roadNumber = 0; Ogre::StringStream convertor; convertor << roadNumber; roadNumber++; return "Building_" + convertor.str(); }
void Sample_VolumeTex::generate() { /* Evaluate julia fractal for each point */ Julia julia(global_real, global_imag, global_theta); const float scale = 2.5; const float vcut = 29.0f; const float vscale = 1.0f/vcut; HardwarePixelBufferSharedPtr buffer = ptex->getBuffer(0, 0); Ogre::StringStream d; d << "HardwarePixelBuffer " << buffer->getWidth() << " " << buffer->getHeight() << " " << buffer->getDepth(); LogManager::getSingleton().logMessage(d.str()); buffer->lock(HardwareBuffer::HBL_NORMAL); const PixelBox &pb = buffer->getCurrentLock(); d.str(""); d << "PixelBox " << pb.getWidth() << " " << pb.getHeight() << " " << pb.getDepth() << " " << pb.rowPitch << " " << pb.slicePitch << " " << pb.data << " " << PixelUtil::getFormatName(pb.format); LogManager::getSingleton().logMessage(d.str()); Ogre::uint32 *pbptr = static_cast<Ogre::uint32*>(pb.data); for(size_t z=pb.front; z<pb.back; z++) { for(size_t y=pb.top; y<pb.bottom; y++) { for(size_t x=pb.left; x<pb.right; x++) { if(z==pb.front || z==(pb.back-1) || y==pb.top|| y==(pb.bottom-1) || x==pb.left || x==(pb.right-1)) { // On border, must be zero pbptr[x] = 0; } else { float val = julia.eval(((float)x/pb.getWidth()-0.5f) * scale, ((float)y/pb.getHeight()-0.5f) * scale, ((float)z/pb.getDepth()-0.5f) * scale); if(val > vcut) val = vcut; PixelUtil::packColour((float)x/pb.getWidth(), (float)y/pb.getHeight(), (float)z/pb.getDepth(), (1.0f-(val*vscale))*0.7f, PF_A8R8G8B8, &pbptr[x]); } } pbptr += pb.rowPitch; } pbptr += pb.getSliceSkip(); } buffer->unlock(); }
//----------------------------------------------------------------------- String RenderTarget::writeContentsToTimestampedFile(const String& filenamePrefix, const String& filenameSuffix) { struct tm *pTime; time_t ctTime; time(&ctTime); pTime = localtime( &ctTime ); Ogre::StringStream oss; oss << std::setw(2) << std::setfill('0') << (pTime->tm_mon + 1) << std::setw(2) << std::setfill('0') << pTime->tm_mday << std::setw(2) << std::setfill('0') << (pTime->tm_year + 1900) << "_" << std::setw(2) << std::setfill('0') << pTime->tm_hour << std::setw(2) << std::setfill('0') << pTime->tm_min << std::setw(2) << std::setfill('0') << pTime->tm_sec << std::setw(3) << std::setfill('0') << (mTimer->getMilliseconds() % 1000); String filename = filenamePrefix + oss.str() + filenameSuffix; writeContentsToFile(filename); return filename; }
//----------------------------------------------------------------------------------- void Sample_Compositor::changePage(size_t pageNum) { assert(pageNum < mNumCompositorPages); mActiveCompositorPage = pageNum; size_t maxCompositorsInPage = mCompositorNames.size() - (pageNum * COMPOSITORS_PER_PAGE); for (size_t i=0; i < COMPOSITORS_PER_PAGE; i++) { String checkBoxName = "Compositor_" + Ogre::StringConverter::toString(i); CheckBox* cb = static_cast<CheckBox*>(mTrayMgr->getWidget(TL_TOPLEFT, checkBoxName)); if (i < maxCompositorsInPage) { String compositorName = mCompositorNames[pageNum * COMPOSITORS_PER_PAGE + i]; CompositorInstance *tmpCompo = CompositorManager::getSingleton().getCompositorChain(mViewport) ->getCompositor(compositorName); cb->setCaption(compositorName); if( tmpCompo ) { cb->setChecked( tmpCompo->getEnabled(), false ); cb->show(); } else { cb->setChecked( false, false ); cb->hide(); } } else { cb->hide(); } } OgreBites::Button* pageButton = static_cast<OgreBites::Button*>(mTrayMgr->getWidget(TL_TOPLEFT, "PageButton")); Ogre::StringStream ss; ss << "Compositors " << pageNum + 1 << "/" << mNumCompositorPages; pageButton->setCaption(ss.str()); }
//----------------------------------------------------------------------- CoherentUIView::CoherentUIView(Ogre::CoherentUIViewListener* listener, int width, int height, bool enableDepthWrite) : mView(NULL) { mViewListener = OGRE_NEW CoherentUIViewListenerBridge(this, listener); static int _textureCounter = 0; Ogre::StringStream ss; ss << "CoherentDynamicTexture" << ++_textureCounter; Ogre::String textureName = ss.str(); ss << "_Mat"; Ogre::String materialName = ss.str(); // Create a texture mTexture = TextureManager::getSingleton().createManual( textureName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, width, height, 1, PF_BYTE_BGRA, TU_DYNAMIC_WRITE_ONLY_DISCARDABLE); // Clear the texture Ogre::HardwarePixelBufferSharedPtr pixelBuffer = mTexture->getBuffer(); pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD); const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock(); Ogre::uint32* dest = static_cast<Ogre::uint32*>(pixelBox.data); std::memset(dest, 0, (width * 4 + pixelBox.getRowSkip()) * height); pixelBuffer->unlock(); // Create a material using the texture mTextureMaterial = MaterialManager::getSingleton().create( materialName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); mTextureMaterial->getTechnique(0)->getPass(0)->createTextureUnitState(textureName); mTextureMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBF_ONE, SBF_ONE_MINUS_SOURCE_ALPHA); mTextureMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(enableDepthWrite); }
//------------------------------------------------------ Ogre::MaterialPtr MaterialService::getWorldMaterialInstance(unsigned int idx, int tag) { if (tag < 0) { MaterialPtr mat = getWorldMaterialTemplate(idx); return mat; } else { MaterialPtr tmat = getWorldMaterialTemplate(idx); MaterialPtr imat; // have to look for it and clone WorldMaterialInstanceMap::iterator it = mWorldMaterials.find(idx); if (it == mWorldMaterials.end()) { // no slot for the idx. have to clone std::pair<WorldMaterialInstanceMap::iterator, bool> res = mWorldMaterials.insert(make_pair(idx, SlotMaterialMap())); it = res.first; } // now search SlotMaterialMap::iterator sit = it->second.find(tag); if (sit == it->second.end()) { Ogre::StringStream tmp; tmp << "Shader" << idx << "#" << tag; imat = tmat->clone(tmp.str()); prepareMaterialInstance(imat, idx, tag); it->second.insert(make_pair(tag, imat)); } else { imat = sit->second; } return imat; } }
Ogre::GpuProgramPtr GBufferMaterialGeneratorImpl::generateVertexShader(MaterialGenerator::Perm permutation) { Ogre::StringStream ss; ss << "void ToGBufferVP(" << std::endl; ss << " float4 iPosition : POSITION," << std::endl; ss << " float3 iNormal : NORMAL," << std::endl; Ogre::uint32 numTexCoords = (permutation & GBufferMaterialGenerator::GBP_TEXCOORD_MASK) >> 8; for (Ogre::uint32 i=0; i<numTexCoords; i++) { ss << " float2 iUV" << i << " : TEXCOORD" << i << ',' << std::endl; } if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " float3 iTangent : TANGENT0," << std::endl; } //TODO : Skinning inputs ss << std::endl; ss << " out float4 oPosition : POSITION," << std::endl; #ifdef WRITE_LINEAR_DEPTH ss << " out float3 oViewPos : TEXCOORD0," << std::endl; #else ss << " out float oDepth : TEXCOORD0," << std::endl; #endif ss << " out float3 oNormal : TEXCOORD1," << std::endl; int texCoordNum = 2; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " out float3 oTangent : TEXCOORD" << texCoordNum++ << ',' << std::endl; ss << " out float3 oBiNormal : TEXCOORD" << texCoordNum++ << ',' << std::endl; } for (Ogre::uint32 i=0; i<numTexCoords; i++) { ss << " out float2 oUV" << i << " : TEXCOORD" << texCoordNum++ << ',' << std::endl; } ss << std::endl; ss << " uniform float4x4 cWorldViewProj," << std::endl; ss << " uniform float4x4 cWorldView" << std::endl; ss << " )" << std::endl; ss << "{" << std::endl; ss << " oPosition = mul(cWorldViewProj, iPosition);" << std::endl; ss << " oNormal = mul(cWorldView, float4(iNormal,0)).xyz;" << std::endl; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " oTangent = mul(cWorldView, float4(iTangent,0)).xyz;" << std::endl; ss << " oBiNormal = cross(oNormal, oTangent);" << std::endl; } #ifdef WRITE_LINEAR_DEPTH ss << " oViewPos = mul(cWorldView, iPosition).xyz;" << std::endl; #else ss << " oDepth = oPosition.w;" << std::endl; #endif for (Ogre::uint32 i=0; i<numTexCoords; i++) { ss << " oUV" << i << " = iUV" << i << ';' << std::endl; } ss << "}" << std::endl; Ogre::String programSource = ss.str(); Ogre::String programName = mBaseName + "VP_" + Ogre::StringConverter::toString(permutation); #if OGRE_DEBUG_MODE Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource); #endif // Create shader object Ogre::HighLevelGpuProgramPtr ptrProgram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram( programName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", Ogre::GPT_VERTEX_PROGRAM); ptrProgram->setSource(programSource); ptrProgram->setParameter("entry_point","ToGBufferVP"); ptrProgram->setParameter("profiles","vs_1_1 arbvp1"); const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters(); params->setNamedAutoConstant("cWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX); params->setNamedAutoConstant("cWorldView", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX); ptrProgram->load(); return Ogre::GpuProgramPtr(ptrProgram); }
Ogre::GpuProgramPtr GBufferMaterialGeneratorImpl::generateFragmentShader(MaterialGenerator::Perm permutation) { Ogre::StringStream ss; ss << "void ToGBufferFP(" << std::endl; #ifdef WRITE_LINEAR_DEPTH ss << " float3 iViewPos : TEXCOORD0," << std::endl; #else ss << " float1 iDepth : TEXCOORD0," << std::endl; #endif ss << " float3 iNormal : TEXCOORD1," << std::endl; int texCoordNum = 2; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " float3 iTangent : TEXCOORD" << texCoordNum++ << ',' << std::endl; ss << " float3 iBiNormal : TEXCOORD" << texCoordNum++ << ',' << std::endl; } Ogre::uint32 numTexCoords = (permutation & GBufferMaterialGenerator::GBP_TEXCOORD_MASK) >> 8; for (Ogre::uint32 i=0; i<numTexCoords; i++) { ss << " float2 iUV" << i << " : TEXCOORD" << texCoordNum++ << ',' << std::endl; } ss << std::endl; ss << " out float4 oColor0 : COLOR0," << std::endl; ss << " out float4 oColor1 : COLOR1," << std::endl; ss << std::endl; int samplerNum = 0; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " uniform sampler sNormalMap : register(s" << samplerNum++ << ")," << std::endl; } Ogre::uint32 numTextures = permutation & GBufferMaterialGenerator::GBP_TEXTURE_MASK; for (Ogre::uint32 i=0; i<numTextures; i++) { ss << " uniform sampler sTex" << i << " : register(s" << samplerNum++ << ")," << std::endl; } if (numTextures == 0 || permutation & GBufferMaterialGenerator::GBP_HAS_DIFFUSE_COLOUR) { ss << " uniform float4 cDiffuseColour," << std::endl; } #ifdef WRITE_LINEAR_DEPTH ss << " uniform float cFarDistance," << std::endl; #endif ss << " uniform float cSpecularity" << std::endl; ss << " )" << std::endl; ss << "{" << std::endl; if (numTexCoords > 0 && numTextures > 0) { ss << " oColor0.rgb = tex2D(sTex0, iUV0);" << std::endl; if (permutation & GBufferMaterialGenerator::GBP_HAS_DIFFUSE_COLOUR) { ss << " oColor0.rgb *= cDiffuseColour.rgb;" << std::endl; } } else { ss << " oColor0.rgb = cDiffuseColour.rgb;" << std::endl; } ss << " oColor0.a = cSpecularity;" << std::endl; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " float3 texNormal = (tex2D(sNormalMap, iUV0)-0.5)*2;" << std::endl; ss << " float3x3 normalRotation = float3x3(iTangent, iBiNormal, iNormal);" << std::endl; ss << " oColor1.rgb = normalize(mul(texNormal, normalRotation));" << std::endl; } else { ss << " oColor1.rgb = normalize(iNormal);" << std::endl; } #ifdef WRITE_LINEAR_DEPTH ss << " oColor1.a = length(iViewPos) / cFarDistance;" << std::endl; #else ss << " oColor1.a = iDepth;" << std::endl; #endif ss << "}" << std::endl; Ogre::String programSource = ss.str(); Ogre::String programName = mBaseName + "FP_" + Ogre::StringConverter::toString(permutation); #if OGRE_DEBUG_MODE Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource); #endif // Create shader object Ogre::HighLevelGpuProgramPtr ptrProgram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram( programName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", Ogre::GPT_FRAGMENT_PROGRAM); ptrProgram->setSource(programSource); ptrProgram->setParameter("entry_point","ToGBufferFP"); ptrProgram->setParameter("profiles","ps_2_0 arbfp1"); const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters(); params->setNamedAutoConstant("cSpecularity", Ogre::GpuProgramParameters::ACT_SURFACE_SHININESS); if (numTextures == 0 || permutation & GBufferMaterialGenerator::GBP_HAS_DIFFUSE_COLOUR) { params->setNamedAutoConstant("cDiffuseColour", Ogre::GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR); } #ifdef WRITE_LINEAR_DEPTH //TODO : Should this be the distance to the far corner, not the far clip distance? params->setNamedAutoConstant("cFarDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE); #endif ptrProgram->load(); return Ogre::GpuProgramPtr(ptrProgram); }
void TiXmlElement::SetAttribute( const TIXML_STRING& name, int val ) { Ogre::StringStream oss; oss << val; SetAttribute( name, oss.str().c_str() ); }
Ogre::GpuProgramPtr GBufferMaterialGeneratorImpl::generateVertexShader(MaterialGenerator::Perm permutation) { Ogre::StringStream ss; if(mIsGLSL) { int shadingLangVersion = Ogre::Root::getSingleton().getRenderSystem()->getNativeShadingLanguageVersion(); const char *inSemantic = shadingLangVersion >= 150 ? "in" : "attribute"; const char *outSemantic = shadingLangVersion >= 150 ? "out" : "varying"; if(Ogre::GpuProgramManager::getSingleton().isSyntaxSupported("glsles")) { ss << "#version 300 es" << std::endl; ss << "precision mediump int;" << std::endl; ss << "precision mediump float;" << std::endl; } else ss << "#version " << shadingLangVersion << std::endl; ss << inSemantic << " vec4 vertex;" << std::endl; ss << inSemantic << " vec3 normal;" << std::endl; Ogre::uint32 numTexCoords = (permutation & GBufferMaterialGenerator::GBP_TEXCOORD_MASK) >> 8; for (Ogre::uint32 i = 0; i < numTexCoords; i++) { ss << inSemantic << " vec2 uv" << i << ';' << std::endl; } if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << inSemantic << " vec3 tangent;" << std::endl; } //TODO : Skinning inputs ss << std::endl; #ifdef WRITE_LINEAR_DEPTH ss << outSemantic << " vec3 oViewPos;" << std::endl; #else ss << outSemantic << " float oDepth;" << std::endl; #endif ss << outSemantic << " vec3 oNormal;" << std::endl; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << outSemantic << " vec3 oTangent;" << std::endl; ss << outSemantic << " vec3 oBiNormal;" << std::endl; } for (Ogre::uint32 i = 0; i < numTexCoords; i++) { ss << outSemantic << " vec2 oUv" << i << ";" << std::endl; } ss << std::endl; ss << "uniform mat4 cWorldViewProj;" << std::endl; ss << "uniform mat4 cWorldView;" << std::endl; ss << "void main()" << std::endl; ss << "{" << std::endl; ss << " gl_Position = cWorldViewProj * vertex;" << std::endl; ss << " oNormal = (cWorldView * vec4(normal,0)).xyz;" << std::endl; if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP) { ss << " oTangent = (cWorldView * vec4(tangent,0)).xyz;" << std::endl; ss << " oBiNormal = cross(oNormal, oTangent);" << std::endl; } #ifdef WRITE_LINEAR_DEPTH ss << " oViewPos = (cWorldView * vertex).xyz;" << std::endl; #else ss << " oDepth = gl_Position.w;" << std::endl; #endif for (Ogre::uint32 i=0; i<numTexCoords; i++) { ss << " oUv" << i << " = uv" << i << ';' << std::endl; } ss << "}" << std::endl; Ogre::String programSource = ss.str(); Ogre::String programName = mBaseName + "VP_" + Ogre::StringConverter::toString(permutation); #if OGRE_DEBUG_MODE Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource); #endif // Create shader object Ogre::HighLevelGpuProgramPtr ptrProgram; if(Ogre::GpuProgramManager::getSingleton().isSyntaxSupported("glsles")) { ptrProgram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(programName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "glsles", Ogre::GPT_VERTEX_PROGRAM); ptrProgram->setParameter("syntax", "glsles"); } else { ptrProgram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(programName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "glsl", Ogre::GPT_VERTEX_PROGRAM); } ptrProgram->setSource(programSource); const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters(); params->setNamedAutoConstant("cWorldViewProj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX); params->setNamedAutoConstant("cWorldView", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX); ptrProgram->load(); return Ogre::GpuProgramPtr(ptrProgram); } else {
Ogre::String Projectile::get_next_name() { Ogre::StringStream ss; ss << Projectile::id; return "Projectile" + ss.str(); }
//------------------------------------------------------ void MaterialService::loadMaterials(const FileGroupPtr &db) { if (!db->hasFile("TXLIST")) throw Exception( Exception::ERR_ITEM_NOT_FOUND, "Mission file does not contain Texture list chunk (TXLIST)", "MaterialService::loadMaterials"); // Load the TXLIST chunk from the resource mission file. Opde::FilePtr txtList = db->getFile("TXLIST"); // TODO: Exception handling on the chunk readout! // Okay, we are ready to map the arrays if (mFamilies != NULL) delete[] mFamilies; if (mTextures != NULL) delete[] mTextures; try { // TODO: This should be implemented using dtypes // Read the header... txtList->read(&mTxlistHeader, sizeof(DarkDBChunkTXLIST)); // now read all the families // allocate the needed space mFamilies = new DarkDBTXLIST_fam[mTxlistHeader.fam_count]; // load txtList->read(&(mFamilies[0]), sizeof(DarkDBTXLIST_fam) * mTxlistHeader.fam_count); // Now read the textures. Same as before // allocate the needed space mTextures = new DarkDBTXLIST_texture[mTxlistHeader.txt_count]; // load texture names txtList->read(&(mTextures[0]), sizeof(DarkDBTXLIST_texture) * mTxlistHeader.txt_count); } catch (Ogre::Exception &e) { if (mFamilies != NULL) delete[] mFamilies; if (mTextures != NULL) delete[] mTextures; // Connect the original exception to the printout: OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, String("Could not load texture list : ") + e.getFullDescription(), "BspLevel::loadMaterials"); } // Okay, we are ready to load the materials now! // Our resource group String resourceGroup = ResourceGroupManager::getSingleton().getWorldResourceGroupName(); // ------------- Following code loads the standard materials // ------------------- // Iterate through all materials, and load them (tries to load material as a // script (named family/texture), and if it fails, it constructs one with // the default settings, and tries a few extensions too for the image) for (unsigned int id = 1; id < mTxlistHeader.txt_count; id++) { // Try to find the family for the texture std::string path = getMaterialName(id); // Resulting material name Ogre::StringStream matName; matName << "@template" << id; if (MaterialManager::getSingleton().resourceExists( matName.str())) // if the material is already defined // remove, as we have to redefine it MaterialManager::getSingleton().remove(matName.str()); // See if the material is defined by a script. If so, clone it to be // named @templateXXXX (XXXX = texture number) We seek material named: // family/texture if (MaterialManager::getSingleton().resourceExists(path)) { LOG_INFO("loadMaterials: Found material definition for %s", path.c_str()); MaterialPtr origMat = MaterialManager::getSingleton().getByName(path); MaterialPtr shadMat = origMat->clone(matName.str(), true, resourceGroup); shadMat->load(); addWorldMaterialTemplate(id, shadMat); } else { // The material script was not found createStandardMaterial(id, matName.str(), path, resourceGroup); } // This is it. Material @templateXX created } // Initialize the flow textures (do this first so water specialisation will // override) loadFlowTextures(db); createSkyHackMaterial(resourceGroup); createJorgeMaterial(resourceGroup); }
//----------------------------------------------------------------------- void MaterialService::loadFlowTextures(const FileGroupPtr &db) { // Load the TXLIST chunk from the resource mission file. Opde::FilePtr flow_tex; try { flow_tex = db->getFile("FLOW_TEX"); } catch (FileException) { LOG_ERROR("Flow chunk does not exist. Water materials may not be " "correctly displayed", "MaterialService::loadFlowTextures"); return; } // TODO: Exception handling on the chunk readout! // Okay, we are ready to map the arrays DarkDBChunkFLOW_TEX flows; int flow_count = flow_tex->size() / 32; // The record is 32 bytes long, this way we do // not fail if the chunk is shorter try { // load flow_tex->read(&flows, flow_tex->size()); // To be sure we do not overlap } catch (Ogre::Exception &e) { // Connect the original exception to the printout: OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, String("Could not load flow textures : ") + e.getFullDescription(), "MaterialService::loadFlowTextures"); } // now try to load non-zero flow textures as materials for (int fnum = 0; fnum < flow_count; fnum++) { if (strlen(flows.flow[fnum].name) > 0) { // nonzero name, try to load // Construct the basic name of the material std::string matname("water/"); matname += flows.flow[fnum].name; LOG_INFO("MaterialService::loadFlowTextures: Loading flow %d : " "%d/%d '%s'", fnum, flows.flow[fnum].in_texture, flows.flow[fnum].out_texture, matname.c_str()); // try to find the texture definition. If found, clone to the // @template + the in_texture/out_texture number if (MaterialManager::getSingleton().resourceExists(matname + "_in")) { MaterialPtr origMat = MaterialManager::getSingleton().getByName(matname + "_in"); Ogre::StringStream strb; strb << "@template" << flows.flow[fnum].in_texture; std::string templn(strb.str()); if (MaterialManager::getSingleton().resourceExists(templn)) { MaterialManager::getSingleton().remove(templn); } MaterialPtr shadMat = origMat->clone(templn); shadMat->load(); addWorldMaterialTemplate(flows.flow[fnum].in_texture, shadMat); LOG_INFO("Flow now defined : %s (template %s_in)", templn.c_str(), matname.c_str()); } else { LOG_ERROR("Material not found : %s_in", matname.c_str()); } // OUT if (MaterialManager::getSingleton().resourceExists(matname + "_out")) { MaterialPtr origMat = MaterialManager::getSingleton().getByName(matname + "_out"); Ogre::StringStream strb; strb << "@template" << flows.flow[fnum].in_texture; std::string templn(strb.str()); if (MaterialManager::getSingleton().resourceExists(templn)) { MaterialManager::getSingleton().remove(templn); } MaterialPtr shadMat = origMat->clone(templn); shadMat->load(); addWorldMaterialTemplate(flows.flow[fnum].out_texture, shadMat); LOG_INFO("Flow now defined : %s (template %s_in)", templn.c_str(), matname.c_str()); } else { LOG_ERROR("Material not found : %s_out", matname.c_str()); } } } }