krisyotam/overte

34

#include "RenderCommonTask.h"

34

#include "RenderCommonTask.h"

35

#include "RenderHUDLayerTask.h"

35

#include "RenderHUDLayerTask.h"

36

37

namespace ru {

39

namespace ru {

38

using render_utils::slot::texture::Texture;

40

using render_utils::slot::texture::Texture;

39

using render_utils::slot::buffer::Buffer;

41

using render_utils::slot::buffer::Buffer;

66

preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale);

68

preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale);

67

}

69

}

68

70

task.addJob<SetRenderMethod>("SetRenderMethodTask", render::Args::FORWARD);

72

task.addJob<SetRenderMethod>("SetRenderMethodTask", render::Args::FORWARD);

71

73

72

// Prepare the ShapePipelines

74

// Prepare the ShapePipelines

73

auto fadeEffect = DependencyManager::get<FadeEffect>();

75

auto fadeEffect = DependencyManager::get<FadeEffect>();

76

81

77

// Unpack inputs

82

// Unpack inputs

78

const auto& inputs = input.get<Input>();

83

const auto& inputs = input.get<Input>();

86

const auto& opaques = items[RenderFetchCullSortTask::OPAQUE_SHAPE];

91

const auto& opaques = items[RenderFetchCullSortTask::OPAQUE_SHAPE];

87

const auto& transparents = items[RenderFetchCullSortTask::TRANSPARENT_SHAPE];

92

const auto& transparents = items[RenderFetchCullSortTask::TRANSPARENT_SHAPE];

88

const auto& metas = items[RenderFetchCullSortTask::META];

93

const auto& metas = items[RenderFetchCullSortTask::META];

89

const auto& inFrontOpaque = items[RenderFetchCullSortTask::LAYER_FRONT_OPAQUE_SHAPE];

95

const auto& inFrontOpaque = items[RenderFetchCullSortTask::LAYER_FRONT_OPAQUE_SHAPE];

90

const auto& inFrontTransparent = items[RenderFetchCullSortTask::LAYER_FRONT_TRANSPARENT_SHAPE];

96

const auto& inFrontTransparent = items[RenderFetchCullSortTask::LAYER_FRONT_TRANSPARENT_SHAPE];

91

const auto& hudOpaque = items[RenderFetchCullSortTask::LAYER_HUD_OPAQUE_SHAPE];

97

const auto& hudOpaque = items[RenderFetchCullSortTask::LAYER_HUD_OPAQUE_SHAPE];

107

// First job, alter faded

113

// First job, alter faded

108

fadeEffect->build(task, opaques);

114

fadeEffect->build(task, opaques);

109

115

111

// GPU jobs: Start preparing the main framebuffer

116

// GPU jobs: Start preparing the main framebuffer

112

const auto scaledPrimaryFramebuffer = task.addJob<PreparePrimaryFramebufferMSAA>("PreparePrimaryBufferForward");

117

const auto scaledPrimaryFramebuffer = task.addJob<PreparePrimaryFramebufferMSAA>("PreparePrimaryBufferForward");

113

118

125

const auto opaqueInputs = DrawForward::Inputs(opaques, lightingModel, hazeFrame).asVarying();

130

const auto opaqueInputs = DrawForward::Inputs(opaques, lightingModel, hazeFrame).asVarying();

126

task.addJob<DrawForward>("DrawOpaques", opaqueInputs, shapePlumber, true);

131

task.addJob<DrawForward>("DrawOpaques", opaqueInputs, shapePlumber, true);

127

132

128

// Similar to light stage, background stage has been filled by several potential render items and resolved for the frame in this job

143

// Similar to light stage, background stage has been filled by several potential render items and resolved for the frame in this job

129

const auto backgroundInputs = DrawBackgroundStage::Inputs(lightingModel, backgroundFrame, hazeFrame).asVarying();

144

const auto backgroundInputs = DrawBackgroundStage::Inputs(lightingModel, backgroundFrame, hazeFrame).asVarying();

130

task.addJob<DrawBackgroundStage>("DrawBackgroundForward", backgroundInputs);

145

task.addJob<DrawBackgroundStage>("DrawBackgroundForward", backgroundInputs);

134

task.addJob<DrawForward>("DrawTransparents", transparentInputs, shapePlumber, false);

149

task.addJob<DrawForward>("DrawTransparents", transparentInputs, shapePlumber, false);

135

150

136

// Layered

151

// Layered

138

const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, lightingModel, hazeFrame, nullJitter).asVarying();

152

const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, lightingModel, hazeFrame, nullJitter).asVarying();

139

const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, lightingModel, hazeFrame, nullJitter).asVarying();

153

const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, lightingModel, hazeFrame, nullJitter).asVarying();

140

task.addJob<DrawLayered3D>("DrawInFrontOpaque", inFrontOpaquesInputs, true);

154

task.addJob<DrawLayered3D>("DrawInFrontOpaque", inFrontOpaquesInputs, true);

159

const auto destFramebuffer = static_cast<gpu::FramebufferPointer>(nullptr);

173

const auto destFramebuffer = static_cast<gpu::FramebufferPointer>(nullptr);

160

174

161

const auto toneMappingInputs = ToneMapAndResample::Input(resolvedFramebuffer, destFramebuffer).asVarying();

175

const auto toneMappingInputs = ToneMapAndResample::Input(resolvedFramebuffer, destFramebuffer).asVarying();

163

// HUD Layer

177

// HUD Layer

164

const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying();

178

const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying();

165

task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);

179

task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);

Revert "Revert "Mirrors + Portals""

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

 #include "RenderCommonTask.h"
 #include "RenderHUDLayerTask.h"
+#include "RenderViewTask.h"
 namespace ru {
     using render_utils::slot::texture::Texture;
     using render_utils::slot::buffer::Buffer;
     preparePrimaryBufferConfig->setResolutionScale(config.resolutionScale);
 }
-void RenderForwardTask::build(JobModel& task, const render::Varying& input, render::Varying& output) {
+void RenderForwardTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, size_t depth) {
     task.addJob<SetRenderMethod>("SetRenderMethodTask", render::Args::FORWARD);
     // Prepare the ShapePipelines
     auto fadeEffect = DependencyManager::get<FadeEffect>();
-    ShapePlumberPointer shapePlumber = std::make_shared<ShapePlumber>();
+    static ShapePlumberPointer shapePlumber = std::make_shared<ShapePlumber>();
-    initForwardPipelines(*shapePlumber);
+    static std::once_flag once;
+    std::call_once(once, [] {
+        initForwardPipelines(*shapePlumber);
+    });
     // Unpack inputs
     const auto& inputs = input.get<Input>();
             const auto& opaques = items[RenderFetchCullSortTask::OPAQUE_SHAPE];
             const auto& transparents = items[RenderFetchCullSortTask::TRANSPARENT_SHAPE];
             const auto& metas = items[RenderFetchCullSortTask::META];
+            const auto& mirrors = items[RenderFetchCullSortTask::MIRROR];
             const auto& inFrontOpaque = items[RenderFetchCullSortTask::LAYER_FRONT_OPAQUE_SHAPE];
             const auto& inFrontTransparent = items[RenderFetchCullSortTask::LAYER_FRONT_TRANSPARENT_SHAPE];
             const auto& hudOpaque = items[RenderFetchCullSortTask::LAYER_HUD_OPAQUE_SHAPE];
     // First job, alter faded
     fadeEffect->build(task, opaques);
     // GPU jobs: Start preparing the main framebuffer
     const auto scaledPrimaryFramebuffer = task.addJob<PreparePrimaryFramebufferMSAA>("PreparePrimaryBufferForward");
     const auto opaqueInputs = DrawForward::Inputs(opaques, lightingModel, hazeFrame).asVarying();
     task.addJob<DrawForward>("DrawOpaques", opaqueInputs, shapePlumber, true);
+    const auto nullJitter = Varying(glm::vec2(0.0f, 0.0f));
+#ifndef Q_OS_ANDROID
+    if (depth < RenderMirrorTask::MAX_MIRROR_DEPTH) {
+        const auto mirrorInputs = RenderMirrorTask::Inputs(mirrors, scaledPrimaryFramebuffer, nullJitter).asVarying();
+        for (size_t i = 0; i < RenderMirrorTask::MAX_MIRRORS_PER_LEVEL; i++) {
+            task.addJob<RenderMirrorTask>("RenderMirrorTask" + std::to_string(i) + "Depth" + std::to_string(depth), mirrorInputs, i, cullFunctor, depth);
+        }
+    }
+#endif
     // Similar to light stage, background stage has been filled by several potential render items and resolved for the frame in this job
     const auto backgroundInputs = DrawBackgroundStage::Inputs(lightingModel, backgroundFrame, hazeFrame).asVarying();
     task.addJob<DrawBackgroundStage>("DrawBackgroundForward", backgroundInputs);
     task.addJob<DrawForward>("DrawTransparents", transparentInputs, shapePlumber, false);
      // Layered
-    const auto nullJitter = Varying(glm::vec2(0.0f, 0.0f));
     const auto inFrontOpaquesInputs = DrawLayered3D::Inputs(inFrontOpaque, lightingModel, hazeFrame, nullJitter).asVarying();
     const auto inFrontTransparentsInputs = DrawLayered3D::Inputs(inFrontTransparent, lightingModel, hazeFrame, nullJitter).asVarying();
     task.addJob<DrawLayered3D>("DrawInFrontOpaque", inFrontOpaquesInputs, true);
     const auto destFramebuffer = static_cast<gpu::FramebufferPointer>(nullptr);
     const auto toneMappingInputs = ToneMapAndResample::Input(resolvedFramebuffer, destFramebuffer).asVarying();
-    const auto toneMappedBuffer = task.addJob<ToneMapAndResample>("ToneMapping", toneMappingInputs);
+    const auto toneMappedBuffer = task.addJob<ToneMapAndResample>("ToneMapping", toneMappingInputs, depth);
     // HUD Layer
     const auto renderHUDLayerInputs = RenderHUDLayerTask::Input(toneMappedBuffer, lightingModel, hudOpaque, hudTransparent, hazeFrame).asVarying();
     task.addJob<RenderHUDLayerTask>("RenderHUDLayer", renderHUDLayerInputs);