Closes #5 billboard sprites (#232)

Author: xavieran

app/main3d.cpp

@@ -502,14 +502,16 @@ int main(int argc, char** argv)
                 gameRunner.mSystems->GetRenderables(),
                 light,
                 lightCamera,
-                *cameraPtr);
+                *cameraPtr,
+                false);
 
             renderer.DrawWithShadow(
                 gameRunner.GetZoneRenderData(),
                 gameRunner.mSystems->GetSprites(),
                 light,
                 lightCamera,
-                *cameraPtr);
+                *cameraPtr,
+                true);
 
             const auto& dynamicRenderables = gameRunner.mSystems->GetDynamicRenderables();
             for (const auto& obj : dynamicRenderables)
@@ -521,7 +523,8 @@ int main(int argc, char** argv)
                     data,
                     light,
                     lightCamera,
-                    *cameraPtr);
+                    *cameraPtr,
+                    true);
             }
         }
 

game/gameRunner.cpp

@@ -23,6 +23,7 @@
 
 #include "game/combatModelLoader.hpp"
 
+#include "graphics/glm.hpp"
 #include "gui/guiManager.hpp"
 #include "gui/IDialogScene.hpp"
 
@@ -141,11 +142,12 @@ void GameRunner::LoadSystems()
             if (item.GetZoneItem().GetVertices().size() > 1)
             {
                 auto id = mSystems->GetNextItemId();
+                auto rotation = item.GetZoneItem().IsSprite() ? Graphics::sNinetyDegreeRotation : item.GetRotation();
                 auto renderable = Renderable{
                     id,
                     mZoneData->mObjects.GetObject(item.GetZoneItem().GetName()),
                     item.GetLocation(),
-                    item.GetRotation(),
+                    rotation,
                     glm::vec3{static_cast<float>(item.GetZoneItem().GetScale())}};
 
                 if (item.GetZoneItem().IsSprite())
@@ -329,7 +331,7 @@ void GameRunner::LoadCombatants(std::uint8_t tileIndex)
                     entityId,
                     {},
                     BAK::ToGlCoord<float>(combatant.mLocation.mPosition + tilePos),
-                    glm::vec3{0},
+                    Graphics::sNinetyDegreeRotation,
                     glm::vec3{1},
                     BAK::MonsterIndex{combatant.mMonster},
                     combatComplete ? BAK::AnimationType::Dead : BAK::AnimationType::Idle,

graphics/glm.hpp

@@ -37,4 +37,6 @@ bool PointWithinRectangle(glm::vec<2, T> point, glm::vec<2, T> topLeft, glm::vec
         && glm::all(glm::lessThanEqual(point, bottomRight));
 }
 
+constexpr auto sNinetyDegreeRotation = glm::vec3{0, glm::pi<float>() * .5, 0};
+
 }

graphics/renderer.hpp

@@ -35,12 +35,24 @@ class Renderer
                 "directional.frag.glsl"};
             return shader.Compile();
         })},
+        mSpriteShader{std::invoke([]{
+            auto shader = ShaderProgram{
+                "sprite.vert.glsl",
+                "sprite.frag.glsl"};
+            return shader.Compile();
+        })},
         mPickShader{std::invoke([]{
             auto shader = ShaderProgram{
                 "pick.vert.glsl",
                 "pick.frag.glsl"};
             return shader.Compile();
         })},
+        mPickSpriteShader{std::invoke([]{
+            auto shader = ShaderProgram{
+                "pick.sprite.vert.glsl",
+                "pick.sprite.frag.glsl"};
+            return shader.Compile();
+        })},
         mShadowMapShader{std::invoke([]{
             auto shader = ShaderProgram{
                 "shadowMap.vert.glsl",
@@ -99,18 +111,21 @@ class Renderer
         glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-        auto& shader = mPickShader;
-        shader.UseProgramGL();
+        auto* shader = &mPickShader;
+        shader->UseProgramGL();
 
-        shader.SetUniform(shader.GetUniformLocation("texture0"), 0);
+        shader->SetUniform(shader->GetUniformLocation("texture0"), 0);
 
-        const auto mvpMatrixId = shader.GetUniformLocation("MVP");
-        const auto entityIdId = shader.GetUniformLocation("entityId");
+        auto mvpMatrixId = shader->GetUniformLocation("MVP");
+        auto entityIdId = shader->GetUniformLocation("entityId");
+
+        auto modelMatrixId = mPickSpriteShader.GetUniformLocation("M");
+        auto cameraPositionId = mPickSpriteShader.GetUniformLocation("cameraPosition_worldspace");
 
         const auto& viewMatrix = camera.GetViewMatrix();
         glm::mat4 MVP;
 
-        const auto RenderItem = [&](const auto& item)
+        const auto RenderItem = [&](const auto& item, bool isSprite)
         {
             if (glm::distance(camera.GetPosition(), item.GetLocation()) > sClickDistance) return;
 
@@ -119,8 +134,13 @@ class Renderer
 
             MVP = camera.GetProjectionMatrix() * viewMatrix * modelMatrix;
 
-            shader.SetUniform(mvpMatrixId, MVP);
-            shader.SetUniform(entityIdId, item.GetId().mValue);
+            shader->SetUniform(mvpMatrixId, MVP);
+            shader->SetUniform(entityIdId, item.GetId().mValue);
+            if (isSprite)
+            {
+                shader->SetUniform(modelMatrixId, modelMatrix);
+                shader->SetUniform(cameraPositionId, camera.GetPosition());
+            }
 
             glDrawElementsBaseVertex(
                 GL_TRIANGLES,
@@ -133,18 +153,26 @@ class Renderer
 
         for (const auto& item : renderables)
         {
-            RenderItem(item);
+            RenderItem(item, false);
         }
 
+        shader = &mPickSpriteShader;
+        shader->UseProgramGL();
+
+        shader->SetUniform(shader->GetUniformLocation("texture0"), 0);
+
+        mvpMatrixId = shader->GetUniformLocation("MVP");
+        entityIdId = shader->GetUniformLocation("entityId");
+
         for (const auto& item : sprites)
         {
-            RenderItem(item);
+            RenderItem(item, true);
         }
 
         for (const auto& item : dynamicRenderables)
         {
             item.GetRenderData()->Bind(GL_TEXTURE0);
-            RenderItem(item);
+            RenderItem(item, true);
         }
 
         mPickFB.UnbindGL();
@@ -157,7 +185,8 @@ class Renderer
         const Renderables& renderables,
         const Light& light,
         const Camera& lightCamera,
-        const Camera& camera)
+        const Camera& camera,
+        bool isSprite)
     {
         renderData.Bind(GL_TEXTURE0);
 
@@ -167,7 +196,7 @@ class Renderer
             ? mDepthBuffer1.GetId()
             : mDepthBuffer2.GetId());
 
-        auto& shader = mModelShader;
+        auto& shader = isSprite ? mSpriteShader : mModelShader;
         shader.UseProgramGL();
 
         shader.SetUniform(shader.GetUniformLocation("texture0"), 0);
@@ -301,7 +330,9 @@ class Renderer
 
 //private:
     ShaderProgramHandle mModelShader;
+    ShaderProgramHandle mSpriteShader;
     ShaderProgramHandle mPickShader;
+    ShaderProgramHandle mPickSpriteShader;
     ShaderProgramHandle mShadowMapShader;
     ShaderProgramHandle mNormalShader;
 

shaders/CMakeLists.txt

@@ -14,6 +14,8 @@ list(APPEND SHADERS
     instance
     gui
     pick
+    pick.sprite
+    sprite
     shadowMap
 )
 

shaders/pick.sprite.frag.glsl

@@ -0,0 +1,26 @@
+#version 330 core
+
+in vec3 uvCoords;
+in float texBlend;
+
+// Ouput data
+out vec4 color;
+
+uniform sampler2DArray texture0;
+uniform uint entityId;
+
+void main()
+{
+    vec4 textureSample = texture(texture0, uvCoords);
+    float textureAlpha = textureSample.a;
+
+    if (!(texBlend < 1) && textureAlpha == 0) discard;
+
+    // I want to output this RGBui8 but can't get it working
+    float entityIdR = (entityId & 0xffu);
+    float entityIdG = ((entityId >> 8) & 0xffu);
+    float entityIdB = ((entityId >> 16) & 0xffu);
+    float entityIdA = ((entityId >> 24) & 0xffu);
+    color = vec4(entityIdR, entityIdG, entityIdB, entityIdA);
+}
+

shaders/pick.sprite.vert.glsl

@@ -0,0 +1,32 @@
+#version 330 core
+
+layout(location = 0) in vec3  vertexPosition_modelspace;
+layout(location = 1) in vec3  vertexNormal_modelspace;
+layout(location = 2) in vec4  vertexColor_modelspace;
+layout(location = 3) in vec3  textureCoords;
+layout(location = 4) in float texBlendVec;
+
+out vec3 uvCoords;
+out float texBlend;
+
+uniform mat4 MVP;
+uniform mat4 M;
+uniform vec3 cameraPosition_worldspace;
+
+void main(){
+    vec3 vertexPosition_worldspace = (M * vec4(vertexPosition_modelspace, 1.0)).xyz;
+    vec3 direction_toCamera = normalize(cameraPosition_worldspace - vertexPosition_worldspace);
+    mat4 billboardRotationMatrix;
+
+    billboardRotationMatrix[0] = vec4(direction_toCamera.x, 0.0, direction_toCamera.z, 0.0);
+    billboardRotationMatrix[1] = vec4(0.0, 1.0, 0.0, 0.0);
+    billboardRotationMatrix[2] = vec4(-direction_toCamera.z, 0.0, direction_toCamera.x, 0.0);
+    billboardRotationMatrix[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+    vec4 billboardPosition = billboardRotationMatrix * vec4(vertexPosition_modelspace, 1.0);
+
+    gl_Position = MVP * billboardPosition;
+
+    uvCoords = textureCoords.xyz;
+    texBlend = texBlendVec;
+}

shaders/sprite.frag.glsl

@@ -0,0 +1,101 @@
+#version 330 core
+
+struct Light
+{
+    vec3 mDirection;
+    vec3 mAmbientColor;
+    vec3 mDiffuseColor;
+    vec3 mSpecularColor;
+};
+
+in vec3 Position_lightSpace;
+in vec3 Normal_cameraspace;
+in vec3 EyeDirection_cameraspace;
+in vec3 lightDirection_cameraspace;
+
+in vec4 vertexColor;
+in vec3 uvCoords;
+in float texBlend;
+in float DistanceFromCamera;
+
+// Ouput data
+out vec4 color;
+
+uniform vec3 fogColor;
+uniform Light light;
+uniform sampler2DArray texture0;
+uniform sampler2D shadowMap;
+uniform mat4 lightSpaceMatrix;
+
+float ShadowCalculation(vec4 fragPosLightSpace)
+{
+    // perform perspective divide
+    vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
+    // transform to [0,1] range
+    projCoords = projCoords * 0.5 + 0.5;
+    // get closest depth value from light's perspective (using [0,1] range fragPosLight as coords)
+    float closestDepth = texture(shadowMap, projCoords.xy).r; 
+    // get depth of current fragment from light's perspective
+    float currentDepth = projCoords.z;
+    // check whether current frag pos is in shadow
+    float shadow = (currentDepth - .001) > closestDepth  ? 1.0 : 0.0;
+
+    return shadow;
+}
+
+void main()
+{
+    float k = .0005;
+    float fogFactor = exp(-DistanceFromCamera * k);
+    
+    vec3 materialDiffuseColor = vertexColor.xyz;
+    float materialAlpha = vertexColor.a;
+
+    vec4 textureSample = texture(texture0, uvCoords);
+    vec3 textureColor  = textureSample.xyz;
+    float textureAlpha = textureSample.a;
+
+    // Choose either vertex color or texture color with the texBlend
+    vec3 diffuseColor = mix(materialDiffuseColor, textureColor, texBlend);
+    float alpha       = mix(materialAlpha, textureAlpha, texBlend);
+
+    if (alpha == 0) discard;
+
+    vec3 materialAmbientColor = diffuseColor;
+    vec3 materialSpecularColor = materialDiffuseColor;
+
+    // Normal of the computed fragment, in camera space
+    vec3 n = Normal_cameraspace;
+    // Direction of the light (from the fragment to the light)
+    vec3 l = lightDirection_cameraspace;
+
+    // Cosine of the angle between the normal and the light direction, 
+    // clamped above 0
+    //  - light is at the vertical of the triangle -> 1
+    //  - light is perpendicular to the triangle -> 0
+    //  - light is behind the triangle -> 0
+    float cosTheta = clamp(dot(n, l), 0, 1);
+    
+    // Eye vector (towards the camera)
+    vec3 E = EyeDirection_cameraspace;
+    // Direction in which the triangle reflects the light
+    vec3 R = reflect(-l, n);
+    // Cosine of the angle between the Eye vector and the Reflect vector,
+    // clamped to 0
+    //  - Looking into the reflection -> 1
+    //  - Looking elsewhere -> < 1
+    float cosAlpha = clamp(dot(E, R), 0, 1);
+
+    float shadow = ShadowCalculation(vec4(Position_lightSpace, 1));
+
+    vec3 litColor
+        = materialAmbientColor * light.mAmbientColor
+        + (1 - shadow) 
+            * (cosTheta * diffuseColor * light.mDiffuseColor
+            + pow(cosAlpha, 4) * materialSpecularColor * light.mSpecularColor);
+    
+    vec3 foggedColor = mix(fogColor, litColor, fogFactor);
+
+    color = vec4(foggedColor, alpha);
+}
+