[core] change gl::Uniform -> gl::UniformState

3 files changed, 32 insertions, 28 deletions

diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp
index f9fe74a36d..bb93db3e35 100644
--- a/src/mbgl/gl/context.cpp
+++ b/src/mbgl/gl/context.cpp
@@ -191,6 +191,8 @@ UniqueProgram Context::createProgram(ShaderID vertexShader, ShaderID fragmentSha
     MBGL_CHECK_ERROR(glAttachShader(result, vertexShader));
     MBGL_CHECK_ERROR(glAttachShader(result, fragmentShader));
 
+    linkProgram(result);
+
     return result;
 }
 
diff --git a/src/mbgl/gl/program.hpp b/src/mbgl/gl/program.hpp
index 815be75736..cb6c118fe1 100644
--- a/src/mbgl/gl/program.hpp
+++ b/src/mbgl/gl/program.hpp
@@ -33,20 +33,17 @@ public:
     using UniformValues = gfx::UniformValues<UniformList>;
     using TextureBindings = gfx::TextureBindings<TextureList>;
 
-    using Uniforms = gl::Uniforms<UniformList>;
-
     Program(Context& context, const std::string& vertexSource, const std::string& fragmentSource)
         : program(
               context.createProgram(context.createShader(ShaderType::Vertex, vertexSource),
                                     context.createShader(ShaderType::Fragment, fragmentSource))),
-          uniformsState((context.linkProgram(program), Uniforms::bindLocations(program))),
           attributeLocations(context, program) {
-        // Re-link program after manually binding only active attributes in Attributes::bindLocations
+        // Re-link program after manually binding only active attributes in Attributes::queryLocations
         context.linkProgram(program);
 
         // We have to re-initialize the uniforms state from the bindings as the uniform locations
         // get shifted on some implementations
-        uniformsState = Uniforms::bindLocations(program);
+        uniformStates.queryLocations(program);
 
         // Texture units are specified via uniforms as well, so we need query their locations
         textures.queryLocations(program);
@@ -55,11 +52,11 @@ public:
     template <class BinaryProgram>
     Program(Context& context, const BinaryProgram& binaryProgram)
         : program(context.createProgram(binaryProgram.format(), binaryProgram.code())),
-          uniformsState(Uniforms::loadNamedLocations(binaryProgram)),
           attributeLocations(binaryProgram) {
+        uniformStates.loadNamedLocations(binaryProgram);
         textures.loadNamedLocations(binaryProgram);
     }
-    
+
     static Program createProgram(gl::Context& context,
                                  const ProgramParameters& programParameters,
                                  const char* name,
@@ -113,9 +110,11 @@ public:
     template <class BinaryProgram>
     optional<BinaryProgram> get(Context& context, const std::string& identifier) const {
         if (auto binaryProgram = context.getBinaryProgram(program)) {
-            return BinaryProgram{ binaryProgram->first, std::move(binaryProgram->second),
-                                  identifier, attributeLocations.getNamedLocations(),
-                                  Uniforms::getNamedLocations(uniformsState),
+            return BinaryProgram{ binaryProgram->first,
+                                  std::move(binaryProgram->second),
+                                  identifier,
+                                  attributeLocations.getNamedLocations(),
+                                  uniformStates.getNamedLocations(),
                                   textures.getNamedLocations() };
         }
         return {};
@@ -146,7 +145,7 @@ public:
 
         context.program = program;
 
-        Uniforms::bind(uniformsState, uniformValues);
+        uniformStates.bind(uniformValues);
 
         textures.bind(context, textureBindings);
 
@@ -163,7 +162,7 @@ public:
 private:
     UniqueProgram program;
 
-    typename Uniforms::State uniformsState;
+    gl::UniformStates<UniformList> uniformStates;
     gl::AttributeLocations<AttributeList> attributeLocations;
     gl::Textures<TextureList> textures;
 };
diff --git a/src/mbgl/gl/uniform.hpp b/src/mbgl/gl/uniform.hpp
index 3827015bb3..770f3e2294 100644
--- a/src/mbgl/gl/uniform.hpp
+++ b/src/mbgl/gl/uniform.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/gfx/uniform.hpp>
 #include <mbgl/gl/types.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/ignore.hpp>
@@ -49,23 +50,25 @@ public:
     optional<Value> current = {};
 };
 
-UniformLocation uniformLocation(ProgramID, const char * name);
+UniformLocation uniformLocation(ProgramID, const char* name);
+
+using NamedUniformLocations = std::vector<std::pair<const std::string, UniformLocation>>;
 
 template <class>
-class Uniforms;
+class UniformStates;
 
 template <class... Us>
-class Uniforms<TypeList<Us...>> final {
-public:
-    using Types = TypeList<Us...>;
+class UniformStates<TypeList<Us...>> final {
+private:
     using State = IndexedTuple<TypeList<Us...>, TypeList<UniformState<typename Us::Value>...>>;
-    using Values = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>;
-    using NamedLocations = std::vector<std::pair<const std::string, UniformLocation>>;
 
-    static State bindLocations(const ProgramID& id) {
+    State state;
+
+public:
+    void queryLocations(const ProgramID& id) {
 #ifndef NDEBUG
         // Verify active uniform types match the enum
-        const auto active = activeUniforms(id);
+        const auto active = gl::activeUniforms(id);
 
         util::ignore(
             { // Some shader programs have uniforms declared, but not used, so they're not active.
@@ -75,19 +78,19 @@ public:
                    : false)... });
 #endif
 
-        return State(uniformLocation(id, Us::name())...);
+        state = State{ gl::uniformLocation(id, Us::name())... };
     }
 
-    template <class Program>
-    static State loadNamedLocations(const Program& program) {
-        return State(UniformState<typename Us::Value>(program.uniformLocation(Us::name()))...);
+    template <class BinaryProgram>
+    void loadNamedLocations(const BinaryProgram& program) {
+        state = State{ UniformState<typename Us::Value>(program.uniformLocation(Us::name()))... };
     }
 
-    static NamedLocations getNamedLocations(const State& state) {
-        return NamedLocations{ { Us::name(), state.template get<Us>().location }... };
+    NamedUniformLocations getNamedLocations() const {
+        return NamedUniformLocations{ { Us::name(), state.template get<Us>().location }... };
     }
 
-    static void bind(State& state, const Values& values) {
+    void bind(const gfx::UniformValues<TypeList<Us...>>& values) {
         util::ignore({ (state.template get<Us>() = values.template get<Us>(), 0)... });
     }
 };