vibe3_physics/source/shapes/wave_grid_shape.cpp

#include "wave_grid_shape.h"
#include "../defines.h"
#include <cmath>

void WaveGridShape::generatePoints(int num_points, float screen_width, float screen_height) {
    num_points_ = num_points;
    grid_size_ = screen_height * WAVE_GRID_SIZE_FACTOR;
    amplitude_ = screen_height * WAVE_GRID_AMPLITUDE;

    // Calcular grid cuadrado aproximado basado en número de puntos
    // Queremos grid_cols * grid_rows ≈ num_points
    grid_cols_ = static_cast<int>(sqrtf(static_cast<float>(num_points)));
    grid_rows_ = grid_cols_;

    // Ajustar para que grid_cols * grid_rows no exceda num_points
    while (grid_cols_ * grid_rows_ > num_points && grid_rows_ > 1) {
        grid_rows_--;
    }

    // Si tenemos menos puntos que celdas, ajustar columnas también
    if (grid_cols_ * grid_rows_ > num_points) {
        grid_cols_ = num_points / grid_rows_;
    }

    // Casos especiales para pocos puntos
    if (num_points < 4) {
        grid_cols_ = num_points;
        grid_rows_ = 1;
    }
}

void WaveGridShape::update(float delta_time, float screen_width, float screen_height) {
    // Recalcular dimensiones por si cambió resolución (F4)
    grid_size_ = screen_height * WAVE_GRID_SIZE_FACTOR;
    amplitude_ = screen_height * WAVE_GRID_AMPLITUDE;

    // Pivoteo sutil en ejes X e Y (esquinas adelante/atrás, izq/der)
    // Usamos velocidades lentas para movimiento sutil y orgánico
    tilt_x_ += 0.3f * delta_time;  // Pivoteo vertical (esquinas arriba/abajo)
    tilt_y_ += 0.5f * delta_time;  // Pivoteo horizontal (esquinas izq/der)

    // Actualizar fase de las ondas (animación)
    phase_ += WAVE_GRID_PHASE_SPEED * delta_time;
}

void WaveGridShape::getPoint3D(int index, float& x, float& y, float& z) const {
    // Convertir índice lineal a coordenadas 2D del grid
    int col = index % grid_cols_;
    int row = index / grid_cols_;

    // Si el índice está fuera del grid válido, colocar en origen
    if (row >= grid_rows_) {
        x = 0.0f;
        y = 0.0f;
        z = 0.0f;
        return;
    }

    // Normalizar coordenadas del grid a rango [-1, 1]
    float u = (static_cast<float>(col) / static_cast<float>(grid_cols_ - 1)) * 2.0f - 1.0f;
    float v = (static_cast<float>(row) / static_cast<float>(grid_rows_ - 1)) * 2.0f - 1.0f;

    // Casos especiales para grids de 1 columna/fila
    if (grid_cols_ == 1) u = 0.0f;
    if (grid_rows_ == 1) v = 0.0f;

    // Posición base en el grid (escalada por tamaño)
    float x_base = u * grid_size_;
    float y_base = v * grid_size_;

    // Calcular Z usando función de onda 2D
    // z = amplitude * sin(frequency * x + phase) * cos(frequency * y + phase)
    float kx = WAVE_GRID_FREQUENCY * PI;  // Frecuencia en X
    float ky = WAVE_GRID_FREQUENCY * PI;  // Frecuencia en Y
    float z_wave = amplitude_ * sinf(kx * u + phase_) * cosf(ky * v + phase_);

    // Añadir pivoteo sutil: esquinas se mueven adelante/atrás según posición
    // tilt_x oscila esquinas arriba/abajo, tilt_y oscila esquinas izq/der
    float tilt_amount_x = sinf(tilt_x_) * 0.15f;  // Máximo 15% del grid_size
    float tilt_amount_y = sinf(tilt_y_) * 0.1f;   // Máximo 10% del grid_size

    float z_tilt = (u * tilt_amount_y + v * tilt_amount_x) * grid_size_;

    // Z final = ondas + pivoteo
    float z_final = z_wave + z_tilt;

    // Retornar coordenadas (grid paralelo a pantalla, sin rotación global)
    x = x_base;
    y = y_base;
    z = z_final;
}

float WaveGridShape::getScaleFactor(float screen_height) const {
    // Factor de escala para física: proporcional al tamaño del grid
    // Grid base = 84px (0.35 * 240px en resolución 320x240)
    const float BASE_SIZE = 84.0f;
    float current_size = screen_height * WAVE_GRID_SIZE_FACTOR;
    return current_size / BASE_SIZE;
}