[Feature]: Add Circle and Sphere to ShapeRenderer

assets/shaders/circle_renderer.frag

@@ -0,0 +1,33 @@
+#if __VERSION__ >= 330
+in vec3 localPos;
+out vec4 FragColor;
+#else
+varying vec3 localPos;
+#endif
+
+uniform vec4 color;
+
+float circleAlpha(vec3 lPos)
+{
+    const float RADIUS = 1.0;
+    const float MULTIPLIER = 2.1; // Quad is -0.5 to 0.5, scale to radius 1.0
+
+    vec3 samplePos = lPos * MULTIPLIER;
+
+    float dist = length(samplePos);
+    float edgeWidth = fwidth(dist);
+    float alpha = 1.0 - smoothstep(RADIUS - edgeWidth, RADIUS + edgeWidth, dist);
+
+    return alpha;
+}
+
+void main()
+{
+    float alpha = circleAlpha(localPos);
+
+#if __VERSION__ >= 330
+    FragColor = vec4(color.rgb, color.a * alpha);
+#else
+    gl_FragColor = vec4(color.rgb, color.a * alpha);
+#endif
+}

assets/shaders/circle_renderer.vert

@@ -0,0 +1,27 @@
+#if __VERSION__ >= 330
+layout (location = 0) in vec3 aPos;
+out vec3 localPos;
+#else
+attribute vec3 aPos;
+varying vec3 localPos;
+#endif
+
+uniform mat4 model;
+#if GAMECOE_HAS_UBO
+layout(std140) uniform CameraMatrices
+{
+    mat4 projection;
+    mat4 view;
+    vec3 cameraPosition;
+};
+#else
+uniform mat4 view;
+uniform mat4 projection;
+uniform vec3 cameraPosition;
+#endif
+
+void main()
+{
+    localPos = aPos;
+    gl_Position = projection * view * model * vec4(aPos, 1.0);
+}

assets/shaders/shape_renderer.frag

@@ -1,9 +1,9 @@
-uniform vec4 color;
-
 #if __VERSION__ >= 330
 out vec4 FragColor;
 #endif
 
+uniform vec4 color;
+
 void main()
 {
 #if __VERSION__ >= 330

assets/shaders/shape_renderer.vert

@@ -3,18 +3,19 @@ layout (location = 0) in vec3 aPos;
 #else
 attribute vec3 aPos;
 #endif
-// texture, etc... in the future
 
 uniform mat4 model;
 #if GAMECOE_HAS_UBO
 layout(std140) uniform CameraMatrices
 {
     mat4 projection;
     mat4 view;
+    vec3 cameraPosition;
 };
 #else
 uniform mat4 view;
 uniform mat4 projection;
+uniform vec3 cameraPosition;
 #endif
 
 void main()

assets/shaders/sphere_renderer.frag

@@ -0,0 +1,73 @@
+#if __VERSION__ >= 330
+in vec3 worldPos;
+out vec4 FragColor;
+#else
+varying vec3 worldPos;
+#endif
+
+uniform mat4 model;
+uniform vec4 color;
+#if GAMECOE_HAS_UBO
+layout(std140) uniform CameraMatrices
+{
+    mat4 projection;
+    mat4 view;
+    vec3 cameraPosition;
+};
+#else
+uniform mat4 view;
+uniform mat4 projection;
+uniform vec3 cameraPosition;
+#endif
+uniform vec3 sphereCenter;
+uniform vec3 sphereScale;
+uniform mat3 sphereRotation;
+
+vec3 sphereIntersection(vec3 rayOrigin, vec3 wPos)
+{
+    const float RADIUS = 1.0;
+    const float BOX_RADIUS = 0.5;
+
+    mat3 sphereRotationT = transpose(sphereRotation);
+
+    vec3 effectiveScale = sphereScale * BOX_RADIUS;
+    vec3 rayDirection = vec3(sphereRotationT * normalize(wPos - rayOrigin)) / effectiveScale;
+    vec3 sphereCenterToRayOrigin = (sphereRotationT * vec3(rayOrigin - sphereCenter)) / effectiveScale;
+
+    float a = dot(rayDirection, rayDirection);
+    float b = 2.0 * dot(sphereCenterToRayOrigin, rayDirection);
+    float c = dot(sphereCenterToRayOrigin, sphereCenterToRayOrigin) - (RADIUS * RADIUS);
+
+    float discriminant = b * b - 4.0 * a * c;
+
+    if (discriminant < 0.0)
+    {
+        return vec3(0.0);
+    }
+
+    float t1 = (-b + sqrt(discriminant)) / (2.0 * a);
+    float t2 = (-b - sqrt(discriminant)) / (2.0 * a);
+    float t = t2 > 0.0 ? t2 : t1;
+    vec3 intersection = rayOrigin + (sphereRotation * (vec3(t * rayDirection) * effectiveScale));
+
+    return intersection;
+}
+
+void main()
+{
+    vec3 spherePoint = sphereIntersection(cameraPosition, worldPos);
+    if (spherePoint == vec3(0.0))
+    {
+        discard;
+    }
+
+    vec4 shadingPos = projection * view * model * vec4(spherePoint, 1.0);
+    shadingPos /= shadingPos.w;
+    gl_FragDepth = shadingPos.z; // need version gating?
+
+#if __VERSION__ >= 330
+    FragColor = color;
+#else
+    gl_FragColor = color;
+#endif
+}

assets/shaders/sphere_renderer.vert

@@ -0,0 +1,28 @@
+#if __VERSION__ >= 330
+layout (location = 0) in vec3 aPos;
+out vec3 worldPos;
+#else
+attribute vec3 aPos;
+varying vec3 worldPos;
+#endif
+
+uniform mat4 model;
+#if GAMECOE_HAS_UBO
+layout(std140) uniform CameraMatrices
+{
+    mat4 projection;
+    mat4 view;
+    vec3 cameraPosition;
+};
+#else
+uniform mat4 view;
+uniform mat4 projection;
+uniform vec3 cameraPosition;
+#endif
+
+void main()
+{
+    vec4 wPos = model * vec4(aPos, 1.0);
+    worldPos = vec3(wPos);
+    gl_Position = projection * view * wPos;
+}

include/gamecoe/entity/renderer/shape_renderer.hpp

@@ -16,21 +16,24 @@ namespace gamecoe
         Triangle,
         Rectangle,
         Box,
+        Circle,
+        Sphere,
         // TODO: Support more primitive shapes
     };
 
     class ShapeRenderer : public Renderer
     {
         static std::atomic<std::uint32_t> s_counter;
-        static std::optional<Shader> s_shader;
-#if GAMECOE_HAS_UBO
-        static std::uint32_t s_cameraUniformBlockIndex;
-#endif
+        static std::optional<Shader> s_shapeShader;
+        static std::optional<Shader> s_circleShader;
+        static std::optional<Shader> s_sphereShader;
 
         Shape m_shape;
         Color m_color;
         const VertexArray &m_vertexArray;
 
+        std::optional<gamecoe::Shader> &shapeToShader(gamecoe::Shape shape) const;
+
         ShapeRenderer(GameObject &owner, Shape shape, const Color &color, std::int8_t layer = 0);
 
     public:
@@ -55,6 +58,8 @@ namespace gamecoe
         static std::unique_ptr<ShapeRenderer> triangle(GameObject &owner, const Color &color, std::int8_t layer = 0);
         static std::unique_ptr<ShapeRenderer> rectangle(GameObject &owner, const Color &color, std::int8_t layer = 0);
         static std::unique_ptr<ShapeRenderer> box(GameObject &owner, const Color &color, std::int8_t layer = 0);
+        static std::unique_ptr<ShapeRenderer> circle(GameObject &owner, const Color &color, std::int8_t layer = 0);
+        static std::unique_ptr<ShapeRenderer> sphere(GameObject &owner, const Color &color, std::int8_t layer = 0);
     };
 
 } // namespace gamecoe

src/gamecoe/core/game.cpp

@@ -59,6 +59,11 @@ namespace gamecoe
 #if GAMECOE_USE_OPENGL
         if(!gladLoadGL(glfwGetProcAddress))
             detail::throwError("Game::Game(): Failed to initialize glad");
+
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_MULTISAMPLE);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 #endif
 
         m_internalScene.emplace(*this, "gamecoe::Internal");

src/gamecoe/core/window.cpp

@@ -38,6 +38,7 @@ namespace gamecoe
         glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
 #endif
 #endif
+        glfwWindowHint(GLFW_SAMPLES, 4); // which opengl version? work only on opengl?
 
         GLFWwindow *current = glfwGetCurrentContext();
         GLFWwindow *window = glfwCreateWindow(m_width, m_height, m_title.c_str(), nullptr, current);

src/gamecoe/entity/camera.cpp

@@ -37,9 +37,11 @@ namespace gamecoe
         {
             glm::mat4 m_projection;
             glm::mat4 m_view;
+            glm::vec3 m_cameraPosition;
         } data;
         data.m_projection = projectionMatrix();
         data.m_view = viewMatrix();
+        data.m_cameraPosition = m_owner.transform().position();
 
         m_uniformBuffer->uploadData(&data, sizeof(data));
 #endif