History

Switch to deferred lighting for metavoxels.

Andrzej Kapolka committed 12 years ago

Commit 21f3f2b1 parent a02656022 files · +666 −531Browse files

Showing the changes to interface/src/MetavoxelSystem.cpp (1 of 22 files). Show all

Unified · Split

interface/src/MetavoxelSystem.cpp+311−203
@@ -9,7 +9,11 @@ · 8 unmodified lines
99 // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
1010 //
1111
12+// include this before QOpenGLFramebufferObject, which includes an earlier version of OpenGL
13+#include "InterfaceConfig.h"
14+
1215 #include <QMutexLocker>
16+#include <QOpenGLFramebufferObject>
1317 #include <QReadLocker>
1418 #include <QWriteLocker>
1519 #include <QtDebug>
@@ -24,6 +28,7 @@ · 8 unmodified lines
2428 #include "Application.h"
2529 #include "MetavoxelSystem.h"
2630 #include "renderer/Model.h"
31+#include "renderer/RenderUtil.h"
2732
2833 REGISTER_META_OBJECT(DefaultMetavoxelRendererImplementation)
2934 REGISTER_META_OBJECT(SphereRenderer)
@@ -46,6 +51,12 @@ void MetavoxelSystem::init() { · 16 unmodified lines
4651 new BufferDataAttribute("voxelBuffer"));
4752 _voxelBufferAttribute->setLODThresholdMultiplier(
4853 AttributeRegistry::getInstance()->getVoxelColorAttribute()->getLODThresholdMultiplier());
54+
55+ loadLightProgram("shaders/directional_light.frag", _directionalLight, _directionalLightLocations);
56+ loadLightProgram("shaders/directional_light_shadow_map.frag", _directionalLightShadowMap,
57+ _directionalLightShadowMapLocations);
58+ loadLightProgram("shaders/directional_light_cascaded_shadow_map.frag", _directionalLightCascadedShadowMap,
59+ _directionalLightCascadedShadowMapLocations);
4960 }
5061
5162 MetavoxelLOD MetavoxelSystem::getLOD() {
@@ -116,6 +127,10 @@ int RenderVisitor::visit(MetavoxelInfo& info) { · 64 unmodified lines
116127 return STOP_RECURSION;
117128 }
118129
130+const GLenum COLOR_DRAW_BUFFERS[] = { GL_COLOR_ATTACHMENT0 };
131+const GLenum NORMAL_DRAW_BUFFERS[] = { GL_COLOR_ATTACHMENT1 };
132+const GLenum COLOR_NORMAL_DRAW_BUFFERS[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
133+
119134 void MetavoxelSystem::render() {
120135 // update the frustum
121136 ViewFrustum* viewFrustum = Application::getInstance()->getViewFrustum();
@@ -123,8 +138,128 @@ void MetavoxelSystem::render() { · 1 unmodified line
123138 viewFrustum->getFarBottomRight(), viewFrustum->getNearTopLeft(), viewFrustum->getNearTopRight(),
124139 viewFrustum->getNearBottomLeft(), viewFrustum->getNearBottomRight());
125140
141+ _needToLight = false;
142+
143+ // clear the normal buffer
144+ glDrawBuffers(sizeof(NORMAL_DRAW_BUFFERS) / sizeof(NORMAL_DRAW_BUFFERS[0]), NORMAL_DRAW_BUFFERS);
145+ glClear(GL_COLOR_BUFFER_BIT);
146+
147+ glDrawBuffers(sizeof(COLOR_DRAW_BUFFERS) / sizeof(COLOR_DRAW_BUFFERS[0]), COLOR_DRAW_BUFFERS);
148+
126149 RenderVisitor renderVisitor(getLOD());
127150 guideToAugmented(renderVisitor, true);
151+
152+ // give external parties a chance to join in
153+ emit rendering();
154+
155+ if (!_needToLight) {
156+ return; // skip lighting if not needed
157+ }
158+
159+ // perform deferred lighting, rendering to free fbo
160+ glPushMatrix();
161+ glLoadIdentity();
162+
163+ glMatrixMode(GL_PROJECTION);
164+ glPushMatrix();
165+ glLoadIdentity();
166+
167+ glDisable(GL_BLEND);
168+ glDisable(GL_LIGHTING);
169+ glDisable(GL_DEPTH_TEST);
170+ glDepthMask(false);
171+
172+ QOpenGLFramebufferObject* primaryFBO = Application::getInstance()->getTextureCache()->getPrimaryFramebufferObject();
173+ primaryFBO->release();
174+
175+ QOpenGLFramebufferObject* freeFBO = Application::getInstance()->getGlowEffect()->getFreeFramebufferObject();
176+ freeFBO->bind();
177+ glClear(GL_COLOR_BUFFER_BIT);
178+
179+ glBindTexture(GL_TEXTURE_2D, primaryFBO->texture());
180+
181+ glActiveTexture(GL_TEXTURE1);
182+ glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getPrimaryNormalTextureID());
183+
184+ if (Menu::getInstance()->getShadowsEnabled()) {
185+ glActiveTexture(GL_TEXTURE2);
186+ glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getPrimaryDepthTextureID());
187+
188+ glActiveTexture(GL_TEXTURE3);
189+ glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getShadowDepthTextureID());
190+
191+ ProgramObject* program = &_directionalLightShadowMap;
192+ const LightLocations* locations = &_directionalLightShadowMapLocations;
193+ if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
194+ program = &_directionalLightCascadedShadowMap;
195+ locations = &_directionalLightCascadedShadowMapLocations;
196+ _directionalLightCascadedShadowMap.bind();
197+ _directionalLightCascadedShadowMap.setUniform(locations->shadowDistances,
198+ Application::getInstance()->getShadowDistances());
199+
200+ } else {
201+ program->bind();
202+ }
203+ program->setUniformValue(locations->shadowScale,
204+ 1.0f / Application::getInstance()->getTextureCache()->getShadowFramebufferObject()->width());
205+
206+ float left, right, bottom, top, nearVal, farVal;
207+ glm::vec4 nearClipPlane, farClipPlane;
208+ Application::getInstance()->computeOffAxisFrustum(
209+ left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
210+ program->setUniformValue(locations->near, nearVal);
211+ program->setUniformValue(locations->depthScale, (farVal - nearVal) / farVal);
212+ float nearScale = -1.0f / nearVal;
213+ program->setUniformValue(locations->depthTexCoordOffset, left * nearScale, bottom * nearScale);
214+ program->setUniformValue(locations->depthTexCoordScale, (right - left) * nearScale, (top - bottom) * nearScale);
215+
216+ renderFullscreenQuad();
217+
218+ program->release();
219+
220+ glBindTexture(GL_TEXTURE_2D, 0);
221+
222+ glActiveTexture(GL_TEXTURE2);
223+ glBindTexture(GL_TEXTURE_2D, 0);
224+
225+ glActiveTexture(GL_TEXTURE1);
226+
227+ } else {
228+ _directionalLight.bind();
229+ renderFullscreenQuad();
230+ _directionalLight.release();
231+ }
232+
233+ glBindTexture(GL_TEXTURE_2D, 0);
234+ glActiveTexture(GL_TEXTURE0);
235+
236+ freeFBO->release();
237+
238+ // now transfer the lit region to the primary fbo
239+ glEnable(GL_BLEND);
240+
241+ primaryFBO->bind();
242+
243+ glBindTexture(GL_TEXTURE_2D, freeFBO->texture());
244+ glEnable(GL_TEXTURE_2D);
245+
246+ glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
247+
248+ renderFullscreenQuad();
249+
250+ glBindTexture(GL_TEXTURE_2D, 0);
251+ glDisable(GL_TEXTURE_2D);
252+
253+ glEnable(GL_LIGHTING);
254+ glEnable(GL_DEPTH_TEST);
255+ glDepthMask(true);
256+
257+ glDisable(GL_ALPHA_TEST);
258+
259+ glPopMatrix();
260+
261+ glMatrixMode(GL_MODELVIEW);
262+ glPopMatrix();
128263 }
129264
130265 class RayHeightfieldIntersectionVisitor : public RayIntersectionVisitor {
@@ -484,6 +619,24 @@ void MetavoxelSystem::guideToAugmented(MetavoxelVisitor& visitor, bool render) { · 353 unmodified lines
484619 }
485620 }
486621
622+void MetavoxelSystem::loadLightProgram(const char* name, ProgramObject& program, LightLocations& locations) {
623+ program.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() + name);
624+ program.link();
625+
626+ program.bind();
627+ program.setUniformValue("diffuseMap", 0);
628+ program.setUniformValue("normalMap", 1);
629+ program.setUniformValue("depthMap", 2);
630+ program.setUniformValue("shadowMap", 3);
631+ locations.shadowDistances = program.uniformLocation("shadowDistances");
632+ locations.shadowScale = program.uniformLocation("shadowScale");
633+ locations.near = program.uniformLocation("near");
634+ locations.depthScale = program.uniformLocation("depthScale");
635+ locations.depthTexCoordOffset = program.uniformLocation("depthTexCoordOffset");
636+ locations.depthTexCoordScale = program.uniformLocation("depthTexCoordScale");
637+ program.release();
638+}
639+
487640 MetavoxelSystemClient::MetavoxelSystemClient(const SharedNodePointer& node, MetavoxelUpdater* updater) :
488641 MetavoxelClient(node, updater) {
489642 }
@@ -807,7 +960,6 @@ void HeightfieldBuffer::render(bool cursor) { · 317 unmodified lines
807960 glDrawRangeElements(GL_TRIANGLES, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
808961
809962 } else if (!_materials.isEmpty()) {
810− DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().bind();
811963 DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().setUniformValue(
812964 DefaultMetavoxelRendererImplementation::getBaseHeightScaleLocation(), 1.0f / _heightSize);
813965 DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().setUniformValue(
@@ -817,6 +969,8 @@ void HeightfieldBuffer::render(bool cursor) { · 3 unmodified lines
817969
818970 glDrawRangeElements(GL_TRIANGLES, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
819971
972+ glDrawBuffers(sizeof(COLOR_DRAW_BUFFERS) / sizeof(COLOR_DRAW_BUFFERS[0]), COLOR_DRAW_BUFFERS);
973+
820974 glDepthFunc(GL_LEQUAL);
821975 glDepthMask(false);
822976 glEnable(GL_BLEND);
@@ -825,18 +979,18 @@ void HeightfieldBuffer::render(bool cursor) { · 2 unmodified lines
825979 glPolygonOffset(-1.0f, -1.0f);
826980
827981 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().bind();
982+ const DefaultMetavoxelRendererImplementation::SplatLocations& locations =
983+ DefaultMetavoxelRendererImplementation::getSplatHeightfieldLocations();
828984 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
829− DefaultMetavoxelRendererImplementation::getSplatHeightScaleLocation(), 1.0f / _heightSize);
985+ locations.heightScale, 1.0f / _heightSize);
830986 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
831− DefaultMetavoxelRendererImplementation::getSplatTextureScaleLocation(), (float)_heightSize / innerSize);
987+ locations.textureScale, (float)_heightSize / innerSize);
832988 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
833− DefaultMetavoxelRendererImplementation::getSplatTextureOffsetLocation(),
834− _translation.x / _scale, _translation.z / _scale);
989+ locations.splatTextureOffset, _translation.x / _scale, _translation.z / _scale);
835990
836991 glBindTexture(GL_TEXTURE_2D, _materialTextureID);
837992
838− const int TEXTURES_PER_SPLAT = 4;
839− for (int i = 0; i < _materials.size(); i += TEXTURES_PER_SPLAT) {
993+ for (int i = 0; i < _materials.size(); i += SPLAT_COUNT) {
840994 QVector4D scalesS, scalesT;
841995
842996 for (int j = 0; j < SPLAT_COUNT; j++) {
@@ -858,23 +1012,20 @@ void HeightfieldBuffer::render(bool cursor) { · 15 unmodified lines
8581012 }
8591013 const float QUARTER_STEP = 0.25f * EIGHT_BIT_MAXIMUM_RECIPROCAL;
8601014 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
861− DefaultMetavoxelRendererImplementation::getSplatTextureScalesSLocation(), scalesS);
1015+ locations.splatTextureScalesS, scalesS);
8621016 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
863− DefaultMetavoxelRendererImplementation::getSplatTextureScalesTLocation(), scalesT);
1017+ locations.splatTextureScalesT, scalesT);
8641018 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
865− DefaultMetavoxelRendererImplementation::getSplatTextureValueMinimaLocation(),
1019+ locations.textureValueMinima,
8661020 (i + 1) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP, (i + 2) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP,
8671021 (i + 3) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP, (i + 4) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP);
8681022 DefaultMetavoxelRendererImplementation::getSplatHeightfieldProgram().setUniformValue(
869− DefaultMetavoxelRendererImplementation::getSplatTextureValueMaximaLocation(),
1023+ locations.textureValueMaxima,
8701024 (i + 1) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP, (i + 2) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP,
8711025 (i + 3) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP, (i + 4) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP);
8721026 glDrawRangeElements(GL_TRIANGLES, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
8731027 }
8741028
875− glEnable(GL_ALPHA_TEST);
876− glBlendFunc(GL_DST_COLOR, GL_ZERO);
877−
8781029 for (int i = 0; i < SPLAT_COUNT; i++) {
8791030 glActiveTexture(GL_TEXTURE0 + SPLAT_TEXTURE_UNITS[i]);
8801031 glBindTexture(GL_TEXTURE_2D, 0);
@@ -882,53 +1033,24 @@ void HeightfieldBuffer::render(bool cursor) { · 1 unmodified line
8821033
8831034 glActiveTexture(GL_TEXTURE1);
8841035 glBindTexture(GL_TEXTURE_2D, 0);
885−
886− if (Menu::getInstance()->isOptionChecked(MenuOption::SimpleShadows)) {
887− DefaultMetavoxelRendererImplementation::getShadowLightHeightfieldProgram().bind();
888− DefaultMetavoxelRendererImplementation::getShadowLightHeightfieldProgram().setUniformValue(
889− DefaultMetavoxelRendererImplementation::getShadowLightHeightScaleLocation(), 1.0f / _heightSize);
890− glDrawRangeElements(GL_TRIANGLES, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
891− DefaultMetavoxelRendererImplementation::getShadowMapHeightfieldProgram().bind();
892−
893− } else if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
894− DefaultMetavoxelRendererImplementation::getCascadedShadowLightHeightfieldProgram().bind();
895− DefaultMetavoxelRendererImplementation::getCascadedShadowLightHeightfieldProgram().setUniformValue(
896− DefaultMetavoxelRendererImplementation::getCascadedShadowLightHeightScaleLocation(), 1.0f / _heightSize);
897− glDrawRangeElements(GL_TRIANGLES, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
898− DefaultMetavoxelRendererImplementation::getCascadedShadowMapHeightfieldProgram().bind();
899−
900− } else {
901− DefaultMetavoxelRendererImplementation::getLightHeightfieldProgram().bind();
902− DefaultMetavoxelRendererImplementation::getLightHeightfieldProgram().setUniformValue(
903− DefaultMetavoxelRendererImplementation::getLightHeightScaleLocation(), 1.0f / _heightSize);
904− glDrawRangeElements(GL_TRIANGLES, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
905− DefaultMetavoxelRendererImplementation::getHeightfieldProgram().bind();
906− }
1036+
1037+ glActiveTexture(GL_TEXTURE0);
9071038
9081039 glDisable(GL_POLYGON_OFFSET_FILL);
1040+ glEnable(GL_ALPHA_TEST);
9091041 glDisable(GL_BLEND);
910− glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
911− glDepthFunc(GL_LESS);
9121042 glDepthMask(true);
1043+ glDepthFunc(GL_LESS);
9131044
914− glActiveTexture(GL_TEXTURE0);
1045+ glDrawBuffers(sizeof(COLOR_NORMAL_DRAW_BUFFERS) / sizeof(COLOR_NORMAL_DRAW_BUFFERS[0]), COLOR_NORMAL_DRAW_BUFFERS);
1046+
1047+ DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().bind();
9151048
9161049 } else {
917− int heightScaleLocation = DefaultMetavoxelRendererImplementation::getHeightScaleLocation();
918− int colorScaleLocation = DefaultMetavoxelRendererImplementation::getColorScaleLocation();
919− ProgramObject* program = &DefaultMetavoxelRendererImplementation::getHeightfieldProgram();
920− if (Menu::getInstance()->isOptionChecked(MenuOption::SimpleShadows)) {
921− heightScaleLocation = DefaultMetavoxelRendererImplementation::getShadowMapHeightScaleLocation();
922− colorScaleLocation = DefaultMetavoxelRendererImplementation::getShadowMapColorScaleLocation();
923− program = &DefaultMetavoxelRendererImplementation::getShadowMapHeightfieldProgram();
924−
925− } else if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
926− heightScaleLocation = DefaultMetavoxelRendererImplementation::getCascadedShadowMapHeightScaleLocation();
927− colorScaleLocation = DefaultMetavoxelRendererImplementation::getCascadedShadowMapColorScaleLocation();
928− program = &DefaultMetavoxelRendererImplementation::getCascadedShadowMapHeightfieldProgram();
929− }
930− program->setUniformValue(heightScaleLocation, 1.0f / _heightSize);
931− program->setUniformValue(colorScaleLocation, (float)_heightSize / innerSize);
1050+ DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().setUniformValue(
1051+ DefaultMetavoxelRendererImplementation::getBaseHeightScaleLocation(), 1.0f / _heightSize);
1052+ DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().setUniformValue(
1053+ DefaultMetavoxelRendererImplementation::getBaseColorScaleLocation(), (float)_heightSize / innerSize);
9321054 glActiveTexture(GL_TEXTURE1);
9331055 glBindTexture(GL_TEXTURE_2D, _colorTextureID);
9341056
@@ -944,6 +1066,8 @@ void HeightfieldBuffer::render(bool cursor) { · 9 unmodified lines
9441066
9451067 bufferPair.first.release();
9461068 bufferPair.second.release();
1069+
1070+ Application::getInstance()->getMetavoxels()->noteNeedToLight();
9471071 }
9481072
9491073 QHash<int, HeightfieldBuffer::BufferPair> HeightfieldBuffer::_bufferPairs;
@@ -959,7 +1083,7 @@ void HeightfieldPreview::render(const glm::vec3& translation, float scale) const · 9 unmodified lines
9591083 glEnableClientState(GL_VERTEX_ARRAY);
9601084 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
9611085
962− DefaultMetavoxelRendererImplementation::getHeightfieldProgram().bind();
1086+ DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().bind();
9631087
9641088 glPushMatrix();
9651089 glTranslatef(translation.x, translation.y, translation.z);
@@ -971,7 +1095,7 @@ void HeightfieldPreview::render(const glm::vec3& translation, float scale) const · 5 unmodified lines
9711095
9721096 glPopMatrix();
9731097
974− DefaultMetavoxelRendererImplementation::getHeightfieldProgram().release();
1098+ DefaultMetavoxelRendererImplementation::getBaseHeightfieldProgram().release();
9751099
9761100 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
9771101 glDisableClientState(GL_VERTEX_ARRAY);
@@ -1025,8 +1149,89 @@ void VoxelBuffer::render(bool cursor) { · 47 unmodified lines
10251149
10261150 glDrawRangeElements(GL_QUADS, 0, _vertexCount - 1, _indexCount, GL_UNSIGNED_INT, 0);
10271151
1152+ if (!_materials.isEmpty()) {
1153+ glDrawBuffers(sizeof(COLOR_DRAW_BUFFERS) / sizeof(COLOR_DRAW_BUFFERS[0]), COLOR_DRAW_BUFFERS);
1154+
1155+ glDepthFunc(GL_LEQUAL);
1156+ glDepthMask(false);
1157+ glEnable(GL_BLEND);
1158+ glDisable(GL_ALPHA_TEST);
1159+ glEnable(GL_POLYGON_OFFSET_FILL);
1160+ glPolygonOffset(-1.0f, -1.0f);
1161+
1162+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().bind();
1163+ const DefaultMetavoxelRendererImplementation::SplatLocations& locations =
1164+ DefaultMetavoxelRendererImplementation::getSplatVoxelLocations();
1165+
1166+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().setAttributeBuffer(locations.materials,
1167+ GL_UNSIGNED_BYTE, (qint64)&point->materials, SPLAT_COUNT, sizeof(VoxelPoint));
1168+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().enableAttributeArray(locations.materials);
1169+
1170+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().setAttributeBuffer(locations.materialWeights,
1171+ GL_UNSIGNED_BYTE, (qint64)&point->materialWeights, SPLAT_COUNT, sizeof(VoxelPoint));
1172+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().enableAttributeArray(locations.materialWeights);
1173+
1174+ for (int i = 0; i < _materials.size(); i += SPLAT_COUNT) {
1175+ QVector4D scalesS, scalesT;
1176+
1177+ for (int j = 0; j < SPLAT_COUNT; j++) {
1178+ glActiveTexture(GL_TEXTURE0 + SPLAT_TEXTURE_UNITS[j]);
1179+ int index = i + j;
1180+ if (index < _networkTextures.size()) {
1181+ const NetworkTexturePointer& texture = _networkTextures.at(index);
1182+ if (texture) {
1183+ MaterialObject* material = static_cast<MaterialObject*>(_materials.at(index).data());
1184+ scalesS[j] = 1.0f / material->getScaleS();
1185+ scalesT[j] = 1.0f / material->getScaleT();
1186+ glBindTexture(GL_TEXTURE_2D, texture->getID());
1187+ } else {
1188+ glBindTexture(GL_TEXTURE_2D, 0);
1189+ }
1190+ } else {
1191+ glBindTexture(GL_TEXTURE_2D, 0);
1192+ }
1193+ }
1194+ const float QUARTER_STEP = 0.25f * EIGHT_BIT_MAXIMUM_RECIPROCAL;
1195+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().setUniformValue(
1196+ locations.splatTextureScalesS, scalesS);
1197+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().setUniformValue(
1198+ locations.splatTextureScalesT, scalesT);
1199+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().setUniformValue(
1200+ locations.textureValueMinima,
1201+ (i + 1) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP, (i + 2) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP,
1202+ (i + 3) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP, (i + 4) * EIGHT_BIT_MAXIMUM_RECIPROCAL - QUARTER_STEP);
1203+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().setUniformValue(
1204+ locations.textureValueMaxima,
1205+ (i + 1) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP, (i + 2) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP,
1206+ (i + 3) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP, (i + 4) * EIGHT_BIT_MAXIMUM_RECIPROCAL + QUARTER_STEP);
1207+ glDrawRangeElements(GL_QUADS, 0, _vertexCount - 1, _indexCount, GL_UNSIGNED_INT, 0);
1208+ }
1209+
1210+ for (int i = 0; i < SPLAT_COUNT; i++) {
1211+ glActiveTexture(GL_TEXTURE0 + SPLAT_TEXTURE_UNITS[i]);
1212+ glBindTexture(GL_TEXTURE_2D, 0);
1213+ }
1214+
1215+ glActiveTexture(GL_TEXTURE0);
1216+
1217+ glDisable(GL_POLYGON_OFFSET_FILL);
1218+ glEnable(GL_ALPHA_TEST);
1219+ glDisable(GL_BLEND);
1220+ glDepthMask(true);
1221+ glDepthFunc(GL_LESS);
1222+
1223+ glDrawBuffers(sizeof(COLOR_NORMAL_DRAW_BUFFERS) / sizeof(COLOR_NORMAL_DRAW_BUFFERS[0]), COLOR_NORMAL_DRAW_BUFFERS);
1224+
1225+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().disableAttributeArray(locations.materials);
1226+ DefaultMetavoxelRendererImplementation::getSplatVoxelProgram().disableAttributeArray(locations.materialWeights);
1227+
1228+ DefaultMetavoxelRendererImplementation::getBaseVoxelProgram().bind();
1229+ }
1230+
10281231 _vertexBuffer.release();
10291232 _indexBuffer.release();
1233+
1234+ Application::getInstance()->getMetavoxels()->noteNeedToLight();
10301235 }
10311236
10321237 BufferDataAttribute::BufferDataAttribute(const QString& name) :
@@ -1056,48 +1261,6 @@ void DefaultMetavoxelRendererImplementation::init() { · 23 unmodified lines
10561261 _pointScaleLocation = _pointProgram.uniformLocation("pointScale");
10571262 _pointProgram.release();
10581263
1059− _heightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1060− "shaders/metavoxel_heightfield.vert");
1061− _heightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1062− "shaders/metavoxel_heightfield.frag");
1063− _heightfieldProgram.link();
1064−
1065− _heightfieldProgram.bind();
1066− _heightfieldProgram.setUniformValue("heightMap", 0);
1067− _heightfieldProgram.setUniformValue("diffuseMap", 1);
1068− _heightScaleLocation = _heightfieldProgram.uniformLocation("heightScale");
1069− _colorScaleLocation = _heightfieldProgram.uniformLocation("colorScale");
1070− _heightfieldProgram.release();
1071−
1072− _shadowMapHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1073− "shaders/metavoxel_heightfield.vert");
1074− _shadowMapHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1075− "shaders/metavoxel_heightfield_shadow_map.frag");
1076− _shadowMapHeightfieldProgram.link();
1077−
1078− _shadowMapHeightfieldProgram.bind();
1079− _shadowMapHeightfieldProgram.setUniformValue("heightMap", 0);
1080− _shadowMapHeightfieldProgram.setUniformValue("diffuseMap", 1);
1081− _shadowMapHeightfieldProgram.setUniformValue("shadowMap", 2);
1082− _shadowMapHeightScaleLocation = _shadowMapHeightfieldProgram.uniformLocation("heightScale");
1083− _shadowMapColorScaleLocation = _shadowMapHeightfieldProgram.uniformLocation("colorScale");
1084− _shadowMapHeightfieldProgram.release();
1085−
1086− _cascadedShadowMapHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1087− "shaders/metavoxel_heightfield.vert");
1088− _cascadedShadowMapHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1089− "shaders/metavoxel_heightfield_cascaded_shadow_map.frag");
1090− _cascadedShadowMapHeightfieldProgram.link();
1091−
1092− _cascadedShadowMapHeightfieldProgram.bind();
1093− _cascadedShadowMapHeightfieldProgram.setUniformValue("heightMap", 0);
1094− _cascadedShadowMapHeightfieldProgram.setUniformValue("diffuseMap", 1);
1095− _cascadedShadowMapHeightfieldProgram.setUniformValue("shadowMap", 2);
1096− _cascadedShadowMapHeightScaleLocation = _cascadedShadowMapHeightfieldProgram.uniformLocation("heightScale");
1097− _cascadedShadowMapColorScaleLocation = _cascadedShadowMapHeightfieldProgram.uniformLocation("colorScale");
1098− _shadowDistancesLocation = _cascadedShadowMapHeightfieldProgram.uniformLocation("shadowDistances");
1099− _cascadedShadowMapHeightfieldProgram.release();
1100−
11011264 _baseHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
11021265 "shaders/metavoxel_heightfield_base.vert");
11031266 _baseHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
@@ -1111,60 +1274,7 @@ void DefaultMetavoxelRendererImplementation::init() { · 7 unmodified lines
11111274 _baseColorScaleLocation = _baseHeightfieldProgram.uniformLocation("colorScale");
11121275 _baseHeightfieldProgram.release();
11131276
1114− _splatHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1115− "shaders/metavoxel_heightfield_splat.vert");
1116− _splatHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1117− "shaders/metavoxel_heightfield_splat.frag");
1118− _splatHeightfieldProgram.link();
1119−
1120− _splatHeightfieldProgram.bind();
1121− _splatHeightfieldProgram.setUniformValue("heightMap", 0);
1122− _splatHeightfieldProgram.setUniformValue("textureMap", 1);
1123− _splatHeightfieldProgram.setUniformValueArray("diffuseMaps", SPLAT_TEXTURE_UNITS, SPLAT_COUNT);
1124− _splatHeightScaleLocation = _splatHeightfieldProgram.uniformLocation("heightScale");
1125− _splatTextureScaleLocation = _splatHeightfieldProgram.uniformLocation("textureScale");
1126− _splatTextureOffsetLocation = _splatHeightfieldProgram.uniformLocation("splatTextureOffset");
1127− _splatTextureScalesSLocation = _splatHeightfieldProgram.uniformLocation("splatTextureScalesS");
1128− _splatTextureScalesTLocation = _splatHeightfieldProgram.uniformLocation("splatTextureScalesT");
1129− _splatTextureValueMinimaLocation = _splatHeightfieldProgram.uniformLocation("textureValueMinima");
1130− _splatTextureValueMaximaLocation = _splatHeightfieldProgram.uniformLocation("textureValueMaxima");
1131− _splatHeightfieldProgram.release();
1132−
1133− _lightHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1134− "shaders/metavoxel_heightfield_light.vert");
1135− _lightHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1136− "shaders/metavoxel_heightfield_light.frag");
1137− _lightHeightfieldProgram.link();
1138−
1139− _lightHeightfieldProgram.bind();
1140− _lightHeightfieldProgram.setUniformValue("heightMap", 0);
1141− _lightHeightScaleLocation = _lightHeightfieldProgram.uniformLocation("heightScale");
1142− _lightHeightfieldProgram.release();
1143−
1144− _shadowLightHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1145− "shaders/metavoxel_heightfield_light.vert");
1146− _shadowLightHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1147− "shaders/metavoxel_heightfield_light_shadow_map.frag");
1148− _shadowLightHeightfieldProgram.link();
1149−
1150− _shadowLightHeightfieldProgram.bind();
1151− _shadowLightHeightfieldProgram.setUniformValue("heightMap", 0);
1152− _shadowLightHeightfieldProgram.setUniformValue("shadowMap", 2);
1153− _shadowLightHeightScaleLocation = _shadowLightHeightfieldProgram.uniformLocation("heightScale");
1154− _shadowLightHeightfieldProgram.release();
1155−
1156− _cascadedShadowLightHeightfieldProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1157− "shaders/metavoxel_heightfield_light.vert");
1158− _cascadedShadowLightHeightfieldProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1159− "shaders/metavoxel_heightfield_light_cascaded_shadow_map.frag");
1160− _cascadedShadowLightHeightfieldProgram.link();
1161−
1162− _cascadedShadowLightHeightfieldProgram.bind();
1163− _cascadedShadowLightHeightfieldProgram.setUniformValue("heightMap", 0);
1164− _cascadedShadowLightHeightfieldProgram.setUniformValue("shadowMap", 2);
1165− _cascadedShadowLightHeightScaleLocation = _cascadedShadowLightHeightfieldProgram.uniformLocation("heightScale");
1166− _shadowLightDistancesLocation = _cascadedShadowLightHeightfieldProgram.uniformLocation("shadowDistances");
1167− _cascadedShadowLightHeightfieldProgram.release();
1277+ loadSplatProgram("heightfield", _splatHeightfieldProgram, _splatHeightfieldLocations);
11681278
11691279 _heightfieldCursorProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
11701280 "shaders/metavoxel_heightfield_cursor.vert");
@@ -1175,6 +1285,14 @@ void DefaultMetavoxelRendererImplementation::init() { · 4 unmodified lines
11751285 _heightfieldCursorProgram.bind();
11761286 _heightfieldCursorProgram.setUniformValue("heightMap", 0);
11771287 _heightfieldCursorProgram.release();
1288+
1289+ _baseVoxelProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
1290+ "shaders/metavoxel_voxel_base.vert");
1291+ _baseVoxelProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
1292+ "shaders/metavoxel_voxel_base.frag");
1293+ _baseVoxelProgram.link();
1294+
1295+ loadSplatProgram("voxel", _splatVoxelProgram, _splatVoxelLocations);
11781296 }
11791297 }
11801298
@@ -1844,7 +1962,7 @@ int VoxelAugmentVisitor::visit(MetavoxelInfo& info) { · 663 unmodified lines
18441962 glm::vec3 center;
18451963 glm::vec3 normal;
18461964 const int MAX_MATERIALS_PER_VERTEX = 4;
1847− quint8 materials[4];
1965+ quint8 materials[] = { 0, 0, 0, 0 };
18481966 glm::vec4 materialWeights;
18491967 float totalWeight = 0.0f;
18501968 int red = 0, green = 0, blue = 0;
@@ -1865,7 +1983,7 @@ int VoxelAugmentVisitor::visit(MetavoxelInfo& info) { · 14 unmodified lines
18651983 totalWeight += 1.0f;
18661984 break;
18671985
1868− } else if (materials[j] == 0.0f) {
1986+ } else if (materials[j] == 0) {
18691987 materials[j] = crossing.material;
18701988 materialWeights[j] = 1.0f;
18711989 totalWeight += 1.0f;
@@ -2149,38 +2267,22 @@ void DefaultMetavoxelRendererImplementation::render(MetavoxelData& data, Metavox · 277 unmodified lines
21492267
21502268 _pointProgram.release();
21512269
2270+ glDrawBuffers(sizeof(COLOR_NORMAL_DRAW_BUFFERS) / sizeof(COLOR_NORMAL_DRAW_BUFFERS[0]), COLOR_NORMAL_DRAW_BUFFERS);
2271+
21522272 glEnable(GL_CULL_FACE);
21532273 glEnable(GL_ALPHA_TEST);
21542274 glAlphaFunc(GL_EQUAL, 0.0f);
21552275
21562276 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
21572277
2158− ProgramObject* program = &_heightfieldProgram;
2159− if (Menu::getInstance()->getShadowsEnabled()) {
2160− if (Menu::getInstance()->isOptionChecked(MenuOption::CascadedShadows)) {
2161− _cascadedShadowLightHeightfieldProgram.bind();
2162− _cascadedShadowLightHeightfieldProgram.setUniform(_shadowLightDistancesLocation,
2163− Application::getInstance()->getShadowDistances());
2164− program = &_cascadedShadowMapHeightfieldProgram;
2165− program->bind();
2166− program->setUniform(_shadowDistancesLocation, Application::getInstance()->getShadowDistances());
2167−
2168− } else {
2169− program = &_shadowMapHeightfieldProgram;
2170− }
2171− glActiveTexture(GL_TEXTURE2);
2172− glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getShadowDepthTextureID());
2173− glActiveTexture(GL_TEXTURE0);
2174− }
2175−
2176− program->bind();
2278+ _baseHeightfieldProgram.bind();
21772279
21782280 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
21792281
21802282 BufferRenderVisitor heightfieldRenderVisitor(Application::getInstance()->getMetavoxels()->getHeightfieldBufferAttribute());
21812283 data.guide(heightfieldRenderVisitor);
21822284
2183− program->release();
2285+ _baseHeightfieldProgram.release();
21842286
21852287 glActiveTexture(GL_TEXTURE2);
21862288 glBindTexture(GL_TEXTURE_2D, 0);
@@ -2189,57 +2291,63 @@ void DefaultMetavoxelRendererImplementation::render(MetavoxelData& data, Metavox · 2 unmodified lines
21892291 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
21902292 glDisableClientState(GL_VERTEX_ARRAY);
21912293
2192− glDisable(GL_ALPHA_TEST);
2193− glDisable(GL_CULL_FACE);
2194− glEnable(GL_BLEND);
2195−
21962294 glEnableClientState(GL_VERTEX_ARRAY);
21972295 glEnableClientState(GL_COLOR_ARRAY);
21982296 glEnableClientState(GL_NORMAL_ARRAY);
21992297
2200− glEnable(GL_CULL_FACE);
2298+ _baseVoxelProgram.bind();
22012299
22022300 BufferRenderVisitor voxelRenderVisitor(Application::getInstance()->getMetavoxels()->getVoxelBufferAttribute());
22032301 data.guide(voxelRenderVisitor);
22042302
2303+ _baseVoxelProgram.release();
2304+
2305+ glDisable(GL_ALPHA_TEST);
22052306 glDisable(GL_CULL_FACE);
2307+ glEnable(GL_BLEND);
22062308
22072309 glDisableClientState(GL_VERTEX_ARRAY);
22082310 glDisableClientState(GL_COLOR_ARRAY);
22092311 glDisableClientState(GL_NORMAL_ARRAY);
2312+
2313+ glDrawBuffers(sizeof(COLOR_DRAW_BUFFERS) / sizeof(COLOR_DRAW_BUFFERS[0]), COLOR_DRAW_BUFFERS);
2314+}
2315+
2316+void DefaultMetavoxelRendererImplementation::loadSplatProgram(const char* type,
2317+ ProgramObject& program, SplatLocations& locations) {
2318+ program.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
2319+ "shaders/metavoxel_" + type + "_splat.vert");
2320+ program.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
2321+ "shaders/metavoxel_" + type + "_splat.frag");
2322+ program.link();
2323+
2324+ program.bind();
2325+ program.setUniformValue("heightMap", 0);
2326+ program.setUniformValue("textureMap", 1);
2327+ program.setUniformValueArray("diffuseMaps", SPLAT_TEXTURE_UNITS, SPLAT_COUNT);
2328+ locations.heightScale = program.uniformLocation("heightScale");
2329+ locations.textureScale = program.uniformLocation("textureScale");
2330+ locations.splatTextureOffset = program.uniformLocation("splatTextureOffset");
2331+ locations.splatTextureScalesS = program.uniformLocation("splatTextureScalesS");
2332+ locations.splatTextureScalesT = program.uniformLocation("splatTextureScalesT");
2333+ locations.textureValueMinima = program.uniformLocation("textureValueMinima");
2334+ locations.textureValueMaxima = program.uniformLocation("textureValueMaxima");
2335+ locations.materials = program.attributeLocation("materials");
2336+ locations.materialWeights = program.attributeLocation("materialWeights");
2337+ program.release();
22102338 }
22112339
22122340 ProgramObject DefaultMetavoxelRendererImplementation::_pointProgram;
22132341 int DefaultMetavoxelRendererImplementation::_pointScaleLocation;
2214−ProgramObject DefaultMetavoxelRendererImplementation::_heightfieldProgram;
2215−int DefaultMetavoxelRendererImplementation::_heightScaleLocation;
2216−int DefaultMetavoxelRendererImplementation::_colorScaleLocation;
2217−ProgramObject DefaultMetavoxelRendererImplementation::_shadowMapHeightfieldProgram;
2218−int DefaultMetavoxelRendererImplementation::_shadowMapHeightScaleLocation;
2219−int DefaultMetavoxelRendererImplementation::_shadowMapColorScaleLocation;
2220−ProgramObject DefaultMetavoxelRendererImplementation::_cascadedShadowMapHeightfieldProgram;
2221−int DefaultMetavoxelRendererImplementation::_cascadedShadowMapHeightScaleLocation;
2222−int DefaultMetavoxelRendererImplementation::_cascadedShadowMapColorScaleLocation;
2223−int DefaultMetavoxelRendererImplementation::_shadowDistancesLocation;
22242342 ProgramObject DefaultMetavoxelRendererImplementation::_baseHeightfieldProgram;
22252343 int DefaultMetavoxelRendererImplementation::_baseHeightScaleLocation;
22262344 int DefaultMetavoxelRendererImplementation::_baseColorScaleLocation;
22272345 ProgramObject DefaultMetavoxelRendererImplementation::_splatHeightfieldProgram;
2228−int DefaultMetavoxelRendererImplementation::_splatHeightScaleLocation;
2229−int DefaultMetavoxelRendererImplementation::_splatTextureScaleLocation;
2230−int DefaultMetavoxelRendererImplementation::_splatTextureOffsetLocation;
2231−int DefaultMetavoxelRendererImplementation::_splatTextureScalesSLocation;
2232−int DefaultMetavoxelRendererImplementation::_splatTextureScalesTLocation;
2233−int DefaultMetavoxelRendererImplementation::_splatTextureValueMinimaLocation;
2234−int DefaultMetavoxelRendererImplementation::_splatTextureValueMaximaLocation;
2235−ProgramObject DefaultMetavoxelRendererImplementation::_lightHeightfieldProgram;
2236−int DefaultMetavoxelRendererImplementation::_lightHeightScaleLocation;
2237−ProgramObject DefaultMetavoxelRendererImplementation::_shadowLightHeightfieldProgram;
2238−int DefaultMetavoxelRendererImplementation::_shadowLightHeightScaleLocation;
2239−ProgramObject DefaultMetavoxelRendererImplementation::_cascadedShadowLightHeightfieldProgram;
2240−int DefaultMetavoxelRendererImplementation::_cascadedShadowLightHeightScaleLocation;
2241−int DefaultMetavoxelRendererImplementation::_shadowLightDistancesLocation;
2346+DefaultMetavoxelRendererImplementation::SplatLocations DefaultMetavoxelRendererImplementation::_splatHeightfieldLocations;
22422347 ProgramObject DefaultMetavoxelRendererImplementation::_heightfieldCursorProgram;
2348+ProgramObject DefaultMetavoxelRendererImplementation::_baseVoxelProgram;
2349+ProgramObject DefaultMetavoxelRendererImplementation::_splatVoxelProgram;
2350+DefaultMetavoxelRendererImplementation::SplatLocations DefaultMetavoxelRendererImplementation::_splatVoxelLocations;
22432351
22442352 static void enableClipPlane(GLenum plane, float x, float y, float z, float w) {
22452353 GLdouble coefficients[] = { x, y, z, w };