summaryrefslogtreecommitdiffstats
path: root/src/runtimerender/rendererimpl/Qt3DSRenderableObjects.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/runtimerender/rendererimpl/Qt3DSRenderableObjects.cpp')
-rw-r--r--src/runtimerender/rendererimpl/Qt3DSRenderableObjects.cpp543
1 files changed, 543 insertions, 0 deletions
diff --git a/src/runtimerender/rendererimpl/Qt3DSRenderableObjects.cpp b/src/runtimerender/rendererimpl/Qt3DSRenderableObjects.cpp
new file mode 100644
index 0000000..fff7e32
--- /dev/null
+++ b/src/runtimerender/rendererimpl/Qt3DSRenderableObjects.cpp
@@ -0,0 +1,543 @@
+/****************************************************************************
+**
+** Copyright (C) 2008-2012 NVIDIA Corporation.
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt 3D Studio.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) any later version
+** approved by the KDE Free Qt Foundation. The licenses are as published by
+** the Free Software Foundation and appearing in the file LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "Qt3DSRenderableObjects.h"
+#include "Qt3DSRendererImpl.h"
+#include "Qt3DSRenderCustomMaterialSystem.h"
+#include "Qt3DSRenderCustomMaterialRenderContext.h"
+#include "Qt3DSRenderLight.h"
+#include "Qt3DSRenderPathManager.h"
+#include "Qt3DSRenderPathRenderContext.h"
+#include "Qt3DSRenderDefaultMaterialShaderGenerator.h"
+
+using qt3ds::foundation::CRegisteredString;
+
+namespace qt3ds {
+namespace render {
+ struct SRenderableImage;
+ struct SShaderGeneratorGeneratedShader;
+ struct SSubsetRenderable;
+ using eastl::make_pair;
+ using eastl::reverse;
+
+ STextScaleAndOffset::STextScaleAndOffset(NVRenderTexture2D &inTexture,
+ const STextTextureDetails &inTextDetails,
+ const STextRenderInfo &inInfo)
+ : m_TextOffset(0, 0)
+ , m_TextScale(1, 1)
+
+ {
+ NVRenderTexture2D &theTexture = inTexture;
+ STextureDetails theDetails(theTexture.GetTextureDetails());
+ QT3DSVec2 textDimensions(inTextDetails.m_TextWidth / 2.0f, inTextDetails.m_TextHeight / 2.0f);
+ textDimensions.x /= inTextDetails.m_ScaleFactor.x;
+ textDimensions.y /= inTextDetails.m_ScaleFactor.y;
+ QT3DSVec2 theTextScale(textDimensions.x, textDimensions.y);
+ QT3DSVec2 theTextOffset(0, 0);
+
+ // Set the offsets to use after scaling the rect coordinates.
+ switch (inInfo.m_HorizontalAlignment) {
+ case TextHorizontalAlignment::Left:
+ theTextOffset[0] = theTextScale[0];
+ break;
+ case TextHorizontalAlignment::Center:
+ break;
+ case TextHorizontalAlignment::Right:
+ theTextOffset[0] = -theTextScale[0];
+ break;
+ default:
+ break;
+ }
+
+ switch (inInfo.m_VerticalAlignment) {
+ case TextVerticalAlignment::Top:
+ theTextOffset[1] = -theTextScale[1];
+ break;
+ case TextVerticalAlignment::Middle:
+ break;
+ case TextVerticalAlignment::Bottom:
+ theTextOffset[1] = theTextScale[1];
+ break;
+ default:
+ break;
+ }
+ m_TextScale = theTextScale;
+ m_TextOffset = theTextOffset;
+ }
+
+ void SSubsetRenderableBase::RenderShadowMapPass(const QT3DSVec2 &inCameraVec,
+ const SLight *inLight, const SCamera &inCamera,
+ SShadowMapEntry *inShadowMapEntry)
+ {
+ NVRenderContext &context(m_Generator.GetContext());
+ SRenderableDepthPrepassShader *shader = NULL;
+ NVRenderInputAssembler *pIA = NULL;
+
+ /*
+ if ( inLight->m_LightType == RenderLightTypes::Area )
+ shader = m_Generator.GetParaboloidDepthShader( m_TessellationMode );
+ else if ( inLight->m_LightType == RenderLightTypes::Directional )
+ shader = m_Generator.GetOrthographicDepthShader( m_TessellationMode );
+ else if ( inLight->m_LightType == RenderLightTypes::Point )
+ shader = m_Generator.GetCubeShadowDepthShader( m_TessellationMode ); // This
+ will change to include a geometry shader pass.
+ */
+
+ if (inLight->m_LightType == RenderLightTypes::Directional)
+ shader = m_Generator.GetOrthographicDepthShader(m_TessellationMode);
+ else
+ shader = m_Generator.GetCubeShadowDepthShader(m_TessellationMode);
+
+ if (shader == NULL || inShadowMapEntry == NULL)
+ return;
+
+ // for phong and npatch tesselleation we need the normals too
+ if (m_TessellationMode == TessModeValues::NoTess
+ || m_TessellationMode == TessModeValues::TessLinear)
+ pIA = m_Subset.m_InputAssemblerDepth;
+ else
+ pIA = m_Subset.m_InputAssembler;
+
+ QT3DSMat44 theModelViewProjection = inShadowMapEntry->m_LightVP * m_GlobalTransform;
+ // QT3DSMat44 theModelView = inLight->m_GlobalTransform.getInverse() * m_GlobalTransform;
+
+ context.SetActiveShader(&shader->m_Shader);
+ shader->m_MVP.Set(theModelViewProjection);
+ shader->m_CameraPosition.Set(inCamera.m_Position);
+ shader->m_GlobalTransform.Set(m_GlobalTransform);
+ shader->m_CameraProperties.Set(inCameraVec);
+ /*
+ shader->m_CameraDirection.Set( inCamera.GetDirection() );
+
+ shader->m_ShadowMV[0].Set( inShadowMapEntry->m_LightCubeView[0] * m_GlobalTransform );
+ shader->m_ShadowMV[1].Set( inShadowMapEntry->m_LightCubeView[1] * m_GlobalTransform );
+ shader->m_ShadowMV[2].Set( inShadowMapEntry->m_LightCubeView[2] * m_GlobalTransform );
+ shader->m_ShadowMV[3].Set( inShadowMapEntry->m_LightCubeView[3] * m_GlobalTransform );
+ shader->m_ShadowMV[4].Set( inShadowMapEntry->m_LightCubeView[4] * m_GlobalTransform );
+ shader->m_ShadowMV[5].Set( inShadowMapEntry->m_LightCubeView[5] * m_GlobalTransform );
+ shader->m_Projection.Set( inCamera.m_Projection );
+ */
+
+ // tesselation
+ if (m_TessellationMode != TessModeValues::NoTess) {
+ // set uniforms we need
+ shader->m_Tessellation.m_EdgeTessLevel.Set(m_Subset.m_EdgeTessFactor);
+ shader->m_Tessellation.m_InsideTessLevel.Set(m_Subset.m_InnerTessFactor);
+ // the blend value is hardcoded
+ shader->m_Tessellation.m_PhongBlend.Set(0.75);
+ // set distance range value
+ shader->m_Tessellation.m_DistanceRange.Set(inCameraVec);
+ // disable culling
+ shader->m_Tessellation.m_DisableCulling.Set(1.0);
+ }
+
+ context.SetInputAssembler(pIA);
+ context.Draw(m_Subset.m_PrimitiveType, m_Subset.m_Count, m_Subset.m_Offset);
+ }
+
+ void SSubsetRenderableBase::RenderDepthPass(const QT3DSVec2 &inCameraVec,
+ SRenderableImage *inDisplacementImage,
+ float inDisplacementAmount)
+ {
+ NVRenderContext &context(m_Generator.GetContext());
+ SRenderableDepthPrepassShader *shader = NULL;
+ NVRenderInputAssembler *pIA = NULL;
+ SRenderableImage *displacementImage = inDisplacementImage;
+
+ if (m_Subset.m_PrimitiveType != NVRenderDrawMode::Patches)
+ shader = m_Generator.GetDepthPrepassShader(displacementImage != NULL);
+ else
+ shader = m_Generator.GetDepthTessPrepassShader(m_TessellationMode,
+ displacementImage != NULL);
+
+ if (shader == NULL)
+ return;
+
+ // for phong and npatch tesselleation or displacement mapping we need the normals (and uv's)
+ // too
+ if ((m_TessellationMode == TessModeValues::NoTess
+ || m_TessellationMode == TessModeValues::TessLinear)
+ && !displacementImage)
+ pIA = m_Subset.m_InputAssemblerDepth;
+ else
+ pIA = m_Subset.m_InputAssembler;
+
+ context.SetActiveShader(&shader->m_Shader);
+ context.SetCullingEnabled(true);
+
+ shader->m_MVP.Set(m_ModelContext.m_ModelViewProjection);
+
+ if (displacementImage) {
+ // setup image transform
+ const QT3DSMat44 &textureTransform = displacementImage->m_Image.m_TextureTransform;
+ const QT3DSF32 *dataPtr(textureTransform.front());
+ QT3DSVec3 offsets(dataPtr[12], dataPtr[13],
+ displacementImage->m_Image.m_TextureData.m_TextureFlags.IsPreMultiplied()
+ ? 1.0f
+ : 0.0f);
+ QT3DSVec4 rotations(dataPtr[0], dataPtr[4], dataPtr[1], dataPtr[5]);
+ displacementImage->m_Image.m_TextureData.m_Texture->SetTextureWrapS(
+ displacementImage->m_Image.m_HorizontalTilingMode);
+ displacementImage->m_Image.m_TextureData.m_Texture->SetTextureWrapT(
+ displacementImage->m_Image.m_VerticalTilingMode);
+
+ shader->m_DisplaceAmount.Set(inDisplacementAmount);
+ shader->m_DisplacementProps.m_Offsets.Set(offsets);
+ shader->m_DisplacementProps.m_Rotations.Set(rotations);
+ shader->m_DisplacementProps.m_Sampler.Set(
+ displacementImage->m_Image.m_TextureData.m_Texture);
+ }
+
+ // tesselation
+ if (m_TessellationMode != TessModeValues::NoTess) {
+ // set uniforms we need
+ shader->m_GlobalTransform.Set(m_GlobalTransform);
+
+ if (m_Generator.GetLayerRenderData() && m_Generator.GetLayerRenderData()->m_Camera)
+ shader->m_CameraPosition.Set(
+ m_Generator.GetLayerRenderData()->m_Camera->GetGlobalPos());
+ else if (m_Generator.GetLayerRenderData()->m_Camera)
+ shader->m_CameraPosition.Set(QT3DSVec3(0.0, 0.0, 1.0));
+
+ shader->m_Tessellation.m_EdgeTessLevel.Set(m_Subset.m_EdgeTessFactor);
+ shader->m_Tessellation.m_InsideTessLevel.Set(m_Subset.m_InnerTessFactor);
+ // the blend value is hardcoded
+ shader->m_Tessellation.m_PhongBlend.Set(0.75);
+ // set distance range value
+ shader->m_Tessellation.m_DistanceRange.Set(inCameraVec);
+ // enable culling
+ shader->m_Tessellation.m_DisableCulling.Set(0.0);
+ }
+
+ context.SetInputAssembler(pIA);
+ context.Draw(m_Subset.m_PrimitiveType, m_Subset.m_Count, m_Subset.m_Offset);
+ }
+
+ // An interface to the shader generator that is available to the renderables
+
+ void SSubsetRenderable::Render(const QT3DSVec2 &inCameraVec, TShaderFeatureSet inFeatureSet)
+ {
+ NVRenderContext &context(m_Generator.GetContext());
+
+ SShaderGeneratorGeneratedShader *shader = m_Generator.GetShader(*this, inFeatureSet);
+ if (shader == NULL)
+ return;
+
+ context.SetActiveShader(&shader->m_Shader);
+
+ m_Generator.GetQt3DSContext().GetDefaultMaterialShaderGenerator().SetMaterialProperties(
+ shader->m_Shader, m_Material, inCameraVec, m_ModelContext.m_ModelViewProjection,
+ m_ModelContext.m_NormalMatrix, m_ModelContext.m_Model.m_GlobalTransform, m_FirstImage,
+ m_Opacity, m_Generator.GetLayerGlobalRenderProperties());
+
+ // tesselation
+ if (m_Subset.m_PrimitiveType == NVRenderDrawMode::Patches) {
+ shader->m_Tessellation.m_EdgeTessLevel.Set(m_Subset.m_EdgeTessFactor);
+ shader->m_Tessellation.m_InsideTessLevel.Set(m_Subset.m_InnerTessFactor);
+ // the blend value is hardcoded
+ shader->m_Tessellation.m_PhongBlend.Set(0.75);
+ // this should finally be based on some user input
+ shader->m_Tessellation.m_DistanceRange.Set(inCameraVec);
+ // enable culling
+ shader->m_Tessellation.m_DisableCulling.Set(0.0);
+
+ if (m_Subset.m_WireframeMode) {
+ // we need the viewport matrix
+ NVRenderRect theViewport(context.GetViewport());
+ QT3DSMat44 vpMatrix;
+ vpMatrix.column0 = QT3DSVec4((float)theViewport.m_Width / 2.0f, 0.0, 0.0, 0.0);
+ vpMatrix.column1 = QT3DSVec4(0.0, (float)theViewport.m_Height / 2.0f, 0.0, 0.0);
+ vpMatrix.column2 = QT3DSVec4(0.0, 0.0, 1.0, 0.0);
+ vpMatrix.column3 =
+ QT3DSVec4((float)theViewport.m_Width / 2.0f + (float)theViewport.m_X,
+ (float)theViewport.m_Height / 2.0f + (float)theViewport.m_Y, 0.0, 1.0);
+
+ shader->m_ViewportMatrix.Set(vpMatrix);
+ }
+ }
+
+ context.SetCullingEnabled(true);
+ context.SetInputAssembler(m_Subset.m_InputAssembler);
+ context.Draw(m_Subset.m_PrimitiveType, m_Subset.m_Count, m_Subset.m_Offset);
+ }
+
+ void SSubsetRenderable::RenderDepthPass(const QT3DSVec2 &inCameraVec)
+ {
+ SRenderableImage *displacementImage = NULL;
+ for (SRenderableImage *theImage = m_FirstImage;
+ theImage != NULL && displacementImage == NULL; theImage = theImage->m_NextImage) {
+ if (theImage->m_MapType == ImageMapTypes::Displacement)
+ displacementImage = theImage;
+ }
+ SSubsetRenderableBase::RenderDepthPass(inCameraVec, displacementImage,
+ m_Material.m_DisplaceAmount);
+ }
+
+ void STextRenderable::Render(const QT3DSVec2 &inCameraVec)
+ {
+ NVRenderContext &context(m_Generator.GetContext());
+
+ if (!m_Text.m_PathFontDetails) {
+
+ STextRenderHelper theInfo = m_Generator.GetShader(*this, false);
+ if (theInfo.m_Shader == NULL)
+ return;
+ // All of our shaders produce premultiplied values.
+ qt3ds::render::NVRenderBlendFunctionArgument blendFunc(
+ NVRenderSrcBlendFunc::One, NVRenderDstBlendFunc::OneMinusSrcAlpha,
+ NVRenderSrcBlendFunc::One, NVRenderDstBlendFunc::OneMinusSrcAlpha);
+
+ qt3ds::render::NVRenderBlendEquationArgument blendEqu(NVRenderBlendEquation::Add,
+ NVRenderBlendEquation::Add);
+
+ context.SetBlendFunction(blendFunc);
+ context.SetBlendEquation(blendEqu);
+ QT3DSVec4 theColor(m_Text.m_TextColor.x, m_Text.m_TextColor.y, m_Text.m_TextColor.z,
+ m_Text.m_GlobalOpacity);
+
+ STextShader &shader(*theInfo.m_Shader);
+ shader.Render(*m_Text.m_TextTexture, *this, theColor, m_ModelViewProjection,
+ inCameraVec, context, theInfo.m_QuadInputAssembler,
+ theInfo.m_QuadInputAssembler.GetIndexCount(), m_Text.m_TextTextureDetails,
+ QT3DSVec3(0, 0, 0));
+ } else {
+ QT3DS_ASSERT(context.IsPathRenderingSupported() && context.IsProgramPipelineSupported());
+
+ STextRenderHelper theInfo = m_Generator.GetShader(*this, true);
+ if (theInfo.m_Shader == NULL)
+ return;
+
+ // All of our shaders produce premultiplied values.
+ qt3ds::render::NVRenderBlendFunctionArgument blendFunc(
+ NVRenderSrcBlendFunc::One, NVRenderDstBlendFunc::OneMinusSrcAlpha,
+ NVRenderSrcBlendFunc::One, NVRenderDstBlendFunc::OneMinusSrcAlpha);
+
+ qt3ds::render::NVRenderBlendEquationArgument blendEqu(NVRenderBlendEquation::Add,
+ NVRenderBlendEquation::Add);
+
+ context.SetBlendFunction(blendFunc);
+ context.SetBlendEquation(blendEqu);
+ QT3DSVec4 theColor(m_Text.m_TextColor.x, m_Text.m_TextColor.y, m_Text.m_TextColor.z,
+ m_Text.m_GlobalOpacity);
+ STextShader &shader(*theInfo.m_Shader);
+
+ shader.RenderPath(*m_Text.m_PathFontItem, *m_Text.m_PathFontDetails, *this, theColor,
+ m_ViewProjection, m_GlobalTransform, inCameraVec, context,
+ m_Text.m_TextTextureDetails, QT3DSVec3(0, 0, 0));
+ }
+ }
+
+ void STextRenderable::RenderDepthPass(const QT3DSVec2 &inCameraVec)
+ {
+ NVRenderContext &context(m_Generator.GetContext());
+ STextDepthShader *theDepthShader = m_Generator.GetTextDepthShader();
+ if (theDepthShader == NULL)
+ return;
+
+ if (!m_Text.m_PathFontDetails) {
+ // we may change stencil test state
+ qt3ds::render::NVRenderContextScopedProperty<bool> __stencilTest(
+ context, &NVRenderContext::IsStencilTestEnabled,
+ &NVRenderContext::SetStencilTestEnabled, true);
+
+ NVRenderShaderProgram &theShader(theDepthShader->m_Shader);
+ context.SetCullingEnabled(false);
+ context.SetActiveShader(&theShader);
+ theDepthShader->m_MVP.Set(m_ModelViewProjection);
+ theDepthShader->m_Sampler.Set(m_Text.m_TextTexture);
+ const STextScaleAndOffset &theScaleAndOffset(*this);
+ theDepthShader->m_Dimensions.Set(
+ QT3DSVec4(theScaleAndOffset.m_TextScale.x, theScaleAndOffset.m_TextScale.y,
+ theScaleAndOffset.m_TextOffset.x, theScaleAndOffset.m_TextOffset.y));
+ theDepthShader->m_CameraProperties.Set(inCameraVec);
+
+ STextureDetails theTextureDetails = m_Text.m_TextTexture->GetTextureDetails();
+ const STextTextureDetails &theTextTextureDetails(m_Text.m_TextTextureDetails);
+ QT3DSF32 theWidthScale =
+ (QT3DSF32)theTextTextureDetails.m_TextWidth / (QT3DSF32)theTextureDetails.m_Width;
+ QT3DSF32 theHeightScale =
+ (QT3DSF32)theTextTextureDetails.m_TextHeight / (QT3DSF32)theTextureDetails.m_Height;
+ theDepthShader->m_TextDimensions.Set(
+ QT3DSVec3(theWidthScale, theHeightScale, theTextTextureDetails.m_FlipY ? 1.0f : 0.0f));
+ context.SetInputAssembler(&theDepthShader->m_QuadInputAssembler);
+ context.Draw(NVRenderDrawMode::Triangles,
+ theDepthShader->m_QuadInputAssembler.GetIndexCount(), 0);
+ } else {
+ qt3ds::render::NVRenderBoolOp::Enum theDepthFunction = context.GetDepthFunction();
+ bool isDepthEnabled = context.IsDepthTestEnabled();
+ bool isStencilEnabled = context.IsStencilTestEnabled();
+ bool isDepthWriteEnabled = context.IsDepthWriteEnabled();
+ qt3ds::render::NVRenderStencilFunctionArgument theArg(qt3ds::render::NVRenderBoolOp::NotEqual,
+ 0, 0xFF);
+ qt3ds::render::NVRenderStencilOperationArgument theOpArg(
+ qt3ds::render::NVRenderStencilOp::Keep, qt3ds::render::NVRenderStencilOp::Keep,
+ qt3ds::render::NVRenderStencilOp::Zero);
+ NVScopedRefCounted<NVRenderDepthStencilState> depthStencilState =
+ context.CreateDepthStencilState(isDepthEnabled, isDepthWriteEnabled,
+ theDepthFunction, false, theArg, theArg, theOpArg,
+ theOpArg);
+
+ context.SetActiveShader(NULL);
+ context.SetCullingEnabled(false);
+
+ context.SetDepthStencilState(depthStencilState);
+
+ // setup transform
+ QT3DSMat44 offsetMatrix = QT3DSMat44::createIdentity();
+ offsetMatrix.setPosition(QT3DSVec3(
+ m_TextOffset.x - (QT3DSF32)m_Text.m_TextTextureDetails.m_TextWidth / 2.0f,
+ m_TextOffset.y - (QT3DSF32)m_Text.m_TextTextureDetails.m_TextHeight / 2.0f, 0.0));
+
+ QT3DSMat44 pathMatrix = m_Text.m_PathFontItem->GetTransform();
+
+ context.SetPathProjectionMatrix(m_ViewProjection);
+ context.SetPathModelViewMatrix(m_GlobalTransform * offsetMatrix * pathMatrix);
+
+ // first pass
+ m_Text.m_PathFontDetails->StencilFillPathInstanced(*m_Text.m_PathFontItem);
+
+ // second pass
+ context.SetStencilTestEnabled(true);
+ m_Text.m_PathFontDetails->CoverFillPathInstanced(*m_Text.m_PathFontItem);
+
+ context.SetStencilTestEnabled(isStencilEnabled);
+ context.SetDepthFunction(theDepthFunction);
+ }
+ }
+
+#if QT_VERSION >= QT_VERSION_CHECK(5,12,2)
+ void SDistanceFieldRenderable::Render(const QT3DSVec2 &inCameraVec)
+ {
+ m_distanceFieldText.renderText(m_text, m_mvp);
+ }
+
+ void SDistanceFieldRenderable::RenderDepthPass(const QT3DSVec2 &inCameraVec)
+ {
+ m_distanceFieldText.renderTextDepth(m_text, m_mvp);
+ }
+#endif
+
+ void SCustomMaterialRenderable::Render(const QT3DSVec2 & /*inCameraVec*/,
+ const SLayerRenderData &inLayerData,
+ const SLayer &inLayer, NVDataRef<SLight *> inLights,
+ const SCamera &inCamera,
+ const NVRenderTexture2D *inDepthTexture,
+ const NVRenderTexture2D *inSsaoTexture,
+ TShaderFeatureSet inFeatureSet)
+ {
+ IQt3DSRenderContext &qt3dsContext(m_Generator.GetQt3DSContext());
+ SCustomMaterialRenderContext theRenderContext(
+ inLayer, inLayerData, inLights, inCamera, m_ModelContext.m_Model, m_Subset,
+ m_ModelContext.m_ModelViewProjection, m_GlobalTransform, m_ModelContext.m_NormalMatrix,
+ m_Material, inDepthTexture, inSsaoTexture, m_ShaderDescription, m_FirstImage,
+ m_Opacity);
+
+ qt3dsContext.GetCustomMaterialSystem().RenderSubset(theRenderContext, inFeatureSet);
+ }
+
+ void SCustomMaterialRenderable::RenderDepthPass(const QT3DSVec2 &inCameraVec,
+ const SLayer & /*inLayer*/,
+ NVConstDataRef<SLight *> /*inLights*/
+ ,
+ const SCamera & /*inCamera*/,
+ const NVRenderTexture2D * /*inDepthTexture*/)
+ {
+
+ IQt3DSRenderContext &qt3dsContext(m_Generator.GetQt3DSContext());
+ if (!qt3dsContext.GetCustomMaterialSystem().RenderDepthPrepass(
+ m_ModelContext.m_ModelViewProjection, m_Material, m_Subset)) {
+ SRenderableImage *displacementImage = NULL;
+ for (SRenderableImage *theImage = m_FirstImage;
+ theImage != NULL && displacementImage == NULL; theImage = theImage->m_NextImage) {
+ if (theImage->m_MapType == ImageMapTypes::Displacement)
+ displacementImage = theImage;
+ }
+
+ SSubsetRenderableBase::RenderDepthPass(inCameraVec, displacementImage,
+ m_Material.m_DisplaceAmount);
+ }
+ }
+
+ void SPathRenderable::RenderDepthPass(const QT3DSVec2 &inCameraVec, const SLayer & /*inLayer*/,
+ NVConstDataRef<SLight *> inLights,
+ const SCamera &inCamera,
+ const NVRenderTexture2D * /*inDepthTexture*/)
+ {
+ IQt3DSRenderContext &qt3dsContext(m_Generator.GetQt3DSContext());
+ SPathRenderContext theRenderContext(
+ inLights, inCamera, m_Path, m_ModelViewProjection, m_GlobalTransform, m_NormalMatrix,
+ m_Opacity, m_Material, m_ShaderDescription, m_FirstImage, qt3dsContext.GetWireframeMode(),
+ inCameraVec, false, m_IsStroke);
+
+ qt3dsContext.GetPathManager().RenderDepthPrepass(
+ theRenderContext, m_Generator.GetLayerGlobalRenderProperties(), TShaderFeatureSet());
+ }
+
+ void SPathRenderable::Render(const QT3DSVec2 &inCameraVec, const SLayer & /*inLayer*/,
+ NVConstDataRef<SLight *> inLights, const SCamera &inCamera,
+ const NVRenderTexture2D * /*inDepthTexture*/
+ ,
+ const NVRenderTexture2D * /*inSsaoTexture*/
+ ,
+ TShaderFeatureSet inFeatureSet)
+ {
+ IQt3DSRenderContext &qt3dsContext(m_Generator.GetQt3DSContext());
+ SPathRenderContext theRenderContext(
+ inLights, inCamera, m_Path, m_ModelViewProjection, m_GlobalTransform, m_NormalMatrix,
+ m_Opacity, m_Material, m_ShaderDescription, m_FirstImage, qt3dsContext.GetWireframeMode(),
+ inCameraVec, m_RenderableFlags.HasTransparency(), m_IsStroke);
+
+ qt3dsContext.GetPathManager().RenderPath(
+ theRenderContext, m_Generator.GetLayerGlobalRenderProperties(), inFeatureSet);
+ }
+
+ void SPathRenderable::RenderShadowMapPass(const QT3DSVec2 &inCameraVec, const SLight *inLight,
+ const SCamera &inCamera,
+ SShadowMapEntry *inShadowMapEntry)
+ {
+ NVConstDataRef<SLight *> theLights;
+ IQt3DSRenderContext &qt3dsContext(m_Generator.GetQt3DSContext());
+
+ QT3DSMat44 theModelViewProjection = inShadowMapEntry->m_LightVP * m_GlobalTransform;
+ SPathRenderContext theRenderContext(
+ theLights, inCamera, m_Path, theModelViewProjection, m_GlobalTransform, m_NormalMatrix,
+ m_Opacity, m_Material, m_ShaderDescription, m_FirstImage, qt3dsContext.GetWireframeMode(),
+ inCameraVec, false, m_IsStroke);
+
+ if (inLight->m_LightType != RenderLightTypes::Directional) {
+ qt3dsContext.GetPathManager().RenderCubeFaceShadowPass(
+ theRenderContext, m_Generator.GetLayerGlobalRenderProperties(),
+ TShaderFeatureSet());
+ } else
+ qt3dsContext.GetPathManager().RenderShadowMapPass(
+ theRenderContext, m_Generator.GetLayerGlobalRenderProperties(),
+ TShaderFeatureSet());
+ }
+}
+}