//---------------------------------------------------------------------
MaterialPtr TerrainMaterialGeneratorA::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_4_0") && !gmgr.isSyntaxSupported("ps_3_0") && !gmgr.isSyntaxSupported("ps_2_x")
&& !gmgr.isSyntaxSupported("fp40") && !gmgr.isSyntaxSupported("arbfp1") && !gmgr.isSyntaxSupported("glsl")
&& !gmgr.isSyntaxSupported("glsles"))
{
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 TerrainMaterialGeneratorC::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;
}
veMaterial* veDeferredRenderPipeline::createIBLightMaterial(veLight *light)
{
auto material = new veMaterial;
auto technique = new veTechnique;
auto pass = new vePass;
material->addTechnique(technique);
technique->addPass(pass);
initLightCommomParams(light, pass);
pass->setRenderPass(vePass::FORWARD_PASS);
pass->depthTest() = false;
pass->depthWrite() = false;
pass->stencilTest() = false;
pass->cullFace() = true;
pass->cullFaceMode() = GL_BACK;
pass->blendFunc().src = GL_ONE;
pass->blendFunc().dst = GL_ONE;
pass->blendEquation() = GL_FUNC_ADD;
pass->setShader(new veShader(veShader::VERTEX_SHADER, SCREEN_BASED_LIGHT_VERTEX_SHADER));
pass->setShader(new veShader(veShader::FRAGMENT_SHADER, IB_LIGHT_FRAGMENT_SHADER));
pass->addUniform(new veUniform("u_lightDirection", veVec3::ZERO));
pass->addUniform(new veUniform("u_specularMipMapCount", 1.0f));
pass->addUniform(new veUniform("u_diffuseLighting", 4));
pass->addUniform(new veUniform("u_specularLighting", 5));
return material;
}
veMaterial* veDeferredRenderPipeline::createDirectionalLightMaterial(veLight *light)
{
auto material = new veMaterial;
auto technique = new veTechnique;
auto pass = new vePass;
material->addTechnique(technique);
technique->addPass(pass);
initLightCommomParams(light, pass);
pass->setRenderPass(vePass::FORWARD_PASS);
pass->depthTest() = false;
pass->depthWrite() = false;
pass->stencilTest() = false;
pass->cullFace() = true;
pass->cullFaceMode() = GL_BACK;
pass->blendFunc().src = GL_ONE;
pass->blendFunc().dst = GL_ONE;
pass->blendEquation() = GL_FUNC_ADD;
pass->setShader(new veShader(veShader::VERTEX_SHADER, SCREEN_BASED_LIGHT_VERTEX_SHADER));
pass->setShader(new veShader(veShader::FRAGMENT_SHADER, DIRECTIONAL_LIGHT_FRAGMENT_SHADER));
pass->addUniform(new veUniform("u_lightDirection", veVec3::ZERO));
pass->addUniform(new veUniform("u_lightMatrixs", &veMat4::IDENTITY, 1));
pass->addUniform(new veUniform("u_shadowCascadedLevels", 0.f));
pass->addUniform(new veUniform("u_shadowCascadedCount", 0.f));
pass->addUniform(new veUniform("u_shadowTex", 4));
return material;
}
bool Effect::define_techniques()
{
try
{
if (mUseShaders && mShaderManager)
addTechnique(new ShaderTechnique(*mShaderManager, mForcePerPixelLighting, mClampLighting, mLayers, mBlendmaps, mBlendmapScale, mLayerTileSize));
else
addTechnique(new FixedFunctionTechnique(mLayers, mBlendmaps, mBlendmapScale, mLayerTileSize));
}
catch (std::exception& e)
{
std::cerr << "Error: " << e.what() << std::endl;
addTechnique(new FixedFunctionTechnique(mLayers, mBlendmaps, mBlendmapScale, mLayerTileSize));
}
return true;
}
//-----------------------------------------------------------------------
ParticleSystem& ParticleSystem::operator=(const ParticleSystem& ps)
{
// Destroy all existing techniques.
destroyAllTechniques();
// Copy techniques
size_t i = 0;
ParticleTechnique* psTechnique = 0;
ParticleTechnique* clonedTechnique = 0;
for(i = 0; i < ps.getNumTechniques(); ++i)
{
psTechnique = ps.getTechnique(i);
clonedTechnique = ParticleSystemManager::getSingletonPtr()->cloneTechnique(psTechnique);
addTechnique(clonedTechnique);
}
// Copy attributes
mNonvisibleUpdateTimeout = ps.mNonvisibleUpdateTimeout;
mNonvisibleUpdateTimeoutSet = ps.mNonvisibleUpdateTimeoutSet;
mResourceGroupName = ps.mResourceGroupName;
mLodDistanceList = ps.mLodDistanceList;
mSmoothLod = ps.mSmoothLod;
mIterationIntervalSet = ps.mIterationIntervalSet;
mIterationInterval = ps.mIterationInterval;
mTimeSinceLastUpdate = ps.mTimeSinceLastUpdate;
mFixedTimeout = ps.mFixedTimeout;
mFixedTimeoutSet = ps.mFixedTimeoutSet;
mState = ps.mState;
mTimeElapsedSinceStart = ps.mTimeElapsedSinceStart;
mSuppressNotifyEmissionChange = ps.mSuppressNotifyEmissionChange;
mFastForwardSet = ps.mFastForwardSet;
mOriginalFastForwardSet = ps.mOriginalFastForwardSet;
mFastForwardTime = ps.mFastForwardTime;
mFastForwardInterval = ps.mFastForwardInterval;
mMainCameraName = ps.mMainCameraName;
mMainCameraNameSet = ps.mMainCameraNameSet;
mParticleSystemScale = ps.mParticleSystemScale;
mParticleSystemScaleVelocity = ps.mParticleSystemScaleVelocity;
mParticleSystemScaleTime = ps.mParticleSystemScaleTime;
mKeepLocal = ps.mKeepLocal;
mTightBoundingBox = ps.mTightBoundingBox;
mPauseTime = ps.mPauseTime;
mPauseTimeSet = ps.mPauseTimeSet;
mPauseTimeElapsed = ps.mPauseTimeElapsed;
mTemplateName = ps.mTemplateName;
mSceneManager = ps.mSceneManager;
mStopFadeSet = ps.mStopFadeSet;
mCategory = ps.mCategory;
// Notify.
mSuppressNotifyEmissionChange = false;
_notifyEmissionChange();
_notifyRescaled();
_notifyVelocityRescaled();
return *this;
}
SceneEffect::SceneEffect(Qt3DCore::QNode *parent)
: Qt3DRender::QEffect(parent)
, m_gl3Technique(new Qt3DRender::QTechnique())
, m_gl2Technique(new Qt3DRender::QTechnique())
, m_gl2Pass(new Qt3DRender::QRenderPass())
, m_gl3Pass(new Qt3DRender::QRenderPass())
, m_passCriterion(new Qt3DRender::QAnnotation(this))
{
m_gl3Technique->graphicsApiFilter()->setProfile(Qt3DRender::QGraphicsApiFilter::NoProfile);
m_gl3Technique->graphicsApiFilter()->setApi(Qt3DRender::QGraphicsApiFilter::OpenGL);
m_gl3Technique->graphicsApiFilter()->setMajorVersion(3);
m_gl3Technique->graphicsApiFilter()->setMinorVersion(3);
m_gl2Technique->graphicsApiFilter()->setApi(Qt3DRender::QGraphicsApiFilter::OpenGL);
m_gl2Technique->graphicsApiFilter()->setMajorVersion(2);
m_gl2Technique->graphicsApiFilter()->setMinorVersion(0);
m_gl2Technique->graphicsApiFilter()->setProfile(Qt3DRender::QGraphicsApiFilter::NoProfile);
m_passCriterion->setName(QStringLiteral("pass"));
m_passCriterion->setValue(QStringLiteral("geometry"));
Qt3DRender::QShaderProgram *gl3Shader = new Qt3DRender::QShaderProgram();
gl3Shader->setVertexShaderCode(Qt3DRender::QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/geometry_gl3.vert"))));
gl3Shader->setFragmentShaderCode(Qt3DRender::QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/geometry_gl3.frag"))));
m_gl3Pass->addAnnotation(m_passCriterion);
m_gl3Pass->setShaderProgram(gl3Shader);
m_gl3Technique->addPass(m_gl3Pass);
Qt3DRender::QShaderProgram *gl2Shader = new Qt3DRender::QShaderProgram();
gl2Shader->setVertexShaderCode(Qt3DRender::QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/geometry_gl2.vert"))));
gl2Shader->setFragmentShaderCode(Qt3DRender::QShaderProgram::loadSource(QUrl(QStringLiteral("qrc:/geometry_gl2.frag"))));
m_gl2Pass->addAnnotation(m_passCriterion);
m_gl2Pass->setShaderProgram(gl2Shader);
m_gl2Technique->addPass(m_gl2Pass);
addTechnique(m_gl3Technique);
addTechnique(m_gl2Technique);
}
veMaterial* veDeferredRenderPipeline::createSpotLightMaterial(veLight *light)
{
auto material = new veMaterial;
auto technique = new veTechnique;
auto pass0 = new vePass;
auto pass1 = new vePass;
material->addTechnique(technique);
technique->addPass(pass0);
technique->addPass(pass1);
pass0->setRenderPass(vePass::FORWARD_PASS);
pass0->depthTest() = true;
pass0->depthWrite() = false;
pass0->stencilTest() = true;
pass0->cullFace() = false;
pass0->stencilFunc() = { GL_ALWAYS, 0, 0, GL_ALWAYS, 0, 0 };
pass0->stencilOp() = { GL_KEEP, GL_DECR_WRAP, GL_KEEP, GL_KEEP, GL_INCR_WRAP, GL_KEEP };
pass0->blendFunc() = veBlendFunc::DISABLE;
pass0->setShader(new veShader(veShader::VERTEX_SHADER, WORLD_BASED_LIGHT_VERTEX_SHADER));
pass0->setShader(new veShader(veShader::FRAGMENT_SHADER, "layout(location=0) out vec4 fragColor;void main(){}"));
pass0->addUniform(new veUniform("u_ModelViewProjectMat", MVP_MATRIX));
pass0->setApplyFunctionCallback([]() {
glClear(GL_STENCIL_BUFFER_BIT);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
});
initLightCommomParams(light, pass1);
pass1->setRenderPass(vePass::FORWARD_PASS);
pass1->depthTest() = false;
pass1->depthWrite() = false;
pass1->stencilTest() = true;
pass1->cullFace() = true;
pass1->cullFaceMode() = GL_FRONT;
pass1->blendFunc().src = GL_ONE;
pass1->blendFunc().dst = GL_ONE;
pass1->blendEquation() = GL_FUNC_ADD;
pass1->stencilFunc() = { GL_NOTEQUAL, 0, 0xFF, GL_NOTEQUAL, 0, 0xFF };
pass1->setShader(new veShader(veShader::VERTEX_SHADER, WORLD_BASED_LIGHT_VERTEX_SHADER));
pass1->setShader(new veShader(veShader::FRAGMENT_SHADER, SPOT_LIGHT_FRAGMENT_SHADER));
pass1->addUniform(new veUniform("u_ModelViewProjectMat", MVP_MATRIX));
pass1->addUniform(new veUniform("u_lightDirection", veVec3(0.0f)));
pass1->addUniform(new veUniform("u_lightPosition", veVec3(0.0f)));
pass1->addUniform(new veUniform("u_lightMatrix", veMat4::IDENTITY));
pass1->addUniform(new veUniform("u_lightARI", 0.0f));
pass1->addUniform(new veUniform("u_lightInnerAngleCos", 0.0f));
pass1->addUniform(new veUniform("u_lightOuterAngleCos", 0.0f));
pass1->addUniform(new veUniform("u_shadowTex", 4));
pass1->setApplyFunctionCallback([]() {
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
});
return material;
}
//---------------------------------------------------------------------
MaterialPtr TerrainMaterialGeneratorC::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();
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;
}
QMaterial *RayCloudPlot::makeMaterial()
{
auto mat = new QMaterial();
auto eff = new QEffect(mat);
mat->addParameter(m_linewidthParam);
mat->addParameter(m_pixelSize);
mat->addParameter(m_colorParam);
// Set up the shader
auto gl3tech = new QTechnique();
auto api = gl3tech->graphicsApiFilter();
api->setApi(QGraphicsApiFilter::OpenGL);
// api->setMajorVersion(3);
// api->setMinorVersion(1);
// api->setProfile(QGraphicsApiFilter::CoreProfile);
api->setMajorVersion(2);
api->setMinorVersion(0);
api->setProfile(QGraphicsApiFilter::NoProfile);
// Forward render
auto ann = new QAnnotation();
ann->setName("renderingStyle");
ann->setValue("forward");
// Shader render pass
auto gl3program = new QShaderProgram();
gl3program->setVertexShaderCode(QShaderProgram::loadSource(QUrl("qrc:/shaders/ray.vert")));
gl3program->setFragmentShaderCode(QShaderProgram::loadSource(QUrl("qrc:/shaders/ray.frag")));
auto gl3pass = new QRenderPass();
gl3pass->setShaderProgram(gl3program);
// auto pointsize = new QPointSize();
// pointsize->setEnabled(true);
// gl3pass->addRenderState(pointsize);
// auto cullface = new QCullFace();
// cullface->setMode(QCullFace::Front);
// cullface->setEnabled(true);
// gl3pass->addRenderState(cullface);
gl3tech->addAnnotation(ann);
gl3tech->addPass(gl3pass);
// Push it all in
eff->addTechnique(gl3tech);
mat->setEffect(eff);
return mat;
}
veMaterial* veDeferredRenderPipeline::createAmbientLightMaterial()
{
auto material = new veMaterial;
auto technique = new veTechnique;
auto pass = new vePass;
material->addTechnique(technique);
technique->addPass(pass);
pass->setRenderPass(vePass::FORWARD_PASS);
pass->depthTest() = false;
pass->depthWrite() = false;
pass->stencilTest() = false;
pass->cullFace() = true;
pass->cullFaceMode() = GL_BACK;
pass->blendFunc().src = GL_ONE;
pass->blendFunc().dst = GL_ONE;
pass->blendEquation() = GL_FUNC_ADD;
pass->setShader(new veShader(veShader::VERTEX_SHADER, SCREEN_BASED_LIGHT_VERTEX_SHADER));
pass->setShader(new veShader(veShader::FRAGMENT_SHADER, AMBIENT_LIGHT_FRAGMENT_SHADER));
pass->addUniform(new veUniform("u_ambient", veVec3::ZERO));
pass->addUniform(new veUniform("u_RT1", 0));
return material;
}
bool SketchPre::define_techniques()
{
addTechnique(new sketchPreTechnique());
return true;
}
//-----------------------------------------------------------------------
ParticleTechnique* ParticleSystem::createTechnique(void)
{
ParticleTechnique* technique = ParticleSystemManager::getSingletonPtr()->createTechnique();
addTechnique(technique);
return technique;
}
bool SketchPost::define_techniques()
{
addTechnique(new SketchPostTechnique());
return true;
}
