//! [schemenotfound]
Technique* GBufferSchemeHandler::handleSchemeNotFound(unsigned short schemeIndex,
const String& schemeName, Material* originalMaterial, unsigned short lodIndex,
const Renderable* rend)
{
Ogre::MaterialManager& matMgr = Ogre::MaterialManager::getSingleton();
String curSchemeName = matMgr.getActiveScheme();
matMgr.setActiveScheme(MaterialManager::DEFAULT_SCHEME_NAME);
Technique* originalTechnique = originalMaterial->getBestTechnique(lodIndex, rend);
matMgr.setActiveScheme(curSchemeName);
Technique* gBufferTech = originalMaterial->createTechnique();
gBufferTech->removeAllPasses();
gBufferTech->setSchemeName(schemeName);
#ifdef OGRE_BUILD_COMPONENT_RTSHADERSYSTEM
RTShader::ShaderGenerator& rtShaderGen = RTShader::ShaderGenerator::getSingleton();
rtShaderGen.createShaderBasedTechnique(originalTechnique, "NoGBuffer");
#else
Technique* noGBufferTech = originalMaterial->createTechnique();
noGBufferTech->removeAllPasses();
noGBufferTech->setSchemeName("NoGBuffer");
#endif
for (unsigned short i=0; i<originalTechnique->getNumPasses(); i++)
{
Pass* originalPass = originalTechnique->getPass(i);
PassProperties props = inspectPass(originalPass, lodIndex, rend);
if (!props.isDeferred)
{
#ifdef OGRE_BUILD_COMPONENT_RTSHADERSYSTEM
rtShaderGen.validateMaterial("NoGBuffer", originalMaterial->getName(), originalMaterial->getGroup());
#else
//Just copy the technique so it gets rendered regularly
Pass* clonePass = noGBufferTech->createPass();
*clonePass = *originalPass;
#endif
continue;
}
Pass* newPass = gBufferTech->createPass();
MaterialGenerator::Perm perm = getPermutation(props);
const Ogre::MaterialPtr& templateMat = mMaterialGenerator.getMaterial(perm);
//We assume that the GBuffer technique contains only one pass. But its true.
*newPass = *(templateMat->getTechnique(0)->getPass(0));
fillPass(newPass, originalPass, props);
}
return gBufferTech;
}
void App::createRoadSelMtr(String sMtrName)
{
MaterialPtr mat = MaterialManager::getSingleton().getByName(sMtrName);
if (!mat.isNull() && mat->getNumTechniques()>0)
{
/*unsigned short np = mat->getTechnique(0)->getNumPasses()-1; // last unsigned!
try {
if (mat->getTechnique(0)->getPass(np)->hasFragmentProgram()
&& mat->getTechnique(0)->getPass(np)->getFragmentProgramParameters()->_findNamedConstantDefinition("pssmSplitPoints",false)
)
mat->getTechnique(0)->getPass(np)->getFragmentProgramParameters()->setNamedConstant("pssmSplitPoints", splitPoints);
} catch(...) { }*/
// create selected materials for road
if (StringUtil::startsWith(sMtrName,"road",false) || StringUtil::startsWith(sMtrName,"pipe",false) )
{
String selName = sMtrName + "_sel";
MaterialPtr selMtr = MaterialManager::getSingleton().getByName(selName);
if (selMtr.isNull()) { // once
//LogO("new sel mtr: " +selName);
MaterialPtr sel = mat->clone(selName);
Technique* tech = sel->getTechnique(0); Pass* p = tech->createPass();
p->setSceneBlending(SBT_ADD); p->setDepthBias(3.f);//
p->setAmbient(0,0,0); p->setDiffuse(0,0,0,0); p->setSpecular(0,0,0,0);
p->setDepthCheckEnabled(false); p->setDepthWriteEnabled(true);
p->setCullingMode(CULL_NONE);
p->setFragmentProgram("sel_ps"); //p->setSelfIllumination(0,0.1,0.2);
} }
}
}
void MaterialGenerator::createOccluderTechnique()
{
Technique* occluderpasstech = mMaterial->createTechnique();
occluderpasstech->setName("occluder");
occluderpasstech->setSchemeName("occluder");
Pass* occluderpass = occluderpasstech->createPass();
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
// choose vertex program
std::string vprogname = "occluder_vs";
if ( mDef->mProps->transparent )
vprogname = "occluder_coord_vs";
//TODO:this is a workaround until a valid sun material is available to be used.
if(StringUtil::startsWith(this->mDef->getName(), "sky/"))
{
//use the sky object as the sun
vprogname = mVertexProgram->getName();
}
// choose fragment program
std::string fprogname = "occluder_ps";
if ( mDef->mProps->transparent )
fprogname = "occluder_alpha_ps";
//TODO:this is a workaround until a valid sun material is available to be used.
if(StringUtil::startsWith(this->mDef->getName(), "sky/"))
{
//use the sky object as the sun
fprogname = mFragmentProgram->getName();
}
occluderpass->setVertexProgram(vprogname);
occluderpass->setFragmentProgram(fprogname);
if (mDef->mProps->alphaRejectValue > 0)
occluderpass->setAlphaRejectSettings(mDef->mProps->alphaRejectFunc, mDef->mProps->alphaRejectValue);
if ( !mDef->mProps->transparent )
{
occluderpass->setCullingMode( chooseCullingMode() );
if(StringUtil::startsWith(this->mDef->getName(), "sky/"))
{
//Set the sky object as the sun
occluderpass->createTextureUnitState( mDiffuseMap );
}
}
else
{
occluderpass->setCullingMode( CULL_NONE );
occluderpass->setAlphaRejectSettings(CMPF_GREATER_EQUAL, 128);
occluderpass->createTextureUnitState( mDiffuseMap );
}
}
void MaterialGenerator::createSSAOTechnique()
{
Technique* ssaopasstech = mMaterial->createTechnique();
ssaopasstech->setName("geom");
ssaopasstech->setSchemeName("geom");
Pass* ssaopass = ssaopasstech->createPass();
ssaopass->setDepthWriteEnabled( mDef->mProps->depthWrite );
ssaopass->setDepthCheckEnabled( mDef->mProps->depthCheck );
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
// choose vertex program
std::string vprogname = "geom_vs";
if ( mDef->mProps->transparent )
vprogname = "geom_coord_vs";
// choose fragment program
std::string fprogname = "geom_ps";
if ( !mDef->mProps->ssao )
fprogname = "geom_white_ps"; // no contribution to ssao, will just return (0,0,0,0)
else if ( mDef->mProps->transparent )
fprogname = "geom_alpha_ps";
ssaopass->setVertexProgram(vprogname);
ssaopass->setFragmentProgram(fprogname);
if (mDef->mProps->ssaoReject)
ssaopass->setAlphaRejectSettings(CMPF_GREATER, 128);
if ( !mDef->mProps->transparent )
{
ssaopass->setCullingMode( chooseCullingMode() );
}
else
{
ssaopass->setCullingMode( CULL_NONE );
ssaopass->setAlphaRejectSettings(CMPF_GREATER_EQUAL, 128);
ssaopass->createTextureUnitState( mDiffuseMap );
}
}
void VolumeRenderable::initialise()
{
// Create geometry
size_t nvertices = mSlices*4; // n+1 planes
size_t elemsize = 3*3;
size_t dsize = elemsize*nvertices;
size_t x;
Ogre::IndexData *idata = new Ogre::IndexData();
Ogre::VertexData *vdata = new Ogre::VertexData();
// Create structures
float *vertices = new float[dsize];
float coords[4][2] = {
{0.0f, 0.0f},
{0.0f, 1.0f},
{1.0f, 0.0f},
{1.0f, 1.0f}
};
for(x=0; x<mSlices; x++)
{
for(size_t y=0; y<4; y++)
{
float xcoord = coords[y][0]-0.5;
float ycoord = coords[y][1]-0.5;
float zcoord = -((float)x/(float)(mSlices-1) - 0.5f);
// 1.0f .. a/(a+1)
// coordinate
vertices[x*4*elemsize+y*elemsize+0] = xcoord*(mSize/2.0f);
vertices[x*4*elemsize+y*elemsize+1] = ycoord*(mSize/2.0f);
vertices[x*4*elemsize+y*elemsize+2] = zcoord*(mSize/2.0f);
// normal
vertices[x*4*elemsize+y*elemsize+3] = 0.0f;
vertices[x*4*elemsize+y*elemsize+4] = 0.0f;
vertices[x*4*elemsize+y*elemsize+5] = 1.0f;
// tex
vertices[x*4*elemsize+y*elemsize+6] = xcoord*sqrtf(3.0f);
vertices[x*4*elemsize+y*elemsize+7] = ycoord*sqrtf(3.0f);
vertices[x*4*elemsize+y*elemsize+8] = zcoord*sqrtf(3.0f);
}
}
unsigned short *faces = new unsigned short[mSlices*6];
for(x=0; x<mSlices; x++)
{
faces[x*6+0] = x*4+0;
faces[x*6+1] = x*4+1;
faces[x*6+2] = x*4+2;
faces[x*6+3] = x*4+1;
faces[x*6+4] = x*4+2;
faces[x*6+5] = x*4+3;
}
// Setup buffers
vdata->vertexStart = 0;
vdata->vertexCount = nvertices;
VertexDeclaration* decl = vdata->vertexDeclaration;
VertexBufferBinding* bind = vdata->vertexBufferBinding;
size_t offset = 0;
decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
decl->addElement(0, offset, VET_FLOAT3, VES_NORMAL);
offset += VertexElement::getTypeSize(VET_FLOAT3);
decl->addElement(0, offset, VET_FLOAT3, VES_TEXTURE_COORDINATES);
offset += VertexElement::getTypeSize(VET_FLOAT3);
HardwareVertexBufferSharedPtr vbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
offset, nvertices, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
bind->setBinding(0, vbuf);
vbuf->writeData(0, vbuf->getSizeInBytes(), vertices, true);
HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
createIndexBuffer(
HardwareIndexBuffer::IT_16BIT,
mSlices*6,
HardwareBuffer::HBU_STATIC_WRITE_ONLY);
idata->indexBuffer = ibuf;
idata->indexCount = mSlices*6;
idata->indexStart = 0;
ibuf->writeData(0, ibuf->getSizeInBytes(), faces, true);
// Delete temporary buffers
delete [] vertices;
delete [] faces;
// Now make the render operation
mRenderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
mRenderOp.indexData = idata;
mRenderOp.vertexData = vdata;
mRenderOp.useIndexes = true;
// Create a brand new private material
MaterialPtr material =
MaterialManager::getSingleton().create(mTexture, "VolumeRenderable",
false, 0); // Manual, loader
// Remove pre-created technique from defaults
material->removeAllTechniques();
// Create a techinique and a pass and a texture unit
Technique * technique = material->createTechnique();
Pass * pass = technique->createPass();
TextureUnitState * textureUnit = pass->createTextureUnitState();
// Set pass parameters
pass->setSceneBlending(SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
pass->setCullingMode(CULL_NONE);
pass->setLightingEnabled(false);
// Set texture unit parameters
textureUnit->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
textureUnit->setTextureName(mTexture, TEX_TYPE_3D);
textureUnit->setTextureFiltering(TFO_TRILINEAR);
mUnit = textureUnit;
m_pMaterial = material;
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorC::SM2Profile::addTechnique(
const MaterialPtr& mat, const Terrain* terrain, TechniqueType tt)
{
Technique* tech = mat->createTechnique();
tech->setSchemeName("GBuffer");
// Only supporting one pass
Pass* pass = tech->createPass();
//pass->setName("NO_DEFERRED");
GpuProgramManager& gmgr = GpuProgramManager::getSingleton();
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
if (!mShaderGen)
{
if (hmgr.isLanguageSupported("cg"))
mShaderGen = OGRE_NEW ShaderHelperCg();
else
{
// todo
}
// check SM3 features
mSM3Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_3_0");
mSM4Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_4_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
pass->createTextureUnitState(terrain->getLayerTextureName(i, 0));
// normal / height
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!
}
}
//---------------------------------------------------------------------
void TerrainMaterialGeneratorA::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_4_0")) ||
(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 if (hmgr.isLanguageSupported("glsles"))
{
mShaderGen = OGRE_NEW ShaderHelperGLSLES();
}
// check SM3 features
mSM3Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_3_0");
mSM4Available = GpuProgramManager::getSingleton().isSyntaxSupported("ps_4_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
pass->createTextureUnitState(terrain->getLayerTextureName(i, 0));
// normal / height
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 = (uint)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);
}
}
}
