Multiple Light Terrain
This is a Terrain Material Generator that supports multiple point lights.
[+] .h File
Copy to clipboard
#ifndef __Ogre_TerrainMaterialGeneratorB_H__ #define __Ogre_TerrainMaterialGeneratorB_H__ #include <Terrain\OgreTerrainMaterialGenerator.h> #include <Terrain\OgreTerrainPrerequisites.h> #include <OgreGpuProgramParams.h> namespace Ogre { class PSSMShadowCameraSetup; /** \addtogroup Optional Components * @{ */ /** \addtogroup Terrain * Some details on the terrain component * @{ */ /** A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain. Supports 8 point lights and 1 directional light. @note Requires the Cg plugin to render correctly @note shader model 2 */ class TerrainMaterialGeneratorB : public TerrainMaterialGenerator { public: TerrainMaterialGeneratorB(); ~TerrainMaterialGeneratorB(); /** Shader model 2 profile target. */ class SM2Profile : public TerrainMaterialGenerator::Profile { public: SM2Profile(TerrainMaterialGenerator* parent, const String& name, const String& desc); ~SM2Profile(); bool isVertexCompressionSupported() const {return false;} MaterialPtr generate(const Terrain* terrain); MaterialPtr generateForCompositeMap(const Terrain* terrain); uint8 getMaxLayers(const Terrain* terrain) const; void updateParams(const MaterialPtr& mat, const Terrain* terrain); void updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain); void requestOptions(Terrain* terrain); void setShadowFar(float far); void setShadowFadeStart(float fadestart); /** Whether to support normal mapping per layer in the shader (default true). */ bool isLayerNormalMappingEnabled() const { return mLayerNormalMappingEnabled; } /** Whether to support normal mapping per layer in the shader (default true). */ void setLayerNormalMappingEnabled(bool enabled); /** Whether to support parallax mapping per layer in the shader (default true). */ bool isLayerParallaxMappingEnabled() const { return mLayerParallaxMappingEnabled; } /** Whether to support parallax mapping per layer in the shader (default true). */ void setLayerParallaxMappingEnabled(bool enabled); /** Whether to support specular mapping per layer in the shader (default true). */ bool isLayerSpecularMappingEnabled() const { return mLayerSpecularMappingEnabled; } /** Whether to support specular mapping per layer in the shader (default true). */ void setLayerSpecularMappingEnabled(bool enabled); /** Whether to support a global colour map over the terrain in the shader, if it's present (default true). */ bool isGlobalColourMapEnabled() const { return mGlobalColourMapEnabled; } /** Whether to support a global colour map over the terrain in the shader, if it's present (default true). */ void setGlobalColourMapEnabled(bool enabled); /** Whether to support a light map over the terrain in the shader, if it's present (default true). */ bool isLightmapEnabled() const { return mLightmapEnabled; } /** Whether to support a light map over the terrain in the shader, if it's present (default true). */ void setLightmapEnabled(bool enabled); /** Whether to use the composite map to provide a lower LOD technique in the distance (default true). */ bool isCompositeMapEnabled() const { return mCompositeMapEnabled; } /** Whether to use the composite map to provide a lower LOD technique in the distance (default true). */ void setCompositeMapEnabled(bool enabled); /** Whether to support dynamic texture shadows received from other objects, on the terrain (default true). */ bool getReceiveDynamicShadowsEnabled() const { return mReceiveDynamicShadows; } /** Whether to support dynamic texture shadows received from other objects, on the terrain (default true). */ void setReceiveDynamicShadowsEnabled(bool enabled); /** Whether to use PSSM support dynamic texture shadows, and if so the settings to use (default 0). */ void setReceiveDynamicShadowsPSSM(PSSMShadowCameraSetup* pssmSettings); /** Whether to use PSSM support dynamic texture shadows, and if so the settings to use (default 0). */ PSSMShadowCameraSetup* getReceiveDynamicShadowsPSSM() const { return mPSSM; } /** Whether to use depth shadows (default false). */ void setReceiveDynamicShadowsDepth(bool enabled); /** Whether to use depth shadows (default false). */ bool getReceiveDynamicShadowsDepth() const { return mDepthShadows; } /** Whether to use shadows on low LOD material rendering (when using composite map) (default false). */ void setReceiveDynamicShadowsLowLod(bool enabled); /** Whether to use shadows on low LOD material rendering (when using composite map) (default false). */ bool getReceiveDynamicShadowsLowLod() const { return mLowLodShadows; } int getNumberOfLightsSupported() const; /// Internal bool _isSM3Available() const { return mSM3Available; } protected: enum TechniqueType { HIGH_LOD, LOW_LOD, RENDER_COMPOSITE_MAP }; void addTechnique(const MaterialPtr& mat, const Terrain* terrain, TechniqueType tt); /// Interface definition for helper class to generate shaders class ShaderHelper : public TerrainAlloc { public: ShaderHelper() : mShadowSamplerStartHi(0), mShadowSamplerStartLo(0) {} virtual ~ShaderHelper() {} virtual HighLevelGpuProgramPtr generateVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); virtual HighLevelGpuProgramPtr generateFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); virtual void updateParams(const SM2Profile* prof, const MaterialPtr& mat, const Terrain* terrain, bool compositeMap); protected: virtual String getVertexProgramName(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); virtual String getFragmentProgramName(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); virtual HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) = 0; virtual HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) = 0; virtual void generateVertexProgramSource(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); virtual void generateFragmentProgramSource(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); virtual void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0; virtual void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0; virtual void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) = 0; virtual void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) = 0; virtual void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0; virtual void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0; virtual void defaultVpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog); virtual void defaultFpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog); virtual void updateVpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params); virtual void updateFpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params); static String getChannel(uint idx); size_t mShadowSamplerStartHi; size_t mShadowSamplerStartLo; }; /// Utility class to help with generating shaders for Cg / HLSL. class ShaderHelperCg : public ShaderHelper { protected: HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream); void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream); void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); uint generateVpDynamicShadowsParams(uint texCoordStart, const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateVpDynamicShadows(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateFpDynamicShadowsHelpers(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateFpDynamicShadowsParams(uint* texCoord, uint* sampler, const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); void generateFpDynamicShadows(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream); }; class ShaderHelperHLSL : public ShaderHelperCg { protected: HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); }; /// Utility class to help with generating shaders for GLSL. class ShaderHelperGLSL : public ShaderHelper { protected: HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt); void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {} void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {} void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) {} void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) {} void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {} void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {} }; ShaderHelper* mShaderGen; bool mLayerNormalMappingEnabled; bool mLayerParallaxMappingEnabled; bool mLayerSpecularMappingEnabled; bool mGlobalColourMapEnabled; bool mLightmapEnabled; bool mCompositeMapEnabled; bool mReceiveDynamicShadows; PSSMShadowCameraSetup* mPSSM; bool mDepthShadows; bool mLowLodShadows; bool mSM3Available; float mShadowFar; float mShadowFadeStart; bool isShadowingEnabled(TechniqueType tt, const Terrain* terrain) const; }; }; /** @} */ /** @} */ } #endif
[+] .cpp File
Copy to clipboard
#include "TerrainMaterialGeneratorB.h" #include <Terrain\OgreTerrain.h> #include <OgreMaterialManager.h> #include <OgreTechnique.h> #include <OgrePass.h> #include <OgreTextureUnitState.h> #include <OgreGpuProgramManager.h> #include <OgreHighLevelGpuProgramManager.h> #include <OgreHardwarePixelBuffer.h> #include <OgreShadowCameraSetupPSSM.h> namespace Ogre { //--------------------------------------------------------------------- TerrainMaterialGeneratorB::TerrainMaterialGeneratorB() { // define the layers // We expect terrain textures to have no alpha, so we use the alpha channel // in the albedo texture to store specular reflection // similarly we double-up the normal and height (for parallax) mLayerDecl.samplers.push_back(TerrainLayerSampler("albedo_specular", PF_BYTE_RGBA)); mLayerDecl.samplers.push_back(TerrainLayerSampler("normal_height", PF_BYTE_RGBA)); mLayerDecl.elements.push_back( TerrainLayerSamplerElement(0, TLSS_ALBEDO, 0, 3)); mLayerDecl.elements.push_back( TerrainLayerSamplerElement(0, TLSS_SPECULAR, 3, 1)); mLayerDecl.elements.push_back( TerrainLayerSamplerElement(1, TLSS_NORMAL, 0, 3)); mLayerDecl.elements.push_back( TerrainLayerSamplerElement(1, TLSS_HEIGHT, 3, 1)); mProfiles.push_back(OGRE_NEW SM2Profile(this, "SM2", "Profile for rendering on Shader Model 2 capable cards")); //! @todo - check hardware capabilities & use fallbacks if required (more profiles needed) setActiveProfile("SM2"); } //--------------------------------------------------------------------- TerrainMaterialGeneratorB::~TerrainMaterialGeneratorB() { } //--------------------------------------------------------------------- //--------------------------------------------------------------------- TerrainMaterialGeneratorB::SM2Profile::SM2Profile(TerrainMaterialGenerator* parent, const String& name, const String& desc) : Profile(parent, name, desc) , mShaderGen(0) , mLayerNormalMappingEnabled(true) , mLayerParallaxMappingEnabled(true) , mLayerSpecularMappingEnabled(true) , mGlobalColourMapEnabled(true) , mLightmapEnabled(true) , mCompositeMapEnabled(true) , mReceiveDynamicShadows(true) , mPSSM(0) , mDepthShadows(false) , mLowLodShadows(false) { } //--------------------------------------------------------------------- TerrainMaterialGeneratorB::SM2Profile::~SM2Profile() { OGRE_DELETE mShaderGen; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::requestOptions(Terrain* terrain) { terrain->_setMorphRequired(true); terrain->_setNormalMapRequired(true); terrain->_setLightMapRequired(mLightmapEnabled, true); terrain->_setCompositeMapRequired(mCompositeMapEnabled); } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setLayerNormalMappingEnabled(bool enabled) { if (enabled != mLayerNormalMappingEnabled) { mLayerNormalMappingEnabled = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setLayerParallaxMappingEnabled(bool enabled) { if (enabled != mLayerParallaxMappingEnabled) { mLayerParallaxMappingEnabled = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setLayerSpecularMappingEnabled(bool enabled) { if (enabled != mLayerSpecularMappingEnabled) { mLayerSpecularMappingEnabled = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setGlobalColourMapEnabled(bool enabled) { if (enabled != mGlobalColourMapEnabled) { mGlobalColourMapEnabled = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setLightmapEnabled(bool enabled) { if (enabled != mLightmapEnabled) { mLightmapEnabled = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setCompositeMapEnabled(bool enabled) { if (enabled != mCompositeMapEnabled) { mCompositeMapEnabled = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setReceiveDynamicShadowsEnabled(bool enabled) { if (enabled != mReceiveDynamicShadows) { mReceiveDynamicShadows = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setReceiveDynamicShadowsPSSM(PSSMShadowCameraSetup* pssmSettings) { if (pssmSettings != mPSSM) { mPSSM = pssmSettings; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setReceiveDynamicShadowsDepth(bool enabled) { if (enabled != mDepthShadows) { mDepthShadows = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::setReceiveDynamicShadowsLowLod(bool enabled) { if (enabled != mLowLodShadows) { mLowLodShadows = enabled; mParent->_markChanged(); } } //--------------------------------------------------------------------- uint8 TerrainMaterialGeneratorB::SM2Profile::getMaxLayers(const Terrain* terrain) const { // count the texture units free uint8 freeTextureUnits = 16; // lightmap --freeTextureUnits; // normalmap --freeTextureUnits; // colourmap if (terrain->getGlobalColourMapEnabled()) --freeTextureUnits; if (isShadowingEnabled(HIGH_LOD, terrain)) { uint numShadowTextures = 1; if (getReceiveDynamicShadowsPSSM()) { numShadowTextures = getReceiveDynamicShadowsPSSM()->getSplitCount(); } freeTextureUnits -= numShadowTextures; } // each layer needs 2.25 units (1xdiffusespec, 1xnormalheight, 0.25xblend) return static_cast<uint8>(freeTextureUnits / 2.25f); } //--------------------------------------------------------------------- //added to return 9 light total; 1 directional, 8 point int TerrainMaterialGeneratorB::SM2Profile::getNumberOfLightsSupported() const { return 9; } //--------------------------------------------------------------------- MaterialPtr TerrainMaterialGeneratorB::SM2Profile::generate(const Terrain* terrain) { // re-use old material if exists MaterialPtr mat = terrain->_getMaterial(); if (mat.isNull()) { MaterialManager& matMgr = MaterialManager::getSingleton(); // it's important that the names are deterministic for a given terrain, so // use the terrain pointer as an ID const String& matName = terrain->getMaterialName(); mat = matMgr.getByName(matName); if (mat.isNull()) { mat = matMgr.create(matName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); } } // clear everything mat->removeAllTechniques(); // Automatically disable normal & parallax mapping if card cannot handle it // We do this rather than having a specific technique for it since it's simpler GpuProgramManager& gmgr = GpuProgramManager::getSingleton(); if (!gmgr.isSyntaxSupported("ps_3_0") && !gmgr.isSyntaxSupported("ps_2_x") && !gmgr.isSyntaxSupported("fp40") && !gmgr.isSyntaxSupported("arbfp1")) { setLayerNormalMappingEnabled(false); setLayerParallaxMappingEnabled(false); } addTechnique(mat, terrain, HIGH_LOD); // LOD if(mCompositeMapEnabled) { addTechnique(mat, terrain, LOW_LOD); Material::LodValueList lodValues; lodValues.push_back(TerrainGlobalOptions::getSingleton().getCompositeMapDistance()); mat->setLodLevels(lodValues); Technique* lowLodTechnique = mat->getTechnique(1); lowLodTechnique->setLodIndex(1); } updateParams(mat, terrain); return mat; } //--------------------------------------------------------------------- MaterialPtr TerrainMaterialGeneratorB::SM2Profile::generateForCompositeMap(const Terrain* terrain) { // re-use old material if exists MaterialPtr mat = terrain->_getCompositeMapMaterial(); if (mat.isNull()) { MaterialManager& matMgr = MaterialManager::getSingleton(); // it's important that the names are deterministic for a given terrain, so // use the terrain pointer as an ID const String& matName = terrain->getMaterialName() + "/comp"; mat = matMgr.getByName(matName); if (mat.isNull()) { mat = matMgr.create(matName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); } } // clear everything mat->removeAllTechniques(); addTechnique(mat, terrain, RENDER_COMPOSITE_MAP); updateParamsForCompositeMap(mat, terrain); return mat; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::addTechnique( const MaterialPtr& mat, const Terrain* terrain, TechniqueType tt) { Technique* tech = mat->createTechnique(); // Only supporting one pass Pass* pass = tech->createPass(); GpuProgramManager& gmgr = GpuProgramManager::getSingleton(); HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton(); if (!mShaderGen) { bool check2x = mLayerNormalMappingEnabled || mLayerParallaxMappingEnabled; if (hmgr.isLanguageSupported("cg")) mShaderGen = OGRE_NEW ShaderHelperCg(); else if (hmgr.isLanguageSupported("hlsl") && ((check2x && gmgr.isSyntaxSupported("ps_2_x")) || (!check2x && gmgr.isSyntaxSupported("ps_2_0")))) mShaderGen = OGRE_NEW ShaderHelperHLSL(); else if (hmgr.isLanguageSupported("glsl")) mShaderGen = OGRE_NEW ShaderHelperGLSL(); else { // todo } // check SM3 features mSM3Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_3_0"); } HighLevelGpuProgramPtr vprog = mShaderGen->generateVertexProgram(this, terrain, tt); HighLevelGpuProgramPtr fprog = mShaderGen->generateFragmentProgram(this, terrain, tt); pass->setVertexProgram(vprog->getName()); pass->setFragmentProgram(fprog->getName()); if (tt == HIGH_LOD || tt == RENDER_COMPOSITE_MAP) { // global normal map TextureUnitState* tu = pass->createTextureUnitState(); tu->setTextureName(terrain->getTerrainNormalMap()->getName()); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); // global colour map if (terrain->getGlobalColourMapEnabled() && isGlobalColourMapEnabled()) { tu = pass->createTextureUnitState(terrain->getGlobalColourMap()->getName()); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); } // light map if (isLightmapEnabled()) { tu = pass->createTextureUnitState(terrain->getLightmap()->getName()); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); } // blend maps uint maxLayers = getMaxLayers(terrain); uint numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount()); uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount())); for (uint i = 0; i < numBlendTextures; ++i) { tu = pass->createTextureUnitState(terrain->getBlendTextureName(i)); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); } // layer textures for (uint i = 0; i < numLayers; ++i) { // diffuse / specular tu = pass->createTextureUnitState(terrain->getLayerTextureName(i, 0)); // normal / height tu = pass->createTextureUnitState(terrain->getLayerTextureName(i, 1)); } } else { // LOW_LOD textures // composite map TextureUnitState* tu = pass->createTextureUnitState(); tu->setTextureName(terrain->getCompositeMap()->getName()); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); // That's it! } // Add shadow textures (always at the end) if (isShadowingEnabled(tt, terrain)) { uint numTextures = 1; if (getReceiveDynamicShadowsPSSM()) { numTextures = getReceiveDynamicShadowsPSSM()->getSplitCount(); } for (uint i = 0; i < numTextures; ++i) { TextureUnitState* tu = pass->createTextureUnitState(); tu->setContentType(TextureUnitState::CONTENT_SHADOW); tu->setTextureAddressingMode(TextureUnitState::TAM_BORDER); tu->setTextureBorderColour(ColourValue::White); } } //! @todo caustics still don't work //! @todo maybe add optin to set here if(true) { TextureUnitState* tu = pass->createTextureUnitState(); tu->setAnimatedTextureName("Caustic.bmp",16,1.5); tu->setColourOperationEx(LayerBlendOperationEx::LBX_MODULATE,LayerBlendSource::LBS_CURRENT,LayerBlendSource::LBS_TEXTURE); tu->setTextureScale(0.1,0.1); } } //--------------------------------------------------------------------- bool TerrainMaterialGeneratorB::SM2Profile::isShadowingEnabled(TechniqueType tt, const Terrain* terrain) const { return getReceiveDynamicShadowsEnabled() && tt != RENDER_COMPOSITE_MAP && (tt != LOW_LOD || mLowLodShadows) && terrain->getSceneManager()->isShadowTechniqueTextureBased(); } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::updateParams(const MaterialPtr& mat, const Terrain* terrain) { mShaderGen->updateParams(this, mat, terrain, false); } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain) { mShaderGen->updateParams(this, mat, terrain, true); } //--------------------------------------------------------------------- //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::generateVertexProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramPtr ret = createVertexProgram(prof, terrain, tt); StringUtil::StrStreamType sourceStr; generateVertexProgramSource(prof, terrain, tt, sourceStr); ret->setSource(sourceStr.str()); ret->load(); defaultVpParams(prof, terrain, tt, ret); #if OGRE_DEBUG_MODE LogManager::getSingleton().stream(LML_TRIVIAL) << "*** Terrain Vertex Program: " << ret->getName() << " ***\n" << ret->getSource() << "\n*** ***"; #endif return ret; } //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::generateFragmentProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramPtr ret = createFragmentProgram(prof, terrain, tt); StringUtil::StrStreamType sourceStr; generateFragmentProgramSource(prof, terrain, tt, sourceStr); ret->setSource(sourceStr.str()); ret->load(); defaultFpParams(prof, terrain, tt, ret); #if OGRE_DEBUG_MODE LogManager::getSingleton().stream(LML_TRIVIAL) << "*** Terrain Fragment Program: " << ret->getName() << " ***\n" << ret->getSource() << "\n*** ***"; #endif return ret; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::generateVertexProgramSource( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { generateVpHeader(prof, terrain, tt, outStream); if (tt != LOW_LOD) { uint maxLayers = prof->getMaxLayers(terrain); uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount())); for (uint i = 0; i < numLayers; ++i) generateVpLayer(prof, terrain, tt, i, outStream); } generateVpFooter(prof, terrain, tt, outStream); } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::generateFragmentProgramSource( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { generateFpHeader(prof, terrain, tt, outStream); if (tt != LOW_LOD) { uint maxLayers = prof->getMaxLayers(terrain); uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount())); for (uint i = 0; i < numLayers; ++i) generateFpLayer(prof, terrain, tt, i, outStream); } generateFpFooter(prof, terrain, tt, outStream); } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::defaultVpParams( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog) { GpuProgramParametersSharedPtr params = prog->getDefaultParameters(); params->setIgnoreMissingParams(true); params->setNamedAutoConstant("worldMatrix", GpuProgramParameters::ACT_WORLD_MATRIX); params->setNamedAutoConstant("viewProjMatrix", GpuProgramParameters::ACT_VIEWPROJ_MATRIX); params->setNamedAutoConstant("lodMorph", GpuProgramParameters::ACT_CUSTOM, Terrain::LOD_MORPH_CUSTOM_PARAM); params->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS); if (prof->isShadowingEnabled(tt, terrain)) { uint numTextures = 1; if (prof->getReceiveDynamicShadowsPSSM()) { numTextures = prof->getReceiveDynamicShadowsPSSM()->getSplitCount(); } for (uint i = 0; i < numTextures; ++i) { params->setNamedAutoConstant("texViewProjMatrix" + StringConverter::toString(i), GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX, i); if (prof->getReceiveDynamicShadowsDepth()) { params->setNamedAutoConstant("depthRange" + StringConverter::toString(i), GpuProgramParameters::ACT_SHADOW_SCENE_DEPTH_RANGE, i); } } } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::defaultFpParams( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog) { GpuProgramParametersSharedPtr params = prog->getDefaultParameters(); params->setIgnoreMissingParams(true); params->setNamedAutoConstant("ambient", GpuProgramParameters::ACT_AMBIENT_LIGHT_COLOUR); // openMW MULTILIGHT for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) { params->setNamedAutoConstant("lightPosObjSpace"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE, i); params->setNamedAutoConstant("lightDiffuseColour"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR, i); if (i > 0) params->setNamedAutoConstant("lightAttenuation"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_ATTENUATION, i); if(i == 0) params->setNamedAutoConstant("lightSpecularColour", GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR, i); } //params->setNamedAutoConstant("lightPosObjSpace", GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE, 0); //params->setNamedAutoConstant("lightDiffuseColour", GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR, 0); //params->setNamedAutoConstant("lightSpecularColour", GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR, 0); params->setNamedAutoConstant("eyePosObjSpace", GpuProgramParameters::ACT_CAMERA_POSITION_OBJECT_SPACE); params->setNamedAutoConstant("fogColour", GpuProgramParameters::ACT_FOG_COLOUR); if (prof->isShadowingEnabled(tt, terrain)) { uint numTextures = 1; if (prof->getReceiveDynamicShadowsPSSM()) { PSSMShadowCameraSetup* pssm = prof->getReceiveDynamicShadowsPSSM(); numTextures = pssm->getSplitCount(); Vector4 splitPoints; const PSSMShadowCameraSetup::SplitPointList& splitPointList = pssm->getSplitPoints(); // Populate from split point 1, not 0, since split 0 isn't useful (usually 0) for (uint i = 1; i < numTextures; ++i) { splitPoints[i-1] = splitPointList[i]; } params->setNamedConstant("pssmSplitPoints", splitPoints); } if (prof->getReceiveDynamicShadowsDepth()) { size_t samplerOffset = (tt == HIGH_LOD) ? mShadowSamplerStartHi : mShadowSamplerStartLo; for (uint i = 0; i < numTextures; ++i) { params->setNamedAutoConstant("inverseShadowmapSize" + StringConverter::toString(i), GpuProgramParameters::ACT_INVERSE_TEXTURE_SIZE, i + samplerOffset); } } } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::updateParams( const SM2Profile* prof, const MaterialPtr& mat, const Terrain* terrain, bool compositeMap) { Pass* p = mat->getTechnique(0)->getPass(0); if (compositeMap) { updateVpParams(prof, terrain, RENDER_COMPOSITE_MAP, p->getVertexProgramParameters()); updateFpParams(prof, terrain, RENDER_COMPOSITE_MAP, p->getFragmentProgramParameters()); } else { // high lod updateVpParams(prof, terrain, HIGH_LOD, p->getVertexProgramParameters()); updateFpParams(prof, terrain, HIGH_LOD, p->getFragmentProgramParameters()); if(prof->isCompositeMapEnabled()) { // low lod p = mat->getTechnique(1)->getPass(0); updateVpParams(prof, terrain, LOW_LOD, p->getVertexProgramParameters()); updateFpParams(prof, terrain, LOW_LOD, p->getFragmentProgramParameters()); } } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::updateVpParams( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params) { params->setIgnoreMissingParams(true); uint maxLayers = prof->getMaxLayers(terrain); uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount())); uint numUVMul = numLayers / 4; if (numLayers % 4) ++numUVMul; for (uint i = 0; i < numUVMul; ++i) { Vector4 uvMul( terrain->getLayerUVMultiplier(i * 4), terrain->getLayerUVMultiplier(i * 4 + 1), terrain->getLayerUVMultiplier(i * 4 + 2), terrain->getLayerUVMultiplier(i * 4 + 3) ); params->setNamedConstant("uvMul" + StringConverter::toString(i), uvMul); } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::updateFpParams( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params) { params->setIgnoreMissingParams(true); // TODO - parameterise this? Vector4 scaleBiasSpecular(0.03, -0.04, 32, 0.5); params->setNamedConstant("scaleBiasSpecular", scaleBiasSpecular); } //--------------------------------------------------------------------- String TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::getChannel(uint idx) { uint rem = idx % 4; switch(rem) { case 0: default: return "r"; case 1: return "g"; case 2: return "b"; case 3: return "a"; }; } //--------------------------------------------------------------------- String TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::getVertexProgramName( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { String progName = terrain->getMaterialName() + "/sm2/vp"; switch(tt) { case HIGH_LOD: progName += "/hlod"; break; case LOW_LOD: progName += "/llod"; break; case RENDER_COMPOSITE_MAP: progName += "/comp"; break; } return progName; } //--------------------------------------------------------------------- String TerrainMaterialGeneratorB::SM2Profile::ShaderHelper::getFragmentProgramName( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { String progName = terrain->getMaterialName() + "/sm2/fp"; switch(tt) { case HIGH_LOD: progName += "/hlod"; break; case LOW_LOD: progName += "/llod"; break; case RENDER_COMPOSITE_MAP: progName += "/comp"; break; } return progName; } //--------------------------------------------------------------------- //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::createVertexProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton(); String progName = getVertexProgramName(prof, terrain, tt); HighLevelGpuProgramPtr ret = mgr.getByName(progName); if (ret.isNull()) { ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_VERTEX_PROGRAM); } else { ret->unload(); } ret->setParameter("profiles", "vs_3_0 vs_2_0 arbvp1"); ret->setParameter("entry_point", "main_vp"); return ret; } //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::createFragmentProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton(); String progName = getFragmentProgramName(prof, terrain, tt); HighLevelGpuProgramPtr ret = mgr.getByName(progName); if (ret.isNull()) { ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_FRAGMENT_PROGRAM); } else { ret->unload(); } if(prof->isLayerNormalMappingEnabled() || prof->isLayerParallaxMappingEnabled()) ret->setParameter("profiles", "ps_3_0 ps_2_x fp40 arbfp1"); else ret->setParameter("profiles", "ps_3_0 ps_2_0 fp30 arbfp1"); ret->setParameter("entry_point", "main_fp"); return ret; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateVpHeader( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { outStream << "void main_vp(\n" "float4 pos : POSITION,\n" "float2 uv : TEXCOORD0,\n"; if (tt != RENDER_COMPOSITE_MAP) outStream << "float2 delta : TEXCOORD1,\n"; // lodDelta, lodThreshold outStream << "uniform float4x4 worldMatrix,\n" "uniform float4x4 viewProjMatrix,\n" "uniform float2 lodMorph,\n"; // morph amount, morph LOD target // uv multipliers uint maxLayers = prof->getMaxLayers(terrain); uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount())); uint numUVMultipliers = (numLayers / 4); if (numLayers % 4) ++numUVMultipliers; for (uint i = 0; i < numUVMultipliers; ++i) outStream << "uniform float4 uvMul" << i << ", \n"; outStream << "out float4 oPos : POSITION,\n" "out float4 oPosObj : TEXCOORD0 \n"; uint texCoordSet = 1; outStream << ", out float4 oUVMisc : TEXCOORD" << texCoordSet++ <<" // xy = uv, z = camDepth\n"; // layer UV's premultiplied, packed as xy/zw uint numUVSets = numLayers / 2; if (numLayers % 2) ++numUVSets; if (tt != LOW_LOD) { for (uint i = 0; i < numUVSets; ++i) { outStream << ", out float4 oUV" << i << " : TEXCOORD" << texCoordSet++ << "\n"; } } if (prof->getParent()->getDebugLevel() && tt != RENDER_COMPOSITE_MAP) { outStream << ", out float2 lodInfo : TEXCOORD" << texCoordSet++ << "\n"; } bool fog = terrain->getSceneManager()->getFogMode() != FOG_NONE && tt != RENDER_COMPOSITE_MAP; if (fog) { outStream << ", uniform float4 fogParams\n" ", out float fogVal : COLOR\n"; } if (prof->isShadowingEnabled(tt, terrain)) { texCoordSet = generateVpDynamicShadowsParams(texCoordSet, prof, terrain, tt, outStream); } // check we haven't exceeded texture coordinates if (texCoordSet > 8) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Requested options require too many texture coordinate sets! Try reducing the number of layers.", __FUNCTION__); } outStream << ")\n" "{\n" " float4 worldPos = mul(worldMatrix, pos);\n" " oPosObj = pos;\n"; if (tt != RENDER_COMPOSITE_MAP) { // determine whether to apply the LOD morph to this vertex // we store the deltas against all vertices so we only want to apply // the morph to the ones which would disappear. The target LOD which is // being morphed to is stored in lodMorph.y, and the LOD at which // the vertex should be morphed is stored in uv.w. If we subtract // the former from the latter, and arrange to only morph if the // result is negative (it will only be -1 in fact, since after that // the vertex will never be indexed), we will achieve our aim. // sign(vertexLOD - targetLOD) == -1 is to morph outStream << " float toMorph = -min(0, sign(delta.y - lodMorph.y));\n"; // this will either be 1 (morph) or 0 (don't morph) if (prof->getParent()->getDebugLevel()) { // x == LOD level (-1 since value is target level, we want to display actual) outStream << "lodInfo.x = (lodMorph.y - 1) / " << terrain->getNumLodLevels() << ";\n"; // y == LOD morph outStream << "lodInfo.y = toMorph * lodMorph.x;\n"; } // morph switch (terrain->getAlignment()) { case Terrain::ALIGN_X_Y: outStream << " worldPos.z += delta.x * toMorph * lodMorph.x;\n"; break; case Terrain::ALIGN_X_Z: outStream << " worldPos.y += delta.x * toMorph * lodMorph.x;\n"; break; case Terrain::ALIGN_Y_Z: outStream << " worldPos.x += delta.x * toMorph * lodMorph.x;\n"; break; }; } // generate UVs if (tt != LOW_LOD) { for (uint i = 0; i < numUVSets; ++i) { uint layer = i * 2; uint uvMulIdx = layer / 4; outStream << " oUV" << i << ".xy = " << " uv.xy * uvMul" << uvMulIdx << "." << getChannel(layer) << ";\n"; outStream << " oUV" << i << ".zw = " << " uv.xy * uvMul" << uvMulIdx << "." << getChannel(layer+1) << ";\n"; } } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateFpHeader( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { // Main header outStream << // helpers "float4 expand(float4 v)\n" "{ \n" " return v * 2 - 1;\n" "}\n\n\n"; if (prof->isShadowingEnabled(tt, terrain)) generateFpDynamicShadowsHelpers(prof, terrain, tt, outStream); outStream << "float4 main_fp(\n" "float4 position : TEXCOORD0,\n"; uint texCoordSet = 1; outStream << "float4 uvMisc : TEXCOORD" << texCoordSet++ << ",\n"; // UV's premultiplied, packed as xy/zw uint maxLayers = prof->getMaxLayers(terrain); uint numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount()); uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount())); uint numUVSets = numLayers / 2; if (numLayers % 2) ++numUVSets; if (tt != LOW_LOD) { for (uint i = 0; i < numUVSets; ++i) { outStream << "float4 layerUV" << i << " : TEXCOORD" << texCoordSet++ << ", \n"; } } if (prof->getParent()->getDebugLevel() && tt != RENDER_COMPOSITE_MAP) { outStream << "float2 lodInfo : TEXCOORD" << texCoordSet++ << ", \n"; } bool fog = terrain->getSceneManager()->getFogMode() != FOG_NONE && tt != RENDER_COMPOSITE_MAP; if (fog) { outStream << "uniform float3 fogColour, \n" "float fogVal : COLOR,\n"; } uint currentSamplerIdx = 0; outStream << // Only 1 light supported in this version // deferred shading profile / generator later, ok? :) "uniform float3 ambient,\n"; //MULTILIGHT for loop num lights here //"uniform float4 lightPosObjSpace,\n" //"uniform float3 lightDiffuseColour,\n" //"uniform float3 lightSpecularColour,\n" //openmw adds attenuation for num light - 9 lights here; probly one directional light all more pont lights //en here //openmw multi for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) { outStream << "uniform float4 lightPosObjSpace"<<i<<",\n" "uniform float3 lightDiffuseColour"<<i<<",\n" //"uniform float3 lightSpecularColour"<<i<<",\n" ; if(i == 0) outStream << "uniform float3 lightSpecularColour,\n"; if (i > 0) outStream << "uniform float4 lightAttenuation"<<i<<",\n"; } outStream << "uniform float3 eyePosObjSpace,\n" // pack scale, bias and specular "uniform float4 scaleBiasSpecular,\n"; if (tt == LOW_LOD) { // single composite map covers all the others below outStream << "uniform sampler2D compositeMap : register(s" << currentSamplerIdx++ << ")\n"; } else { outStream << "uniform sampler2D globalNormal : register(s" << currentSamplerIdx++ << ")\n"; if (terrain->getGlobalColourMapEnabled() && prof->isGlobalColourMapEnabled()) { outStream << ", uniform sampler2D globalColourMap : register(s" << currentSamplerIdx++ << ")\n"; } if (prof->isLightmapEnabled()) { outStream << ", uniform sampler2D lightMap : register(s" << currentSamplerIdx++ << ")\n"; } // Blend textures - sampler definitions for (uint i = 0; i < numBlendTextures; ++i) { outStream << ", uniform sampler2D blendTex" << i << " : register(s" << currentSamplerIdx++ << ")\n"; } // Layer textures - sampler definitions & UV multipliers for (uint i = 0; i < numLayers; ++i) { outStream << ", uniform sampler2D difftex" << i << " : register(s" << currentSamplerIdx++ << ")\n"; outStream << ", uniform sampler2D normtex" << i << " : register(s" << currentSamplerIdx++ << ")\n"; } } if (prof->isShadowingEnabled(tt, terrain)) { generateFpDynamicShadowsParams(&texCoordSet, ¤tSamplerIdx, prof, terrain, tt, outStream); } // check we haven't exceeded samplers if (currentSamplerIdx > 16) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Requested options require too many texture samplers! Try reducing the number of layers.", __FUNCTION__); } outStream << ") : COLOR\n" "{\n" " float4 outputCol;\n" " float shadow = 1.0;\n" " float2 uv = uvMisc.xy;\n" // base colour " outputCol = float4(0,0,0,1);\n"; if (tt != LOW_LOD) { outStream << // global normal " float3 normal = expand(tex2D(globalNormal, uv)).rgb;\n"; } // openMW MULTILIAGHT for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " float3 lightDir"<<i<<" = \n" " lightPosObjSpace"<<i<<".xyz - (position.xyz * lightPosObjSpace"<<i<<".w);\n"; //outStream << // " float3 lightDir = \n" // " lightPosObjSpace.xyz - (position.xyz * lightPosObjSpace.w);\n"; outStream << " float3 eyeDir = eyePosObjSpace - position.xyz;\n" // set up accumulation areas " float3 diffuse = float3(0,0,0);\n" " float specular = 0;\n"; if (tt == LOW_LOD) { // we just do a single calculation from composite map outStream << " float4 composite = tex2D(compositeMap, uv);\n" " diffuse = composite.rgb;\n"; // TODO - specular; we'll need normals for this! } else { // set up the blend values for (uint i = 0; i < numBlendTextures; ++i) { outStream << " float4 blendTexVal" << i << " = tex2D(blendTex" << i << ", uv);\n"; } if (prof->isLayerNormalMappingEnabled()) { // derive the tangent space basis // we do this in the pixel shader because we don't have per-vertex normals // because of the LOD, we use a normal map // tangent is always +x or -z in object space depending on alignment switch(terrain->getAlignment()) { case Terrain::ALIGN_X_Y: case Terrain::ALIGN_X_Z: outStream << " float3 tangent = float3(1, 0, 0);\n"; break; case Terrain::ALIGN_Y_Z: outStream << " float3 tangent = float3(0, 0, -1);\n"; break; }; outStream << " float3 binormal = normalize(cross(tangent, normal));\n"; // note, now we need to re-cross to derive tangent again because it wasn't orthonormal outStream << " tangent = normalize(cross(normal, binormal));\n"; // derive final matrix outStream << " float3x3 TBN = float3x3(tangent, binormal, normal);\n"; // set up lighting result placeholders for interpolation outStream << " float4 litRes, litResLayer;\n"; for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " float4 litResLayer"<<i<<";\n"; //outStream << " float3 TSlightDir;\n"; //outStream << " float3 TShalfAngle;\n"; for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " float3 TShalfAngle"<<i<<";\n"; outStream << " float3 TSeyeDir, TSnormal;\n"; if (prof->isLayerParallaxMappingEnabled()) outStream << " float displacement;\n"; // move //outStream << " TSlightDir = normalize(mul(TBN, lightDir));\n"; outStream << " TSeyeDir = normalize(mul(TBN, eyeDir));\n"; //init litRes<i> vars if (prof->getNumberOfLightsSupported() > 1) outStream << "float d; \n" "float attn; \n"; outStream << " eyeDir = normalize(eyeDir); \n"; // simple per-pixel lighting with no normal mapping for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) { outStream << " float4 litRes"<<i<<" = lit(dot(normalize(lightDir"<<i<<"), normalize(normal)), dot(normalize(lightDir"<<i<<"+eyeDir),normalize(normal)), scaleBiasSpecular.z);\n"; outStream << " float3 TSlightDir"<<i<<" = normalize(mul(TBN, lightDir"<<i<<"));\n"; if (i > 0) outStream << // pre-multiply light color with attenuation factor "d = length( lightDir"<<i<<" ); \n" "attn = ( 1.0 / (( lightAttenuation"<<i<<".y ) + ( lightAttenuation"<<i<<".z * d ) + ( lightAttenuation"<<i<<".w * d * d ))); \n" "lightDiffuseColour"<<i<<" *= attn; \n"; } //init litRes<i> vars END } else { // openMW MULTILIGHT if (prof->getNumberOfLightsSupported() > 1) outStream << "float d; \n" "float attn; \n"; outStream << " eyeDir = normalize(eyeDir); \n"; // simple per-pixel lighting with no normal mapping for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) { outStream << //" float4 litRes"<<i<<" = lit(dot(normalize(lightDir"<<i<<"), normalize(normal)), 0, scaleBiasSpecular.z);\n"; " float4 litRes"<<i<<" = lit(dot(normalize(lightDir"<<i<<"), normalize(normal)), dot(normalize(lightDir"<<i<<"+eyeDir),normalize(normal)), scaleBiasSpecular.z);\n"; if (i > 0) outStream << // pre-multiply light color with attenuation factor "d = length( lightDir"<<i<<" ); \n" "attn = ( 1.0 / (( lightAttenuation"<<i<<".y ) + ( lightAttenuation"<<i<<".z * d ) + ( lightAttenuation"<<i<<".w * d * d ))); \n" "lightDiffuseColour"<<i<<" *= attn; \n"; } // simple per-pixel lighting with no normal mapping //outStream << " lightDir = normalize(lightDir);\n"; //outStream << " eyeDir = normalize(eyeDir);\n"; //outStream << " float3 halfAngle = normalize(lightDir + eyeDir);\n"; //outStream << " float4 litRes = lit(dot(lightDir, normal), dot(halfAngle, normal), scaleBiasSpecular.z);\n"; } } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateVpLayer( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) { // nothing to do } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateFpLayer( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) { uint uvIdx = layer / 2; String uvChannels = layer % 2 ? ".zw" : ".xy"; uint blendIdx = (layer-1) / 4; String blendChannel = getChannel(layer-1); String blendWeightStr = String("blendTexVal") + StringConverter::toString(blendIdx) + "." + blendChannel; // generate early-out conditional /* Disable - causing some issues even when trying to force the use of texldd if (layer && prof->_isSM3Available()) outStream << " if (" << blendWeightStr << " > 0.0003)\n { \n"; */ // generate UV outStream << " float2 uv" << layer << " = layerUV" << uvIdx << uvChannels << ";\n"; // calculate lighting here if normal mapping if (prof->isLayerNormalMappingEnabled()) { if (prof->isLayerParallaxMappingEnabled() && tt != RENDER_COMPOSITE_MAP) { // modify UV - note we have to sample an extra time outStream << " displacement = tex2D(normtex" << layer << ", uv" << layer << ").a\n" " * scaleBiasSpecular.x + scaleBiasSpecular.y;\n"; outStream << " uv" << layer << " += TSeyeDir.xy * displacement;\n"; } // access TS normal map outStream << " TSnormal = expand(tex2D(normtex" << layer << ", uv" << layer << ")).rgb;\n"; //outStream << " TShalfAngle = normalize(TSlightDir + TSeyeDir);\n"; for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " TShalfAngle"<<i<<"= normalize(TSlightDir"<<i<<" + TSeyeDir);\n"; for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " litResLayer"<<i<<" = lit(dot(TSlightDir"<<i<<", TSnormal), dot(TShalfAngle"<<i<<", TSnormal), scaleBiasSpecular.z);\n"; if (!layer) { for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " litRes"<<i<<" = litResLayer"<<i<<";\n"; } else { for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) outStream << " litRes"<<i<<" = lerp(litRes"<<i<<", litResLayer"<<i<<", " << blendWeightStr << ");\n"; } } // sample diffuse texture outStream << " float4 diffuseSpecTex" << layer << " = tex2D(difftex" << layer << ", uv" << layer << ");\n"; // apply to common if (!layer) { outStream << " diffuse = diffuseSpecTex0.rgb;\n"; if (prof->isLayerSpecularMappingEnabled()) outStream << " specular = diffuseSpecTex0.a;\n"; } else { outStream << " diffuse = lerp(diffuse, diffuseSpecTex" << layer << ".rgb, " << blendWeightStr << ");\n"; if (prof->isLayerSpecularMappingEnabled()) outStream << " specular = lerp(specular, diffuseSpecTex" << layer << ".a, " << blendWeightStr << ");\n"; } // End early-out /* Disable - causing some issues even when trying to force the use of texldd if (layer && prof->_isSM3Available()) outStream << " } // early-out blend value\n"; */ } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateVpFooter( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { outStream << " oPos = mul(viewProjMatrix, worldPos);\n" " oUVMisc.xy = uv.xy;\n"; bool fog = terrain->getSceneManager()->getFogMode() != FOG_NONE && tt != RENDER_COMPOSITE_MAP; if (fog) { if (terrain->getSceneManager()->getFogMode() == FOG_LINEAR) { outStream << " fogVal = saturate((oPos.z - fogParams.y) * fogParams.w);\n"; } else { outStream << " fogVal = saturate(1 / (exp(oPos.z * fogParams.x)));\n"; } } if (prof->isShadowingEnabled(tt, terrain)) generateVpDynamicShadows(prof, terrain, tt, outStream); outStream << "}\n"; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateFpFooter( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { if (tt == LOW_LOD) { if (prof->isShadowingEnabled(tt, terrain)) { generateFpDynamicShadows(prof, terrain, tt, outStream); outStream << " outputCol.rgb = diffuse * rtshadow;\n"; } else { outStream << " outputCol.rgb = diffuse;\n"; } } else { if (terrain->getGlobalColourMapEnabled() && prof->isGlobalColourMapEnabled()) { // sample colour map and apply to diffuse outStream << " diffuse *= tex2D(globalColourMap, uv).rgb;\n"; } if (prof->isLightmapEnabled()) { // sample lightmap outStream << " shadow = tex2D(lightMap, uv).r;\n"; } if (prof->isShadowingEnabled(tt, terrain)) { generateFpDynamicShadows(prof, terrain, tt, outStream); } // diffuse lighting //outStream << " outputCol.rgb += ambient * diffuse + litRes.y * lightDiffuseColour * diffuse * shadow;\n"; //openMW MULTILIGHT outStream << " outputCol.rgb += ambient * diffuse; \n"; // diffuse lighting for (int i=0; i<prof->getNumberOfLightsSupported(); ++i) { // shadows only for first light (directional) if (i==0) outStream << " outputCol.rgb += litRes"<<i<<".y * lightDiffuseColour"<<i<<" * diffuse * shadow;\n"; else outStream << " outputCol.rgb += litRes"<<i<<".y * lightDiffuseColour"<<i<<" * diffuse;\n"; } // specular default if (!prof->isLayerSpecularMappingEnabled()) outStream << " specular = 1.0;\n"; if (tt == RENDER_COMPOSITE_MAP) { // Lighting embedded in alpha outStream << " outputCol.a = shadow;\n"; } else { // Apply specular outStream << " outputCol.rgb += litRes0.z * lightSpecularColour * specular * shadow;\n"; if (prof->getParent()->getDebugLevel()) { outStream << " outputCol.rg += lodInfo.xy;\n"; } } } bool fog = terrain->getSceneManager()->getFogMode() != FOG_NONE && tt != RENDER_COMPOSITE_MAP; if (fog) { outStream << " outputCol.rgb = lerp(outputCol.rgb, fogColour, fogVal);\n"; } // Final return outStream << " return outputCol;\n" << "}\n"; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateFpDynamicShadowsHelpers( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { // TODO make filtering configurable outStream << "// Simple PCF \n" "// Number of samples in one dimension (square for total samples) \n" "#define NUM_SHADOW_SAMPLES_1D 2.0 \n" "#define SHADOW_FILTER_SCALE 1 \n" "#define SHADOW_SAMPLES NUM_SHADOW_SAMPLES_1D*NUM_SHADOW_SAMPLES_1D \n" "float4 offsetSample(float4 uv, float2 offset, float invMapSize) \n" "{ \n" " return float4(uv.xy + offset * invMapSize * uv.w, uv.z, uv.w); \n" "} \n"; if (prof->getReceiveDynamicShadowsDepth()) { outStream << "float calcDepthShadow(sampler2D shadowMap, float4 uv, float invShadowMapSize) \n" "{ \n" " // 4-sample PCF \n" " float shadow = 0.0; \n" " float offset = (NUM_SHADOW_SAMPLES_1D/2 - 0.5) * SHADOW_FILTER_SCALE; \n" " for (float y = -offset; y <= offset; y += SHADOW_FILTER_SCALE) \n" " for (float x = -offset; x <= offset; x += SHADOW_FILTER_SCALE) \n" " { \n" " float4 newUV = offsetSample(uv, float2(x, y), invShadowMapSize);\n" " // manually project and assign derivatives \n" " // to avoid gradient issues inside loops \n" " newUV = newUV / newUV.w; \n" " float depth = tex2D(shadowMap, newUV.xy, 1, 1).x; \n" " if (depth >= 1 || depth >= uv.z)\n" " shadow += 1.0;\n" " } \n" " shadow /= SHADOW_SAMPLES; \n" " return shadow; \n" "} \n"; } else { outStream << "float calcSimpleShadow(sampler2D shadowMap, float4 shadowMapPos) \n" "{ \n" " return tex2Dproj(shadowMap, shadowMapPos).x; \n" "} \n"; } if (prof->getReceiveDynamicShadowsPSSM()) { uint numTextures = prof->getReceiveDynamicShadowsPSSM()->getSplitCount(); if (prof->getReceiveDynamicShadowsDepth()) { outStream << "float calcPSSMDepthShadow("; } else { outStream << "float calcPSSMSimpleShadow("; } outStream << "\n "; for (uint i = 0; i < numTextures; ++i) outStream << "sampler2D shadowMap" << i << ", "; outStream << "\n "; for (uint i = 0; i < numTextures; ++i) outStream << "float4 lsPos" << i << ", "; if (prof->getReceiveDynamicShadowsDepth()) { outStream << "\n "; for (uint i = 0; i < numTextures; ++i) outStream << "float invShadowmapSize" << i << ", "; } outStream << "\n" " float4 pssmSplitPoints, float camDepth) \n" "{ \n" " float shadow; \n" " // calculate shadow \n"; for (uint i = 0; i < numTextures; ++i) { if (!i) outStream << " if (camDepth <= pssmSplitPoints." << ShaderHelper::getChannel(i) << ") \n"; else if (i < numTextures - 1) outStream << " else if (camDepth <= pssmSplitPoints." << ShaderHelper::getChannel(i) << ") \n"; else outStream << " else \n"; outStream << " { \n"; if (prof->getReceiveDynamicShadowsDepth()) { outStream << " shadow = calcDepthShadow(shadowMap" << i << ", lsPos" << i << ", invShadowmapSize" << i << "); \n"; } else { outStream << " shadow = calcSimpleShadow(shadowMap" << i << ", lsPos" << i << "); \n"; } outStream << " } \n"; } outStream << " return shadow; \n" "} \n\n\n"; } } //--------------------------------------------------------------------- uint TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateVpDynamicShadowsParams( uint texCoord, const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { // out semantics & params uint numTextures = 1; if (prof->getReceiveDynamicShadowsPSSM()) { numTextures = prof->getReceiveDynamicShadowsPSSM()->getSplitCount(); } for (uint i = 0; i < numTextures; ++i) { outStream << ", out float4 oLightSpacePos" << i << " : TEXCOORD" << texCoord++ << " \n" << ", uniform float4x4 texViewProjMatrix" << i << " \n"; if (prof->getReceiveDynamicShadowsDepth()) { outStream << ", uniform float4 depthRange" << i << " // x = min, y = max, z = range, w = 1/range \n"; } } return texCoord; } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateVpDynamicShadows( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { uint numTextures = 1; if (prof->getReceiveDynamicShadowsPSSM()) { numTextures = prof->getReceiveDynamicShadowsPSSM()->getSplitCount(); } // Calculate the position of vertex in light space for (uint i = 0; i < numTextures; ++i) { outStream << " oLightSpacePos" << i << " = mul(texViewProjMatrix" << i << ", worldPos); \n"; if (prof->getReceiveDynamicShadowsDepth()) { // make linear outStream << "oLightSpacePos" << i << ".z = (oLightSpacePos" << i << ".z - depthRange" << i << ".x) * depthRange" << i << ".w;\n"; } } if (prof->getReceiveDynamicShadowsPSSM()) { outStream << " // pass cam depth\n" " oUVMisc.z = oPos.z;\n"; } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateFpDynamicShadowsParams( uint* texCoord, uint* sampler, const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { if (tt == HIGH_LOD) mShadowSamplerStartHi = *sampler; else if (tt == LOW_LOD) mShadowSamplerStartLo = *sampler; // in semantics & params uint numTextures = 1; if (prof->getReceiveDynamicShadowsPSSM()) { numTextures = prof->getReceiveDynamicShadowsPSSM()->getSplitCount(); outStream << ", uniform float4 pssmSplitPoints \n"; } for (uint i = 0; i < numTextures; ++i) { outStream << ", float4 lightSpacePos" << i << " : TEXCOORD" << *texCoord << " \n" << ", uniform sampler2D shadowMap" << i << " : register(s" << *sampler << ") \n"; *sampler = *sampler + 1; *texCoord = *texCoord + 1; if (prof->getReceiveDynamicShadowsDepth()) { outStream << ", uniform float inverseShadowmapSize" << i << " \n"; } } } //--------------------------------------------------------------------- void TerrainMaterialGeneratorB::SM2Profile::ShaderHelperCg::generateFpDynamicShadows( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) { if (prof->getReceiveDynamicShadowsPSSM()) { uint numTextures = prof->getReceiveDynamicShadowsPSSM()->getSplitCount(); outStream << " float camDepth = uvMisc.z;\n"; if (prof->getReceiveDynamicShadowsDepth()) { outStream << " float rtshadow = calcPSSMDepthShadow("; } else { outStream << " float rtshadow = calcPSSMSimpleShadow("; } for (uint i = 0; i < numTextures; ++i) outStream << "shadowMap" << i << ", "; outStream << "\n "; for (uint i = 0; i < numTextures; ++i) outStream << "lightSpacePos" << i << ", "; if (prof->getReceiveDynamicShadowsDepth()) { outStream << "\n "; for (uint i = 0; i < numTextures; ++i) outStream << "inverseShadowmapSize" << i << ", "; } outStream << "\n" << " pssmSplitPoints, camDepth);\n"; } else { if (prof->getReceiveDynamicShadowsDepth()) { outStream << " float rtshadow = calcDepthShadow(shadowMap0, lightSpacePos0, inverseShadowmapSize0);"; } else { outStream << " float rtshadow = calcSimpleShadow(shadowMap0, lightSpacePos0);"; } } outStream << " shadow = min(shadow, rtshadow);\n"; } //--------------------------------------------------------------------- //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelperHLSL::createVertexProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton(); String progName = getVertexProgramName(prof, terrain, tt); HighLevelGpuProgramPtr ret = mgr.getByName(progName); if (ret.isNull()) { ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "hlsl", GPT_VERTEX_PROGRAM); } else { ret->unload(); } if (prof->_isSM3Available()) ret->setParameter("target", "vs_3_0"); else ret->setParameter("target", "vs_2_0"); ret->setParameter("entry_point", "main_vp"); return ret; } //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelperHLSL::createFragmentProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton(); String progName = getFragmentProgramName(prof, terrain, tt); HighLevelGpuProgramPtr ret = mgr.getByName(progName); if (ret.isNull()) { ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "hlsl", GPT_FRAGMENT_PROGRAM); } else { ret->unload(); } if (prof->_isSM3Available()) ret->setParameter("target", "ps_3_0"); else ret->setParameter("target", "ps_2_x"); ret->setParameter("entry_point", "main_fp"); return ret; } //--------------------------------------------------------------------- //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelperGLSL::createVertexProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton(); String progName = getVertexProgramName(prof, terrain, tt); switch(tt) { case HIGH_LOD: progName += "/hlod"; break; case LOW_LOD: progName += "/llod"; break; case RENDER_COMPOSITE_MAP: progName += "/comp"; break; } HighLevelGpuProgramPtr ret = mgr.getByName(progName); if (ret.isNull()) { ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "glsl", GPT_VERTEX_PROGRAM); } else { ret->unload(); } return ret; } //--------------------------------------------------------------------- HighLevelGpuProgramPtr TerrainMaterialGeneratorB::SM2Profile::ShaderHelperGLSL::createFragmentProgram( const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) { HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton(); String progName = getFragmentProgramName(prof, terrain, tt); HighLevelGpuProgramPtr ret = mgr.getByName(progName); if (ret.isNull()) { ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "glsl", GPT_FRAGMENT_PROGRAM); } else { ret->unload(); } return ret; } }
Use
To enable it do this when you make your terrain:
Copy to clipboard
Ogre::TerrainMaterialGeneratorPtr matGen; Ogre::TerrainMaterialGeneratorB* matGenP = new Ogre::TerrainMaterialGeneratorB(); matGen.bind(matGenP); m_pTerrainGlobals->setDefaultMaterialGenerator(matGen);