SO3MaterialGenerator.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3_DEFERRED_SHADING_MATERIAL_GENERATOR_H__
#define __SO3_DEFERRED_SHADING_MATERIAL_GENERATOR_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include "SO3GBuffer.h"
#include "OgreMaterial.h"
 
namespace SO3
{
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> class SMaterialGenerator
{
public:
  typedef PERMUTATION_TYPE Perm;            
protected:
  const Ogre::String materialBaseName;  
private:
  typedef typename Ogre::map<PERMUTATION_TYPE, Ogre::GpuProgramPtr>::type ProgramPermMap;
  typedef typename Ogre::map<SGBuffer*, typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap*>::type ProgramMap;
  typedef typename Ogre::map<PERMUTATION_TYPE, Ogre::MaterialPtr>::type MaterialPermMap;
  typedef typename Ogre::map<SGBuffer*, typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap*>::type MaterialMap;
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap mVs;                       
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap mFs;                       
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap templateMaterials;        
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap materials;                
 
public:
  virtual ~SMaterialGenerator();
 
  const Ogre::MaterialPtr& GetMaterial(SGBuffer* gbuffer, PERMUTATION_CLASS permutation);
 
  /*
  Function to get statistic on how many materials (instances) resources where created by this deferred material generator.
  */
  unsigned int GetDeferredMaterialNumber(SGBuffer* gbuffer);
 
  /*
  Function to get statistic on how many materials (templates) resources where created by this deferred material generator.
  */
  unsigned int GetDeferredMaterialTemplateNumber(SGBuffer* gbuffer);
 
  unsigned int GetDeferredVertexShaderNumber(SGBuffer* gbuffer);
 
  unsigned int GetDeferredPixelShaderNumber(SGBuffer* gbuffer);
 
  void ResetResources(SGBuffer* gbuffer);
protected:
  SMaterialGenerator(const Ogre::String& typeName);
 
  const Ogre::GpuProgramPtr& GetVertexShader(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue);
 
  /*
  */
  const Ogre::GpuProgramPtr& GetFragmentShader(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue);
 
  const Ogre::MaterialPtr& GetTemplateMaterial(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue);
 
  virtual Ogre::GpuProgramPtr GenerateVertexShader(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue) = 0;
 
  virtual Ogre::GpuProgramPtr GenerateFragmentShader(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue) = 0;
 
  virtual Ogre::MaterialPtr GenerateTemplateMaterial(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue) = 0;
private:
  SMaterialGenerator();
};
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::SMaterialGenerator(const Ogre::String& typeName) : materialBaseName(Ogre::String("SO3/Deferred/") + typeName)
{
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::SMaterialGenerator() : materialBaseName("")
{
  // Forbiden ctor
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::~SMaterialGenerator()
{
  // Build gbuffer list
  std::vector<SGBuffer*> gbufferList;
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator iTemplateMaterials = templateMaterials.begin();
  while(iTemplateMaterials != templateMaterials.end())
  {
    gbufferList.push_back(iTemplateMaterials->first);
    iTemplateMaterials++;
  }
 
  // Clean all gbuffers
  std::vector<SGBuffer*>::iterator iGBuffer = gbufferList.begin();
  while(iGBuffer != gbufferList.end())
  {
    // Clean MaterialPermMap etc... instance
    SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ResetResources(*iGBuffer);
    iGBuffer++;
  }
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> unsigned int SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetDeferredMaterialNumber(SGBuffer* gbuffer)
{
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator i = materials.find(gbuffer);
  if(i != materials.end())
    return i->second.size();
  else
    return 0;
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> unsigned int SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetDeferredMaterialTemplateNumber(SGBuffer* gbuffer)
{
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator i = templateMaterials.find(gbuffer);
  if(i != templateMaterials.end())
    return i->second.size();
  else
    return 0;
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> unsigned int SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetDeferredVertexShaderNumber(SGBuffer* gbuffer)
{
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap::iterator i = mVs.find(gbuffer);
  if(i != mVs.end())
    return i->second.size();
  else
    return 0;         
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> unsigned int SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetDeferredPixelShaderNumber(SGBuffer* gbuffer)
{
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap::iterator i = mFs.find(gbuffer);
  if(i != mFs.end())
    return i->second.size();
  else
    return 0;
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> void SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ResetResources(SGBuffer* gbuffer)
{
  // Ogre's references
  Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr();
  Ogre::HighLevelGpuProgramManager* programManager = Ogre::HighLevelGpuProgramManager::getSingletonPtr();
 
  // Reset templates materials
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator iTemplateMaterials = templateMaterials.find(gbuffer);
  if(iTemplateMaterials != templateMaterials.end())
  {
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap* materialPermMap = iTemplateMaterials->second;
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap::iterator iTemplatePermutations = materialPermMap->begin();
    while(iTemplatePermutations != materialPermMap->end())
    {
      materialManager->remove(iTemplatePermutations->second->getHandle());
      iTemplatePermutations++;
    }
 
    // Erase from our list, this will erase the last reference to MaterialPtr, and will effectively destroy it.
    SO3_SAFE_DELETE(iTemplateMaterials->second);
    templateMaterials.erase(iTemplateMaterials);
  }
 
  // Reset materials
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator iMaterials = materials.find(gbuffer);
  if(iMaterials != materials.end())
  {
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap* materialPermMap = iMaterials->second;
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap::iterator iPermutations = materialPermMap->begin();
    while(iPermutations != materialPermMap->end())
    {
      materialManager->remove(iPermutations->second->getHandle());
      iPermutations++;
    }
 
    // Erase from our list, this will erase the last reference to MaterialPtr, and will effectively destroy it.
    SO3_SAFE_DELETE(iMaterials->second);
    materials.erase(iMaterials);
  }
 
  // Reset vertex shaders
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap::iterator iVertex = mVs.find(gbuffer);
  if(iVertex != mVs.end())
  {
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap* vertexPermMap = iVertex->second;
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap::iterator iPermutations = vertexPermMap->begin();
    while(iPermutations != vertexPermMap->end())
    {
      programManager->remove(iPermutations->second->getHandle());
      iPermutations++;
    }
 
    // Erase from our list, this will erase the last reference to MaterialPtr, and will effectively destroy it.
    SO3_SAFE_DELETE(iVertex->second);
    mVs.erase(iVertex);
  }
 
  // Reset fragments shaders
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap::iterator iFragment = mFs.find(gbuffer);
  if(iFragment != mFs.end())
  {
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap* fragmentPermMap = iFragment->second;
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap::iterator iPermutations = fragmentPermMap->begin();
    while(iPermutations != fragmentPermMap->end())
    {
      programManager->remove(iPermutations->second->getHandle());
      iPermutations++;
    }
 
    // Erase from our list, this will erase the last reference to MaterialPtr, and will effectively destroy it.
    SO3_SAFE_DELETE(iFragment->second);
    mFs.erase(iFragment);
  }
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> const Ogre::MaterialPtr& SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetMaterial(SGBuffer* gbuffer, PERMUTATION_CLASS permutation)
{
  // Check if the GBuffer instance was already used
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap* materialPermMap = 0;
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator i = materials.find(gbuffer);
  if(i == materials.end())
  {
    // Not found create a new material permutation map
    materialPermMap = new SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap();
    materials[gbuffer] = materialPermMap;
  }
  else
  {
    materialPermMap = i->second;
  }
 
  // Check if material/shader permutation was already generated
  PERMUTATION_TYPE permutationValue = permutation.GetPermutations();
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap::iterator j = materialPermMap->find(permutationValue);
  if(j != materialPermMap->end())
  {
    return j->second;
  }
  else
  {
    // Create it
    Ogre::MaterialPtr templ = GetTemplateMaterial(gbuffer, permutation.GetMaterialPermutations());
    Ogre::GpuProgramPtr vs = GetVertexShader(gbuffer, permutation.GetVertexPermutations());
    Ogre::GpuProgramPtr fs = GetFragmentShader(gbuffer, permutation.GetFragmentPermutations());
 
    // Create material name
    Ogre::String name = materialBaseName + permutation.ToString();
    std::cerr << name << " " << vs->getName() << " " << fs->getName() << std::endl;
 
    // Create material from template, and set shaders
    Ogre::MaterialPtr mat = templ->clone(name);
    Ogre::Technique* tech = mat->getTechnique(0);
    Ogre::Pass* pass = tech->getPass(0);
    pass->setFragmentProgram(fs->getName());
    pass->setVertexProgram(vs->getName());
 
    // Store it and return it
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap::value_type val(permutationValue, mat);
    materialPermMap->insert(materialPermMap->begin(), val);
    return mat;
  }
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> const Ogre::GpuProgramPtr& SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetVertexShader(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue)
{
  // Check if the GBuffer instance was already used
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap* programPermMap = 0;
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap::iterator i = mVs.find(gbuffer);
  if(i == mVs.end())
  {
    // Not found create a new material permutation map
    programPermMap = new SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap();
    mVs[gbuffer] = programPermMap;
  }
  else
  {
    programPermMap = i->second;
  }
 
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap::iterator j = programPermMap->find(permutationValue);
  if(j != programPermMap->end())
  {
    return j->second;
  }
  else
  {
    // Create it, store it and return it
    Ogre::GpuProgramPtr progptr = GenerateVertexShader(gbuffer, permutationValue);
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap::value_type val(permutationValue, progptr);
    programPermMap->insert(programPermMap->begin(), val);
    return progptr;
  }
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> const Ogre::GpuProgramPtr& SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetFragmentShader(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue)
{
  // Check if the GBuffer instance was already used
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap* programPermMap = 0;
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramMap::iterator i = mFs.find(gbuffer);
  if(i == mFs.end())
  {
    // Not found create a new material permutation map
    programPermMap = new SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap();
    mFs[gbuffer] = programPermMap;
  }
  else
  {
    programPermMap = i->second;
  }
 
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap::iterator j = programPermMap->find(permutationValue);
  if(j != programPermMap->end())
  {
    return j->second;
  }
  else
  {
    // Create it, store it and return it
    Ogre::GpuProgramPtr progptr = GenerateFragmentShader(gbuffer, permutationValue);
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::ProgramPermMap::value_type val(permutationValue, progptr);
    programPermMap->insert(programPermMap->begin(), val);
    return progptr;
  }
}
 
template <class PERMUTATION_CLASS, typename PERMUTATION_TYPE> const Ogre::MaterialPtr& SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::GetTemplateMaterial(SGBuffer* gbuffer, PERMUTATION_TYPE permutationValue)
{
  // Check if the GBuffer instance was already used
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap* materialPermMap = 0;
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialMap::iterator i = templateMaterials.find(gbuffer);
  if(i == templateMaterials.end())
  {
    // Not found create a new material permutation map
    materialPermMap = new SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap();
    templateMaterials[gbuffer] = materialPermMap;
  }
  else
  {
    materialPermMap = i->second;
  }
 
  typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap::iterator j = materialPermMap->find(permutationValue);
  if(j != materialPermMap->end())
  {
    return j->second;
  }
  else
  {
    // Create it
    Ogre::MaterialPtr matptr = GenerateTemplateMaterial(gbuffer, permutationValue);
    typename SMaterialGenerator<PERMUTATION_CLASS, PERMUTATION_TYPE>::MaterialPermMap::value_type val(permutationValue, matptr);
    materialPermMap->insert(materialPermMap->begin(), val);
    return matptr;
  }
}
 
}
 
#endif