Support ptex mesh - step 5: improve the shader and rendering code

src/esp/assets/PTexMeshData.cpp

@@ -50,23 +50,23 @@ float PTexMeshData::exposure() const {
   return exposure_;
 }
 
-void PTexMeshData::setExposure(const float& val) {
+void PTexMeshData::setExposure(float val) {
   exposure_ = val;
 }
 
 float PTexMeshData::gamma() const {
   return gamma_;
 }
 
-void PTexMeshData::setGamma(const float& val) {
+void PTexMeshData::setGamma(float val) {
   gamma_ = val;
 }
 
 float PTexMeshData::saturation() const {
   return saturation_;
 }
 
-void PTexMeshData::setSaturation(const float& val) {
+void PTexMeshData::setSaturation(float val) {
   saturation_ = val;
 }
 

src/esp/assets/PTexMeshData.h

@@ -63,23 +63,28 @@ class PTexMeshData : public BaseMesh {
   virtual Magnum::GL::Mesh* getMagnumGLMesh(int submeshID) override;
 
   float exposure() const;
-  void setExposure(const float& val);
+  void setExposure(float val);
 
   float gamma() const;
-  void setGamma(const float& val);
+  void setGamma(float val);
 
   float saturation() const;
-  void setSaturation(const float& val);
+  void setSaturation(float val);
 
  protected:
   void loadMeshData(const std::string& meshFile);
 
   float splitSize_ = 0.0f;
   uint32_t tileSize_ = 0;
 
-  // based on ReplicaSDK
+  // initial values are based on ReplicaSDK
+  //! @brief expsure, the amount of light per unit area reaching the image
   float exposure_ = 0.025f;
-  float gamma_ = 1.6969f;
+
+  //! @brief gamma, the exponent applied in the gamma correction
+  float gamma_ = 1.0f / 1.6969f;
+
+  //! @brief saturation, the intensity of a color
   float saturation_ = 1.5f;
 
   std::string atlasFolder_;

src/esp/gfx/PTexMeshShader.cpp

@@ -69,7 +69,7 @@ PTexMeshShader::PTexMeshShader() {
   // cache the uniform locations
   MVPMatrixUniform_ = uniformLocation("MVP");
   exposureUniform_ = uniformLocation("exposure");
-  gammaInverseUniform_ = uniformLocation("gammaInverse");
+  gammaUniform_ = uniformLocation("gamma");
   saturationUniform_ = uniformLocation("saturation");
   tileSizeUniform_ = uniformLocation("tileSize");
   widthInTilesUniform_ = uniformLocation("widthInTiles");
@@ -100,8 +100,7 @@ PTexMeshShader& PTexMeshShader::setExposure(float exposure) {
   return *this;
 }
 PTexMeshShader& PTexMeshShader::setGamma(float gamma) {
-  // Careful: we set its inverse, not gamma directly
-  setUniform(gammaInverseUniform_, 1.0f / gamma);
+  setUniform(gammaUniform_, gamma);
   return *this;
 }
 
@@ -115,10 +114,9 @@ PTexMeshShader& PTexMeshShader::setAtlasTextureSize(
     uint32_t tileSize) {
   setUniform(tileSizeUniform_, (int)tileSize);
 
-  // Image size in given mip level 0
+  // get image width in given mip level 0
   int mipLevel = 0;
-  int widthEntry = 0;
-  const auto width = texture.imageSize(mipLevel)[widthEntry];
+  const auto width = texture.imageSize(mipLevel).x();
   setUniform(widthInTilesUniform_, int(width / tileSize));
   return *this;
 }

src/esp/gfx/PTexMeshShader.h

@@ -23,19 +23,51 @@ namespace gfx {
 
 class PTexMeshShader : public Magnum::GL::AbstractShaderProgram {
  public:
+  //! @brief vertex positions
   typedef Magnum::GL::Attribute<0, Magnum::Vector4> Position;
 
+  /**
+   * @brief Constructor
+   */
   explicit PTexMeshShader();
 
   // ======== texture binding ========
+  /**
+   *! @brief Bind the atlas texture
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& bindAtlasTexture(Magnum::GL::Texture2D& texture);
+  /**
+   *! @brief Bind the buffer texture containing the adjacent faces
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& bindAdjFacesBufferTexture(Magnum::GL::BufferTexture& texture);
 
   // ======== set uniforms ===========
+  /**
+   *! @brief Set modelview and projection matrix to the uniform on GPU
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& setMVPMatrix(const Magnum::Matrix4& matrix);
+  /**
+   *! @brief Set expsure to the uniform on GPU
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& setExposure(float exposure);
+  /**
+   *! @brief Set gamma to the uniform on GPU
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& setGamma(float gamma);
+  /**
+   *! @brief Set saturation to the uniform on GPU
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& setSaturation(float saturation);
+  /**
+   *! @brief Set the tile size of the atlas texture
+   *! @return Reference to self (for method chaining)
+   */
   PTexMeshShader& setAtlasTextureSize(Magnum::GL::Texture2D& texture,
                                       uint32_t tileSize);
 
@@ -45,7 +77,7 @@ class PTexMeshShader : public Magnum::GL::AbstractShaderProgram {
   // therefore, cache the locations in the constructor
   int MVPMatrixUniform_;
   int exposureUniform_;
-  int gammaInverseUniform_;
+  int gammaUniform_;
   int saturationUniform_;
   int tileSizeUniform_;
   int widthInTilesUniform_;

src/shaders/ptex-default-gl410.frag

@@ -171,14 +171,14 @@ layout(location = 0) out vec4 FragColor;
 uniform sampler2D atlasTex;
 
 uniform float exposure;
-uniform float gammaInverse;
+uniform float gamma;
 uniform float saturation;
 
 in vec2 uv;
 
 void main() {
   vec4 c = textureAtlas(atlasTex, gl_PrimitiveID, uv * tileSize) * exposure;
 	applySaturation(c, saturation);
-	c.rgb = pow(c.rgb, vec3(gammaInverse));
+	c.rgb = pow(c.rgb, vec3(gamma));
 	FragColor = vec4(c.rgb, 1.0f);
 }