mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Copied in RPM/Fwk/AppFwk
Commented out use of stipple line, as VizFwk is not update yet
This commit is contained in:
Magne Sjaastad
@@ -0,0 +1,557 @@
|
||||
|
||||
#include "cafTransparentWBRenderConfiguration.h"
|
||||
|
||||
#include "cvfLibCore.h"
|
||||
#include "cvfLibRender.h"
|
||||
#include "cvfLibViewing.h"
|
||||
#include "cvfRenderQueueSorter.h"
|
||||
#include "cvfDynamicUniformSet.h"
|
||||
|
||||
#include "TranspWB_Shaders.h"
|
||||
|
||||
namespace caf {
|
||||
|
||||
using namespace cvf;
|
||||
|
||||
/*
|
||||
This is an implementation of
|
||||
Weighted Blended Order-Independent Transparency
|
||||
based on
|
||||
Morgan McGuire and Louis Bavoil NVIDIA
|
||||
Journal of Computer Graphics Techniques Vol. 2, No. 2, 2013
|
||||
|
||||
It can be developed further to support completely unsorted and partially transparent objects
|
||||
by making the first pass include all parts, but discard transparent fragments,
|
||||
while the transparency pass discards all opaque fragments.
|
||||
This should be quite possible. (Experimentally done now)
|
||||
|
||||
A more experimental idea To improve high opaque transparent object looks, and make them
|
||||
hide the transparent object behind, better,
|
||||
we can set a threshold on the opacity (above 0.9 e.g), and limis it contribution to the
|
||||
blended color to just include one (possible) transparent layer behind it.
|
||||
To do this we will try to make the Z-buffer for the transparent pass contain the
|
||||
depth of the fragment behind the one with opaqueThreshold < alpha < 1.0
|
||||
|
||||
To do this we need to do somewhat the following (experimental idea):
|
||||
P0 Opaque Pass => TB: OpaqueBuffer, DB: DepthBufferOpaque, TB: DepthBufferToPeel
|
||||
Including all parts
|
||||
Discarding all transparent fragments with alpha < opaqueThreshold
|
||||
Opaque fragments rendered normally, also write to depth to DepthbufferToPeel
|
||||
If (opaqueThreshold < alpha < 1.0) discard color, write depth to DepthBufferToPeel
|
||||
|
||||
P1 Peel Pass (TB: DepthBufferToPeel) ==> PeeledDepthBuffer
|
||||
Discarding all transparent fragments with alpha < opaqueThreshold
|
||||
Discard all fragments with depth <= DepthBufferToPeel,
|
||||
Normal depth test
|
||||
|
||||
P3 Transparent Pass (DB: DepthBufferOpaque, TB: PeeledDepthBuffer) => WeightedSumColorAndAlpha, ProdOneMinusAlpha
|
||||
This pass is the mostly the same as the one described in the original method except (No write to depth buffer)
|
||||
Discard Opaque fragments
|
||||
if (depth > PeeledDepthBuffer) discard
|
||||
|
||||
P4 Combination pass
|
||||
|
||||
*/
|
||||
|
||||
class RenderPassPreparator : public cvf::DynamicUniformSet
|
||||
{
|
||||
public:
|
||||
RenderPassPreparator(TransparentWBRenderConfiguration* renderConfiguration)
|
||||
{
|
||||
CVF_ASSERT(renderConfiguration);
|
||||
m_renderConfiguration = renderConfiguration;
|
||||
}
|
||||
virtual cvf::UniformSet* uniformSet() { return NULL; }
|
||||
virtual void update(cvf::Rendering* rendering)
|
||||
{
|
||||
m_renderConfiguration->updateEffectsForRendering(rendering);
|
||||
}
|
||||
|
||||
private:
|
||||
TransparentWBRenderConfiguration * m_renderConfiguration;
|
||||
};
|
||||
|
||||
|
||||
class RenderQueueFilter : public cvf::RenderQueueSorterBasic
|
||||
{
|
||||
public:
|
||||
RenderQueueFilter(cvf::RenderStateBlending* blendingToRespect, bool isOpaquePass, cvf::RenderQueueSorterBasic::SortStrategy sortStrategy):
|
||||
cvf::RenderQueueSorterBasic(sortStrategy)
|
||||
{
|
||||
CVF_ASSERT(blendingToRespect);
|
||||
|
||||
m_blendingToRespect = blendingToRespect;
|
||||
m_isOpaquePass = isOpaquePass;
|
||||
}
|
||||
|
||||
virtual void sort(cvf::RenderQueue* renderQueue) const
|
||||
{
|
||||
using namespace cvf;
|
||||
std::vector<RenderItem*>* renderItems = renderQueue->renderItemsForSorting();
|
||||
std::vector<RenderItem*> filteredRenderItems;
|
||||
filteredRenderItems.reserve(renderItems->size());
|
||||
|
||||
for (size_t riIdx = 0; riIdx < renderItems->size(); ++riIdx)
|
||||
{
|
||||
bool hasBlending = (*renderItems)[riIdx]->effect()->renderStateOfType(cvf::RenderState::BLENDING) == m_blendingToRespect.p();
|
||||
if (m_isOpaquePass && !hasBlending)
|
||||
{
|
||||
filteredRenderItems.push_back((*renderItems)[riIdx]);
|
||||
}
|
||||
if (!m_isOpaquePass && hasBlending)
|
||||
{
|
||||
filteredRenderItems.push_back((*renderItems)[riIdx]);
|
||||
}
|
||||
}
|
||||
|
||||
renderItems->swap(filteredRenderItems);
|
||||
|
||||
cvf::RenderQueueSorterBasic::sort(renderQueue);
|
||||
}
|
||||
|
||||
private:
|
||||
cvf::ref<cvf::RenderStateBlending> m_blendingToRespect;
|
||||
bool m_isOpaquePass;
|
||||
};
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
TransparentWBRenderConfiguration::TransparentWBRenderConfiguration()
|
||||
{
|
||||
// Initialize effect system
|
||||
WBTransparencySurfaceEffectGenerator::initStaticData();
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
TransparentWBRenderConfiguration::~TransparentWBRenderConfiguration()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void TransparentWBRenderConfiguration::setUpRenderSequence(cvf::RenderSequence* renderSeq)
|
||||
{
|
||||
if (EffectGenerator::renderingMode() == EffectGenerator::SHADER_BASED)
|
||||
{
|
||||
// Set up opaque pass
|
||||
ref<RenderbufferObject> depthBuffer = new RenderbufferObject(RenderbufferObject::DEPTH_COMPONENT24, 1, 1);
|
||||
ref<Texture> opaceColorTexture = new Texture(Texture::TEXTURE_RECTANGLE, Texture::RGBA32F);
|
||||
ref<Texture> sumWeightedRgbAndProductOneMinusAlphaTexture = new Texture(Texture::TEXTURE_RECTANGLE, Texture::RGBA32F);
|
||||
ref<Texture> sumWeightedAlphaTexture = new Texture(Texture::TEXTURE_RECTANGLE, Texture::R32F);
|
||||
|
||||
ref<RenderPassPreparator> renderPassPrep = new RenderPassPreparator(this);
|
||||
|
||||
{
|
||||
m_opaceRendering = renderSeq->firstRendering();
|
||||
CVF_ASSERT(m_opaceRendering.notNull());
|
||||
|
||||
m_opaceRenderingFbo = new FramebufferObject;
|
||||
|
||||
m_opaceRenderingFbo->attachDepthRenderbuffer(depthBuffer.p());
|
||||
|
||||
opaceColorTexture->setSize(1, 1);
|
||||
m_opaceRenderingFbo->attachColorTexture2d(0, opaceColorTexture.p());
|
||||
|
||||
m_opaceRendering->setTargetFramebuffer(m_opaceRenderingFbo.p());
|
||||
//m_opaceRendering->camera()->viewport()->setClearColor(Color4f(0.69f, 0.77f, 0.87f, 1.0f));
|
||||
m_opaceRendering->addDynamicUniformSet(renderPassPrep.p());
|
||||
m_opaceRendering->setRenderQueueSorter(new RenderQueueFilter(WBTransparencySurfaceEffectGenerator::m_blending.p(), true, RenderQueueSorterBasic::EFFECT_ONLY));
|
||||
|
||||
}
|
||||
|
||||
// Set up transparency pass
|
||||
{
|
||||
// Frame buffer
|
||||
m_transparencyFbo = new FramebufferObject;
|
||||
|
||||
m_transparencyFbo->attachDepthRenderbuffer(depthBuffer.p());
|
||||
|
||||
sumWeightedRgbAndProductOneMinusAlphaTexture->setSize(1, 1);
|
||||
m_transparencyFbo->attachColorTexture2d(0, sumWeightedRgbAndProductOneMinusAlphaTexture.p());
|
||||
|
||||
sumWeightedAlphaTexture->setSize(1, 1);
|
||||
m_transparencyFbo->attachColorTexture2d(1, sumWeightedAlphaTexture.p());
|
||||
|
||||
// Rendering
|
||||
m_transparentRendering = new Rendering;
|
||||
|
||||
m_transparentRendering->setTargetFramebuffer(m_transparencyFbo.p());
|
||||
ref<Camera> transpCam = new Camera;
|
||||
transpCam->viewport()->setClearColor(Color4f(0, 0, 0, 1));
|
||||
copyCameraView(renderSeq->firstRendering()->camera(), transpCam.p());
|
||||
m_transparentRendering->setCamera(transpCam.p());
|
||||
m_transparentRendering->setClearMode(Viewport::CLEAR_COLOR);
|
||||
|
||||
renderSeq->addRendering(m_transparentRendering.p());
|
||||
m_transparentRendering->addDynamicUniformSet(renderPassPrep.p());
|
||||
m_transparentRendering->setRenderQueueSorter(new RenderQueueFilter(WBTransparencySurfaceEffectGenerator::m_blending.p(), false, RenderQueueSorterBasic::EFFECT_ONLY));
|
||||
}
|
||||
|
||||
// Setup last rendering combining the textures on the screen
|
||||
// -------------------------------------------------------------------------
|
||||
{
|
||||
SingleQuadRenderingGenerator quadRenderGen;
|
||||
ref<Sampler> sampler = new Sampler;
|
||||
sampler->setWrapMode(cvf::Sampler::CLAMP_TO_EDGE);
|
||||
sampler->setMinFilter(cvf::Sampler::NEAREST);
|
||||
sampler->setMagFilter(cvf::Sampler::NEAREST);
|
||||
|
||||
quadRenderGen.addTexture(sumWeightedRgbAndProductOneMinusAlphaTexture.p(), sampler.p(), "sumWeightedRgbAndProductOneMinusAlphaTexture");
|
||||
quadRenderGen.addTexture(sumWeightedAlphaTexture.p(), sampler.p(), "sumWeightedAlphaTexture");
|
||||
quadRenderGen.addTexture(opaceColorTexture.p(), sampler.p(), "opaceColorTexture");
|
||||
|
||||
quadRenderGen.addFragmentShaderCode(String(TranspWB_CombinationFrag_inl));
|
||||
m_combinationRendering = quadRenderGen.generate();
|
||||
renderSeq->addRendering(m_combinationRendering.p());
|
||||
m_combinationRendering->addDynamicUniformSet(renderPassPrep.p());
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_opaceRendering = renderSeq->firstRendering();
|
||||
m_opaceRendering->setRenderQueueSorter(new RenderQueueFilter(WBTransparencySurfaceEffectGenerator::m_oGL11Blending.p(), true, RenderQueueSorterBasic::EFFECT_ONLY));
|
||||
|
||||
m_transparentRendering = new Rendering;
|
||||
ref<Camera> transpCam = new Camera;
|
||||
copyCameraView(renderSeq->firstRendering()->camera(), transpCam.p());
|
||||
m_transparentRendering->setCamera(transpCam.p());
|
||||
m_transparentRendering->setClearMode(Viewport::DO_NOT_CLEAR);
|
||||
|
||||
renderSeq->addRendering(m_transparentRendering.p());
|
||||
m_transparentRendering->setRenderQueueSorter(new RenderQueueFilter(WBTransparencySurfaceEffectGenerator::m_oGL11Blending.p(), false, RenderQueueSorterBasic::BACK_TO_FRONT));
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void TransparentWBRenderConfiguration::resize(int width, int height)
|
||||
{
|
||||
// Resize the FBO (and the rendering viewports)
|
||||
|
||||
m_opaceRendering->camera()->viewport()->set(0, 0, width, height);
|
||||
m_transparentRendering->camera()->viewport()->set(0, 0, width, height);
|
||||
|
||||
if (EffectGenerator::renderingMode() == EffectGenerator::SHADER_BASED)
|
||||
{
|
||||
m_combinationRendering->camera()->viewport()->set(0, 0, width, height);
|
||||
|
||||
m_opaceRenderingFbo->resizeAttachedBuffers(width, height);
|
||||
m_transparencyFbo->resizeAttachedBuffers(width, height);
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void TransparentWBRenderConfiguration::copyCameraView(Camera* srcCamera, Camera* dstCamera)
|
||||
{
|
||||
if (srcCamera->projection() == Camera::PERSPECTIVE)
|
||||
{
|
||||
dstCamera->setProjectionAsPerspective(srcCamera->fieldOfViewYDeg(), srcCamera->nearPlane(), srcCamera->farPlane());
|
||||
}
|
||||
else
|
||||
{
|
||||
dstCamera->setProjectionAsOrtho(srcCamera->frontPlaneFrustumHeight(), srcCamera->nearPlane(), srcCamera->farPlane());
|
||||
}
|
||||
|
||||
dstCamera->setViewMatrix(srcCamera->viewMatrix());
|
||||
}
|
||||
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void TransparentWBRenderConfiguration::prepareForRendering()
|
||||
{
|
||||
m_transparentRendering->setScene(m_opaceRendering->scene());
|
||||
copyCameraView(m_opaceRendering->camera(), m_transparentRendering->camera());
|
||||
WBTransparencySurfaceEffectGenerator::m_cameraNearUniform->set((float)(m_opaceRendering->camera()->nearPlane()));
|
||||
WBTransparencySurfaceEffectGenerator::m_cameraFarUniform->set((float)(m_opaceRendering->camera()->farPlane()));
|
||||
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void TransparentWBRenderConfiguration::updateEffectsForRendering(Rendering *rendering)
|
||||
{
|
||||
if (EffectGenerator::renderingMode() == EffectGenerator::SHADER_BASED)
|
||||
{
|
||||
// This is to support partially transparent objects. So not yet actually operational.
|
||||
if (rendering == m_opaceRendering)
|
||||
{
|
||||
WBTransparencySurfaceEffectGenerator::m_renderPassUniform->set(1);
|
||||
WBTransparencySurfaceEffectGenerator::m_blending->enableBlending(false);
|
||||
WBTransparencySurfaceEffectGenerator::m_depth->enableDepthWrite(true);
|
||||
}
|
||||
else if (rendering == m_transparentRendering)
|
||||
{
|
||||
WBTransparencySurfaceEffectGenerator::m_renderPassUniform->set(0);
|
||||
WBTransparencySurfaceEffectGenerator::m_blending->enableBlending(true);
|
||||
WBTransparencySurfaceEffectGenerator::m_depth->enableDepthWrite(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::Rendering> TransparentWBRenderConfiguration::overlayRendering()
|
||||
{
|
||||
if (EffectGenerator::renderingMode() == EffectGenerator::SHADER_BASED)
|
||||
{
|
||||
return m_combinationRendering;
|
||||
}
|
||||
else
|
||||
{
|
||||
return m_transparentRendering;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//==================================================================================================
|
||||
//
|
||||
// WBTransparencySurfaceEffectGenerator
|
||||
//
|
||||
//==================================================================================================
|
||||
|
||||
cvf::ref<cvf::ShaderProgram> WBTransparencySurfaceEffectGenerator::m_shaderForTransparentParts;
|
||||
cvf::ref<cvf::ShaderProgram> WBTransparencySurfaceEffectGenerator::m_shaderForOpaqueParts;
|
||||
cvf::ref<cvf::ShaderProgram> WBTransparencySurfaceEffectGenerator::m_shaderForTransparentPartsSpec;
|
||||
cvf::ref<cvf::ShaderProgram> WBTransparencySurfaceEffectGenerator::m_shaderForOpaquePartsSpec;
|
||||
cvf::ref<cvf::UniformInt> WBTransparencySurfaceEffectGenerator::m_renderPassUniform;
|
||||
cvf::ref<cvf::RenderStateBlending> WBTransparencySurfaceEffectGenerator::m_blending;
|
||||
cvf::ref<cvf::RenderStateBlending> WBTransparencySurfaceEffectGenerator::m_oGL11Blending;
|
||||
cvf::ref<cvf::RenderStateDepth> WBTransparencySurfaceEffectGenerator::m_depth;
|
||||
|
||||
cvf::ref<cvf::UniformFloat> WBTransparencySurfaceEffectGenerator::m_cameraNearUniform;
|
||||
cvf::ref<cvf::UniformFloat> WBTransparencySurfaceEffectGenerator::m_cameraFarUniform;
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
WBTransparencySurfaceEffectGenerator::WBTransparencySurfaceEffectGenerator(const cvf::Color4f& color, PolygonOffset polygonOffset, bool useSpecular)
|
||||
{
|
||||
m_color = color;
|
||||
m_polygonOffset = polygonOffset;
|
||||
m_useSpecularColor = useSpecular;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void WBTransparencySurfaceEffectGenerator::updateForShaderBasedRendering(cvf::Effect* effect) const
|
||||
{
|
||||
if (m_color.a() < 1.0f)
|
||||
{
|
||||
if (m_useSpecularColor)
|
||||
{
|
||||
effect->setShaderProgram(m_shaderForTransparentPartsSpec.p());
|
||||
}
|
||||
else
|
||||
{
|
||||
effect->setShaderProgram(m_shaderForTransparentParts.p());
|
||||
}
|
||||
//effect->setUniform(m_renderPassUniform.p()); // To be used in effects for partially transparent objects
|
||||
effect->setUniform(m_cameraNearUniform.p());
|
||||
effect->setUniform(m_cameraFarUniform.p());
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_useSpecularColor)
|
||||
{
|
||||
effect->setShaderProgram(m_shaderForOpaquePartsSpec.p());
|
||||
}
|
||||
else
|
||||
{
|
||||
effect->setShaderProgram(m_shaderForOpaqueParts.p());
|
||||
}
|
||||
}
|
||||
|
||||
effect->setUniform(new cvf::UniformFloat("u_color", m_color));
|
||||
|
||||
if (m_color.a() < 1.0f)
|
||||
{
|
||||
effect->setRenderState(m_blending.p());
|
||||
}
|
||||
|
||||
this->updateCommonEffect(effect);
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void WBTransparencySurfaceEffectGenerator::updateForFixedFunctionRendering(cvf::Effect* effect) const
|
||||
{
|
||||
cvf::ref<cvf::Effect> eff = effect;
|
||||
|
||||
cvf::ref<cvf::RenderStateMaterial_FF> mat = new cvf::RenderStateMaterial_FF(m_color.toColor3f());
|
||||
mat->setAlpha(m_color.a());
|
||||
|
||||
eff->setRenderState(mat.p());
|
||||
|
||||
cvf::ref<cvf::RenderStateLighting_FF> lighting = new cvf::RenderStateLighting_FF;
|
||||
lighting->enableTwoSided(true);
|
||||
eff->setRenderState(lighting.p());
|
||||
|
||||
if (m_color.a() < 1.0f)
|
||||
{
|
||||
effect->setRenderState(m_oGL11Blending.p());
|
||||
}
|
||||
|
||||
this->updateCommonEffect(effect);
|
||||
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void WBTransparencySurfaceEffectGenerator::updateCommonEffect(cvf::Effect* effect) const
|
||||
{
|
||||
if (m_polygonOffset != PO_NONE)
|
||||
{
|
||||
cvf::ref<cvf::RenderStatePolygonOffset> polyOffset = EffectGenerator::CreateAngConfigurePolygonOffsetRenderState(m_polygonOffset);
|
||||
effect->setRenderState(polyOffset.p());
|
||||
}
|
||||
|
||||
if (m_color.a() < 1.0f)
|
||||
{
|
||||
effect->setRenderState(m_depth.p());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool WBTransparencySurfaceEffectGenerator::isEqual(const EffectGenerator* other) const
|
||||
{
|
||||
const WBTransparencySurfaceEffectGenerator* otherSurfaceEffect = dynamic_cast<const WBTransparencySurfaceEffectGenerator*>(other);
|
||||
|
||||
if (otherSurfaceEffect)
|
||||
{
|
||||
if (m_color == otherSurfaceEffect->m_color
|
||||
&& m_polygonOffset == otherSurfaceEffect->m_polygonOffset
|
||||
&& m_useSpecularColor == otherSurfaceEffect->m_useSpecularColor)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
EffectGenerator* WBTransparencySurfaceEffectGenerator::copy() const
|
||||
{
|
||||
WBTransparencySurfaceEffectGenerator* effGen = new WBTransparencySurfaceEffectGenerator(m_color, m_polygonOffset, m_useSpecularColor);
|
||||
|
||||
return effGen;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void WBTransparencySurfaceEffectGenerator::initStaticData()
|
||||
{
|
||||
if (m_blending.notNull()) return;
|
||||
|
||||
{
|
||||
ShaderProgramGenerator transpPartsShaderGen("TranspPartsShader", ShaderSourceProvider::instance());
|
||||
transpPartsShaderGen.addVertexCode(cvf::ShaderSourceRepository::vs_Standard);
|
||||
transpPartsShaderGen.addFragmentCode(ShaderSourceRepository::src_Color);
|
||||
transpPartsShaderGen.addFragmentCode(CommonShaderSources::light_AmbientDiffuse());
|
||||
|
||||
transpPartsShaderGen.addFragmentCode(String(TranspWB_TransparentPartsFrag_inl));
|
||||
|
||||
m_shaderForTransparentParts = transpPartsShaderGen.generate();
|
||||
}
|
||||
{
|
||||
ShaderProgramGenerator transpPartsShaderGen("TranspPartsShader", ShaderSourceProvider::instance());
|
||||
transpPartsShaderGen.addVertexCode(cvf::ShaderSourceRepository::vs_Standard);
|
||||
transpPartsShaderGen.addFragmentCode(ShaderSourceRepository::src_Color);
|
||||
transpPartsShaderGen.addFragmentCode(ShaderSourceRepository::light_SimpleHeadlight);
|
||||
|
||||
transpPartsShaderGen.addFragmentCode(String(TranspWB_TransparentPartsFrag_inl));
|
||||
|
||||
m_shaderForTransparentPartsSpec = transpPartsShaderGen.generate();
|
||||
}
|
||||
|
||||
#if 0 // Code to use when implementing support for partial transparency, but supposedly in a different effect generator
|
||||
{
|
||||
// Shader for partly transparent objects
|
||||
|
||||
ShaderProgramGenerator partlyTranspShaderGen("CommonShader", ShaderSourceProvider::instance());
|
||||
partlyTranspShaderGen.addVertexCode(cvf::ShaderSourceRepository::vs_Standard);
|
||||
partlyTranspShaderGen.addFragmentCode(ShaderSourceRepository::src_Color);
|
||||
partlyTranspShaderGen.addFragmentCode(ShaderSourceRepository::light_SimpleHeadlight);
|
||||
partlyTranspShaderGen.addFragmentCode(String(TranspWB_PartlyTranspPartsFrag_inl));
|
||||
|
||||
m_partlyTranspPartShader = partlyTranspShaderGen.generate();
|
||||
}
|
||||
#endif
|
||||
|
||||
{
|
||||
ShaderProgramGenerator opaquePartsShaderGen("OpaquePartsShader", ShaderSourceProvider::instance());
|
||||
opaquePartsShaderGen.addVertexCode(cvf::ShaderSourceRepository::vs_Standard);
|
||||
opaquePartsShaderGen.addFragmentCode(ShaderSourceRepository::src_Color);
|
||||
opaquePartsShaderGen.addFragmentCode(CommonShaderSources::light_AmbientDiffuse());
|
||||
opaquePartsShaderGen.addFragmentCode(ShaderSourceRepository::fs_Standard);
|
||||
m_shaderForOpaqueParts = opaquePartsShaderGen.generate();
|
||||
}
|
||||
{
|
||||
ShaderProgramGenerator opaquePartsShaderGen("OpaquePartsShader", ShaderSourceProvider::instance());
|
||||
opaquePartsShaderGen.addVertexCode(cvf::ShaderSourceRepository::vs_Standard);
|
||||
opaquePartsShaderGen.addFragmentCode(ShaderSourceRepository::src_Color);
|
||||
opaquePartsShaderGen.addFragmentCode(ShaderSourceRepository::light_SimpleHeadlight);
|
||||
opaquePartsShaderGen.addFragmentCode(ShaderSourceRepository::fs_Standard);
|
||||
m_shaderForOpaquePartsSpec = opaquePartsShaderGen.generate();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
m_blending = new RenderStateBlending;
|
||||
m_blending->setFunctionSeparate(RenderStateBlending::ONE, RenderStateBlending::ONE, RenderStateBlending::ZERO, RenderStateBlending::ONE_MINUS_SRC_ALPHA);
|
||||
m_blending->setEquation(RenderStateBlending::FUNC_ADD);
|
||||
m_blending->enableBlending(true);
|
||||
|
||||
m_oGL11Blending = new RenderStateBlending;
|
||||
m_oGL11Blending->configureTransparencyBlending();
|
||||
|
||||
m_depth = new RenderStateDepth;
|
||||
m_depth->enableDepthWrite(false);
|
||||
|
||||
m_renderPassUniform = new UniformInt("isOpaquePass", 1);
|
||||
m_cameraNearUniform = new UniformFloat("cameraNear", 0.01);
|
||||
m_cameraFarUniform = new UniformFloat("cameraFar",1000);
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
WBTransparencySurfaceEffectGenerator::~WBTransparencySurfaceEffectGenerator()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user