update

Author: markaren

examples/misc/cubemap.cpp

@@ -22,7 +22,7 @@ int main() {
     Canvas canvas("Cubemap");
     GLRenderer renderer(canvas.size());
 
-    PerspectiveCamera camera(50, canvas.aspect(), 1, 5000);
+    PerspectiveCamera camera(50, canvas.aspect(), 1, 50000);
     camera.position.z = 2000;
 
     std::filesystem::path path("data/textures/cube/SwedishRoyalCastle");

src/threepp/renderers/GLCubeRenderTarget.hpp

@@ -88,13 +88,13 @@ namespace threepp {
 
             material->name = "CubemapFromEquirect";
 
-            material->uniforms = std::make_shared<UniformMap>(shader.uniforms);
+            material->uniforms = shader.uniforms;
             material->vertexShader = shader.vertexShader;
             material->fragmentShader = shader.fragmentShader;
             material->side = Side::Back;
             material->blending = Blending::None;
 
-            material->uniforms->at("tEquirect").setValue(&texture);
+            material->uniforms.at("tEquirect").setValue(&texture);
 
             auto mesh = Mesh(geometry, material);
 

src/threepp/renderers/GLRenderer.cpp

@@ -69,7 +69,7 @@ struct GLRenderer::Impl {
     gl::GLState state;
 
 
-    std::shared_ptr<Scene> _emptyScene;
+    std::unique_ptr<Scene> _emptyScene;
 
     OnMaterialDispose onMaterialDispose;
 
@@ -140,6 +140,7 @@ struct GLRenderer::Impl {
 
     Impl(GLRenderer& scope, WindowSize size, const GLRenderer::Parameters& parameters)
         : scope(scope), _size(size),
+          cubemaps(scope),
           bufferRenderer(std::make_unique<gl::GLBufferRenderer>(_info)),
           indexedBufferRenderer(std::make_unique<gl::GLIndexedBufferRenderer>(_info)),
           clipping(properties),
@@ -153,7 +154,7 @@ struct GLRenderer::Impl {
           background(scope, cubemaps, state, objects, parameters.premultipliedAlpha),
           programCache(bindingStates, clipping),
           _currentDrawBuffers(GL_BACK),
-          _emptyScene(Scene::create()),
+          _emptyScene(std::make_unique<Scene>()),
           onMaterialDispose(this) {
 
         this->setViewport(0, 0, size.width, size.height);
@@ -1149,7 +1150,7 @@ struct GLRenderer::Impl {
 GLRenderer::GLRenderer(WindowSize size, const GLRenderer::Parameters& parameters) {
 
 #ifndef EMSCRIPTEN
-    loadGlad(); // if Glad has yet to be loaded, do it now
+    loadGlad();// if Glad has yet to be loaded, do it now
 #endif
 
     pimpl_ = std::make_unique<Impl>(*this, size, parameters);

src/threepp/renderers/gl/GLBackground.cpp

@@ -2,8 +2,8 @@
 #include "threepp/renderers/gl/GLBackground.hpp"
 #include "threepp/renderers/gl/GLCubeMaps.hpp"
 #include "threepp/renderers/gl/GLObjects.hpp"
-#include "threepp/renderers/gl/GLState.hpp"
 #include "threepp/renderers/gl/GLRenderLists.hpp"
+#include "threepp/renderers/gl/GLState.hpp"
 
 #include "threepp/renderers/GLRenderer.hpp"
 
@@ -58,15 +58,15 @@ void GLBackground::render(GLRenderList& renderList, Object3D* scene) {
             if (!boxMesh) {
                 auto shaderMaterial = ShaderMaterial::create();
                 shaderMaterial->name = "BackgroundCubeMaterial";
-                shaderMaterial->uniforms = std::make_shared<UniformMap>(shaders::ShaderLib::instance().cube.uniforms);
+                shaderMaterial->uniforms = shaders::ShaderLib::instance().cube.uniforms;
                 shaderMaterial->vertexShader = shaders::ShaderLib::instance().cube.vertexShader;
                 shaderMaterial->fragmentShader = shaders::ShaderLib::instance().cube.fragmentShader;
                 shaderMaterial->side = Side::Back;
                 shaderMaterial->depthTest = false;
                 shaderMaterial->depthWrite = false;
                 shaderMaterial->fog = false;
 
-                auto geometry = BoxGeometry::create(1, 1, 1);
+                auto geometry = BoxGeometry::create(100, 100, 100);
                 geometry->deleteAttribute("normal");
                 geometry->deleteAttribute("uv");
 
@@ -75,18 +75,18 @@ void GLBackground::render(GLRenderList& renderList, Object3D* scene) {
                 boxMesh->onBeforeRender = [&](void*, Object3D*, Camera* camera, BufferGeometry*, Material*, std::optional<GeometryGroup>) {
                     boxMesh->matrixWorld->copyPosition(*camera->matrixWorld);
                 };
-            }
 
-            objects.update(boxMesh.get());
-        }
+                objects.update(boxMesh.get());
 
-        auto shaderMaterial = boxMesh->material()->as<ShaderMaterial>();
-        shaderMaterial->uniforms->at("envMap").setValue(_background->texture());
-        shaderMaterial->uniforms->at("flipEnvMap").setValue(true);
-        shaderMaterial->needsUpdate();
+                shaderMaterial->needsUpdate();
+            }
 
-        renderList.unshift(boxMesh.get(), boxMesh->geometry(), boxMesh->material(), 0, 0, std::nullopt);
+            auto shaderMaterial = boxMesh->material()->as<ShaderMaterial>();
+            shaderMaterial->uniforms.at("envMap").setValue(_background->texture());
+            shaderMaterial->uniforms.at("flipEnvMap").setValue(true);
 
+            renderList.unshift(boxMesh.get(), boxMesh->geometry(), boxMesh->material(), 0, 0, std::nullopt);
+        }
     }
 }
 

src/threepp/renderers/gl/GLRenderLists.hpp

@@ -67,7 +67,7 @@ namespace threepp::gl {
 
         explicit GLRenderLists(GLProperties& properties);
 
-        GLRenderList* get(Scene* scene, size_t renderCallDepth);
+        GLRenderList* get(Object3D* scene, size_t renderCallDepth);
 
         void dispose();
 

src/threepp/renderers/gl/GLUniforms.cpp

@@ -151,7 +151,14 @@ namespace {
 
         void setValueV1f(const UniformValue& value) {
 
-            float f = std::get<float>(value);
+            float f;
+            if (std::holds_alternative<bool>(value)) {
+                f = std::get<bool>(value);
+            } else if (std::holds_alternative<float>(value)) {
+                f = std::get<float>(value);
+            } else {
+                throw std::runtime_error("Illegal variant index: " + std::to_string(value.index()));
+            }
 
             ensureCapacity(cache, 1);
             if (cache[0] == f) return;