Missing old stuff

src/main/java/engine/demos/voxels/ChatComponent.java

@@ -0,0 +1,117 @@
+package engine.demos.voxels;
+
+import engine.components.AbstractComponent;
+import engine.components.RenderableComponent;
+import engine.demos.voxels.client.event.EventManager;
+import engine.demos.voxels.client.event.MessageSentEvent;
+import engine.input.Input;
+import engine.input.Key;
+import engine.input.KeyEvent;
+import engine.input.KeyListener;
+import engine.resources.Font;
+import engine.scene.camera.Camera;
+import math.Color;
+import workspace.ui.Graphics;
+
+public class ChatComponent extends AbstractComponent implements KeyListener, RenderableComponent {
+
+  private static final int MAX_MESSAGE_LENGTH = 0;
+  private StringBuffer textBuffer;
+  private boolean textInputEnabled;
+  private Input input;
+  private Camera camera;
+  private String message = "";
+  private int cursorPosition;
+  private EventManager eventManager;
+
+  public ChatComponent(Input input, Camera camera, EventManager eventManager) {
+    this.input = input;
+    this.camera = camera;
+    this.textBuffer = new StringBuffer();
+    this.cursorPosition = 0;
+    this.eventManager = eventManager;
+    input.addKeyListener(this);
+  }
+
+  @Override
+  public void onAttach() {}
+
+  @Override
+  public void onDetach() {}
+
+  @Override
+  public void onUpdate(float tpf) {
+    message = textBuffer.toString();
+  }
+
+  @Override
+  public void render(Graphics g) {
+    if (!textInputEnabled) return;
+
+    Font font = new Font("monogram-extended", 32, Font.PLAIN);
+    int y = g.getHeight() - 20;
+    int cursorWidth = 10;
+    int offsetX = 20;
+    g.setColor(Color.YELLOW);
+
+    g.setFont(font);
+    g.text(message, 20, g.getHeight() - offsetX);
+    g.setColor(Color.WHITE);
+
+    float pos = g.textWidth(message);
+    g.drawLine(pos + offsetX, y, pos + offsetX + cursorWidth, y);
+  }
+
+  @Override
+  public void onKeyPressed(KeyEvent e) {
+    if (!shouldProcess(e)) return;
+    processEvent(e);
+  }
+
+  private boolean shouldProcess(KeyEvent e) {
+    return e.getKey() == Key.BACKSPACE || e.getKey() == Key.ENTER || e.getKey() == Key.DELETE;
+  }
+
+  @Override
+  public void onKeyReleased(KeyEvent e) {}
+
+  private void processEvent(KeyEvent e) {
+    if (!textInputEnabled) return;
+
+    if (e.getKey() == Key.BACKSPACE) {
+      if (cursorPosition > 0) {
+        textBuffer.deleteCharAt(cursorPosition - 1);
+        cursorPosition--;
+      }
+    } else if (e.getKey() == Key.DELETE) {
+      if (cursorPosition < textBuffer.length()) {
+        textBuffer.deleteCharAt(cursorPosition);
+      }
+    } else if (e.getKey() == Key.ENTER) {
+      String messageToSend = textBuffer.toString();
+      sendMessage(messageToSend); // Trigger the event here
+      textInputEnabled = false;
+      textBuffer.delete(0, textBuffer.length());
+      cursorPosition = 0;
+    } else {
+      textBuffer.insert(cursorPosition, e.getChar());
+      cursorPosition++;
+    }
+  }
+
+  @Override
+  public void onKeyTyped(KeyEvent e) {
+    if (e.getKey() != Key.BACKSPACE && e.getKey() != Key.DELETE) {
+      processEvent(e);
+    }
+    if (e.getKey() == Key.T && !textInputEnabled) {
+      textInputEnabled = !textInputEnabled;
+    }
+  }
+
+  // Method to send the message and trigger the event
+  private void sendMessage(String message) {
+    MessageSentEvent messageSentEvent = new MessageSentEvent(message);
+    eventManager.triggerEvent(messageSentEvent);
+  }
+}

src/main/java/engine/demos/voxels/RayBlockDetector.java

@@ -0,0 +1,128 @@
+package engine.demos.voxels;
+
+import engine.components.AbstractComponent;
+import engine.components.RenderableComponent;
+import engine.scene.camera.Camera;
+import math.Color;
+import math.Mathf;
+import math.Ray3f;
+import math.Vector3f;
+import mesh.Mesh3D;
+import mesh.creator.primitives.CubeCreator;
+import workspace.ui.Graphics;
+
+public class RayBlockDetector extends AbstractComponent implements RenderableComponent {
+
+  private Camera camera;
+  private Ray3f ray;
+  private Vector3f hitBlock; // Coordinates of the block hit
+  private boolean blockHit; // If the ray hit a block
+
+  private World voxelWorld;
+  private final Mesh3D highlightCube = new CubeCreator(0.5f).create();
+  private TextDisplay display;
+
+  public RayBlockDetector(Camera camera, World voxelWorld, TextDisplay display) {
+    this.camera = camera;
+    this.voxelWorld = voxelWorld;
+    this.ray = new Ray3f(new Vector3f(), new Vector3f());
+    this.blockHit = false;
+    this.display = display;
+  }
+
+  @Override
+  public void render(Graphics g) {
+    g.disableDepthTest();
+
+    if (blockHit) {
+      g.pushMatrix();
+      g.setColor(Color.YELLOW);
+      g.translate(hitBlock.x, -hitBlock.y, hitBlock.z);
+      g.drawFaces(highlightCube);
+      g.popMatrix();
+
+      BlockType type = voxelWorld.getBlock((int) hitBlock.x, (int) hitBlock.y, (int) hitBlock.z);
+      display.setText("Hit: " + hitBlock + ", Type: " + type + ", Origin: " + ray.getOrigin());
+      g.setColor(Color.CYAN);
+      g.drawLine(
+          ray.getOrigin().x,
+          ray.getOrigin().y,
+          ray.getOrigin().z,
+          hitBlock.x + 0.5f,
+          hitBlock.y + 0.5f,
+          hitBlock.z + 0.5f);
+    } else {
+      display.setText("Hit: NONE");
+    }
+
+    g.enableDepthTest();
+  }
+
+  @Override
+  public void onUpdate(float tpf) {
+    Vector3f origin = camera.getTransform().getPosition();
+    Vector3f direction = camera.getTransform().getForward();
+    ray = new Ray3f(origin, direction);
+
+    detectBlock();
+  }
+
+  private void detectBlock() {
+    Vector3f rayOrigin = ray.getOrigin();
+    Vector3f rayDir = ray.getDirection();
+
+    int x = (int) Math.floor(rayOrigin.x);
+    int y = (int) Math.floor(rayOrigin.y);
+    int z = (int) Math.floor(rayOrigin.z);
+
+    float stepX = Math.signum(rayDir.x);
+    float stepY = Math.signum(rayDir.y);
+    float stepZ = Math.signum(rayDir.z);
+
+    float tMaxX = intBound(rayOrigin.x, rayDir.x);
+    float tMaxY = intBound(rayOrigin.y, rayDir.y);
+    float tMaxZ = intBound(rayOrigin.z, rayDir.z);
+
+    float tDeltaX = Math.abs(1 / rayDir.x);
+    float tDeltaY = Math.abs(1 / rayDir.y);
+    float tDeltaZ = Math.abs(1 / rayDir.z);
+
+    for (int i = 0; i < 500; i++) {
+      if (voxelWorld.isBlockAt(x, -y, z)) {
+        hitBlock = new Vector3f(x, -y, z);
+        blockHit = true;
+        return;
+      }
+
+      if (tMaxX < tMaxY && tMaxX < tMaxZ) {
+        tMaxX += tDeltaX;
+        x += stepX;
+      } else if (tMaxY < tMaxZ) {
+        tMaxY += tDeltaY;
+        y += stepY;
+      } else {
+        tMaxZ += tDeltaZ;
+        z += stepZ;
+      }
+    }
+
+    blockHit = false;
+  }
+
+  private float intBound(float s, float ds) {
+    if (ds == 0) return Float.POSITIVE_INFINITY;
+    return (ds > 0 ? Mathf.ceil(s) - s : s - Mathf.floor(s)) / Mathf.abs(ds);
+  }
+
+  @Override
+  public void onAttach() {
+    // TODO Auto-generated method stub
+
+  }
+
+  @Override
+  public void onDetach() {
+    // TODO Auto-generated method stub
+
+  }
+}