Ogre Forums

Code: Select all

material BaseMaterial
{
	technique
	{
		//Original technique
	}

	technique DepthTechnique
	{
		scheme DepthRender
		//....
	}
}

Code: Select all

MaterialManager::setDefaultSchemeMaterial(const Ogre::String& schemeName, const Ogre::String& defaultMaterialName)

Code: Select all

void CustomSceneManager::_renderDepthBuffer(Ogre::Camera *c, Ogre::Viewport *vp) {
        Ogre::RenderSystem *rs = renderSystem;

        Ogre::Matrix4 viewmat = c->getViewMatrix(true);
        Ogre::Matrix4 projmat = c->getProjectionMatrixRS();

        rs->clearFrameBuffer(Ogre::FBT_DEPTH);
        _suppressRenderStateChanges(true); {
            _clearPass();

            rs->_setDepthBufferParams(true, true);
            rs->_setColourBufferWriteEnabled(false, false, false, false);
            rs->setLightingEnabled(false);

            rs->_setViewMatrix(viewmat);
            rs->_setProjectionMatrix(projmat);

            _renderScene(c, vp, false);
        } _suppressRenderStateChanges(false);
    }

Code: Select all

protected:
/// Scheme name -> default material. Never shrinks! Should be pretty static anyway
		typedef std::map<String, MaterialPtr> SchemeMaterialMap;
		//List of material scheme default materials
		SchemeMaterialMap mDefaultSchemeMaterials;
/// The default technique for the active scheme
		Technique* mActiveSchemeDefaultTechnique;

public:
/** Sets the name of the default material for a scheme. All objects rendered as part
			of this scheme that don't have a specific technique set for it will use it
		@par schemeName the name of the scheme to set a default material for
		@par defaultMaterialName the name of the default material to use
		*/
		void setDefaultSchemeMaterial(const Ogre::String& schemeName, 
			const Ogre::String& defaultMaterialName);
		
		/** Get the default technique set up for the current scheme
			@ret the active technique for the current scheme, null if none
		*/
		Technique* _getActiveSchemeDefaultTechnique() const;

/** Overridden from ResourceManager since we have to clean up scheme defaults too. */
		void removeAll(void);

Code: Select all

//-----------------------------------------------------------------------
	void MaterialManager::setDefaultSchemeMaterial(const Ogre::String& schemeName, 
		const Ogre::String& defaultMaterialName)
	{
		MaterialPtr material = static_cast<MaterialPtr>(getByName(defaultMaterialName));
		if (material.isNull())
		{
			return;
		}
		
		if (!material->isLoaded())
		{
			material->load();
		}
		mDefaultSchemeMaterials[schemeName] = material;
		if (mActiveSchemeName == schemeName)
		{
			//This is the currently active scheme, apply material as active technique.
			mActiveSchemeDefaultTechnique = material->getTechnique(0);
		}
	}
	//-----------------------------------------------------------------------
	Technique* MaterialManager::_getActiveSchemeDefaultTechnique() const
	{
		return mActiveSchemeDefaultTechnique;
	}
	//-----------------------------------------------------------------------
	void MaterialManager::removeAll( void )
	{
		for (SchemeMaterialMap::iterator it = mDefaultSchemeMaterials.begin();
			it != mDefaultSchemeMaterials.end(); it++)
		{
			it->second.setNull();
		}
		ResourceManager::removeAll();
	}
	//-----------------------------------------------------------------------

Code: Select all

void MaterialManager::setActiveScheme(const String& schemeName)
	{
		SchemeMap::iterator i = mSchemes.find(schemeName);
		if (i == mSchemes.end())
		{
			// Invalid scheme, use default
			mActiveSchemeName = DEFAULT_SCHEME_NAME;
			mActiveSchemeIndex = 0;
			mActiveSchemeDefaultTechnique = 0;
		}
		else
		{
			mActiveSchemeName = schemeName;
			mActiveSchemeIndex = i->second;
			SchemeMaterialMap::iterator matIt = mDefaultSchemeMaterials.find(schemeName);
			if (matIt != mDefaultSchemeMaterials.end())
			{
				mActiveSchemeDefaultTechnique = matIt->second->getTechnique(0);
			}
			else
			{
				mActiveSchemeDefaultTechnique = 0;
			}
		}

	}

Code: Select all

// scheme not found?
			if (si == mBestTechniquesBySchemeList.end())
			{
				// Check if a default material was set up for this scheme
				Ogre::Technique* defaultSchemeTechnique = 
					MaterialManager::getSingleton()._getActiveSchemeDefaultTechnique();
				if (defaultSchemeTechnique != 0)
				{
					return defaultSchemeTechnique;
				}

				// get the first item, will be 0 (the default) if default
				// scheme techniques exist, otherwise the earliest defined
				si = mBestTechniquesBySchemeList.begin();
			}

Code: Select all

			/** Called if a technique for a given scheme is not found within a material,
				allows the application to specify a Technique instance manually.
			@remarks
				Material schemes allow you to switch wholesale between families of 
				techniques on a material. However they require you to define those
				schemes on the materials up-front, which might not be possible or
				desirable for all materials, particular if, for example, you wanted
				a simple way to replace all materials with another using a scheme.
			@par
				This callback allows you to handle the case where a scheme is requested
				but the material doesn't have an entry for it. You can return a
				Technique pointer from this method to specify the material technique
				you'd like to be applied instead, which can be from another material
				entirely (and probably will be). Note that it is critical that you
				only return a Technique that is supported on this hardware; there are
				utility methods like Material::getBestTechnique to help you with this.
			@param schemeIndex The index of the scheme that was requested - all 
				schemes have a unique index when created that does not alter. 
			@param schemeName The friendly name of the scheme being requested
			@param originalMaterial The material that is being processed, that 
				didn't have a specific technique for this scheme
			@param lodIndex The material level-of-detail that was being asked for, 
				in case you need to use it to determine a technique.
			@param rend Pointer to the Renderable that is requesting this technique
				to be used, so this may influence your choice of Technique. May be
				null if the technique isn't being requested in that context.
			@returns A pointer to the technique to be used, or NULL if you wish to
				use the default technique for this material
			*/
			virtual Technique* handleSchemeNotFound(unsigned short schemeIndex, 
				const String& schemeName, Material* originalMaterial, unsigned short lodIndex, 
				const Renderable* rend) = 0;