virtual GpuProgramPtr generateFragmentShader(Perm permutation)
{
/// Create shader
if (mMasterSource.empty())
{
DataStreamPtr ptrMasterSource;
if(GpuProgramManager::getSingleton().isSyntaxSupported("glsles"))
ptrMasterSource = ResourceGroupManager::getSingleton().openResource("DeferredShading/post/LightMaterial_ps.glsles",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
else
ptrMasterSource = ResourceGroupManager::getSingleton().openResource("DeferredShading/post/LightMaterial_ps.glsl",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
assert(ptrMasterSource.isNull()==false);
mMasterSource = ptrMasterSource->getAsString();
}
assert(mMasterSource.empty()==false);
// Create name
String name = mBaseName+StringConverter::toString(permutation)+"_ps";
// Create shader object
HighLevelGpuProgramPtr ptrProgram;
if(GpuProgramManager::getSingleton().isSyntaxSupported("glsles"))
{
ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsles", GPT_FRAGMENT_PROGRAM);
ptrProgram->setParameter("profiles", "glsles");
}
else
{
ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsl", GPT_FRAGMENT_PROGRAM);
ptrProgram->setParameter("profiles", "glsl150");
}
ptrProgram->setSource(mMasterSource);
// set up the preprocessor defines
// Important to do this before any call to get parameters, i.e. before the program gets loaded
ptrProgram->setParameter("preprocessor_defines", getPPDefines(permutation));
setUpBaseParameters(ptrProgram->getDefaultParameters());
// Bind samplers
GpuProgramParametersSharedPtr params = ptrProgram->getDefaultParameters();
int numSamplers = 0;
params->setNamedConstant("Tex0", (int)numSamplers++);
params->setNamedConstant("Tex1", (int)numSamplers++);
if(permutation & LightMaterialGenerator::MI_SHADOW_CASTER)
params->setNamedConstant("ShadowTex", (int)numSamplers++);
return GpuProgramPtr(ptrProgram);
}
virtual GpuProgramPtr generateFragmentShader(Perm permutation)
{
/// Create shader
if (mMasterSource.empty())
{
DataStreamPtr ptrMasterSource = ResourceGroupManager::getSingleton().openResource(
"DeferredShading/post/LightMaterial_ps.cg"
, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
assert(ptrMasterSource.isNull()==false);
mMasterSource = ptrMasterSource->getAsString();
}
assert(mMasterSource.empty()==false);
// Create name
String name = mBaseName+StringConverter::toString(permutation)+"_ps";
// Create shader object
HighLevelGpuProgramPtr ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(
name, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
ptrProgram->setSource(mMasterSource);
ptrProgram->setParameter("entry_point","main");
ptrProgram->setParameter("profiles","ps_2_x arbfp1");
// set up the preprocessor defines
// Important to do this before any call to get parameters, i.e. before the program gets loaded
ptrProgram->setParameter("compile_arguments", getPPDefines(permutation));
setUpBaseParameters(ptrProgram->getDefaultParameters());
return GpuProgramPtr(ptrProgram);
}
HighLevelGpuProgramPtr WaterMaterialGenerator::createFragmentProgram()
{
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
std::string progName = mDef->getName() + "_FP";
HighLevelGpuProgramPtr ret = mgr.getByName(progName);
if (!ret.isNull())
mgr.remove(progName);
ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
if(MRTSupported())
ret->setParameter("profiles", "ps_4_0 ps_3_0 fp40");
else
ret->setParameter("profiles", "ps_4_0 ps_3_0 fp40 arbfp1");
ret->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType outStream;
generateFragmentProgramSource(outStream);
ret->setSource(outStream.str());
ret->load();
GpuProgramParametersSharedPtr params = ret->getDefaultParameters();
fragmentProgramParams(ret);
return ret;
}
void MaterialGenerator::vertexProgramParams(HighLevelGpuProgramPtr program)
{
GpuProgramParametersSharedPtr params = program->getDefaultParameters();
//#ifndef _DEBUG
params->setIgnoreMissingParams(true);
//#endif
if (vpNeedWMat())
params->setNamedAutoConstant("wMat", GpuProgramParameters::ACT_WORLD_MATRIX);
params->setNamedAutoConstant("wvpMat", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
if (vpNeedWvMat())
params->setNamedAutoConstant("wvMat", GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
if (fpNeedEyeVector() || mShader->wind == 1)
params->setNamedAutoConstant("eyePosition", GpuProgramParameters::ACT_CAMERA_POSITION);
params->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
if (mShader->wind == 2)
params->setNamedConstant("enableWind", Real(1.0));
if(MRTSupported())
{
params->setNamedAutoConstant("far", GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
}
individualVertexProgramParams(params);
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorC::SM2Profile::ShaderHelper::defaultFpParams(
const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog)
{
GpuProgramParametersSharedPtr params = prog->getDefaultParameters();
params->setIgnoreMissingParams(true);
params->setNamedAutoConstant("fogColour", GpuProgramParameters::ACT_FOG_COLOUR);
params->setNamedAutoConstant("cFarDistance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
params->setNamedAutoConstant("viewMatrix", GpuProgramParameters::ACT_WORLDVIEW_MATRIX); // tout sauf Z : VIEW_MATRIX
}
HighLevelGpuProgramPtr ParticleMaterialGenerator::createSoftParticleVertexProgram()
{
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
std::string progName = mDef->getName() + "_ambient_VP";
HighLevelGpuProgramPtr ret = mgr.getByName(progName);
if (!ret.isNull())
mgr.remove(progName);
ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_VERTEX_PROGRAM);
ret->setParameter("profiles", "vs_4_0 vs_1_1 arbvp1");
ret->setParameter("entry_point", "main_vp");
StringUtil::StrStreamType sourceStr;
sourceStr <<
"void main_vp( float4 position : POSITION, \n"
" float4 color : COLOR, \n"
" float2 texCoord : TEXCOORD0, \n"
" out float4 oPosition : POSITION, \n"
" out float4 objectPos : COLOR, \n"
" out float4 oTexCoord : TEXCOORD0, \n"
" out float4 oVertexColour : TEXCOORD1, \n"
" out float4 oScreenPosition : TEXCOORD2, \n"
" out float4 oWorldPosition : TEXCOORD3, \n"
" uniform float enableFog, \n"
" uniform float4 fogParams, \n"
" uniform float4x4 wvpMat, \n"
" uniform float4x4 wMat \n"
") \n"
"{ \n"
" oVertexColour = color; \n"
" oPosition = mul(wvpMat, position); \n"
" oWorldPosition = mul(wMat, position); \n"
" oScreenPosition = oPosition; \n"
" oTexCoord = float4(texCoord.x, texCoord.y, 1, 1); \n"
" objectPos = position; \n"
" objectPos.w = enableFog * saturate(fogParams.x * (oPosition.z - fogParams.y) * fogParams.w); \n"
"} \n";
ret->setSource(sourceStr.str());
ret->load();
// params
GpuProgramParametersSharedPtr params = ret->getDefaultParameters();
params->setIgnoreMissingParams(true);
params->setNamedAutoConstant("wvpMat", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
params->setNamedAutoConstant("wMat", GpuProgramParameters::ACT_WORLD_MATRIX);
params->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
params->setNamedConstant("enableFog", mDef->mProps->fog ? Real(1.0) : Real(0.0));
return ret;
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorA::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 = (uint)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);
}
}
}
if (terrain->_getUseVertexCompression() && tt != RENDER_COMPOSITE_MAP)
{
Matrix4 posIndexToObjectSpace;
terrain->getPointTransform(&posIndexToObjectSpace);
params->setNamedConstant("posIndexToObjectSpace", posIndexToObjectSpace);
}
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorC::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("viewMatrix", GpuProgramParameters::ACT_WORLDVIEW_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 (terrain->_getUseVertexCompression() && tt != RENDER_COMPOSITE_MAP)
{
Matrix4 posIndexToObjectSpace;
terrain->getPointTransform(&posIndexToObjectSpace);
params->setNamedConstant("posIndexToObjectSpace", posIndexToObjectSpace);
}
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorA::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);
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 = (uint)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);
}
}
}
// Explicitly bind samplers for GLSL
if ((prof->_getShaderLanguage() == "glsl") || (prof->_getShaderLanguage() == "glsles"))
{
int numSamplers = 0;
if (tt == LOW_LOD)
{
params->setNamedConstant("compositeMap", (int)numSamplers++);
}
else
{
params->setNamedConstant("globalNormal", (int)numSamplers++);
if (terrain->getGlobalColourMapEnabled() && prof->isGlobalColourMapEnabled())
{
params->setNamedConstant("globalColourMap", (int)numSamplers++);
}
if (prof->isLightmapEnabled())
{
params->setNamedConstant("lightMap", (int)numSamplers++);
}
uint maxLayers = prof->getMaxLayers(terrain);
uint numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount());
uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount()));
// Blend textures - sampler definitions
for (uint i = 0; i < numBlendTextures; ++i)
{
params->setNamedConstant("blendTex" + StringConverter::toString(i), (int)numSamplers++);
}
// Layer textures - sampler definitions & UV multipliers
for (uint i = 0; i < numLayers; ++i)
{
params->setNamedConstant("difftex" + StringConverter::toString(i), (int)numSamplers++);
params->setNamedConstant("normtex" + StringConverter::toString(i), (int)numSamplers++);
}
uint numShadowTextures = 1;
if (prof->getReceiveDynamicShadowsPSSM())
numShadowTextures = (uint)prof->getReceiveDynamicShadowsPSSM()->getSplitCount();
for (uint i = 0; i < numShadowTextures; ++i)
{
if (prof->isShadowingEnabled(tt, terrain))
params->setNamedConstant("shadowMap" + StringConverter::toString(i), (int)numSamplers++);
}
}
}
}
HighLevelGpuProgramPtr ParticleMaterialGenerator::createSoftParticleFragmentProgram()
{
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
std::string progName = mDef->getName() + "_ambient_FP";
HighLevelGpuProgramPtr ret = mgr.getByName(progName);
if (!ret.isNull())
mgr.remove(progName);
ret = mgr.createProgram(progName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
ret->setParameter("profiles", "ps_4_0 ps_3_0 ps_2_0 arbfp1");
ret->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType sourceStr;
sourceStr <<
" void main_fp( in float4 iPosition : POSITION, \n"
" in float4 position : COLOR, \n"
" in float4 texCoord : TEXCOORD0, \n"
" in float4 vertexColour : TEXCOORD1, \n"
" in float4 positionScreen : TEXCOORD2, \n"
" in float4 positionWorld : TEXCOORD3, \n"
" uniform sampler2D diffuseMap : TEXUNIT0, \n";
if(MRTSupported())
{
sourceStr <<
" uniform sampler2D depthMap : TEXUNIT1, \n"
" uniform float useSoftParticles, \n";
}
sourceStr <<
" out float4 oColor : COLOR0, \n"
" uniform float3 fogColor \n";
if(MRTSupported())
{
sourceStr <<
", uniform float4 viewportSize \n"
", uniform float4 cameraPositionWorld //world space \n"
", uniform float far \n"
", uniform half flip \n";
}
sourceStr <<
") \n"
"{ \n"
" float4 diffuseTex = tex2D(diffuseMap, texCoord.xy); \n"
" float4 color1 = diffuseTex; \n"
" color1 *= vertexColour; \n"
" oColor = lerp(color1, float4(fogColor,1), position.w); \n";
if(MRTSupported())
{
sourceStr <<
" //calculate depth at the real position \n"
" positionScreen /= positionScreen.w; \n"
" float2 depthTexCoord = float2(positionScreen) * float2(0.5f, -0.5f) + float2(0.5f, 0.5f); \n"
" float2 uvOffset= (viewportSize.zw)*0.5; \n"
" depthTexCoord += uvOffset; \n"
" depthTexCoord.y =(1-saturate(flip))+flip*depthTexCoord.y; \n"
" float depth = tex2D(depthMap, depthTexCoord).x; \n"
" if(useSoftParticles > 0) \n"
" { \n"
" float distanceToPixel = length(positionWorld.xyz-cameraPositionWorld.xyz); \n"
" float thickness = 0.5;//position_scale[3] * thicknessColour[0]; \n"
" float tNear = distanceToPixel - thickness; \n"
" float tFar = distanceToPixel + thickness; \n"
" depth *= far; \n"
" float depthAlpha = saturate(depth - distanceToPixel); \n"
//these are debug values for the effect ,please don't remove
//" depthAlpha*=depthAlpha; \n"
//" //modify depth to get a good looking fog effect \n"
//" depthAlpha = log(depthAlpha) * 0.7f; \n"
//" oColor = float4(depth/20,depth/20,depth/20,1); \n"
//" oColor = float4(distanceToPixel,distanceToPixel,distanceToPixel,1); \n"
//" oColor = float4(depthAlpha,depthAlpha,depthAlpha,1); \n"
" oColor.a *=depthAlpha; \n"
" } \n";
}
sourceStr << "} \n";
ret->setSource(sourceStr.str());
ret->load();
// params
GpuProgramParametersSharedPtr params = ret->getDefaultParameters();
params->setNamedAutoConstant("fogColor", GpuProgramParameters::ACT_FOG_COLOUR);
if(MRTSupported())
{
params->setNamedAutoConstant("far", GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);
params->setNamedAutoConstant("flip", GpuProgramParameters::ACT_RENDER_TARGET_FLIPPING);
//depth
params->setNamedAutoConstant("viewportSize", GpuProgramParameters::ACT_VIEWPORT_SIZE);
//depthAlpha
params->setNamedAutoConstant("cameraPositionWorld", GpuProgramParameters::ACT_CAMERA_POSITION);
}
return ret;
}
void BillboardObject::init(const String& textureName,
const float initialSize,
const Vector3& position,
SceneNode* rootNode)
{
SceneManager* sceneMgr = rootNode->getCreator();
Vector3 finalPosition = position.normalisedCopy() * 1000.f;
static unsigned int bodyCount=0;
/// \todo These billboards are not 100% correct, might want to revisit them later
mBBSet = sceneMgr->createBillboardSet("SkyBillboardSet"+StringConverter::toString(bodyCount), 1);
mBBSet->setDefaultDimensions(550.f*initialSize, 550.f*initialSize);
mBBSet->setBillboardType(BBT_PERPENDICULAR_COMMON);
mBBSet->setCommonDirection( -position.normalisedCopy() );
mBBSet->setVisibilityFlags(RV_Sky);
mNode = rootNode->createChildSceneNode();
mNode->setPosition(finalPosition);
mNode->attachObject(mBBSet);
mBBSet->createBillboard(0,0,0);
mBBSet->setCastShadows(false);
mMaterial = MaterialManager::getSingleton().create("BillboardMaterial"+StringConverter::toString(bodyCount), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
mMaterial->removeAllTechniques();
Pass* p = mMaterial->createTechnique()->createPass();
p->setSceneBlending(SBT_TRANSPARENT_ALPHA);
p->setDepthCheckEnabled(false);
p->setDepthWriteEnabled(false);
p->setSelfIllumination(1.0,1.0,1.0);
p->setDiffuse(0.0,0.0,0.0,1.0);
p->setAmbient(0.0,0.0,0.0);
p->setPolygonModeOverrideable(false);
p->createTextureUnitState(textureName);
mBBSet->setMaterialName("BillboardMaterial"+StringConverter::toString(bodyCount));
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
HighLevelGpuProgramPtr vshader;
if (mgr.resourceExists("BBO_VP"))
vshader = mgr.getByName("BBO_VP");
else
vshader = mgr.createProgram("BBO_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_VERTEX_PROGRAM);
vshader->setParameter("profiles", "vs_2_x arbvp1");
vshader->setParameter("entry_point", "main_vp");
StringUtil::StrStreamType outStream;
outStream <<
"void main_vp( \n"
" float4 position : POSITION, \n"
" in float2 uv : TEXCOORD0, \n"
" out float2 oUV : TEXCOORD0, \n"
" out float4 oPosition : POSITION, \n"
" uniform float4x4 worldViewProj \n"
") \n"
"{ \n"
" oUV = uv; \n"
" oPosition = mul( worldViewProj, position ); \n"
"}";
vshader->setSource(outStream.str());
vshader->load();
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
mMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
HighLevelGpuProgramPtr fshader;
if (mgr.resourceExists("BBO_FP"))
fshader = mgr.getByName("BBO_FP");
else
fshader = mgr.createProgram("BBO_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_FRAGMENT_PROGRAM);
fshader->setParameter("profiles", "ps_2_x arbfp1");
fshader->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType outStream2;
outStream2 <<
"void main_fp( \n"
" in float2 uv : TEXCOORD0, \n"
" out float4 oColor : COLOR, \n";
if (RenderingManager::useMRT()) outStream2 <<
" out float4 oColor1 : COLOR1, \n";
outStream2 <<
" uniform sampler2D texture : TEXUNIT0, \n"
" uniform float4 diffuse, \n"
" uniform float4 emissive \n"
") \n"
"{ \n"
" float4 tex = tex2D(texture, uv); \n"
" oColor = float4(emissive.xyz,1) * tex * float4(1,1,1,diffuse.a); \n";
if (RenderingManager::useMRT()) outStream2 <<
" oColor1 = float4(1, 0, 0, 1); \n";
outStream2 <<
"}";
fshader->setSource(outStream2.str());
fshader->load();
fshader->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
fshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
mMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(fshader->getName());
bodyCount++;
}
void SkyManager::create()
{
/// \todo preload all the textures and meshes that are used for sky rendering
// Create overlay used for thunderstorm
MaterialPtr material = MaterialManager::getSingleton().create( "ThunderMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
Pass* pass = material->getTechnique(0)->getPass(0);
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
mThunderTextureUnit = pass->createTextureUnitState();
mThunderTextureUnit->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, ColourValue(1.f, 1.f, 1.f));
mThunderTextureUnit->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, 0.5f);
OverlayManager& ovm = OverlayManager::getSingleton();
mThunderOverlay = ovm.create( "ThunderOverlay" );
OverlayContainer* overlay_panel;
overlay_panel = (OverlayContainer*)ovm.createOverlayElement("Panel", "ThunderPanel");
overlay_panel->_setPosition(0, 0);
overlay_panel->_setDimensions(1, 1);
overlay_panel->setMaterialName( "ThunderMaterial" );
overlay_panel->show();
mThunderOverlay->add2D(overlay_panel);
mThunderOverlay->hide();
mSecunda = new Moon("textures\\tx_secunda_full.dds", 0.5, Vector3(-0.4, 0.4, 0.5), mRootNode);
mSecunda->setType(Moon::Type_Secunda);
mSecunda->setRenderQueue(RQG_SkiesEarly+4);
mMasser = new Moon("textures\\tx_masser_full.dds", 0.75, Vector3(-0.4, 0.4, 0.5), mRootNode);
mMasser->setRenderQueue(RQG_SkiesEarly+3);
mMasser->setType(Moon::Type_Masser);
mSun = new BillboardObject("textures\\tx_sun_05.dds", 1, Vector3(0.4, 0.4, 0.4), mRootNode);
mSun->setRenderQueue(RQG_SkiesEarly+4);
mSunGlare = new BillboardObject("textures\\tx_sun_flash_grey_05.dds", 3, Vector3(0.4, 0.4, 0.4), mRootNode);
mSunGlare->setRenderQueue(RQG_SkiesLate);
mSunGlare->setVisibilityFlags(RV_Glare);
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
// Stars
/// \todo sky_night_02.nif (available in Bloodmoon)
MeshPtr mesh = NifOgre::NIFLoader::load("meshes\\sky_night_01.nif");
Entity* night1_ent = mSceneMgr->createEntity("meshes\\sky_night_01.nif");
night1_ent->setRenderQueueGroup(RQG_SkiesEarly+1);
night1_ent->setVisibilityFlags(RV_Sky);
night1_ent->setCastShadows(false);
mAtmosphereNight = mRootNode->createChildSceneNode();
mAtmosphereNight->attachObject(night1_ent);
// Stars vertex shader
HighLevelGpuProgramPtr stars_vp = mgr.createProgram("Stars_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_VERTEX_PROGRAM);
stars_vp->setParameter("profiles", "vs_2_x arbvp1");
stars_vp->setParameter("entry_point", "main_vp");
StringUtil::StrStreamType outStream4;
outStream4 <<
"void main_vp( \n"
" float4 position : POSITION, \n"
" in float2 uv : TEXCOORD0, \n"
" out float2 oUV : TEXCOORD0, \n"
" out float oFade : TEXCOORD1, \n"
" out float4 oPosition : POSITION, \n"
" uniform float4x4 worldViewProj \n"
") \n"
"{ \n"
" oUV = uv; \n"
" oFade = (position.z > 50) ? 1.f : 0.f; \n"
" oPosition = mul( worldViewProj, position ); \n"
"}";
stars_vp->setSource(outStream4.str());
stars_vp->load();
stars_vp->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
// Stars fragment shader
HighLevelGpuProgramPtr stars_fp = mgr.createProgram("Stars_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
stars_fp->setParameter("profiles", "ps_2_x arbfp1");
stars_fp->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType outStream5;
outStream5 <<
"void main_fp( \n"
" in float2 uv : TEXCOORD0, \n"
" out float4 oColor : COLOR, \n";
if (RenderingManager::useMRT()) outStream5 <<
" out float4 oColor1 : COLOR1, \n";
outStream5 <<
" in float fade : TEXCOORD1, \n"
" uniform sampler2D texture : TEXUNIT0, \n"
" uniform float opacity, \n"
" uniform float4 diffuse, \n"
" uniform float4 emissive \n"
") \n"
"{ \n"
" oColor = tex2D(texture, uv) * float4(emissive.xyz, 1) * float4(1,1,1,fade*diffuse.a); \n";
if (RenderingManager::useMRT()) outStream5 <<
" oColor1 = float4(1, 0, 0, 1); \n";
outStream5 <<
"}";
stars_fp->setSource(outStream5.str());
stars_fp->load();
stars_fp->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
stars_fp->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
for (unsigned int i=0; i<night1_ent->getNumSubEntities(); ++i)
{
MaterialPtr mp = night1_ent->getSubEntity(i)->getMaterial();
mp->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
mp->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
mp->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 1.0);
mp->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
mp->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
mp->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
mp->getTechnique(0)->getPass(0)->setVertexProgram(stars_vp->getName());
mp->getTechnique(0)->getPass(0)->setFragmentProgram(stars_fp->getName());
mp->getTechnique(0)->getPass(0)->setPolygonModeOverrideable(false);
mStarsMaterials[i] = mp;
}
// Atmosphere (day)
mesh = NifOgre::NIFLoader::load("meshes\\sky_atmosphere.nif");
Entity* atmosphere_ent = mSceneMgr->createEntity("meshes\\sky_atmosphere.nif");
atmosphere_ent->setCastShadows(false);
ModVertexAlpha(atmosphere_ent, 0);
atmosphere_ent->setRenderQueueGroup(RQG_SkiesEarly);
atmosphere_ent->setVisibilityFlags(RV_Sky);
mAtmosphereDay = mRootNode->createChildSceneNode();
mAtmosphereDay->attachObject(atmosphere_ent);
mAtmosphereMaterial = atmosphere_ent->getSubEntity(0)->getMaterial();
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setPolygonModeOverrideable(false);
// Atmosphere shader
HighLevelGpuProgramPtr vshader = mgr.createProgram("Atmosphere_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_VERTEX_PROGRAM);
vshader->setParameter("profiles", "vs_2_x arbvp1");
vshader->setParameter("entry_point", "main_vp");
StringUtil::StrStreamType outStream;
outStream <<
"void main_vp( \n"
" float4 position : POSITION, \n"
" in float4 color : COLOR, \n"
" out float4 oPosition : POSITION, \n"
" out float4 oVertexColor : TEXCOORD0, \n"
" uniform float4x4 worldViewProj \n"
") \n"
"{ \n"
" oPosition = mul( worldViewProj, position ); \n"
" oVertexColor = color; \n"
"}";
vshader->setSource(outStream.str());
vshader->load();
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
HighLevelGpuProgramPtr fshader = mgr.createProgram("Atmosphere_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
fshader->setParameter("profiles", "ps_2_x arbfp1");
fshader->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType _outStream;
_outStream <<
"void main_fp( \n"
" in float4 iVertexColor : TEXCOORD0, \n"
" out float4 oColor : COLOR, \n";
if (RenderingManager::useMRT()) _outStream <<
" out float4 oColor1 : COLOR1, \n";
_outStream <<
" uniform float4 emissive \n"
") \n"
"{ \n"
" oColor = iVertexColor * emissive; \n";
if (RenderingManager::useMRT()) _outStream <<
" oColor1 = float4(1, 0, 0, 1); \n";
_outStream <<
"}";
fshader->setSource(_outStream.str());
fshader->load();
fshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(fshader->getName());
// Clouds
NifOgre::NIFLoader::load("meshes\\sky_clouds_01.nif");
Entity* clouds_ent = mSceneMgr->createEntity("meshes\\sky_clouds_01.nif");
clouds_ent->setVisibilityFlags(RV_Sky);
clouds_ent->setRenderQueueGroup(RQG_SkiesEarly+5);
SceneNode* clouds_node = mRootNode->createChildSceneNode();
clouds_node->attachObject(clouds_ent);
mCloudMaterial = clouds_ent->getSubEntity(0)->getMaterial();
mCloudMaterial->getTechnique(0)->getPass(0)->setPolygonModeOverrideable(false);
clouds_ent->setCastShadows(false);
// Clouds vertex shader
HighLevelGpuProgramPtr vshader2 = mgr.createProgram("Clouds_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_VERTEX_PROGRAM);
vshader2->setParameter("profiles", "vs_2_x arbvp1");
vshader2->setParameter("entry_point", "main_vp");
StringUtil::StrStreamType outStream3;
outStream3 <<
"void main_vp( \n"
" float4 position : POSITION, \n"
" in float4 color : COLOR, \n"
" out float4 oColor : TEXCOORD1, \n"
" in float2 uv : TEXCOORD0, \n"
" out float2 oUV : TEXCOORD0, \n"
" out float4 oPosition : POSITION, \n"
" uniform float4x4 worldViewProj \n"
") \n"
"{ \n"
" oUV = uv; \n"
" oColor = color; \n"
" oPosition = mul( worldViewProj, position ); \n"
"}";
vshader2->setSource(outStream3.str());
vshader2->load();
vshader2->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
mCloudMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader2->getName());
// Clouds fragment shader
mCloudFragmentShader = mgr.createProgram("Clouds_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
mCloudFragmentShader->setParameter("profiles", "ps_2_x arbfp1");
mCloudFragmentShader->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType outStream2;
outStream2 <<
"void main_fp( \n"
" in float2 uv : TEXCOORD0, \n"
" in float4 color : TEXCOORD1, \n"
" out float4 oColor : COLOR, \n";
if (RenderingManager::useMRT()) outStream2 <<
" out float4 oColor1 : COLOR1, \n";
outStream2 <<
" uniform sampler2D texture : TEXUNIT0, \n"
" uniform sampler2D secondTexture : TEXUNIT1, \n"
" uniform float transitionFactor, \n"
" uniform float time, \n"
" uniform float speed, \n"
" uniform float opacity, \n"
" uniform float4 emissive \n"
") \n"
"{ \n"
" uv += float2(0,1) * time * speed * 0.003; \n" // Scroll in y direction
" float4 tex = lerp(tex2D(texture, uv), tex2D(secondTexture, uv), transitionFactor); \n"
" oColor = color * float4(emissive.xyz,1) * tex * float4(1,1,1,opacity); \n";
if (RenderingManager::useMRT()) outStream2 <<
" oColor1 = float4(1, 0, 0, 1); \n";
outStream2 <<
"}";
mCloudFragmentShader->setSource(outStream2.str());
mCloudFragmentShader->load();
mCloudFragmentShader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
mCloudMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(mCloudFragmentShader->getName());
setCloudsOpacity(0.75);
ModVertexAlpha(clouds_ent, 1);
// I'm not sure if the materials are being used by any other objects
// Make a unique "modifiable" copy of the materials to be sure
mCloudMaterial = mCloudMaterial->clone("Clouds");
clouds_ent->getSubEntity(0)->setMaterial(mCloudMaterial);
mAtmosphereMaterial = mAtmosphereMaterial->clone("Atmosphere");
atmosphere_ent->getSubEntity(0)->setMaterial(mAtmosphereMaterial);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDiffuse(0.0, 0.0, 0.0, 0.0);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setAmbient(0.0, 0.0, 0.0);
mCloudMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1.0, 1.0, 1.0);
mCloudMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
mAtmosphereMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
mCloudMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
mCloudMaterial->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
mCloudMaterial->getTechnique(0)->getPass(0)->createTextureUnitState("textures\\tx_sky_cloudy.dds");
mCloudMaterial->getTechnique(0)->getPass(0)->createTextureUnitState("");
mCreated = true;
}
Moon::Moon( const String& textureName,
const float initialSize,
const Vector3& position,
SceneNode* rootNode)
{
init(textureName, initialSize, position, rootNode);
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
HighLevelGpuProgramPtr vshader;
if (mgr.resourceExists("Moon_VP"))
vshader = mgr.getByName("Moon_VP");
else
vshader = mgr.createProgram("Moon_VP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_VERTEX_PROGRAM);
vshader->setParameter("profiles", "vs_2_x arbvp1");
vshader->setParameter("entry_point", "main_vp");
StringUtil::StrStreamType outStream;
outStream <<
"void main_vp( \n"
" float4 position : POSITION, \n"
" in float2 uv : TEXCOORD0, \n"
" out float2 oUV : TEXCOORD0, \n"
" out float4 oPosition : POSITION, \n"
" uniform float4x4 worldViewProj \n"
") \n"
"{ \n"
" oUV = uv; \n"
" oPosition = mul( worldViewProj, position ); \n"
"}";
vshader->setSource(outStream.str());
vshader->load();
vshader->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
mMaterial->getTechnique(0)->getPass(0)->setVertexProgram(vshader->getName());
HighLevelGpuProgramPtr fshader;
if (mgr.resourceExists("Moon_FP"))
fshader = mgr.getByName("Moon_FP");
else
fshader = mgr.createProgram("Moon_FP", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", GPT_FRAGMENT_PROGRAM);
fshader->setParameter("profiles", "ps_2_x arbfp1");
fshader->setParameter("entry_point", "main_fp");
StringUtil::StrStreamType outStream2;
outStream2 <<
"void main_fp( \n"
" in float2 uv : TEXCOORD0, \n"
" out float4 oColor : COLOR, \n";
if (RenderingManager::useMRT()) outStream2 <<
" out float4 oColor1 : COLOR1, \n";
outStream2 <<
" uniform sampler2D texture : TEXUNIT0, \n"
" uniform float4 skyColour, \n"
" uniform float4 diffuse, \n"
" uniform float4 emissive \n"
") \n"
"{ \n"
" float4 tex = tex2D(texture, uv); \n"
" oColor = float4(emissive.xyz,1) * tex; \n";
if (RenderingManager::useMRT()) outStream2 <<
" oColor1 = float4(1, 0, 0, 1); \n";
outStream2 <<
// use a circle for the alpha (compute UV distance to center)
// looks a bit bad because its not filtered on the edges,
// but it's cheaper than a seperate alpha texture.
" float sqrUVdist = pow(uv.x-0.5,2) + pow(uv.y-0.5, 2); \n"
" oColor.a = diffuse.a * (sqrUVdist >= 0.24 ? 0 : 1); \n"
" oColor.rgb += (1-tex.a) * oColor.a * skyColour.rgb; \n"//fill dark side of moon with skycolour
" oColor.rgb += (1-diffuse.a) * skyColour.rgb; \n"//fade bump
"}";
fshader->setSource(outStream2.str());
fshader->load();
fshader->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
fshader->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
mMaterial->getTechnique(0)->getPass(0)->setFragmentProgram(fshader->getName());
setVisibility(1.0);
mPhase = Moon::Phase_Full;
}
GpuProgramPtr GBufferMaterialGeneratorImpl::generateVertexShader(MaterialGenerator::Perm permutation)
{
StringStream ss;
if(mIsGLSL)
{
ss << "#version 150" << std::endl;
ss << "in vec4 vertex;" << std::endl;
ss << "in vec3 normal;" << std::endl;
uint32 numTexCoords = (permutation & GBufferMaterialGenerator::GBP_TEXCOORD_MASK) >> 8;
for (uint32 i=0; i<numTexCoords; i++)
{
ss << "in vec2 uv" << i << ';' << std::endl;
}
if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP)
{
ss << "in vec3 tangent;" << std::endl;
}
//TODO : Skinning inputs
ss << std::endl;
#ifdef WRITE_LINEAR_DEPTH
ss << "out vec3 oViewPos;" << std::endl;
#else
ss << "out float oDepth;" << std::endl;
#endif
ss << "out vec3 oNormal;" << std::endl;
if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP)
{
ss << "out vec3 oTangent;" << std::endl;
ss << "out vec3 oBiNormal;" << std::endl;
}
for (uint32 i=0; i<numTexCoords; i++)
{
ss << "out vec2 oUv" << i << ";" << std::endl;
}
ss << std::endl;
ss << "uniform mat4 cWorldViewProj;" << std::endl;
ss << "uniform mat4 cWorldView;" << std::endl;
ss << "void main()" << std::endl;
ss << "{" << std::endl;
ss << " gl_Position = cWorldViewProj * vertex;" << std::endl;
ss << " oNormal = (cWorldView * vec4(normal,0)).xyz;" << std::endl;
if (permutation & GBufferMaterialGenerator::GBP_NORMAL_MAP)
{
ss << " oTangent = (cWorldView * vec4(tangent,0)).xyz;" << std::endl;
ss << " oBiNormal = cross(oNormal, oTangent);" << std::endl;
}
#ifdef WRITE_LINEAR_DEPTH
ss << " oViewPos = (cWorldView * vertex).xyz;" << std::endl;
#else
ss << " oDepth = gl_Position.w;" << std::endl;
#endif
for (uint32 i=0; i<numTexCoords; i++) {
ss << " oUv" << i << " = uv" << i << ';' << std::endl;
}
ss << "}" << std::endl;
String programSource = ss.str();
String programName = mBaseName + "VP_" + StringConverter::toString(permutation);
#if OGRE_DEBUG_MODE
LogManager::getSingleton().getDefaultLog()->logMessage(programSource);
#endif
// Create shader object
HighLevelGpuProgramPtr ptrProgram = HighLevelGpuProgramManager::getSingleton().createProgram(programName,
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"glsl", GPT_VERTEX_PROGRAM);
ptrProgram->setSource(programSource);
ptrProgram->setParameter("syntax", "glsl150");
const GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters();
params->setNamedAutoConstant("cWorldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
params->setNamedAutoConstant("cWorldView", GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
ptrProgram->load();
return GpuProgramPtr(ptrProgram);
}
else
{
void ImpostorMaterialGenerator::generate()
{
//!
// note that we only create the shaders (Sprite_vp, Sprite_fp) here.
// the rest (material creation, shader parameters, ...) is done by paged-geom for convenience.
HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
// ---------------- VERTEX -----------------------------------------------
// ensure shader does not exist already.
HighLevelGpuProgramPtr vshader = mgr.getByName("Sprite_vp");
if (vshader.isNull())
{
vshader = mgr.createProgram("Sprite_vp", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_VERTEX_PROGRAM);
if(MRTSupported())
{
vshader->setParameter("profiles", "vs_4_0 vs_3_0 vp40");
}
else
{
vshader->setParameter("profiles", "vs_4_0 vs_2_x arbvp1");
}
vshader->setParameter("entry_point", "Sprite_vp");
StringUtil::StrStreamType outStream;
outStream <<
"void Sprite_vp( \n"
" float4 position : POSITION, \n"
" float3 normal : NORMAL, \n"
" float4 color : COLOR, \n"
" float2 uv : TEXCOORD0, \n"
" out float4 oPosition : POSITION, \n"
" out float2 oUv : TEXCOORD0, \n"
" out float4 oColor : COLOR, \n"
" out float oFog : TEXCOORD1, \n"
" uniform float4 fogParams, \n"
" uniform float4x4 worldViewProj, \n"
" uniform float uScroll, \n"
" uniform float vScroll, \n"
" uniform float4 preRotatedQuad[4] ) \n"
"{ \n"
//Face the camera
" float4 vCenter = float4( position.x, position.y, position.z, 1.0f ); \n"
" float4 vScale = float4( normal.x, normal.y, normal.x, 1.0f ); \n"
" oPosition = mul( worldViewProj, vCenter + (preRotatedQuad[normal.z] * vScale) ); \n"
//Color
" oColor = color; \n"
//UV Scroll
" oUv = uv; \n"
" oUv.x += uScroll; \n"
" oUv.y += vScroll; \n"
//Fog
" oFog = saturate(fogParams.x * (oPosition.z - fogParams.y) * fogParams.w); \n"
"}";
vshader->setSource(outStream.str());
vshader->load();
vshader->getDefaultParameters()->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
}
// ------------- FRAGMENT -----------------------------------------------
// ensure shader does not exist already.
HighLevelGpuProgramPtr fshader = mgr.getByName("Sprite_fp");
if (fshader.isNull())
{
fshader = mgr.createProgram("Sprite_fp", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
"cg", GPT_FRAGMENT_PROGRAM);
if(MRTSupported())
{
fshader->setParameter("profiles", "ps_4_0 ps_3_0 fp40");
}
else
{
fshader->setParameter("profiles", "ps_4_0 ps_2_x arbfp1");
}
fshader->setParameter("entry_point", "Sprite_fp");
// simple pixel shader that only reads texture and fog
StringUtil::StrStreamType outStream;
outStream <<
"void Sprite_fp( \n"
" uniform sampler2D texture, \n"
" float4 iPosition : POSITION, \n"
" float2 texCoord : TEXCOORD0, \n"
" float4 iColor : COLOR, \n"
" float fog : TEXCOORD1, \n"
" uniform float4 fogColor, \n"
" out float4 oColor : COLOR \n"
") \n"
"{ \n"
" float4 texColor = tex2D(texture, texCoord); \n"
" oColor = float4(lerp(texColor.xyz, fogColor.xyz, fog), texColor.a); \n"
" clip( oColor.a > 0.0f ? 1:-1); \n"
"} \n";
fshader->setSource(outStream.str());
fshader->load();
fshader->getDefaultParameters()->setNamedAutoConstant("fogColor", GpuProgramParameters::ACT_FOG_COLOUR);
}
}
