feat: final edits and design patterns

Author: ProgrammingMuffin

miniengine.png

@@ -0,0 +1,53 @@
+### Mini Engine (exploratory)
+
+Mini Engine is a very tiny and lightweight OpenGL based rendering engine which can be used very flexibly and with ease.
+Mini Engine can be used for quickly writing prototypes of games where you can use your own physics and entity component system etc. It can even be used for 
+writing any OpenGL accelerated graphical programs like a picture drawing program or a terminal emulator.
+
+### How do you write prototypes?
+
+Writing prototypes is as simple as this:
+
+```java
+import engine.Init;
+import engine.models.*;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.ArrayList;
+
+public class Application {
+
+    public static void main(String[] args) {
+        System.out.println("Running game");
+        Init.init();
+        ArrayList<IRenderData> coloredRectangles = new ArrayList<>();
+        coloredRectangles.add(GradientQuad.builder().x(-400).y(-400)
+                .width(400).height(400).rgb(new RGBWrapper(120, 150, 120)).build());
+        coloredRectangles.add(ColoredQuad.builder().x(100).y(0)
+                .width(250).height(150).rgb(new RGBWrapper(0, 255, 180)).build());
+        coloredRectangles.add(TextureQuad.builder().x(-100).y(100)
+                .width(300).height(300).image("doge.jpg").build());
+        while (true) {
+            coloredRectangles.forEach(rectangle -> {
+                rectangle.getRenderType().getRenderingStrategy().execute(rectangle);
+            });
+            GLFW.glfwSwapBuffers(Init.window);
+            GLFW.glfwPollEvents();
+        }
+    }
+}
+```
+
+### What does the above program look like?
+
+The above program gives the following output
+
+![MiniEngine simple program](miniengine.png)
+
+
+### Installation and Running
+
+- Install Maven (Maven 3 is recommended)
+- Install Java JRE and JDK (At least Java 11)
+- ```mvn package```
+- java -jar target/<jar>

readme.md

@@ -1,34 +1,25 @@
 import engine.Init;
-import engine.strategy.RectColorRenderingStrategy;
-import engine.strategy.RectTextureRenderingStrategy;
+import engine.models.*;
 import org.lwjgl.glfw.GLFW;
-import org.lwjgl.opengl.GL30;
 
-import java.net.URISyntaxException;
 import java.util.ArrayList;
 
 public class Application {
 
     public static void main(String[] args) {
         System.out.println("Running game");
         Init.init();
-        ArrayList<RectTextureRenderingStrategy> doges = new ArrayList<>();
-        RectColorRenderingStrategy rect1 = new RectColorRenderingStrategy(0, 0, 50, 50);
-        RectTextureRenderingStrategy rect2 = new RectTextureRenderingStrategy(-100, 100, 300, 300, "doge.jpg");
-        for(int i = 0; i < 100; i++) {
-            doges.add(new RectTextureRenderingStrategy(-100 + i, 100 + i, 300, 300, "doge.jpg"));
-        }
+        ArrayList<IRenderData> coloredRectangles = new ArrayList<>();
+        coloredRectangles.add(GradientQuad.builder().x(-400).y(-400)
+                .width(400).height(400).rgb(new RGBWrapper(120, 150, 120)).build());
+        coloredRectangles.add(ColoredQuad.builder().x(100).y(0)
+                .width(250).height(150).rgb(new RGBWrapper(0, 255, 180)).build());
+        coloredRectangles.add(TextureQuad.builder().x(-100).y(100)
+                .width(300).height(300).image("doge.jpg").build());
         while (true) {
-            try {
-                GL30.glClear(GL30.GL_COLOR_BUFFER_BIT | GL30.GL_DEPTH_BUFFER_BIT);
-                rect1.execute();
-                rect2.execute();
-                for (RectTextureRenderingStrategy doge : doges) {
-                    doge.execute();
-                }
-            } catch (URISyntaxException e) {
-                throw new RuntimeException(e);
-            }
+            coloredRectangles.forEach(rectangle -> {
+                rectangle.getRenderType().getRenderingStrategy().execute(rectangle);
+            });
             GLFW.glfwSwapBuffers(Init.window);
             GLFW.glfwPollEvents();
         }

src/main/java/Application.java

@@ -0,0 +1,22 @@
+package engine.models;
+
+import lombok.Builder;
+
+@Builder
+public class ColoredQuad implements IRenderData {
+
+    public int x;
+
+    public int y;
+
+    public int width;
+
+    public int height;
+
+    public RGBWrapper rgb;
+
+    @Override
+    public RenderTypeEnum getRenderType() {
+        return RenderTypeEnum.COLORED_QUAD;
+    }
+}

src/main/java/engine/models/ColoredQuad.java

@@ -0,0 +1,22 @@
+package engine.models;
+
+import lombok.Builder;
+
+@Builder
+public class GradientQuad implements IRenderData {
+
+    public int x;
+
+    public int y;
+
+    public int width;
+
+    public int height;
+
+    public RGBWrapper rgb;
+
+    @Override
+    public RenderTypeEnum getRenderType() {
+        return RenderTypeEnum.GRADIENT_QUAD;
+    }
+}

src/main/java/engine/models/GradientQuad.java

@@ -0,0 +1,7 @@
+package engine.models;
+
+// Marker interface
+public interface IRenderData {
+
+    RenderTypeEnum getRenderType();
+}

src/main/java/engine/models/IRenderData.java

@@ -10,4 +10,6 @@ public class Polygon {
     private float[] textureCoordinates;
 
     private String textureFileName;
+
+    private RGBWrapper rgb;
 }

src/main/java/engine/models/Polygon.java

@@ -2,20 +2,20 @@
 
 import engine.strategy.IRenderingStrategy;
 import engine.strategy.RectColorRenderingStrategy;
+import engine.strategy.RectGradientRenderingStrategy;
 import engine.strategy.RectTextureRenderingStrategy;
+import lombok.Getter;
 
 public enum RenderTypeEnum {
 
-    COLORED_QUAD {
-        public IRenderingStrategy getStrategy(StrategyParams params) {
-            return new RectColorRenderingStrategy(params);
-        }
-    },
-    TEXTURED_QUAD {
-        public IRenderingStrategy getStrategy(StrategyParams params) {
-            return new RectTextureRenderingStrategy(params);
-        }
-    };
+    COLORED_QUAD (new RectColorRenderingStrategy()),
+    TEXTURE_QUAD (new RectTextureRenderingStrategy()),
+    GRADIENT_QUAD (new RectGradientRenderingStrategy());
 
-    public abstract IRenderingStrategy getStrategy(StrategyParams params);
+    RenderTypeEnum(IRenderingStrategy renderingStrategy) {
+        this.renderingStrategy = renderingStrategy;
+    }
+
+    @Getter
+    private IRenderingStrategy renderingStrategy;
 }

src/main/java/engine/models/RenderTypeEnum.java

@@ -0,0 +1,22 @@
+package engine.models;
+
+import lombok.Builder;
+
+@Builder
+public class TextureQuad implements IRenderData {
+
+    public int x;
+
+    public int y;
+
+    public int width;
+
+    public int height;
+
+    public String image;
+
+    @Override
+    public RenderTypeEnum getRenderType() {
+        return RenderTypeEnum.TEXTURE_QUAD;
+    }
+}

src/main/java/engine/models/StrategyParams.java

@@ -1,9 +1,7 @@
 package engine.services;
 
 import engine.Globals;
-import engine.models.BufferEnum;
-import engine.models.DrawTypeEnum;
-import engine.models.ShaderProgram;
+import engine.models.*;
 import engine.models.Polygon;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL30;
@@ -18,8 +16,12 @@
 import java.util.Arrays;
 import java.util.Objects;
 
+import static java.sql.Types.FLOAT;
+
 public class GlService {
 
+    private static final int dataCountPerColor = 3;
+
     public static void renderObject(BufferEnum bufferType, DrawTypeEnum drawType, Polygon polygon,
                                     int dataCountPerCoordinate, ShaderProgram shaderProgram) {
         int program = shaderProgram.getProgram();
@@ -50,6 +52,10 @@ public static void renderObject(BufferEnum bufferType, DrawTypeEnum drawType, Po
             GL30.glEnableVertexAttribArray(GL30.glGetAttribLocation(program, "textureCoord"));
             GL30.glBufferData(GL30.GL_ARRAY_BUFFER, polygon.getTextureCoordinates(), GL30.GL_STATIC_DRAW);
             GL30.glVertexAttribPointer(GL30.glGetAttribLocation(program, "textureCoord"), 2, GL30.GL_FLOAT, false, Float.BYTES * 2, 0);
+        } else if (polygon.getRgb() != null) {
+            int uniformLocation = GL30.glGetUniformLocation(program, "colors");
+            RGBWrapper rgb = polygon.getRgb();
+            GL30.glUniform3f(uniformLocation, (float) rgb.getR() / 255, (float) rgb.getG() / 255, (float) rgb.getB() / 255);
         }
         GL30.glDrawArrays(drawType.getGlEnum(), 0, polygon.getCoordinates().length / dataCountPerCoordinate);
     }

src/main/java/engine/models/TextureQuad.java

@@ -1,6 +1,8 @@
 package engine.strategy;
 
+import engine.models.IRenderData;
+
 public interface IRenderingStrategy {
 
-    void execute();
-}
+    void execute(IRenderData renderData);
+}

src/main/java/engine/models/TextureRenderingStrategyParam.java

@@ -4,6 +4,7 @@
 import engine.Renderer;
 import engine.models.*;
 import engine.services.GlService;
+import engine.utils.FileUtil;
 import engine.utils.ShaderUtil;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -14,27 +15,17 @@
 @NoArgsConstructor
 public class RectColorRenderingStrategy implements IRenderingStrategy {
 
-    private int x;
-
-    private int y;
-
-    private int width;
-
-    private int height;
-
-    private RGBWrapper rgb;
-
-    public RectColorRenderingStrategy(StrategyParams params) {
-        ColorRenderingStrategyParam param = params.colorStrategyParam;
-        this.x = param.x;
-        this.y = param.y;
-        this.width = param.width;
-        this.height = param.height;
-        this.rgb = param.rgb;
-    }
-
     @Override
-    public void execute() {
+    public void execute(IRenderData renderData) {
+        if (!RenderTypeEnum.COLORED_QUAD.equals(renderData.getRenderType())) {
+            return;
+        }
+        ColoredQuad coloredQuad = (ColoredQuad) renderData;
+        int x = coloredQuad.x;
+        int y = coloredQuad.y;
+        int width = coloredQuad.width;
+        int height = coloredQuad.height;
+        RGBWrapper rgb = coloredQuad.rgb;
         float[] coordinates = {
                 (float) x / Globals.screenWidth, (float) y / Globals.screenHeight,
                 (float) (x + width) / Globals.screenWidth, (float) y / Globals.screenHeight,
@@ -44,20 +35,17 @@ public void execute() {
         ShaderProgram shaderProgram;
         if (ShaderUtil.shaderMap.get("2d_simple_shader") == null) {
             shaderProgram = ShaderProgram.builder()
-                    .addVertexShader(getFile("simple_shaders/2d_simple_vertex_shader.glsl"))
-                    .addFragmentShader(getFile("simple_shaders/2d_simple_fragment_shader.glsl"))
+                    .addVertexShader(FileUtil.getFile("simple_shaders/2d_simple_vertex_shader.glsl"))
+                    .addFragmentShader(FileUtil.getFile("simple_shaders/2d_simple_fragment_shader.glsl"))
                     .build();
             ShaderUtil.shaderMap.put("2d_simple_shader", shaderProgram);
         } else {
             shaderProgram = ShaderUtil.shaderMap.get("2d_simple_shader");
         }
         Polygon polygon = new Polygon();
         polygon.setCoordinates(coordinates);
+        polygon.setRgb(rgb);
         GlService.renderObject(BufferEnum.SCENE_BUFFER, DrawTypeEnum.QUADS, polygon, 2, shaderProgram);
         GlService.resetRenderingContext();
     }
-
-    private InputStream getFile(String fileName) {
-        return Renderer.class.getClassLoader().getResourceAsStream(fileName);
-    }
 }