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;
}
void MeshPicking::process() {
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepthPicking);
MeshDrawerGL drawer(meshInport_.getData().get());
shader_.activate();
shader_.setUniform("pickingColor_", picking_.getPickingObject()->getPickingColor());
const auto& ct = meshInport_.getData()->getCoordinateTransformer(camera_.get());
mat4 dataToClip =
ct.getWorldToClipMatrix() * glm::translate(position_.get()) * ct.getDataToWorldMatrix();
shader_.setUniform("dataToClip", dataToClip);
{
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
utilgl::CullFaceState culling(cullFace_.get());
utilgl::DepthFuncState depthfunc(GL_ALWAYS);
drawer.draw();
}
shader_.deactivate();
utilgl::deactivateCurrentTarget();
compositePortsToOutport(outport_, ImageType::ColorDepthPicking, imageInport_);
}
void MeshRenderProcessorGL::process() {
if (imageInport_.isConnected()){
utilgl::activateTargetAndCopySource(outport_, imageInport_);
}
else{
utilgl::activateAndClearTarget(outport_, COLOR_DEPTH);
}
shader_.activate();
utilgl::setShaderUniforms(shader_, camera_, "camera_");
utilgl::setShaderUniforms(shader_, lightingProperty_, "light_");
utilgl::setShaderUniforms(shader_, overrideColor_);
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
utilgl::CullFaceState culling(cullFace_.get());
utilgl::PolygonModeState polygon(polygonMode_.get(), renderLineWidth_, renderPointSize_);
for (auto& drawer : drawers_) {
utilgl::setShaderUniforms(shader_, *(drawer.second->getGeometry()), "geometry_");
drawer.second->draw();
}
shader_.deactivate();
utilgl::deactivateCurrentTarget();
}
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;
}
void PCPUploadRenderer::renderParallelCoordinates() {
std::shared_ptr<const ParallelCoordinatesPlotRawData> data = _inport.getData();
int nDimensions = data->minMax.size();
int nValues = data->data.size();
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, !_depthTesting);
utilgl::BlendModeEquationState blendEquation(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_FUNC_ADD);
utilgl::GlBoolState lineSmooth(GL_LINE_SMOOTH, _lineSmoothing);
if (_lineSmoothing)
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
_shader.activate();
_shader.setUniform("_nDimensions", nDimensions);
_shader.setUniform("_nData", nValues / nDimensions);
_shader.setUniform("_horizontalBorder", _horizontalBorder);
_shader.setUniform("_verticalBorder", _verticalBorder);
_shader.setUniform("_depthTesting", !_depthTesting);
_shader.setUniform("_alphaFactor", _alphaFactor);
TextureUnit tfUnit;
utilgl::bindTexture(_transFunc, tfUnit);
_shader.setUniform("_transFunc", tfUnit.getUnitNumber());
glBindVertexArray(_vao);
bool hasColoringData = _coloringData.hasData() && _coloringData.getData()->hasData;
_shader.setUniform("_hasColoringData", hasColoringData);
if (hasColoringData) {
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, _coloringData.getData()->ssboColor);
}
//glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, data->ssboData);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, _dimensionOrderingBuffer);
//for (int i = 0; i < nValues / nDimensions; ++i) {
// glDrawElements(GL_LINE_STRIP, nDimensions, )
//}
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(PRIM_RESTART);
glDrawElements(GL_LINE_STRIP, nValues / nDimensions, GL_UNSIGNED_INT, _drawElements);
glDisable(GL_PRIMITIVE_RESTART);
//glDrawArrays(GL_LINE_STRIP, 0, nValues);
//glMultiDrawArrays(GL_LINE_STRIP, _multiDrawIndices, _multiDrawCount, nValues / nDimensions);
//glDrawArraysInstanced(GL_LINE_STRIP, 0, data->nDimensions, data->nValues / data->nDimensions);
glBindVertexArray(0);
_shader.deactivate();
}
void MeshRenderProcessorGLSR::process() {
/* if (imageInport_.isConnected()) {
utilgl::activateTargetAndCopySource(outport_, imageInport_);
} else {
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepth);
} */
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepth);
if (meshName_.isConnected())
{
auto inDescr = *meshName_.getData();
sceneDesc_->setInputName(inDescr.getInputName());
}
//LogInfo(inport_.getContentInfo());
//LogInfo(inport_.getClassIdentifier());
shader_.activate();
utilgl::setShaderUniforms(shader_, camera_, "camera_");
//std::cout << "Camera Position = " << camera_.position.x
LogInfo(camera_.getLookFrom());
utilgl::setShaderUniforms(shader_, lightingProperty_, "light_");
LogInfo(lightingProperty_.silhouetteThreshold_);
LogInfo(lightingProperty_.depthThreshold_);
LogInfo(lightingProperty_.specularExponent_);
utilgl::setShaderUniforms(shader_, lightingProperty_.silhouetteThreshold_, "threshold_sil");
utilgl::setShaderUniforms(shader_, lightingProperty_.depthThreshold_, "threshold_depth");
utilgl::setShaderUniforms(shader_, overrideColor_);
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, enableDepthTest_.get());
utilgl::CullFaceState culling(cullFace_.get());
utilgl::PolygonModeState polygon(polygonMode_.get(), renderLineWidth_, renderPointSize_);
for (auto& drawer : drawers_) {
utilgl::setShaderUniforms(shader_, *(drawer.second->getGeometry()), "geometry_");
drawer.second->draw();
}
sceneDesc_->setImageDimensions(outport_.getDimensions());
sceneDesc_->setShaderName(lightingProperty_.shadingMode_.getSelectedDisplayName());
sceneDesc_->setLayerDescription(layersDeclaration_);
/*setImageDimensions(*sceneDesc_);
setShaderName(*sceneDesc_);
setLayerDescription(*sceneDesc_);*/
sceneDesc_->printDescription();
sceneDescOutport_.setData(sceneDesc_);
utilgl::deactivateCurrentTarget();
}
Material::Material(Material_t tag)
: tag(tag),
vertexShader(this),
fragmentShader(this),
index0AttributeName(this)
{
mId = Material::MaterialIdCount++;
mUuid = Math::generateUUID();
mName = "";
side() = kFrontSide;
opacity() = 1.0f;
transparent() = false;
blending() = kNormalBlending;
blendSrc() = kSrcAlphaFactor;
blendDst() = kOneMinusSrcAlphaFactor;
blendEquation() = kAddEquation;
depthTest() = true;
depthWrite() = true;
polygonOffset() = false;
polygonOffsetFactor() = 0;
polygonOffsetUnits() = 0;
// mAlphaTest = 0;
overdraw() = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer
visible() = true;
needsUpdate() = true;
// By default, bind position to attribute index 0. In WebGL, attribute 0
// should always be used to avoid potentially expensive emulation.
index0AttributeName("position");
linewidth() = 1.0f;
metal() = false;
perPixel() = true;
shading() = kNoShading;
vertexColors() = kNoColors;
wireframe() = false;
wireframeLinewidth() = 1.0f;
}
void PCPRenderer::renderParallelCoordinates() {
std::shared_ptr<const ParallelCoordinatesPlotData> data = _inport.getData();
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, !_depthTesting);
//utilgl::GlBoolState alpha(GL_ALPHA, _alphaFactor != 1.f);
utilgl::BlendModeEquationState blendEquation(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_FUNC_ADD);
utilgl::GlBoolState lineSmooth(GL_LINE_SMOOTH, _lineSmoothing);
if (_lineSmoothing)
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
_shader.activate();
_shader.setUniform("_nDimensions", data->nDimensions);
_shader.setUniform("_nData", data->nValues / data->nDimensions);
_shader.setUniform("_horizontalBorder", _horizontalBorder);
_shader.setUniform("_verticalBorder", _verticalBorder);
_shader.setUniform("_depthTesting", _depthTesting);
_shader.setUniform("_alphaFactor", _alphaFactor);
TextureUnit tfUnit;
utilgl::bindTexture(_transFunc, tfUnit);
_shader.setUniform("_transFunc", tfUnit.getUnitNumber());
glBindVertexArray(_vao);
bool hasColoringData = _coloringData.hasData() && _coloringData.getData()->hasData;
_shader.setUniform("_hasColoringData", hasColoringData);
if (hasColoringData) {
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, _coloringData.getData()->ssboColor);
}
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, data->ssboData);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, _dimensionOrderingBuffer);
glDrawArraysInstanced(GL_LINE_STRIP, 0, data->nDimensions, data->nValues / data->nDimensions);
glBindVertexArray(0);
_shader.deactivate();
}
void AxisAlignedCutPlane::process() {
if (imageInport_.isConnected()) {
utilgl::activateTargetAndCopySource(outport_, imageInport_, ImageType::ColorDepth);
} else {
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepth);
}
if (!boundingBoxDrawer_) {
boundingBoxDrawer_ =
getNetwork()->getApplication()->getMeshDrawerFactory()->create(boundingBoxMesh_.get());
}
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
drawBoundingBox();
TextureUnitContainer cont;
sliceShader_.activate();
utilgl::setShaderUniforms(sliceShader_, camera_, "camera_");
utilgl::bindAndSetUniforms(sliceShader_, cont, volume_);
if (nearestInterpolation_.get()) {
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
} else {
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
if (!disableTF_.get()) {
utilgl::bindAndSetUniforms(sliceShader_, cont, tf_);
}
xSlide_.draw(sliceShader_);
ySlide_.draw(sliceShader_);
zSlide_.draw(sliceShader_);
sliceShader_.deactivate();
utilgl::deactivateCurrentTarget();
}
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;
}
void ABufferGeometryGLProcessor::geometryRender() {
ABUFFER_PROFILE("Total-Time");
// tempImage_ = new Image(outport_.getDimensions());
auto tempImage_ = outport_.getEditableData();
ImageGL* tempImageGL = tempImage_->getEditableRepresentation<ImageGL>();
ivec2 dim = outport_.getDimensions();
bool abufferEnabled = abuffer_.settings_.abufferEnable_.get();
// abuffer initialization
if (abufferEnabled) {
ABUFFER_PROFILE("Initialize-abuffer");
abuffer_.abuffer_initABuffer(dim, updateRequried_);
LGL_ERROR;
abuffer_.abuffer_addShaderDefinesAndBuild(&abuffer_.resolveABufferShader_);
LGL_ERROR;
ABUFFER_PROFILE("Reset-abuffer");
abuffer_.aBuffer_resetLinkList(tempImageGL);
updateRequried_ = false;
}
abuffer_.abuffer_addShaderDefinesAndBuild(&abufferGeometryShader_);
// Rendering
{
ABUFFER_PROFILE("Rendering");
tempImageGL = tempImage_->getEditableRepresentation<ImageGL>();
utilgl::activateAndClearTarget(outport_);
// initialize shader
abufferGeometryShader_.activate();
// LGL_ERROR;
utilgl::setShaderUniforms(abufferGeometryShader_, camera_, "camera_");
// LGL_ERROR;
utilgl::setShaderUniforms(abufferGeometryShader_, lightingProperty_, "light_");
// LGL_ERROR;
if (abufferEnabled) {
abuffer_.abuffer_addUniforms(&abufferGeometryShader_);
abufferGeometryShader_.setUniform("globalTransparency_", transparency_.get());
}
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
utilgl::CullFaceState culling(cullFace_.get());
utilgl::PolygonModeState polygon(polygonMode_.get(), renderLineWidth_, renderPointSize_);
for (auto& drawer : drawers_) {
utilgl::setShaderUniforms(abufferGeometryShader_, *(drawer.second->getGeometry()),
"geometry_");
drawer.second->draw();
}
abufferGeometryShader_.deactivate();
utilgl::deactivateCurrentTarget();
glMemoryBarrierEXT(GL_ALL_BARRIER_BITS_EXT);
}
// abuffer resolve
if (abufferEnabled) {
ABUFFER_PROFILE("Resolving-abuffer");
utilgl::activateAndClearTarget(outport_);
abuffer_.aBuffer_resolveLinkList(tempImageGL);
utilgl::deactivateCurrentTarget();
}
}
