Feat: Added texture wrap support

Author: ArtifactForms

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

@@ -2,6 +2,7 @@
 
 import engine.resources.FilterMode;
 import engine.resources.Texture;
+import engine.resources.TextureWrapMode;
 import processing.core.PImage;
 
 public class ProcessingTexture implements Texture {
@@ -10,9 +11,12 @@ public class ProcessingTexture implements Texture {
 
   private FilterMode filterMode;
 
+  private TextureWrapMode textureWrapMode;
+
   public ProcessingTexture(PImage image) {
     this.image = image;
     this.filterMode = FilterMode.BILINEAR;
+    this.textureWrapMode = TextureWrapMode.CLAMP;
   }
 
   @Override
@@ -61,6 +65,16 @@ public void setFilterMode(FilterMode filterMode) {
     this.filterMode = filterMode;
   }
 
+  @Override
+  public TextureWrapMode getTextureWrapMode() {
+    return textureWrapMode;
+  }
+
+  @Override
+  public void setTextureWrapMode(TextureWrapMode textureWrapMode) {
+    this.textureWrapMode = textureWrapMode;
+  }
+
   @Override
   public Texture getBackendTexture() {
     return this;

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

@@ -55,6 +55,29 @@ public interface Texture {
    */
   void setFilterMode(FilterMode filterMode);
 
+  /**
+   * Gets the current texture wrapping mode.
+   *
+   * <p>The texture wrap mode determines how the texture is applied when texture coordinates exceed
+   * the [0, 1] range. For example, in {@link TextureWrapMode#REPEAT}, the texture will repeat,
+   * whereas in {@link TextureWrapMode#CLAMP}, the texture will extend the edge pixels.
+   *
+   * @return the {@link TextureWrapMode} currently applied to the texture.
+   */
+  TextureWrapMode getTextureWrapMode();
+
+  /**
+   * Sets the texture wrapping mode.
+   *
+   * <p>This method controls how the texture is mapped outside the standard [0, 1] texture
+   * coordinate range. Use {@link TextureWrapMode#REPEAT} to tile the texture across a surface, or
+   * {@link TextureWrapMode#CLAMP} to stretch the texture's edge pixels when coordinates exceed the
+   * valid range.
+   *
+   * @param textureWrapMode the new {@link TextureWrapMode} to apply to the texture.
+   */
+  void setTextureWrapMode(TextureWrapMode textureWrapMode);
+
   /**
    * Gets the underlying backend texture implementation. This is useful for accessing
    * engine-specific or platform-specific features.

src/main/java/engine/resources/Texture2D.java

@@ -55,20 +55,33 @@ public int getHeight() {
   /**
    * Binds the texture to the specified texture unit for rendering.
    *
+   * <p>Binding a texture makes it available for use in subsequent rendering operations. The texture
+   * unit represents a specific slot in the graphics pipeline to which the texture is assigned.
+   *
    * @param unit the texture unit to bind this texture to.
+   * @see #unbind()
    */
   @Override
   public void bind(int unit) {
     texture.bind(unit);
   }
 
-  /** Unbinds the texture from its currently bound texture unit. */
+  /**
+   * Unbinds the texture from its currently bound texture unit.
+   *
+   * <p>Once a texture is unbound, it is no longer available for rendering until it is bound again.
+   */
   @Override
   public void unbind() {
     texture.unbind();
   }
 
-  /** Deletes the texture and releases any associated resources. */
+  /**
+   * Deletes the texture and releases any associated resources.
+   *
+   * <p>This method should be called when the texture is no longer needed to free up GPU memory.
+   * After a texture is deleted, it cannot be used for rendering unless it is recreated.
+   */
   @Override
   public void delete() {
     texture.delete();
@@ -77,7 +90,11 @@ public void delete() {
   /**
    * Updates the pixel data of the texture.
    *
+   * <p>This method replaces the existing texture data with new pixel values. The pixel data must
+   * match the dimensions of the texture.
+   *
    * @param pixels an array of pixel data to set for this texture.
+   * @throws IllegalArgumentException if the pixel array size does not match the texture dimensions.
    */
   @Override
   public void setPixels(int[] pixels) {
@@ -87,6 +104,9 @@ public void setPixels(int[] pixels) {
   /**
    * Gets the filter mode currently applied to the texture.
    *
+   * <p>The filter mode determines how the texture is sampled when it is magnified or minified
+   * during rendering. Common filter modes include nearest-neighbor and linear filtering.
+   *
    * @return the filter mode of the texture.
    * @see FilterMode
    */
@@ -98,6 +118,10 @@ public FilterMode getFilterMode() {
   /**
    * Sets the filter mode for the texture.
    *
+   * <p>The filter mode controls how the texture is sampled when rendered at different sizes. For
+   * example, linear filtering smooths the texture when scaled, while nearest-neighbor filtering
+   * preserves sharp edges.
+   *
    * @param filterMode the desired filter mode to apply to the texture.
    * @see FilterMode
    */
@@ -106,9 +130,42 @@ public void setFilterMode(FilterMode filterMode) {
     texture.setFilterMode(filterMode);
   }
 
+  /**
+   * Gets the texture wrapping mode currently applied to this texture.
+   *
+   * <p>The texture wrap mode controls how the texture is applied when texture coordinates exceed
+   * the [0, 1] range. For example, in {@link TextureWrapMode#REPEAT}, the texture will tile
+   * infinitely, whereas in {@link TextureWrapMode#CLAMP}, the texture's edge pixels are stretched.
+   *
+   * @return the {@link TextureWrapMode} applied to the texture.
+   */
+  @Override
+  public TextureWrapMode getTextureWrapMode() {
+    return texture.getTextureWrapMode();
+  }
+
+  /**
+   * Sets the texture wrapping mode for this texture.
+   *
+   * <p>This method controls how the texture is mapped outside the standard [0, 1] texture
+   * coordinate range. Use {@link TextureWrapMode#REPEAT} to tile the texture across a surface, or
+   * {@link TextureWrapMode#CLAMP} to stretch the texture's edge pixels when coordinates exceed the
+   * valid range.
+   *
+   * @param textureWrapMode the new {@link TextureWrapMode} to apply to the texture.
+   */
+  @Override
+  public void setTextureWrapMode(TextureWrapMode textureWrapMode) {
+    this.texture.setTextureWrapMode(textureWrapMode);
+  }
+
   /**
    * Retrieves the backend texture instance used by this facade.
    *
+   * <p>This method provides access to the underlying texture object managed by the {@link
+   * TextureManager}. It is useful for accessing low-level or engine-specific features not exposed
+   * by the {@link Texture2D} class.
+   *
    * @return the underlying {@link Texture} instance.
    */
   @Override

src/main/java/workspace/GraphicsPImpl.java

@@ -9,6 +9,7 @@
 import engine.resources.FilterMode;
 import engine.resources.Image;
 import engine.resources.Texture;
+import engine.resources.TextureWrapMode;
 import engine.scene.camera.Camera;
 import engine.scene.light.Light;
 import engine.scene.light.LightRenderer;
@@ -158,10 +159,36 @@ private void applyTexture() {
       return; // Ensure texture is properly initialized before applying it.
     }
     ((PGraphicsOpenGL) g).textureSampling(getSamplingMode(texture.getFilterMode()));
+    g.textureWrap(getTextureWrapMode());
     g.textureMode(PApplet.NORMAL);
     g.texture(texture.getImage());
   }
 
+  /**
+   * Converts the internal {@link TextureWrapMode} to a corresponding Processing constant.
+   *
+   * <p>This method maps the engine's {@link TextureWrapMode} values to the equivalent constants
+   * defined by the {@link PApplet} class for use in Processing-based rendering. The supported
+   * mappings are:
+   *
+   * <ul>
+   *   <li>{@link TextureWrapMode#CLAMP} -> {@link PApplet#CLAMP}
+   *   <li>{@link TextureWrapMode#REPEAT} -> {@link PApplet#REPEAT}
+   * </ul>
+   *
+   * <p>If an unsupported or unexpected wrap mode is encountered, a warning is printed to {@code
+   * System.err}, and {@link PApplet#CLAMP} is returned as a fallback.
+   *
+   * @return the corresponding Processing constant for the texture wrap mode.
+   */
+  private int getTextureWrapMode() {
+    TextureWrapMode textureWrapMode = texture.getTextureWrapMode();
+    if (textureWrapMode == TextureWrapMode.CLAMP) return PApplet.CLAMP;
+    if (textureWrapMode == TextureWrapMode.REPEAT) return PApplet.REPEAT;
+    System.err.println("Warning: Unexpected texture wrap mode value: " + textureWrapMode);
+    return PApplet.CLAMP;
+  }
+
   /**
    * Maps the given filter mode to the corresponding texture sampling mode.
    *