SO3GBufferSchemeHandler.cpp

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
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Renderer/DeferredShading/SO3GBufferSchemeHandler.h"
#include "SO3Renderer/DeferredShading/SO3DeferredShading.h"
#include "SO3Utils/SO3Exception.h"
#include <OgreTechnique.h>
 
namespace SO3
{
 
// Here we define the pattern that we will search to determine if the pass is a "normal pass".
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN1 = "normal";
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN2 = "_nrm";
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN3 = "_norm";
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN4 = "_nm";
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN5 = "_nrm";
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN6 = "_nmap";
const Ogre::String SGBufferSchemeHandler::NORMAL_MAP_PATTERN7 = "bump";
 
// Same thing for specular map patterns
const Ogre::String SGBufferSchemeHandler::SPECULAR_MAP_PATTERN1 = "specular";
const Ogre::String SGBufferSchemeHandler::SPECULAR_MAP_PATTERN2 = "_spec";
 
// Same thing for light map patterns
const Ogre::String SGBufferSchemeHandler::LIGHT_MAP_PATTERN1 = "lightmap";
const Ogre::String SGBufferSchemeHandler::LIGHT_MAP_PATTERN2 = "light_map";
const Ogre::String SGBufferSchemeHandler::LIGHT_MAP_PATTERN3 = "_light";
 
SGBufferSchemeHandler::SGBufferSchemeHandler(SGBufferMaterialGenerator* materialGeneratorInstance)
{
  materialGenerator = materialGeneratorInstance;
}
 
SGBufferSchemeHandler::SGBufferSchemeHandler()
{
  // Forbiden ctor
}
 
Ogre::Technique* SGBufferSchemeHandler::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
{
  //look if we didn't add the technique in a previous handleSchemeNotFound call
  Ogre::Material::TechniqueIterator schemeTechniqueIt = originalMaterial->getTechniqueIterator();
  while(schemeTechniqueIt.hasMoreElements())
  {
    Ogre::Technique* schemeTechnique = schemeTechniqueIt.getNext();
    if(schemeTechnique->getSchemeName() == schemeName)
      return schemeTechnique;
  }
 
  // Get a reference to the material manager
  Ogre::MaterialManager& matMgr = Ogre::MaterialManager::getSingleton();
  Ogre::String curSchemeName = matMgr.getActiveScheme();
  matMgr.setActiveScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME);
  Ogre::Technique* originalTechnique = 0;
 
  // search for converted material technique with full textures
  for (unsigned int i = 0; i < originalMaterial->getNumTechniques() && !originalTechnique; ++i)
  {
    if (originalMaterial->getTechnique(i)->getSchemeName() == "fulldef")
    {
      originalTechnique = originalMaterial->getTechnique(i);
    }
  }
 
  if (!originalTechnique)
    originalTechnique = originalMaterial->getBestTechnique(lodIndex, rend);
 
  matMgr.setActiveScheme(curSchemeName);
 
  // Create a new empty gbuffer technique on the existing material.
  Ogre::Technique* gBufferTech = originalMaterial->createTechnique();
  gBufferTech->removeAllPasses();
  gBufferTech->setSchemeName(schemeName);
 
  // Create a new empty 'no gbuffer' technique on the existing material
  Ogre::Technique* noGBufferTech = originalMaterial->createTechnique();
  noGBufferTech->removeAllPasses();
  noGBufferTech->setSchemeName("NoGBuffer");
 
  // Parse all pass of the original technique
  unsigned short numPasses = originalTechnique->getNumPasses();
  if(numPasses > 0)
  {
    Ogre::Pass* originalPass = originalTechnique->getPass(0);
    PassProperties props = InspectPass(originalPass, lodIndex, rend);
 
    if((numPasses > 1) || (!props.isDeferred))
    {
      // Not deferred!
      for (unsigned short i=0; i<numPasses; i++)
      {
        // Copy the pass so it gets rendered regularly
        Ogre::Pass* clonePass = noGBufferTech->createPass();
        *clonePass = *(originalTechnique->getPass(i));
      }
    }
    else
    {
      // TODO: if gBufferTech->getNumPasses() == 0 ?
      Ogre::Pass* newPass = gBufferTech->createPass();
      SGBufferMaterialPermutation perm = GetPermutation(props);
 
      //We assume that the GBuffer technique contains only one pass. But its true.
      const Ogre::MaterialPtr& templateMat = materialGenerator->GetMaterial(SDeferredShading::getSingleton().GetGBuffer(), perm);
      *newPass = *(templateMat->getTechnique(0)->getPass(0));
      FillPass(newPass, originalPass, props);
    }
  }
  return gBufferTech;
}
 
 
SGBufferSchemeHandler::PassProperties SGBufferSchemeHandler::InspectPass(Ogre::Pass* pass, unsigned short lodIndex, const Ogre::Renderable* rend)
{
  PassProperties props;
 
  unsigned short numberTu = pass->getNumTextureUnitStates();
  if(numberTu > 4)
  {
    // TODO DEF temporary hack, cause we do not support more than 3 tu at this time (5 planned).
    props.isDeferred = false;
  }
  else
  {
    //TODO : Use renderable to indicate wether this has skinning.
    //Probably use same const cast that renderSingleObject uses.
    if (pass->hasVertexProgram())
      props.isSkinned = pass->getVertexProgram()->isSkeletalAnimationIncluded();
    else
      props.isSkinned = false;
 
    for (unsigned short i=0; i<pass->getNumTextureUnitStates(); i++) 
    {
      // Get a reference to tu
      Ogre::TextureUnitState* tus = pass->getTextureUnitState(i);
 
      // Get tu name
      Ogre::String lowerCaseName = tus->getName();
      Ogre::StringUtil::toLowerCase(lowerCaseName);
 
      // Get tu's texture alias name
      Ogre::String lowerCaseAlias = tus->getTextureNameAlias();
      Ogre::StringUtil::toLowerCase(lowerCaseAlias);
 
      // Get tu's texture filename
      Ogre::String lowerCaseFileName = tus->getTextureName();
      Ogre::StringUtil::toLowerCase(lowerCaseFileName);
 
      if(!CheckNormalMap(tus, props, lowerCaseName, lowerCaseAlias, lowerCaseFileName))
        if(!CheckSpecularMap(tus, props, lowerCaseName, lowerCaseAlias, lowerCaseFileName))
          if(!CheckLightMap(tus, props, lowerCaseName, lowerCaseAlias, lowerCaseFileName))
            props.regularTextures.push_back(tus);
 
      // TODO DEF manage tu effects
      //if (tus->getEffects().size() > 0)
      //  props.isDeferred = false;
    }
 
    // The pass has a diffuse colour
    if (pass->getDiffuse() != Ogre::ColourValue::Black)
      props.hasDiffuseColour = true;
 
    // Override specular colour if a specular map is provided
    if ((pass->getSpecular() != Ogre::ColourValue::Black) && (props.specularMap == 0))
      props.hasSpecularColour = true;
 
    // The pass has an emissive colour
    if (pass->getEmissive() != Ogre::ColourValue::Black)
      props.hasEmissiveColour = true;
 
    // Test alpha rejection (texture mask using alpha channel of the texture).
    if (pass->getAlphaRejectFunction() != Ogre::CMPF_ALWAYS_PASS)
      props.hasAlphaRejection = true;
 
    // Check depth write
    if (pass->getDepthWriteEnabled() == false && !props.hasAlphaRejection)
      props.isDeferred = false;
  }
  return props;
}
 
bool SGBufferSchemeHandler::CheckNormalMap(Ogre::TextureUnitState* tus, SGBufferSchemeHandler::PassProperties& props, const Ogre::String& lowerCaseName, const Ogre::String& lowerCaseAlias, const Ogre::String& lowerCaseFileName)
{
  bool isNormal = false;
 
  // Check if the texture unit alias contains our normal pattern, first condition for efficiency
  if ((lowerCaseName != "") &&
     ((lowerCaseName.find(NORMAL_MAP_PATTERN1) != Ogre::String::npos) || (lowerCaseName.find(NORMAL_MAP_PATTERN2) != Ogre::String::npos) ||
      (lowerCaseName.find(NORMAL_MAP_PATTERN3) != Ogre::String::npos) || (lowerCaseName.find(NORMAL_MAP_PATTERN4) != Ogre::String::npos) ||
      (lowerCaseName.find(NORMAL_MAP_PATTERN5) != Ogre::String::npos) || (lowerCaseName.find(NORMAL_MAP_PATTERN6) != Ogre::String::npos) ||
      (lowerCaseName.find(NORMAL_MAP_PATTERN7) != Ogre::String::npos)))
  {
    isNormal = true;
  }
  else
  {
    // Check if the texture unit alias contains our normal pattern, first condition for efficiency
    if ((lowerCaseAlias != "") &&
       ((lowerCaseAlias.find(NORMAL_MAP_PATTERN1) != Ogre::String::npos) || (lowerCaseAlias.find(NORMAL_MAP_PATTERN2) != Ogre::String::npos) ||
        (lowerCaseAlias.find(NORMAL_MAP_PATTERN3) != Ogre::String::npos) || (lowerCaseAlias.find(NORMAL_MAP_PATTERN4) != Ogre::String::npos) ||
        (lowerCaseAlias.find(NORMAL_MAP_PATTERN5) != Ogre::String::npos) || (lowerCaseAlias.find(NORMAL_MAP_PATTERN6) != Ogre::String::npos) ||
        (lowerCaseAlias.find(NORMAL_MAP_PATTERN7) != Ogre::String::npos)))
    {
      isNormal = true;
    }
    else
    {
      // Check if the texture file name contains our normal pattern, first condition for efficiency
      if ((lowerCaseFileName != "") &&
         ((lowerCaseFileName.find(NORMAL_MAP_PATTERN1) != Ogre::String::npos) || (lowerCaseFileName.find(NORMAL_MAP_PATTERN2) != Ogre::String::npos) ||
          (lowerCaseFileName.find(NORMAL_MAP_PATTERN3) != Ogre::String::npos) || (lowerCaseFileName.find(NORMAL_MAP_PATTERN4) != Ogre::String::npos) ||
          (lowerCaseFileName.find(NORMAL_MAP_PATTERN5) != Ogre::String::npos) || (lowerCaseFileName.find(NORMAL_MAP_PATTERN6) != Ogre::String::npos) ||
          (lowerCaseFileName.find(NORMAL_MAP_PATTERN7) != Ogre::String::npos)))
      {
        isNormal = true;
      }
    }
  }
 
  if (isNormal)
  {
    if (props.normalMap == 0)
      props.normalMap = tus;
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "The pass already have a normal map!", "SGBufferSchemeHandler::CheckNormalMap");
  }
  return isNormal;
}
 
bool SGBufferSchemeHandler::CheckSpecularMap(Ogre::TextureUnitState* tus, SGBufferSchemeHandler::PassProperties& props, const Ogre::String& lowerCaseName, const Ogre::String& lowerCaseAlias, const Ogre::String& lowerCaseFileName)
{
  bool isSpecular = false;
 
  // Check if the texture unit alias contains our speculat pattern, first condition for efficiency
  if ((lowerCaseName != "") &&
     ((lowerCaseName.find(SPECULAR_MAP_PATTERN1) != Ogre::String::npos) || (lowerCaseName.find(SPECULAR_MAP_PATTERN2) != Ogre::String::npos)))
  {
    isSpecular = true;
  }
  else
  {
    // Check if the texture unit alias contains our speculat pattern, first condition for efficiency
    if ((lowerCaseAlias != "") &&
       ((lowerCaseAlias.find(SPECULAR_MAP_PATTERN1) != Ogre::String::npos) || (lowerCaseAlias.find(SPECULAR_MAP_PATTERN2) != Ogre::String::npos)))
    {
      isSpecular = true;
    }
    else
    {
      // Check if the texture file name contains our speculat pattern, first condition for efficiency
      if ((lowerCaseFileName != "") &&
         ((lowerCaseFileName.find(SPECULAR_MAP_PATTERN1) != Ogre::String::npos) || (lowerCaseFileName.find(SPECULAR_MAP_PATTERN2) != Ogre::String::npos)))
      {
        isSpecular = true;
      }
    }
  }
 
  if (isSpecular)
  {
    if (props.specularMap == 0)
      props.specularMap = tus;
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "The pass already have a specular map!", "SGBufferSchemeHandler::CheckSpecularMap");
  }
  return isSpecular;
}
 
bool SGBufferSchemeHandler::CheckLightMap(Ogre::TextureUnitState* tus, SGBufferSchemeHandler::PassProperties& props, const Ogre::String& lowerCaseName, const Ogre::String& lowerCaseAlias, const Ogre::String& lowerCaseFileName)
{
  bool isLightMap = false;
 
  // Check if the texture unit alias contains our lightmap pattern, first condition for efficiency
  if ((lowerCaseName != "") &&
      ((lowerCaseName.find(LIGHT_MAP_PATTERN1) != Ogre::String::npos)
     ||(lowerCaseName.find(LIGHT_MAP_PATTERN2) != Ogre::String::npos)
     ||(lowerCaseName.find(LIGHT_MAP_PATTERN3) != Ogre::String::npos)))
  {
    isLightMap = true;
  }
  else
  {
    // Check if the texture unit alias contains our lightmap pattern, first condition for efficiency
    if ((lowerCaseAlias != "") &&
        ((lowerCaseAlias.find(LIGHT_MAP_PATTERN1) != Ogre::String::npos)
       ||(lowerCaseAlias.find(LIGHT_MAP_PATTERN2) != Ogre::String::npos)
       ||(lowerCaseAlias.find(LIGHT_MAP_PATTERN3) != Ogre::String::npos)))
    {
      isLightMap = true;
    }
    else
    {
      // Check if the texture file name contains our lightmap pattern, first condition for efficiency
      if ((lowerCaseFileName != "") &&
          ((lowerCaseFileName.find(LIGHT_MAP_PATTERN1) != Ogre::String::npos)
         ||(lowerCaseName.find(LIGHT_MAP_PATTERN2) != Ogre::String::npos)
         ||(lowerCaseFileName.find(LIGHT_MAP_PATTERN3) != Ogre::String::npos)))
      {
        isLightMap = true;
      }
    }
  }
 
  if (isLightMap)
  {
    if (props.lightMap == 0)
      props.lightMap = tus;
    else
      OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "The pass already have a light map!", "SGBufferSchemeHandler::CheckLightMap");
  }
  return isLightMap;
}
 
SGBufferMaterialPermutation SGBufferSchemeHandler::GetPermutation(const PassProperties& props)
{
  SGBufferMaterialPermutation perm;
  switch (props.regularTextures.size())
  {
  case 0:
    perm |= SGBufferMaterialPermutation::SO3_GBP_NO_TEXTURES;
    // TODO: strange...
    if((props.normalMap != 0) 
     ||(props.specularMap != 0)
     ||(props.lightMap != 0))
      perm |= SGBufferMaterialPermutation::SO3_GBP_ONE_TEXCOORD;
    else
      perm |= SGBufferMaterialPermutation::SO3_GBP_NO_TEXCOORDS;
    break;
 
  case 1:
      perm |= SGBufferMaterialPermutation::SO3_GBP_ONE_TEXTURE;
    perm |= SGBufferMaterialPermutation::SO3_GBP_ONE_TEXCOORD;
    break;
 
  case 2:
      perm |= SGBufferMaterialPermutation::SO3_GBP_TWO_TEXTURES;
    perm |= SGBufferMaterialPermutation::SO3_GBP_ONE_TEXCOORD;
    break;
 
  case 3:
      perm |= SGBufferMaterialPermutation::SO3_GBP_THREE_TEXTURES;
    perm |= SGBufferMaterialPermutation::SO3_GBP_ONE_TEXCOORD;
    break;
 
  default:
    // TODO
    SO3_EXCEPT(SExceptionUnimplemented, "Can not generate G-Buffer materials for '>3 texture' objects", "SGBufferSchemeHandler::GetPermutation", true);
  }
 
  if (props.isSkinned)
    perm |= SGBufferMaterialPermutation::SO3_GBP_SKINNED;
 
  if (props.normalMap != 0)
    perm |= SGBufferMaterialPermutation::SO3_GBP_NORMAL_MAP;
 
  if (props.specularMap != 0)
    perm |= SGBufferMaterialPermutation::SO3_GBP_SPECULAR_MAP;
 
  if (props.lightMap!= 0)
    perm |= SGBufferMaterialPermutation::SO3_GBP_LIGHT_MAP;
 
  if (props.hasDiffuseColour)
    perm |= SGBufferMaterialPermutation::SO3_GBP_HAS_DIFFUSE_COLOUR;
 
  if (props.hasSpecularColour)
    perm |= SGBufferMaterialPermutation::SO3_GBP_HAS_SPECULAR_COLOUR;
 
  if (props.hasEmissiveColour)
    perm |= SGBufferMaterialPermutation::SO3_GBP_HAS_EMISSIVE_COLOUR;
 
  if (props.hasAlphaRejection != 0)
    perm |= SGBufferMaterialPermutation::SO3_GBP_HAS_ALPHA_REJECTION;
 
  return perm;
}
 
void SGBufferSchemeHandler::FillPass(Ogre::Pass* gBufferPass, Ogre::Pass* originalPass, const PassProperties& props)
{
  //Reference the correct textures. Normal map first!
  int texUnitIndex = 0;
  if (props.normalMap != 0)
  {
    *(gBufferPass->getTextureUnitState(texUnitIndex)) = *(props.normalMap);
    texUnitIndex++;
  }
 
  if (props.specularMap != 0)
  {
    *(gBufferPass->getTextureUnitState(texUnitIndex)) = *(props.specularMap);
    texUnitIndex++;
  }
 
  if (props.lightMap != 0)
  {
    *(gBufferPass->getTextureUnitState(texUnitIndex)) = *(props.lightMap);
    texUnitIndex++;
  }
 
  for (size_t i=0; i<props.regularTextures.size(); i++)
  {
    *(gBufferPass->getTextureUnitState(texUnitIndex)) = *(props.regularTextures[i]);
    texUnitIndex++;
  }
 
  if (props.hasAlphaRejection != 0)
  {
    Ogre::GpuProgramParametersSharedPtr fragProgParams = gBufferPass->getFragmentProgramParameters();
    if (fragProgParams->_findNamedConstantDefinition("cRejectAlpha"))
      fragProgParams->setNamedConstant("cRejectAlpha", Ogre::Real(originalPass->getAlphaRejectValue()/255.0f));
  }
 
  gBufferPass->setAmbient(originalPass->getAmbient());
  gBufferPass->setDiffuse(originalPass->getDiffuse());
  gBufferPass->setSpecular(originalPass->getSpecular());
  gBufferPass->setShininess(originalPass->getShininess());
  gBufferPass->setEmissive(originalPass->getEmissive());
  gBufferPass->setCullingMode(originalPass->getCullingMode());
  gBufferPass->setLightingEnabled(false);
}
 
}