SO3DeferredLightAmbientMaterialGenerator.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/SO3DeferredLightAmbientMaterialGenerator.h"
 
namespace SO3
{
 
SDeferredLightAmbientMaterialGenerator::SDeferredLightAmbientMaterialGenerator() : SDeferredLightMaterialGenerator("Ambient/")
{
}
 
SDeferredLightAmbientMaterialGenerator::~SDeferredLightAmbientMaterialGenerator()
{
}
 
Ogre::GpuProgramPtr SDeferredLightAmbientMaterialGenerator::GenerateVertexShader(SGBuffer* gbuffer, Ogre::uint32 permutationValue)
{
  Ogre::StringStream ss;
 
  ss << "void SO3_DeferredLightAmbient_vs(float4 Pos: POSITION," << std::endl;
  ss << "                                 out float4 oPos: POSITION," << std::endl;
  ss << "                                 out float2 oTexCoord: TEXCOORD0," << std::endl;
  ss << "                                 out float3 oRay : TEXCOORD1," << std::endl;
  ss << "                                 uniform float3 farCorner," << std::endl;
  ss << "                                 uniform float flip" << std::endl;
  ss << ")" << std::endl;
  ss << "{" << std::endl;
 
  // Clean up inaccuracies
  ss << "       Pos.xy = sign(Pos.xy);" << std::endl;
 
  // View space
  ss << "       oPos = float4(Pos.xy, 0, 1);" << std::endl;
  ss << "       oPos.y *= flip;" << std::endl;
 
        // Image-space
  ss << "       oTexCoord.x = 0.5 * (1 + Pos.x);" << std::endl;
  ss << "       oTexCoord.y = 0.5 * (1 - Pos.y);" << std::endl;
 
        // This ray will be interpolated and will be the ray from the camera
        // to the far clip plane, per pixel
  ss << "       oRay = farCorner * float3(Pos.xy, 1);" << std::endl;
  ss << "}" << std::endl;
 
 
  // Prepare shader generation
  Ogre::String programSource = ss.str();
  Ogre::String programName = materialBaseName +"Shaders/Vertex/"+ gbuffer->GetName();
 
#if SO3_DEBUG
  // Show the generated vertex program in the log.
  Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource, Ogre::LML_CRITICAL);
#endif
 
  // Create shader object
  // TODO in another group than Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME?
  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", "SO3_DeferredLightAmbient_vs");
  ptrProgram->setParameter("profiles", "vs_1_1 arbvp1");
 
  // Bind our function parameters to Ogre's related values.
  const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters();
 
  if (params->_findNamedConstantDefinition("flip"))
    params->setNamedAutoConstant("flip", Ogre::GpuProgramParameters::ACT_RENDER_TARGET_FLIPPING);
 
  if (params->_findNamedConstantDefinition("farCorner"))
    params->setNamedConstant("farCorner", Ogre::Vector3::UNIT_SCALE);
 
  // Return light vertex shader
  ptrProgram->load();
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
Ogre::GpuProgramPtr SDeferredLightAmbientMaterialGenerator::GenerateFragmentShader(SGBuffer* gbuffer, Ogre::uint32 permutationValue)
{
  Ogre::StringStream ss;
 
  // Structures defines
  ss << gbuffer->GenerateGBufferCompositorPixelInputStructure();
 
  //GL and DX expect a different value, GL needs it in [0..1]
  ss << "arbfp1 float finalDepth(float4 p)" << std::endl;
  ss << "{" << std::endl;
  ss << "    return (p.z / p.w) * 0.5 + 0.5;" << std::endl;
  ss << "}" << std::endl;
 
  // normally it's in [-1..1]
  ss << "float finalDepth(float4 p)" << std::endl;
  ss << "{" << std::endl;
  ss << "    return p.z / p.w;" << std::endl;
  ss << "}" << std::endl;
 
  ss << "void SO3_DeferredLightAmbient_ps(float2 texCoord       : TEXCOORD0, " << std::endl;
  ss << "                                 float3 ray            : TEXCOORD1," << std::endl;
  ss << "                                 out float4 oColour    : COLOR," << std::endl;
  ss << "                                 out float oDepth      : DEPTH," << std::endl;
  ss << "                                 " << gbuffer->GetGBufferCompositorPixelInputStructureTypeName() << " gBuffer," << std::endl; // Input parameters (list of mrts)
  ss << "                                 uniform float4x4 proj," << std::endl;
  ss << "                                 uniform float4 ambientColor," << std::endl;
  ss << "                                 uniform float farClipDistance" << std::endl;
  ss << "                                 )" << std::endl;
  ss << "{" << std::endl;
 
        // Clip fragment if depth is too close, so the skybox can be rendered on the background
  ss << " float depth = gBuffer.GetDepth(texCoord);" << std::endl;
  ss << "       clip(depth - 0.0001);" << std::endl; // TODO clip(depth - (1 / (farClipDistance - nearClipDistance))
 
  // Get diffuse colour
  ss << "float4 diffuseColour = float4(gBuffer.GetDiffuse(texCoord), 0);" << std::endl;
 
  // If texel got emissive power, and the gbuffer supports emissive channel.
  if(gbuffer->GetChannels() & SGBuffer::SO3_GBUFFER_EMISSIVE)
  {
    ss << " float emissivePower = gBuffer.GetEmissive(texCoord);" << std::endl;
    ss << " if(emissivePower != 0)" << std::endl;
    ss << "   oColour = diffuseColour * emissivePower;" << std::endl;
    ss << " else" << std::endl;
    // Only non-emissive texels takes ambient colour.
  }
 
        // Calculate ambient colour of fragment
  ss << "       oColour = float4(ambientColor*diffuseColour);" << std::endl;
 
        // Calculate depth of fragment;
  ss << "       float3 viewPos = normalize(ray) * farClipDistance * depth;" << std::endl;
  ss << "       float4 projPos = mul(proj, float4(viewPos, 1));" << std::endl;
  ss << "       oDepth = finalDepth(projPos);" << std::endl;
  ss << "}" << std::endl;
 
  // Prepare shader generation
  Ogre::String programSource = ss.str();
  Ogre::String programName = materialBaseName +"Shaders/Pixel/"+ gbuffer->GetName();
 
#if SO3_DEBUG
  // Show the generated vertex program in the log.
  Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource, Ogre::LML_CRITICAL);
#endif
 
  // Create shader object
  // TODO in another group than Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME?
  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", "SO3_DeferredLightAmbient_ps");
  ptrProgram->setParameter("profiles", "ps_2_0 arbfp1");
 
  // Bind our function parameters to Ogre's related values.
  const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters();
 
  if (params->_findNamedConstantDefinition("ambientColor"))
    params->setNamedAutoConstant("ambientColor", Ogre::GpuProgramParameters::ACT_AMBIENT_LIGHT_COLOUR, 0);
  
  if (params->_findNamedConstantDefinition("proj"))
    params->setNamedAutoConstant("proj", Ogre::GpuProgramParameters::ACT_PROJECTION_MATRIX);
  
  if (params->_findNamedConstantDefinition("farClipDistance"))
    params->setNamedAutoConstant("farClipDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
 
  // Return compositor pixel shader
  ptrProgram->load();
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
Ogre::MaterialPtr SDeferredLightAmbientMaterialGenerator::GenerateTemplateMaterial(SGBuffer* gbuffer, Ogre::uint32 permutationValue)
{
  Ogre::MaterialPtr matPtr = SDeferredLightMaterialGenerator::GenerateTemplateMaterial(gbuffer, permutationValue);
  Ogre::Pass* ogrePass = matPtr->getTechnique(0)->getPass(0);
  ogrePass->setDepthWriteEnabled(true);
  return matPtr;
}
 
}