Merge pull request #56 from ArtifactForms/working2

Working2

Author: ArtifactForms

src/main/java/engine/components/FlyByCameraControl.java

@@ -78,13 +78,12 @@ public void update(float tpf) {
     float mouseY = input.getMouseDeltaY() * mouseSensitivity * tpf;
 
     handleRotation(mouseX, mouseY);
-    updateTarget();
 
     Vector3f velocity = calculateVelocity();
     if (velocity.length() > 0) {
       applyMovement(velocity, tpf);
     }
-
+    updateTarget();
     input.center();
   }
 
@@ -147,7 +146,6 @@ private void applyMovement(Vector3f velocity, float tpf) {
     Vector3f position = camera.getTransform().getPosition();
     position.addLocal(velocity.mult(moveSpeed * tpf));
     camera.getTransform().setPosition(position);
-    updateTarget();
   }
 
   /**
@@ -180,4 +178,46 @@ public void onAttach() {
   public void onDetach() {
     // Not used yet
   }
+
+  /**
+   * Returns the current movement speed of the camera.
+   *
+   * @return The movement speed in units per second.
+   */
+  public float getMoveSpeed() {
+    return moveSpeed;
+  }
+
+  /**
+   * Sets the movement speed of the camera.
+   *
+   * @param moveSpeed The new movement speed in units per second.
+   */
+  public void setMoveSpeed(float moveSpeed) {
+    this.moveSpeed = moveSpeed;
+  }
+
+  /**
+   * Returns the current mouse sensitivity used for camera rotation.
+   *
+   * <p>The mouse sensitivity determines how much the camera rotates based on mouse movement. Higher
+   * sensitivity values result in larger rotations for smaller mouse movements.
+   *
+   * @return The current mouse sensitivity.
+   */
+  public float getMouseSensitivity() {
+    return mouseSensitivity;
+  }
+
+  /**
+   * Sets the mouse sensitivity used for camera rotation.
+   *
+   * <p>The mouse sensitivity determines how much the camera rotates based on mouse movement. Higher
+   * sensitivity values result in larger rotations for smaller mouse movements.
+   *
+   * @param mouseSensitivity The new mouse sensitivity value.
+   */
+  public void setMouseSensitivity(float mouseSensitivity) {
+    this.mouseSensitivity = mouseSensitivity;
+  }
 }

src/main/java/engine/processing/ProcessingApplication.java

@@ -6,6 +6,7 @@
 import engine.input.KeyInput;
 import engine.input.MouseInput;
 import engine.resources.ResourceManager;
+import engine.resources.TextureManager;
 import processing.core.PApplet;
 import workspace.GraphicsPImpl;
 import workspace.ui.Graphics;
@@ -31,6 +32,7 @@ public void settings() {
   public void setup() {
     Graphics g = new GraphicsPImpl(this);
     ResourceManager.getInstance().setImageLoader(new ProcessingImageLoader(this));
+    TextureManager.getInstance().setTextureLoader(new ProcessingTextureLoader(this));
     container.setGraphics(g);
     getSurface().setTitle(settings.getTitle());
     setupInput();

src/main/java/engine/processing/ProcessingTexture.java

@@ -0,0 +1,43 @@
+package engine.processing;
+
+import engine.resources.Texture;
+import processing.core.PImage;
+
+public class ProcessingTexture implements Texture {
+
+  private final PImage image;
+
+  public ProcessingTexture(PImage image) {
+    this.image = image;
+  }
+
+  @Override
+  public int getWidth() {
+    return image.width;
+  }
+
+  @Override
+  public int getHeight() {
+    return image.height;
+  }
+
+  @Override
+  public void bind(int unit) {
+    // Processing doesn't use texture units in the same way, just bind globally
+    image.loadPixels();
+  }
+
+  @Override
+  public void unbind() {
+    // No specific unbind operation for Processing
+  }
+
+  @Override
+  public void delete() {
+    // Processing handles memory management automatically
+  }
+
+  public PImage getImage() {
+    return image;
+  }
+}

src/main/java/engine/processing/ProcessingTextureLoader.java

@@ -0,0 +1,27 @@
+package engine.processing;
+
+import engine.resources.Texture;
+import engine.resources.TextureLoader;
+import processing.core.PApplet;
+import processing.core.PImage;
+
+public class ProcessingTextureLoader implements TextureLoader {
+
+  private final PApplet parent;
+
+  public ProcessingTextureLoader(PApplet parent) {
+    this.parent = parent;
+  }
+
+  @Override
+  public Texture loadTexture(String filePath) {
+    PImage image =
+        parent.loadImage(
+            ProcessingTextureLoader.class
+                .getClassLoader()
+                .getResource("images/" + filePath)
+                .getPath());
+    ProcessingTexture texture = new ProcessingTexture(image);
+    return texture;
+  }
+}

src/main/java/engine/render/Material.java

@@ -1,5 +1,6 @@
 package engine.render;
 
+import engine.resources.Texture;
 import math.Color;
 import workspace.ui.Graphics;
 
@@ -67,6 +68,10 @@ public class Material {
   /** Shininess factor for specular highlights. */
   private final float shininess;
 
+  private Texture normalTexture;
+  
+  private Texture diffuseTexture;
+
   /**
    * Constructor to set the base color of the material.
    *
@@ -83,11 +88,13 @@ private Material(Builder builder) {
     this.diffuse = builder.diffuse;
     this.specular = builder.specular;
     this.shininess = builder.shininess;
+    this.normalTexture = builder.normalTexture;
+    this.diffuseTexture = builder.diffuseTexture;
   }
 
   /**
-   * Builder class to facilitate the creation of custom materials with specific lighting and shader
-   * properties.
+   * Builder class to facilitate the creation of custom materials with specific lighting, shader and
+   * texture properties.
    */
   public static class Builder {
 
@@ -103,6 +110,10 @@ public static class Builder {
 
     private float shininess = 10.0f;
 
+    private Texture diffuseTexture = null;
+
+    private Texture normalTexture = null;
+
     /**
      * Sets the base color of the material.
      *
@@ -163,6 +174,28 @@ public Builder setUseLighting(boolean useLighting) {
       return this;
     }
 
+    /**
+     * Sets the normal texture of the material.
+     *
+     * @param normalTexture The normal texture, can be null
+     * @return The builder instance for chaining
+     */
+    public Builder setNormalTexture(Texture normalTexture) {
+      this.normalTexture = normalTexture;
+      return this;
+    }
+
+    /**
+     * Sets the diffuse texture of the material.
+     *
+     * @param diffuseTexture The diffuse texture, can be null.
+     * @return The builder instance for chaining
+     */
+    public Builder setDiffuseTexture(Texture diffuseTexture) {
+      this.diffuseTexture = diffuseTexture;
+      return this;
+    }
+
     /**
      * Builds and returns the Material instance with the set properties.
      *
@@ -180,6 +213,13 @@ public Material build() {
    */
   public void apply(Graphics g) {
     g.setMaterial(this);
+
+    if (diffuseTexture != null) {
+      g.bindTexture(diffuseTexture, 0); // Bind to texture unit 0
+    }
+    if (normalTexture != null) {
+      g.bindTexture(normalTexture, 1); // Bind to texture unit 1
+    }
   }
 
   /**
@@ -240,4 +280,12 @@ public float[] getSpecular() {
   public float getShininess() {
     return shininess;
   }
+
+  public Texture getDiffuseTexture() {
+    return diffuseTexture;
+  }
+
+  public Texture getNormalTexture() {
+    return normalTexture;
+  }
 }

src/main/java/engine/resources/Texture.java

@@ -0,0 +1,14 @@
+package engine.resources;
+
+public interface Texture {
+
+  int getWidth();
+
+  int getHeight();
+
+  void bind(int unit); // Bind to a specific texture unit
+
+  void unbind();
+
+  void delete();
+}

src/main/java/engine/resources/TextureLoader.java

@@ -0,0 +1,6 @@
+package engine.resources;
+
+public interface TextureLoader {
+
+  Texture loadTexture(String filePath);
+}

src/main/java/engine/resources/TextureManager.java

@@ -0,0 +1,45 @@
+package engine.resources;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class TextureManager {
+
+  private static TextureManager instance;
+
+  private TextureLoader imageLoader;
+
+  private final Map<String, Texture> resourceCache = new HashMap<>();
+
+  private TextureManager() {}
+
+  public static TextureManager getInstance() {
+    if (instance == null) {
+      instance = new TextureManager();
+    }
+    return instance;
+  }
+
+  public void setTextureLoader(TextureLoader loader) {
+    this.imageLoader = loader;
+  }
+
+  public Texture loadTexture(String path) {
+    if (resourceCache.containsKey(path)) {
+      return resourceCache.get(path); // Return cached resource
+    }
+
+    if (imageLoader == null) {
+      throw new IllegalStateException("ImageLoader is not set!");
+    }
+
+    Texture texture = imageLoader.loadTexture(path);
+    resourceCache.put(path, texture);
+
+    return texture;
+  }
+
+  public void unloadImage(String path) {
+    resourceCache.remove(path); // Optionally handle cleanup for backend-specific resources
+  }
+}

src/main/java/math/Mathf.java

@@ -94,9 +94,15 @@ public class Mathf {
    *     `numberOfColumns` is less than or equal to zero.
    */
   public static int toOneDimensionalIndex(int rowIndex, int colIndex, int numberOfColumns) {
-    if (rowIndex < 0 || colIndex < 0) throw new IllegalArgumentException();
-
-    if (numberOfColumns <= 0) throw new IllegalArgumentException();
+    if (numberOfColumns <= 0) {
+      throw new IllegalArgumentException("NumberOfColumns must be greater than zero.");
+    }
+    if (rowIndex < 0) {
+      throw new IllegalArgumentException("rowIndex must be non-negative");
+    }
+    if (colIndex < 0 || colIndex >= numberOfColumns) {
+      throw new IllegalArgumentException("colIndex is out of bounds");
+    }
 
     return rowIndex * numberOfColumns + colIndex;
   }
@@ -890,4 +896,17 @@ public static float normalizeAngle(float angle) {
 
     return angle;
   }
+
+  /**
+   * Compares two floating-point numbers for equality within a given tolerance (epsilon).
+   *
+   * @param a The first number.
+   * @param b The second number.
+   * @param epsilon The tolerance within which the two numbers are considered equal.
+   * @return True if the absolute difference between the two numbers is less than or equal to
+   *     epsilon, otherwise false.
+   */
+  public static boolean equals(float a, float b, float epsilon) {
+    return Math.abs(a - b) <= epsilon;
+  }
 }