bool Simple::compileMaterial(Ogre::MaterialPtr material, std::set<std::string>& managedTextures) const { material->removeAllTechniques(); Ogre::Technique* technique = material->createTechnique(); if (!mTerrainPageSurfaces.empty()) { //First add a base pass auto surfaceLayer = mTerrainPageSurfaces.begin()->second; Ogre::Pass* pass = technique->createPass(); pass->setLightingEnabled(false); Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState(); textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale()); textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName()); textureUnitState->setTextureCoordSet(0); for (auto& layer : mLayers) { addPassToTechnique(*mGeometry, technique, layer, managedTextures); } } if (mTerrainPageShadow) { addShadow(technique, mTerrainPageShadow, material, managedTextures); } // addLightingPass(technique, managedTextures); material->load(); if (material->getNumSupportedTechniques() == 0) { S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation()); return false; } return true; }
bool Simple::compileMaterial(Ogre::MaterialPtr material) { material->removeAllTechniques(); Ogre::Technique* technique = material->createTechnique(); for (SurfaceLayerStore::const_iterator I = mTerrainPageSurfaces.begin(); I != mTerrainPageSurfaces.end(); ++I) { const TerrainPageSurfaceLayer* surfaceLayer = I->second; if (I == mTerrainPageSurfaces.begin()) { Ogre::Pass* pass = technique->createPass(); pass->setLightingEnabled(false); //add the first layer of the terrain, no alpha or anything Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState(); textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale()); textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName()); textureUnitState->setTextureCoordSet(0); } else { if (surfaceLayer->intersects(*mGeometry)) { addPassToTechnique(*mGeometry, technique, surfaceLayer); } } } if (mTerrainPageShadow) { addShadow(technique, mTerrainPageShadow, material); } material->load(); if (material->getNumSupportedTechniques() == 0) { S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation()); return false; } return true; }
void Simple::addShadow(Ogre::Technique* technique, const TerrainPageShadow* terrainPageShadow, Ogre::MaterialPtr material, std::set<std::string>& managedTextures) const { Ogre::Pass* shadowPass = technique->createPass(); shadowPass->setSceneBlending(Ogre::SBT_MODULATE); shadowPass->setLightingEnabled(false); // shadowPass->setFog(true, Ogre::FOG_NONE); Ogre::TextureUnitState * textureUnitStateSplat = shadowPass->createTextureUnitState(); Ogre::TexturePtr texture = updateShadowTexture(material, terrainPageShadow, managedTextures); textureUnitStateSplat->setTextureName(texture->getName()); textureUnitStateSplat->setTextureCoordSet(0); textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC); }
void Simple::addLightingPass(Ogre::Technique* technique, std::set<std::string>& managedTextures) const { Ogre::Pass* lightingPass = technique->createPass(); lightingPass->setSceneBlending(Ogre::SBT_MODULATE); lightingPass->setLightingEnabled(false); Ogre::TextureUnitState * textureUnitStateSplat = lightingPass->createTextureUnitState(); //we need an unique name for our alpha texture std::stringstream lightingTextureNameSS; lightingTextureNameSS << technique->getParent()->getName() << "_lighting"; const Ogre::String lightingTextureName(lightingTextureNameSS.str()); Ogre::TexturePtr texture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(lightingTextureName)); if (texture.isNull()) { texture = Ogre::Root::getSingletonPtr()->getTextureManager()->createManual(lightingTextureName, "General", Ogre::TEX_TYPE_2D, mPage.getBlendMapSize(), mPage.getBlendMapSize(), 1, Ogre::PF_L8, Ogre::TU_DYNAMIC_WRITE_ONLY); managedTextures.insert(texture->getName()); } Ogre::Image ogreImage; ogreImage.loadDynamicImage(const_cast<unsigned char*>(mLightingImage->getData()), mLightingImage->getResolution(), mLightingImage->getResolution(), 1, Ogre::PF_L8); texture->loadImage(ogreImage); //blit the whole image to the hardware buffer Ogre::PixelBox sourceBox(ogreImage.getPixelBox()); //blit for each mipmap for (unsigned int i = 0; i <= texture->getNumMipmaps(); ++i) { Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(texture->getBuffer(0, i)); hardwareBuffer->blitFromMemory(sourceBox); } textureUnitStateSplat->setTextureName(texture->getName()); textureUnitStateSplat->setTextureCoordSet(0); textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC); }
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { #else int main (int argc, char *argv[]) { #endif #define OGRE_STATIC_ParticleFX 1 Ogre::Root *ogre; Ogre::RenderWindow *window; Ogre::SceneManager *sceneMgr; Ogre::Camera *camera; // fire up an Ogre rendering window. Clearing the first two (of three) params will let us // specify plugins and resources in code instead of via text file ogre = new Ogre::Root("", ""); // This is a VERY minimal rendersystem loading example; we are hardcoding the OpenGL // renderer, instead of loading GL and D3D9. We will add renderer selection support in a // future article. // I separate the debug and release versions of my plugins using the same "_d" suffix that // the Ogre main libraries use; you may need to remove the "_d" in your code, depending on the // naming convention you use ogre->loadPlugin("RenderSystem_GL_d"); ogre->loadPlugin("Plugin_ParticleFX_d"); const Ogre::RenderSystemList &renderSystems = ogre->getAvailableRenderers(); Ogre::RenderSystemList::const_iterator r_it; // we do this step just to get an iterator that we can use with setRenderSystem. In a future article // we actually will iterate the list to display which renderers are available. // renderSystems = ogre->getAvailableRenderers(); r_it = renderSystems.begin(); ogre->setRenderSystem(*r_it); ogre->initialise(false); // load common plugins ogre->loadPlugin("Plugin_CgProgramManager_d"); ogre->loadPlugin("Plugin_OctreeSceneManager_d"); // setup main window; hardcode some defaults for the sake of presentation Ogre::NameValuePairList opts; opts["resolution"] = "1024x768"; opts["fullscreen"] = "false"; opts["vsync"] = "true"; // create a rendering window with the title "CDK" window = ogre->createRenderWindow("CDK", 1024, 768, false, &opts); // load the basic resource location(s) Ogre::ResourceGroupManager::getSingleton().addResourceLocation( "resource", "FileSystem", "General"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation( "resource/gui.zip", "Zip", "GUI"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation( "resource/textures", "FileSystem", "Textures"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation( "resource/particles", "FileSystem", "Particles"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation( "resource/materials", "FileSystem", "Materials"); #if defined(WIN32) Ogre::ResourceGroupManager::getSingleton().addResourceLocation( "c:\\windows\\fonts", "FileSystem", "GUI"); #endif //Must initialize resource groups after window if using particle effects. Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("General"); Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("GUI"); Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Textures"); Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Materials"); Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Particles"); // since this is basically a CEGUI app, we can use the ST_GENERIC scene manager for now; in a later article // we'll see how to change this sceneMgr = ogre->createSceneManager(Ogre::ST_GENERIC); camera = sceneMgr->createCamera("camera"); camera->setNearClipDistance(1); Ogre::Viewport* vp = window->addViewport(camera); vp->setBackgroundColour(Ogre::ColourValue(0,0,0)); // most examples get the viewport size to calculate this; for now, we'll just // set it to 4:3 the easy way camera->setAspectRatio((Ogre::Real)1.333333); // with a scene manager and window, we can create a the GUI renderer // new way to instantiate a CEGUIOgreRenderer (Ogre 1.7) Ogre::RenderTarget *mRenderTarget = window; CEGUI::OgreRenderer* pGUIRenderer = &CEGUI::OgreRenderer::bootstrapSystem(*mRenderTarget); // create the root CEGUI class CEGUI::System* pSystem = CEGUI::System::getSingletonPtr(); // tell us a lot about what is going on (see CEGUI.log in the working directory) CEGUI::Logger::getSingleton().setLoggingLevel(CEGUI::Informative); // use this CEGUI scheme definition (see CEGUI docs for more) CEGUI::SchemeManager::getSingleton().create((CEGUI::utf8*)"TaharezLookSkin.scheme", (CEGUI::utf8*)"GUI"); // show the CEGUI mouse cursor (defined in the look-n-feel) pSystem->setDefaultMouseCursor((CEGUI::utf8*)"TaharezLook", (CEGUI::utf8*)"MouseArrow"); // use this font for text in the UI CEGUI::FontManager::getSingleton().create("Tahoma-8.font", (CEGUI::utf8*)"GUI"); pSystem->setDefaultFont((CEGUI::utf8*)"Tahoma-8"); // load a layout from the XML layout file (you'll find this in resources/gui.zip), and // put it in the GUI resource group CEGUI::Window* pLayout = CEGUI::WindowManager::getSingleton().loadWindowLayout("katana.layout", "", "GUI"); // you need to tell CEGUI which layout to display. You can call this at any time to change the layout to // another loaded layout (i.e. moving from screen to screen or to load your HUD layout). Note that this takes // a CEGUI::Window instance -- you can use anything (any widget) that serves as a root window. pSystem->setGUISheet(pLayout); // this next bit is for the sake of the input handler unsigned long hWnd; // WINDOW is generic to all platforms now as of Eihort window->getCustomAttribute("WINDOW", &hWnd); // set up the input handlers Simulation *sim = new Simulation(); // since the input handler deals with pushing input to CEGUI, we need to give it a pointer // to the CEGUI System instance to use InputHandler *handler = new InputHandler(pSystem, sim, hWnd); // put us into our "main menu" state sim->requestStateChange(GUI); // make an instance of our GUI sheet handler class MainMenuDlg* pDlg = new MainMenuDlg(pSystem, pLayout, sim); //testing shit Ogre::SceneNode *systemNode = sceneMgr->getRootSceneNode()->createChildSceneNode(Ogre::Vector3(0,0,0)); SphereMesh *sphere = NULL; sphere->createSphere("sphereMesh", 80, 64, 64); /* // Now I can create several entities using that mesh Ogre::Entity *MoonEntity = sceneMgr->createEntity("Moon", planetMesh); // Now I attach it to a scenenode, so that it becomes present in the scene. Ogre::SceneNode *EarthOrbitNode = systemNode->createChildSceneNode("Earth Orbit", Ogre::Vector3(0,0,0)); Ogre::SceneNode *EarthNode = EarthOrbitNode->createChildSceneNode("Earth", Ogre::Vector3(200,0,0)); Ogre::SceneNode *MoonNode = EarthNode->createChildSceneNode("Moon", Ogre::Vector3(150,0,0)); MoonNode->attachObject(MoonEntity); MoonEntity->getParentNode()->scale(0.5,0.5,0.5); */ //Material Tests Ogre::MaterialManager& lMaterialManager = Ogre::MaterialManager::getSingleton(); Ogre::String lNameOfResourceGroup = "Mission 1 : Deliver Tom"; Ogre::ResourceGroupManager& lRgMgr = Ogre::ResourceGroupManager::getSingleton(); lRgMgr.createResourceGroup(lNameOfResourceGroup); { Ogre::MaterialPtr lMaterial = lMaterialManager.create("M_Lighting+OneTexture",lNameOfResourceGroup); Ogre::Technique* lFirstTechnique = lMaterial->getTechnique(0); Ogre::Pass* lFirstPass = lFirstTechnique->getPass(0); lFirstPass->setDiffuse(0.8f, 0.8f, 0.8f,1.0f); lFirstPass->setAmbient(0.3f, 0.3f, 0.3f); lFirstPass->setSpecular(1.0f, 1.0f, 1.0f, 1.0f); lFirstPass->setShininess(64.0f); lFirstPass->setSelfIllumination(0.1f, 0.1f, 0.1f); Ogre::TextureUnitState* lTextureUnit = lFirstPass->createTextureUnitState(); lTextureUnit->setTextureName("SimpleTexture.bmp", Ogre::TEX_TYPE_2D); lTextureUnit->setTextureCoordSet(0); } // 3/ Lighting color. // To have the feeling of '3D', the lighting is good feeling. // It often requires the object to have correct normals (see my manual object construction), // and some lights in the scene. { Ogre::MaterialPtr lMaterial = lMaterialManager.create("Sun",lNameOfResourceGroup); Ogre::Technique* lFirstTechnique = lMaterial->getTechnique(0); Ogre::Pass* lFirstPass = lFirstTechnique->getPass(0); // Lighting is allowed on this pass. lFirstPass->setLightingEnabled(true); // Emissive / self illumination is the color 'produced' by the object. // Color values vary between 0.0(minimum) to 1.0 (maximum). Ogre::ColourValue lSelfIllumnationColour(0.5f, 0.0f, 0.0f, 1.0f); lFirstPass->setSelfIllumination(lSelfIllumnationColour); // diffuse color is the traditionnal color of the lit object. Ogre::ColourValue lDiffuseColour(1.0f, 0.4f, 0.4f, 1.0f); lFirstPass->setDiffuse(lDiffuseColour); // ambient colour is linked to ambient lighting. // If there is no ambient lighting, then this has no influence. // It the ambient lighting is at 1, then this colour is fully added. // This is often use to change the general feeling of a whole scene. Ogre::ColourValue lAmbientColour(0.4f, 0.1f, 0.1f, 1.0f); lFirstPass->setAmbient(lAmbientColour); // specular colour, is the colour of the 'little light reflection' // that you can see on some object. For example, my bald head skin // reflect the sun. This make a 'round of specular lighting'. // Set this to black if you don't want to see it. Ogre::ColourValue lSpecularColour(1.0f, 1.0f, 1.0f, 1.0f); lFirstPass->setSpecular(lSpecularColour); // Shininess is the 'inverse of specular color splattering' coefficient. // If this is big (e.g : 64) you get a very tiny dot with a quite strong color (on round surface). // If this is 0, you get a simple color layer (the dot has become very wide). Ogre::Real lShininess = 64.0f; lFirstPass->setShininess(lShininess); } { Ogre::MaterialPtr lMaterial = lMaterialManager.create("mars",lNameOfResourceGroup); Ogre::Technique* lFirstTechnique = lMaterial->getTechnique(0); Ogre::Pass* lFirstPass = lFirstTechnique->getPass(0); // Lighting is allowed on this pass. lFirstPass->setLightingEnabled(true); // Emissive / self illumination is the color 'produced' by the object. // Color values vary between 0.0(minimum) to 1.0 (maximum). Ogre::ColourValue lSelfIllumnationColour(0.6f, 0.1f, 0.1f, 0.0f); lFirstPass->setSelfIllumination(lSelfIllumnationColour); // diffuse color is the traditionnal color of the lit object. Ogre::ColourValue lDiffuseColour(1.0f, 0.2f, 0.0f, 0.0f); lFirstPass->setDiffuse(lDiffuseColour); // ambient colour is linked to ambient lighting. // If there is no ambient lighting, then this has no influence. // It the ambient lighting is at 1, then this colour is fully added. // This is often use to change the general feeling of a whole scene. Ogre::ColourValue lAmbientColour(1.0f, 0.2f, 0.0f, 0.0f); lFirstPass->setAmbient(lAmbientColour); // specular colour, is the colour of the 'little light reflection' // that you can see on some object. For example, my bald head skin // reflect the sun. This make a 'round of specular lighting'. // Set this to black if you don't want to see it. Ogre::ColourValue lSpecularColour(1.0f, 0.3f, 0.3f, 0.3f); lFirstPass->setSpecular(lSpecularColour); // Shininess is the 'inverse of specular color splattering' coefficient. // If this is big (e.g : 64) you get a very tiny dot with a quite strong color (on round surface). // If this is 0, you get a simple color layer (the dot has become very wide). Ogre::Real lShininess = 34.0f; lFirstPass->setShininess(lShininess); } { Ogre::MaterialPtr lMaterial = lMaterialManager.create("gaia",lNameOfResourceGroup); Ogre::Technique* lFirstTechnique = lMaterial->getTechnique(0); Ogre::Pass* lFirstPass = lFirstTechnique->getPass(0); // Lighting is allowed on this pass. lFirstPass->setLightingEnabled(true); // Emissive / self illumination is the color 'produced' by the object. // Color values vary between 0.0(minimum) to 1.0 (maximum). Ogre::ColourValue lSelfIllumnationColour(0.0f, 0.0f, 0.1f, 0.3f); lFirstPass->setSelfIllumination(lSelfIllumnationColour); // diffuse color is the traditionnal color of the lit object. Ogre::ColourValue lDiffuseColour(0.1f, 0.2f, 0.8f, 1.0f); lFirstPass->setDiffuse(lDiffuseColour); // ambient colour is linked to ambient lighting. // If there is no ambient lighting, then this has no influence. // It the ambient lighting is at 1, then this colour is fully added. // This is often use to change the general feeling of a whole scene. Ogre::ColourValue lAmbientColour(0.0f, 0.1f, 0.4f, 1.0f); lFirstPass->setAmbient(lAmbientColour); // specular colour, is the colour of the 'little light reflection' // that you can see on some object. For example, my bald head skin // reflect the sun. This make a 'round of specular lighting'. // Set this to black if you don't want to see it. Ogre::ColourValue lSpecularColour(0.0f, 0.3f, 1.0f, 1.0f); lFirstPass->setSpecular(lSpecularColour); // Shininess is the 'inverse of specular color splattering' coefficient. // If this is big (e.g : 64) you get a very tiny dot with a quite strong color (on round surface). // If this is 0, you get a simple color layer (the dot has become very wide). Ogre::Real lShininess = 34.0f; lFirstPass->setShininess(lShininess); } { Ogre::MaterialPtr lMaterial = lMaterialManager.create("barren",lNameOfResourceGroup); Ogre::Technique* lFirstTechnique = lMaterial->getTechnique(0); Ogre::Pass* lFirstPass = lFirstTechnique->getPass(0); // Lighting is allowed on this pass. lFirstPass->setLightingEnabled(true); // Emissive / self illumination is the color 'produced' by the object. // Color values vary between 0.0(minimum) to 1.0 (maximum). Ogre::ColourValue lSelfIllumnationColour(0.1f, 0.1f, 0.1f, 0.1f); lFirstPass->setSelfIllumination(lSelfIllumnationColour); // diffuse color is the traditionnal color of the lit object. Ogre::ColourValue lDiffuseColour(0.3f, 0.3f, 0.3f, 0.3f); lFirstPass->setDiffuse(lDiffuseColour); // ambient colour is linked to ambient lighting. // If there is no ambient lighting, then this has no influence. // It the ambient lighting is at 1, then this colour is fully added. // This is often use to change the general feeling of a whole scene. Ogre::ColourValue lAmbientColour(0.3f, 0.3f, 0.3f, 0.3f); lFirstPass->setAmbient(lAmbientColour); // specular colour, is the colour of the 'little light reflection' // that you can see on some object. For example, my bald head skin // reflect the sun. This make a 'round of specular lighting'. // Set this to black if you don't want to see it. Ogre::ColourValue lSpecularColour(0.7f, 0.7f, 0.7f, 0.7f); lFirstPass->setSpecular(lSpecularColour); // Shininess is the 'inverse of specular color splattering' coefficient. // If this is big (e.g : 64) you get a very tiny dot with a quite strong color (on round surface). // If this is 0, you get a simple color layer (the dot has become very wide). Ogre::Real lShininess = 34.0f; lFirstPass->setShininess(lShininess); } { Ogre::MaterialPtr lMaterial = lMaterialManager.create("gasgiant",lNameOfResourceGroup); Ogre::Technique* lFirstTechnique = lMaterial->getTechnique(0); Ogre::Pass* lFirstPass = lFirstTechnique->getPass(0); // Lighting is allowed on this pass. lFirstPass->setLightingEnabled(true); // Emissive / self illumination is the color 'produced' by the object. // Color values vary between 0.0(minimum) to 1.0 (maximum). Ogre::ColourValue lSelfIllumnationColour(0.0f, 0.3f, 0.0f, 0.1f); lFirstPass->setSelfIllumination(lSelfIllumnationColour); // diffuse color is the traditionnal color of the lit object. Ogre::ColourValue lDiffuseColour(0.1f, 0.7f, 0.1f, 0.3f); lFirstPass->setDiffuse(lDiffuseColour); // ambient colour is linked to ambient lighting. // If there is no ambient lighting, then this has no influence. // It the ambient lighting is at 1, then this colour is fully added. // This is often use to change the general feeling of a whole scene. Ogre::ColourValue lAmbientColour(0.1f, 0.7f, 0.3f, 0.3f); lFirstPass->setAmbient(lAmbientColour); // specular colour, is the colour of the 'little light reflection' // that you can see on some object. For example, my bald head skin // reflect the sun. This make a 'round of specular lighting'. // Set this to black if you don't want to see it. Ogre::ColourValue lSpecularColour(0.2f, 1.0f, 0.6f, 0.6f); lFirstPass->setSpecular(lSpecularColour); // Shininess is the 'inverse of specular color splattering' coefficient. // If this is big (e.g : 64) you get a very tiny dot with a quite strong color (on round surface). // If this is 0, you get a simple color layer (the dot has become very wide). Ogre::Real lShininess = 34.0f; lFirstPass->setShininess(lShininess); } //end material tests //System Creator std::string systemDefinition[10] = {"15000,0,0,false,false,false,700000,0", "300,0,0,false,false,barren,2500,1", "300,x,y,false,co2,barren,6000,2", "300,x,y,h2o,n2/o2,gaia,6300,3", "300,x,y,false,co2,mars,3400,4", "300,x,y,false,h2/he,gasgiant,71000,5", "300,x,y,false,h2/he,gasgiant,60000,6", "300,x,y,false,h2/he,gasgiant,25001,7", "300,x,y,false,h2/he,gasgiant,25000,8", "300,x,y,false,n-ice,ice,1100,9"}; StarSystem sol = StarSystem::StarSystem(sceneMgr, systemDefinition); //Star Creator /* { int x = 0; int y = 0; int kelvin = 15000; CelestialBody newstar = CelestialBody::CelestialBody(kelvin, 100, systemNode, sceneMgr, x, y); } // Spectrum testing and multi star generation. int time = 200; int x = -500; int y = 500; for ( int count = 1; count <= time; count++){ int kelvin = count * (40000/time); Star newstar = Star::Star(kelvin, 100, systemNode, sceneMgr, x, y); x += 20; if (count % 10 == 0) { y -= 20; x = -500; } } */ // I move the SceneNode back 15 so that it is visible to the camera. float PositionOffset = 0.0; float distance = -2000.0; systemNode->translate(0, PositionOffset, distance); camera->lookAt(Ogre::Vector3(0,0,distance)); while (sim->getCurrentState() != SHUTDOWN) { sol.rotateOrbits(); handler->capture(); ogre->renderOneFrame(); // run the message pump (uncomment for Eihort) Ogre::WindowEventUtilities::messagePump(); } { window->removeAllViewports(); } { sceneMgr->destroyAllCameras(); sceneMgr->destroyAllManualObjects(); sceneMgr->destroyAllEntities(); sceneMgr->destroyAllLights(); systemNode->removeAndDestroyAllChildren(); } { Ogre::ResourceGroupManager& lRgMgr = Ogre::ResourceGroupManager::getSingleton(); lRgMgr.destroyResourceGroup(lNameOfResourceGroup); } // clean up after ourselves delete pDlg; delete handler; delete sim; delete ogre; return 0; }
// void TerrainPageSurfaceCompiler::addTextureUnitsToPass(Ogre::Pass* pass, const Ogre::String& splatTextureName) { // // if (getMaxTextureUnits() - pass->getNumTextureUnitStates() < 2 || pass->getParent()->getNumPasses() > 1) { // addPassToTechnique(pass->getParent(), splatTextureName); // // S_LOG_WARNING("Trying to add texture units to pass with too few available texture unit states."); // return; // } // // S_LOG_VERBOSE("Adding new texture unit (detailtexture: " << mTextureName << " alphatexture: " << splatTextureName << ") to pass nr " << pass->getIndex() << " in technique for material " << pass->getParent()->getParent()->getName()); // // /* pass->setSelfIllumination(Ogre::ColourValue(1,1,1)); // pass->setAmbient(Ogre::ColourValue(1,1,1)); // pass->setDiffuse(Ogre::ColourValue(1,1,1)); // pass->setLightingEnabled(true);*/ // Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState(); // textureUnitStateSplat->setTextureName(splatTextureName); // // textureUnitStateSplat->setTextureCoordSet(0); // textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC); // textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE); // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT); // textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); // // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE); // // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_TEXTURE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE); // // Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState(); // textureUnitState->setTextureName(mTextureName); // textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP); // /* textureUnitState->setTextureCoordSet(0);*/ // textureUnitState->setTextureScale(0.025, 0.025); // textureUnitState->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT); // // /* Ogre::TextureUnitState * alphaTextureState= pass->createTextureUnitState(); // alphaTextureState->setTextureName(mTextureName); // // alphaTextureState->setTextureName(splatTextureName); // alphaTextureState->setTextureCoordSet(0); // alphaTextureState->setTextureFiltering(Ogre::TFO_ANISOTROPIC); // alphaTextureState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); // alphaTextureState->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE); // // // // // detailTextureState->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE); // // detailTextureState->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT); // // Ogre::TextureUnitState * detailTextureState = pass->createTextureUnitState(); // detailTextureState ->setTextureName(splatTextureName); // // detailTextureState ->setTextureName(mTextureName); // detailTextureState ->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP); // detailTextureState ->setTextureCoordSet(0); // detailTextureState ->setTextureScale(0.01, 0.01); // //detailTextureState ->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);*/ // // } // Ogre::Pass* Simple::addPassToTechnique(const TerrainPageGeometry& geometry, Ogre::Technique* technique, const Layer& layer, std::set<std::string>& managedTextures) const { //check if we instead can reuse the existing pass // if (technique->getNumPasses() != 0) { // Ogre::Pass* pass = technique->getPass(technique->getNumPasses() - 1); // if (4 - pass->getNumTextureUnitStates() >= 2) { // //there's more than two texture units available, use those instead of creating a new pass // S_LOG_VERBOSE("Reusing existing pass. ("<< pass->getNumTextureUnitStates() << " of "<< mNumberOfTextureUnitsOnCard << " texture unit used)"); // addTextureUnitsToPass(pass, splatTextureName); // return pass; // } // // } const OgreImage& ogreImage = *layer.blendMap; Ogre::Image image; image.loadDynamicImage(const_cast<unsigned char*>(ogreImage.getData()), ogreImage.getResolution(), ogreImage.getResolution(), 1, Ogre::PF_A8); std::stringstream splatTextureNameSS; splatTextureNameSS << "terrain_" << mPage.getWFPosition().x() << "_" << mPage.getWFPosition().y() << "_" << technique->getNumPasses(); const Ogre::String splatTextureName(splatTextureNameSS.str()); Ogre::TexturePtr blendMapTexture; if (Ogre::Root::getSingletonPtr()->getTextureManager()->resourceExists(splatTextureName)) { blendMapTexture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(splatTextureName)); blendMapTexture->loadImage(image); Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(blendMapTexture->getBuffer()); //blit the whole image to the hardware buffer Ogre::PixelBox sourceBox(image.getPixelBox()); hardwareBuffer->blitFromMemory(sourceBox); } else { blendMapTexture = Ogre::Root::getSingletonPtr()->getTextureManager()->loadImage(splatTextureName, "General", image, Ogre::TEX_TYPE_2D, 0); managedTextures.insert(blendMapTexture->getName()); } //we need to create the image, update it and then destroy it again (to keep the memory usage down) // if (layer->getBlendMapTextureName() == "") { // //no texture yet; let's create one // layer->createBlendMapImage(); // layer->updateBlendMapImage(geometry); // layer->createTexture(); // } else { // //a texture exists, so we just need to update the image // layer->updateBlendMapImage(geometry); //calling this will also update the texture since the method will blit the image onto it // } Ogre::Pass* pass = technique->createPass(); pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA); pass->setAmbient(1, 1, 1); pass->setDiffuse(1, 1, 1, 1); pass->setLightingEnabled(false); Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState(); textureUnitState->setTextureName(layer.surfaceLayer.getDiffuseTextureName()); textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP); textureUnitState->setTextureCoordSet(0); textureUnitState->setTextureScale(1.0f / layer.surfaceLayer.getScale(), 1.0f / layer.surfaceLayer.getScale()); Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState(); textureUnitStateSplat->setTextureName(blendMapTexture->getName()); textureUnitStateSplat->setTextureCoordSet(0); textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC); // textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE); textureUnitStateSplat->setAlphaOperation(Ogre::LBX_BLEND_DIFFUSE_COLOUR, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT); textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT); return pass; }