SO3RtssCustom.cpp

Go to the documentation of this file.

 
#include "SO3Material/SO3RtssCustom.h"
#include "SO3Material/SO3Pass.h"
#include "SO3Material/SO3Technique.h"
#include "SO3Material/SO3Material.h"
 
namespace SO3
{
 
  /************************************************************************/
  /*                                                                      */
  /************************************************************************/
  const Ogre::String SRS_ADV_COOK_TORRANCE_LIGHTING = "AdvancedCookTorranceLighting";
 
  //-----------------------------------------------------------------------
  AdvancedCookTorranceLighting::AdvancedCookTorranceLighting() : mUseOcclusion(false), mLightCount(0), mMRMapSamplerIndex(0), mLtcLUT1SamplerIndex(-1) {}
 
  //-----------------------------------------------------------------------
  const Ogre::String& AdvancedCookTorranceLighting::getType() const { return SRS_ADV_COOK_TORRANCE_LIGHTING; }
  //-----------------------------------------------------------------------
  bool AdvancedCookTorranceLighting::createCpuSubPrograms(Ogre::RTShader::ProgramSet* programSet)
  {
    Ogre::RTShader::Program* vsProgram = programSet->getCpuProgram(Ogre::GPT_VERTEX_PROGRAM);
    Ogre::RTShader::Function* vsMain = vsProgram->getEntryPointFunction();
    Ogre::RTShader::Program* psProgram = programSet->getCpuProgram(Ogre::GPT_FRAGMENT_PROGRAM);
    Ogre::RTShader::Function* psMain = psProgram->getEntryPointFunction();
 
    vsProgram->addDependency(FFP_LIB_TRANSFORM);
 
    psProgram->addDependency(FFP_LIB_TRANSFORM);
    psProgram->addDependency(FFP_LIB_TEXTURING);
    psProgram->addDependency("SGXLib_CookTorrance");
    psProgram->addPreprocessorDefines(Ogre::StringUtil::format("LIGHT_COUNT=%d", mLightCount));
 
    // Resolve texture coordinates.
    auto vsOutTexcoord = vsMain->getOutputParameter(Ogre::RTShader::Parameter::SPC_TEXTURE_COORDINATE0, Ogre::GCT_FLOAT2); // allow override by others
    Ogre::RTShader::ParameterPtr vsInTexcoord;
    if (!vsOutTexcoord)
    {
      vsInTexcoord = vsMain->resolveInputParameter(Ogre::RTShader::Parameter::SPC_TEXTURE_COORDINATE0, Ogre::GCT_FLOAT2);
      vsOutTexcoord = vsMain->resolveOutputParameter(Ogre::RTShader::Parameter::SPC_TEXTURE_COORDINATE0, Ogre::GCT_FLOAT2);
    }
    auto psInTexcoord = psMain->resolveInputParameter(vsOutTexcoord);
 
    // resolve view position
    auto vsInPosition = vsMain->getLocalParameter(Ogre::RTShader::Parameter::SPC_POSITION_OBJECT_SPACE);
    if (!vsInPosition)
      vsInPosition = vsMain->resolveInputParameter(Ogre::RTShader::Parameter::SPC_POSITION_OBJECT_SPACE);
    auto vsOutViewPos = vsMain->resolveOutputParameter(Ogre::RTShader::Parameter::SPC_POSITION_VIEW_SPACE);
    auto viewPos = psMain->resolveInputParameter(vsOutViewPos);
    auto worldViewMatrix = vsProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
 
    // Resolve normal.
    auto viewNormal = psMain->getLocalParameter(Ogre::RTShader::Parameter::SPC_NORMAL_VIEW_SPACE);
    Ogre::RTShader::ParameterPtr vsInNormal, vsOutNormal;
 
    if (!viewNormal)
    {
      // Resolve input vertex shader normal.
      vsInNormal = vsMain->resolveInputParameter(Ogre::RTShader::Parameter::SPC_NORMAL_OBJECT_SPACE);
 
      // Resolve output vertex shader normal.
      vsOutNormal = vsMain->resolveOutputParameter(Ogre::RTShader::Parameter::SPC_NORMAL_VIEW_SPACE);
 
      // Resolve input pixel shader normal.
      viewNormal = psMain->resolveInputParameter(vsOutNormal);
    }
 
    // resolve light params
    auto outDiffuse = psMain->resolveOutputParameter(Ogre::RTShader::Parameter::SPC_COLOR_DIFFUSE);
    auto outSpecular = psMain->resolveLocalParameter(Ogre::RTShader::Parameter::SPC_COLOR_SPECULAR);
 
    // insert after texturing
    auto vstage = vsMain->getStage(Ogre::RTShader::FFP_PS_COLOUR_BEGIN + 1);
    auto fstage = psMain->getStage(Ogre::RTShader::FFP_PS_COLOUR_END + 50);
 
    // Forward texture coordinates
    if (vsInTexcoord)
      vstage.assign(vsInTexcoord, vsOutTexcoord);
    vstage.callFunction(FFP_FUNC_TRANSFORM, worldViewMatrix, vsInPosition, vsOutViewPos);
 
    // transform normal in VS
    if (vsOutNormal)
    {
      auto worldViewITMatrix = vsProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_NORMAL_MATRIX);
      vstage.callBuiltin("mul", worldViewITMatrix, vsInNormal, vsOutNormal);
    }
 
    auto sceneCol = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_DERIVED_SCENE_COLOUR);
    auto litResult = psMain->resolveLocalParameter(Ogre::GCT_FLOAT4, "litResult");
    auto diffuse = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
    auto baseColor = psMain->resolveLocalParameter(Ogre::GCT_FLOAT4, "baseColor");
    auto ambientColor = psMain->resolveLocalParameter(Ogre::GCT_FLOAT4, "ambientColor");
 
    fstage.assign(Ogre::RTShader::In(sceneCol), Ogre::RTShader::Out(ambientColor));
 
    // add the lighting computation
    auto mrparams = psMain->resolveLocalParameter(Ogre::GCT_FLOAT2, "metalRoughness");
    if (!mMetalRoughnessMapName.empty())
    {
      auto metalRoughnessSampler =
        psProgram->resolveParameter(Ogre::GCT_SAMPLER2D, "metalRoughnessSampler", mMRMapSamplerIndex);
      auto mrSample = psMain->resolveLocalParameter(Ogre::GCT_FLOAT4, "mrSample");
      // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
      // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
      fstage.sampleTexture(metalRoughnessSampler, psInTexcoord, mrSample);
      fstage.assign(Ogre::RTShader::In(mrSample).mask(Ogre::RTShader::Operand::OPM_YZ), mrparams);
      // Apply occlusion from 'r' channel
      // strange gltf texture are black on R channel when not using occlusion
      if(mUseOcclusion)
        fstage.mul(Ogre::RTShader::In(ambientColor).xyz(), Ogre::RTShader::In(mrSample).x(), Ogre::RTShader::Out(ambientColor).xyz());
    }
    else
    {
      auto specular = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_SURFACE_SPECULAR_COLOUR);
      fstage.assign(Ogre::RTShader::In(specular).xy(), mrparams);
    }
 
    auto pixelParams = psMain->resolveLocalStructParameter("PixelParams", "pixel");
 
    fstage.mul(Ogre::RTShader::In(diffuse).xyz(), Ogre::RTShader::In(outDiffuse).xyz(), Ogre::RTShader::Out(baseColor).xyz());
    fstage.assign(Ogre::Vector3(0), Ogre::RTShader::Out(outDiffuse).xyz());
    //use basecolor alpha and diffuse alpha
    fstage.mul(Ogre::RTShader::In(diffuse).w(), Ogre::RTShader::In(outDiffuse).w(), Ogre::RTShader::Out(outDiffuse).w());    
    fstage.callFunction("PBR_MakeParams", { Ogre::RTShader::In(baseColor).xyz(), Ogre::RTShader::In(mrparams), Ogre::RTShader::InOut(pixelParams) });
 
    fstage = psMain->getStage(Ogre::RTShader::FFP_PS_COLOUR_END + 60); // make gap to inject IBL here
    if (mLightCount > 0)
    {
      auto lightPos = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY, mLightCount);
      auto lightDiffuse = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY, mLightCount);
      auto pointParams = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_LIGHT_ATTENUATION_ARRAY, mLightCount);
      auto spotParams = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_SPOTLIGHT_PARAMS_ARRAY, mLightCount);
      auto lightDirView = psProgram->resolveParameter(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY, mLightCount);
 
      std::vector<Ogre::RTShader::Operand> params = { Ogre::RTShader::In(viewNormal),       Ogre::RTShader::In(viewPos),     Ogre::RTShader::In(ambientColor),          Ogre::RTShader::In(lightPos),
                                     Ogre::RTShader::In(lightDiffuse),     Ogre::RTShader::In(pointParams), Ogre::RTShader::In(lightDirView),      Ogre::RTShader::In(spotParams),
                                     Ogre::RTShader::In(pixelParams),      Ogre::RTShader::InOut(outDiffuse).xyz() };
 
      if (mLtcLUT1SamplerIndex > -1)
      {
        auto ltcLUT1 = psProgram->resolveParameter(Ogre::GCT_SAMPLER2D, "ltcLUT1Sampler", mLtcLUT1SamplerIndex);
        auto ltcLUT2 = psProgram->resolveParameter(Ogre::GCT_SAMPLER2D, "ltcLUT2Sampler", mLtcLUT1SamplerIndex + 1);
        params.insert(params.begin(), { Ogre::RTShader::In(ltcLUT1), Ogre::RTShader::In(ltcLUT2) });
        psProgram->addPreprocessorDefines("HAVE_AREA_LIGHTS");
      }
 
      if (auto shadowFactor = psMain->getLocalParameter("lShadowFactor"))
      {
        params.insert(params.begin(), Ogre::RTShader::In(shadowFactor));
      }
 
      fstage.callFunction("PBR_Lights", params);
    }
 
    return true;
  }
 
  //-----------------------------------------------------------------------
  void AdvancedCookTorranceLighting::copyFrom(const Ogre::RTShader::SubRenderState& rhs)
  {
    const AdvancedCookTorranceLighting& rhsLighting = static_cast<const AdvancedCookTorranceLighting&>(rhs);
    mMetalRoughnessMapName = rhsLighting.mMetalRoughnessMapName;
    mUseOcclusion = rhsLighting.mUseOcclusion;
    mLightCount = rhsLighting.mLightCount;
  }
 
  //-----------------------------------------------------------------------
  bool AdvancedCookTorranceLighting::preAddToRenderState(const Ogre::RTShader::RenderState* renderState, Ogre::Pass* srcPass, Ogre::Pass* dstPass)
  {
    if (!srcPass->getLightingEnabled())
      return false;
 
    mLightCount = renderState->getLightCount();
 
    if (renderState->haveAreaLights())
      mLtcLUT1SamplerIndex = Ogre::RTShader::ensureLtcLUTPresent(dstPass);
 
    if (mMetalRoughnessMapName.empty())
      return true;
 
    dstPass->createTextureUnitState(mMetalRoughnessMapName);
    mMRMapSamplerIndex = dstPass->getNumTextureUnitStates() - 1;
 
    return true;
  }
 
  bool AdvancedCookTorranceLighting::setParameter(const Ogre::String& name, const Ogre::String& value)
  {
    if (name == "texture" && !value.empty())
    {
      mMetalRoughnessMapName = value;
      return true;
    }
    else if (name == "occlusion" && !value.empty())
    {
      mUseOcclusion = (value == "ON" || value == "YES") ? true : false;
      return true;
    }
 
    return false;
  }
 
  //-----------------------------------------------------------------------
  const Ogre::String& AdvancedCookTorranceLightingFactory::getType() const { return SRS_ADV_COOK_TORRANCE_LIGHTING; }
 
  //-----------------------------------------------------------------------
  Ogre::RTShader::SubRenderState* AdvancedCookTorranceLightingFactory::createInstance(Ogre::ScriptCompiler* compiler, Ogre::PropertyAbstractNode* prop,
    Ogre::Pass* pass, Ogre::RTShader::SGScriptTranslator* translator)
  {
    if (prop->name == "lighting_stage" && prop->values.size() >= 1)
    {
      Ogre::String strValue;
      Ogre::AbstractNodeList::const_iterator it = prop->values.begin();
 
      // Read light model type.
      if ((*it++)->getString() != "metal_roughness")
        return NULL;
 
      auto subRenderState = createOrRetrieveInstance(translator);
 
      if (prop->values.size() < 3)
        return subRenderState;
 
      if ((*it++)->getString() != "texture")
      {
        compiler->addError(Ogre::ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line);
        return subRenderState;
      }
 
      if (!subRenderState->setParameter("texture", (*it++)->getString()))
        compiler->addError(Ogre::ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line);
 
      return subRenderState;
    }
 
    return NULL;
  }
 
  //-----------------------------------------------------------------------
  void AdvancedCookTorranceLightingFactory::writeInstance(Ogre::MaterialSerializer* ser, Ogre::RTShader::SubRenderState* subRenderState, Ogre::Pass* srcPass,
    Ogre::Pass* dstPass)
  {
    auto ctSubRenderState = static_cast<AdvancedCookTorranceLighting*>(subRenderState);
 
    ser->writeAttribute(4, "lighting_stage");
    ser->writeValue("metal_roughness");
    if (ctSubRenderState->getMetalRoughnessMapName().empty())
      return;
    ser->writeValue("texture");
    ser->writeValue(ctSubRenderState->getMetalRoughnessMapName());
  }
 
  //-----------------------------------------------------------------------
  Ogre::RTShader::SubRenderState* AdvancedCookTorranceLightingFactory::createInstanceImpl() { return OGRE_NEW AdvancedCookTorranceLighting; }
 
}