sábado, 21 de noviembre de 2026

Añadiendo iluminacion con c++ y CodeBlocks y raylib-6.2_win64_mingw-w64;

 


pongo codigo c++ donde empiezo a trastear con la iluminacion, recuerdo que todo lo que ago de estos temas me ayudo de la IA, solo muestro mi curiosidad y los resultados que consigo, y mi trabajo.

  • // Parche definitivo de compatibilidad para MinGW
    • extern "C" {
    •     int stat64(const char *path, void *buffer) { return 0; }
    •     int stat6432(const char *path, void *buffer) { return 0; }
    •     int stat64i32(const char *path, void *buffer) { return 0; }
    •     int _stat64(const char *path, void *buffer) { return 0; }
    • }

    • #include "raylib.h"
    • #include "raymath.h"
    • #include <stdio.h>
    • #include <string.h>

    • // Shader sencillo de iluminación direccional + ambiente + niebla suave (GLSL 330)
    • static const char *vsIluminacion = R"(
    • #version 330

    • in vec3 vertexPosition;
    • in vec2 vertexTexCoord;
    • in vec3 vertexNormal;
    • in vec4 vertexColor;

    • uniform mat4 mvp;
    • uniform mat4 matModel;
    • uniform mat4 matNormal;

    • out vec3 fragPosition;
    • out vec2 fragTexCoord;
    • out vec3 fragNormal;
    • out vec4 fragColor;

    • void main()
    • {
    •     vec4 worldPos = matModel * vec4(vertexPosition, 1.0);
    •     fragPosition = worldPos.xyz;
    •     fragTexCoord = vertexTexCoord;
    •     fragNormal = normalize(vec3(matNormal * vec4(vertexNormal, 1.0)));
    •     fragColor = vertexColor;

    •     gl_Position = mvp * vec4(vertexPosition, 1.0);
    • }
    • )";

    • static const char *fsIluminacion = R"(
    • #version 330

    • in vec3 fragPosition;
    • in vec2 fragTexCoord;
    • in vec3 fragNormal;
    • in vec4 fragColor;

    • uniform sampler2D texture0;
    • uniform vec4 colDiffuse;

    • uniform vec3 lightDir;       // Dirección HACIA donde va la luz (ej. normalize((-0.5, -1.0, -0.3)))
    • uniform vec3 lightColor;     // Color de la luz
    • uniform vec3 ambientColor;   // Luz ambiental mínima para no dejar negro absoluto
    • uniform float fogDensity;    // Densidad de niebla (0.0 = sin niebla)
    • uniform vec3 fogColor;       // Color de la niebla
    • uniform vec3 viewPos;        // Posición de la cámara

    • out vec4 finalColor;

    • void main()
    • {
    •     vec4 texelColor = texture(texture0, fragTexCoord);
    •     vec3 baseColor = texelColor.rgb * fragColor.rgb * colDiffuse.rgb;

    •     vec3 normal = normalize(fragNormal);
    •     // Luz hacia el origen de la luz es -lightDir
    •     vec3 toLight = normalize(-lightDir);
    •     float diff = max(dot(normal, toLight), 0.0);

    •     vec3 lighting = ambientColor + (lightColor * diff);
    •     vec3 litColor = baseColor * lighting;

    •     if (fogDensity > 0.0) {
    •         float dist = length(viewPos - fragPosition);
    •         float fogFactor = 1.0 - exp(-pow(dist * fogDensity, 2.0));
    •         fogFactor = clamp(fogFactor, 0.0, 1.0);
    •         litColor = mix(litColor, fogColor, fogFactor);
    •     }

    •     float alpha = texelColor.a * fragColor.a * colDiffuse.a;
    •     finalColor = vec4(litColor, alpha);
    • }
    • )";

    • // Aplica el shader a todos los materiales de un modelo
    • static void AplicarShaderModelo(Model *modelo, Shader shader) {
    •     if (!modelo || modelo->materialCount <= 0) return;
    •     for (int i = 0; i < modelo->materialCount; i++) {
    •         modelo->materials[i].shader = shader;
    •     }
    • }

    • int main() {
    •     // 1. Inicializamos la ventana redimensionable con el ratón
    •     SetConfigFlags(FLAG_WINDOW_RESIZABLE);
    •     const int ancho = 1000;
    •     const int alto = 700;
    •     InitWindow(ancho, alto, "Prueba Lobo 3D - Camara, Colisiones e Iluminacion");

    •     // Cargar shader de iluminación
    •     Shader shaderLuz = LoadShaderFromMemory(vsIluminacion, fsIluminacion);

    •     int locLightDir     = GetShaderLocation(shaderLuz, "lightDir");
    •     int locLightColor   = GetShaderLocation(shaderLuz, "lightColor");
    •     int locAmbientColor = GetShaderLocation(shaderLuz, "ambientColor");
    •     int locFogDensity   = GetShaderLocation(shaderLuz, "fogDensity");
    •     int locFogColor     = GetShaderLocation(shaderLuz, "fogColor");
    •     int locViewPos      = GetShaderLocation(shaderLuz, "viewPos");

    •     // Configuramos una luz direccional inclinada (como sol/luna)
    •     Vector3 dirLuz = Vector3Normalize((Vector3){ -0.45f, -0.85f, -0.35f });
    •     Vector3 colorLuz = { 1.0f, 0.94f, 0.82f };
    •     Vector3 colorAmbiente = { 0.28f, 0.30f, 0.38f };
    •     float densidadNiebla = 0.018f;
    •     Vector3 colorNiebla = { 0.72f, 0.76f, 0.82f };

    •     SetShaderValue(shaderLuz, locLightDir, &dirLuz, SHADER_UNIFORM_VEC3);
    •     SetShaderValue(shaderLuz, locLightColor, &colorLuz, SHADER_UNIFORM_VEC3);
    •     SetShaderValue(shaderLuz, locAmbientColor, &colorAmbiente, SHADER_UNIFORM_VEC3);
    •     SetShaderValue(shaderLuz, locFogDensity, &densidadNiebla, SHADER_UNIFORM_FLOAT);
    •     SetShaderValue(shaderLuz, locFogColor, &colorNiebla, SHADER_UNIFORM_VEC3);

    •     // 2. Configuramos la cámara 3D que seguirá al personaje
    •     Camera3D camera = { 0 };
    •     Vector3 offsetCamara = { 0.0f, 5.0f, 9.0f };
    •     camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
    •     camera.fovy = 45.0f;
    •     camera.projection = CAMERA_PERSPECTIVE;

    •     // Posición inicial del lobo.
    •     // NOTA: Ponemos Y en -0.9f para compensar el centro del modelo de Blender y que pise el suelo.
    •     Vector3 posicionLobo = { 0.0f, -0.9f, 2.0f };
    •     float anguloRotacion = 0.0f;
    •     float escalaLobo = 1.0f;
    •     float velocidadTraslado = 4.0f;
    •     float velocidadAnimacion = 1.0f;
    •     float frameAnimacionCaminar = 0.0f;
    •     float frameAnimacionCintura = 0.0f;

    •     // 3. Cargar el modelo correcto y sus animaciones
    •     Model modeloLobo = LoadModel("loboescalado10.glb");
    •     AplicarShaderModelo(&modeloLobo, shaderLuz);

    •     int animsCount = 0;
    •     ModelAnimation *animaciones = LoadModelAnimations("loboescalado10.glb", &animsCount);
    •     int indiceAnimCintura = (animsCount > 1) ? 1 : 0;

    •     // 3b. Cargar escenario con arco y su textura PNG
    •     Vector3 posicionEscenario = { 0.0f, 0.0f, 0.0f };
    •     float escalaEscenario = 28.0f;
    •     Model modeloEscenario = LoadModel("escenario arco..obj");
    •     Texture2D texEscenario = LoadTexture("arcotextura.png");
    •     for (int i = 0; i < modeloEscenario.materialCount; i++) {
    •         modeloEscenario.materials[i].maps[MATERIAL_MAP_DIFFUSE].texture = texEscenario;
    •     }
    •     AplicarShaderModelo(&modeloEscenario, shaderLuz);

    •     // 4. Crear el Suelo de baldosas y la Pared de ladrillos
    •     Mesh mallaSuelo = GenMeshPlane(20.0f, 20.0f, 1, 1);
    •     Model modeloSuelo = LoadModelFromMesh(mallaSuelo);
    •     Image imgSuelo = GenImageChecked(512, 512, 32, 32, LIGHTGRAY, DARKGRAY);
    •     Texture2D texSuelo = LoadTextureFromImage(imgSuelo);
    •     UnloadImage(imgSuelo);
    •     modeloSuelo.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texSuelo;
    •     AplicarShaderModelo(&modeloSuelo, shaderLuz);

    •     Vector3 posicionPared = { 0.0f, 1.0f, -3.0f };
    •     Vector3 tamanoPared = { 5.0f, 2.0f, 0.6f };
    •     Mesh mallaPared = GenMeshCube(tamanoPared.x, tamanoPared.y, tamanoPared.z);
    •     Model modeloPared = LoadModelFromMesh(mallaPared);
    •     Image imgPared = GenImageChecked(256, 256, 16, 16, RED, MAROON);
    •     Texture2D texPared = LoadTextureFromImage(imgPared);
    •     UnloadImage(imgPared);
    •     modeloPared.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texPared;
    •     AplicarShaderModelo(&modeloPared, shaderLuz);

    •     // Cajas de colisión sólidas (paredes y laterales del arco; deja libre el hueco del arco)
    •     BoundingBox cajasColision[] = {
    •         // Pared procedural de prueba
    •         (BoundingBox){
    •             (Vector3){ posicionPared.x - tamanoPared.x/2.0f, posicionPared.y - tamanoPared.y/2.0f, posicionPared.z - tamanoPared.z/2.0f },
    •             (Vector3){ posicionPared.x + tamanoPared.x/2.0f, posicionPared.y + tamanoPared.y/2.0f, posicionPared.z + tamanoPared.z/2.0f }
    •         },
    •         // Ejemplo de pilar/muro izquierdo del arco (ajusta min y max según tu escenario)
    •         (BoundingBox){
    •             (Vector3){ -4.0f, -1.0f, -1.0f },
    •             (Vector3){ -1.2f,  3.0f,  1.0f }
    •         },
    •         // Ejemplo de pilar/muro derecho del arco (entre -1.2 y +1.2 en X queda hueco para pasar)
    •         (BoundingBox){
    •             (Vector3){  1.2f, -1.0f, -1.0f },
    •             (Vector3){  4.0f,  3.0f,  1.0f }
    •         }
    •     };
    •     const int numCajasColision = sizeof(cajasColision) / sizeof(cajasColision[0]);

    •     SetTargetFPS(60);

    •     // 5. Bucle principal
    •     while (!WindowShouldClose()) {
    •         float deltaTime = GetFrameTime();
    •         bool estaMoviendo = false;
    •         bool reproduciendoCintura = false;

    •         // Ajustar distancia/altura de seguimiento de la cámara con las flechas
    •         if (IsKeyDown(KEY_UP))    offsetCamara.y += 4.0f * deltaTime;
    •         if (IsKeyDown(KEY_DOWN))  offsetCamara.y -= 4.0f * deltaTime;
    •         if (IsKeyDown(KEY_LEFT))  offsetCamara.z += 6.0f * deltaTime;
    •         if (IsKeyDown(KEY_RIGHT)) offsetCamara.z -= 6.0f * deltaTime;

    •         // Guardamos la posición anterior por si colisiona con alguna pared
    •         Vector3 posicionAntigua = posicionLobo;

    •         // --- CONTROL DE TECLADO (W-A-S-D y E fluido) ---
    •         if (IsKeyDown(KEY_E)) {
    •             reproduciendoCintura = true;
    •         }
    •         else {
    •             if (IsKeyDown(KEY_W)) { posicionLobo.z -= velocidadTraslado * deltaTime; anguloRotacion = 180.0f; estaMoviendo = true; }
    •             if (IsKeyDown(KEY_S)) { posicionLobo.z += velocidadTraslado * deltaTime; anguloRotacion = -180.0f; estaMoviendo = true; }
    •             if (IsKeyDown(KEY_A)) { posicionLobo.x -= velocidadTraslado * deltaTime; anguloRotacion = -90.0f;  estaMoviendo = true; }
    •             if (IsKeyDown(KEY_D)) { posicionLobo.x += velocidadTraslado * deltaTime; anguloRotacion = 90.0f; estaMoviendo = true; }
    •         }

    •         // --- SISTEMA DE COLISIONES ---
    •         BoundingBox cajaLobo = {
    •             (Vector3){ posicionLobo.x - 0.4f, posicionLobo.y, posicionLobo.z - 0.4f },
    •             (Vector3){ posicionLobo.x + 0.4f, posicionLobo.y + 1.8f, posicionLobo.z + 0.4f }
    •         };

    •         for (int i = 0; i < numCajasColision; i++) {
    •             if (CheckCollisionBoxes(cajaLobo, cajasColision[i])) {
    •                 posicionLobo = posicionAntigua;
    •                 break;
    •             }
    •         }

    •         // --- ACTUALIZAR CÁMARA PARA QUE SIGA AL LOBO ---
    •         camera.target = (Vector3){ posicionLobo.x, posicionLobo.y + 1.5f, posicionLobo.z };
    •         camera.position = (Vector3){
    •             posicionLobo.x + offsetCamara.x,
    •             posicionLobo.y + offsetCamara.y,
    •             posicionLobo.z + offsetCamara.z
    •         };

    •         // Actualizar posición de la cámara en el shader para la niebla
    •         SetShaderValue(shaderLuz, locViewPos, &camera.position, SHADER_UNIFORM_VEC3);

    •         // --- SELECCIÓN Y ACTUALIZACIÓN DE ANIMACIÓN ---
    •         if (animsCount > 0) {
    •             if (reproduciendoCintura) {
    •                 frameAnimacionCintura += 24.0f * velocidadAnimacion * deltaTime;
    •                 if (frameAnimacionCintura >= 60.0f) frameAnimacionCintura = 0.0f;
    •                 UpdateModelAnimation(modeloLobo, animaciones[indiceAnimCintura], (int)frameAnimacionCintura);
    •                 frameAnimacionCaminar = 0.0f;
    •             }
    •             else if (estaMoviendo) {
    •                 frameAnimacionCaminar += 24.0f * velocidadAnimacion * deltaTime;
    •                 if (frameAnimacionCaminar >= 60.0f) frameAnimacionCaminar = 0.0f;
    •                 UpdateModelAnimation(modeloLobo, animaciones[0], (int)frameAnimacionCaminar);
    •                 frameAnimacionCintura = 0.0f;
    •             }
    •             else {
    •                 frameAnimacionCaminar = 0.0f;
    •                 frameAnimacionCintura = 0.0f;
    •                 UpdateModelAnimation(modeloLobo, animaciones[0], 0);
    •             }
    •         }

    •         // --- DIBUJO 3D ---
    •         BeginDrawing();
    •         ClearBackground((Color){ 184, 194, 209, 255 });

    •         BeginMode3D(camera);
    •             // Dibujar suelo
    •             DrawModel(modeloSuelo, (Vector3){ 0.0f, 0.0f, 0.0f }, 1.0f, WHITE);

    •             // Sombra proyectada en el suelo bajo el lobo (ligeramente desplazada según la dirección de la luz)
    •             Vector3 posSombraLobo = {
    •                 posicionLobo.x - dirLuz.x * 0.6f,
    •                 0.01f,
    •                 posicionLobo.z - dirLuz.z * 0.6f
    •             };
    •             DrawCylinder(posSombraLobo, 0.55f, 0.55f, 0.01f, 16, Fade(BLACK, 0.35f));

    •             // Dibujar escenario importado escalado y texturizado ("escenario arco..obj")
    •             DrawModelEx(modeloEscenario, posicionEscenario, (Vector3){ 0.0f, 1.0f, 0.0f }, 0.0f,
    •                         (Vector3){ escalaEscenario, escalaEscenario, escalaEscenario }, WHITE);

    •             // Dibujar pared de ladrillos
    •             DrawModel(modeloPared, posicionPared, 1.0f, WHITE);

    •             // Dibujar el lobo apoyado correctamente en el suelo con la posición acumulada
    •             DrawModelEx(modeloLobo, posicionLobo, (Vector3){ 0.0f, 1.0f, 0.0f }, anguloRotacion, (Vector3){ escalaLobo, escalaLobo, escalaLobo }, WHITE);

    •             // Cajas de colisión visibles para ajustarlas
    •             for (int i = 0; i < numCajasColision; i++) DrawBoundingBox(cajasColision[i], LIME);
    •         EndMode3D();

    •         // --- TEXTO INFORMATIVO ---
    •         DrawText("W-A-S-D: Mover | [E]: Cintura | Flechas: Ajustar camara", 20, 20, 16, DARKGRAY);
    •         DrawText("Luz direccional + sombra bajo el lobo activas.", 20, 45, 14, RED);

    •         const char *textoCoords = TextFormat("Posicion X: %.2f | Y: %.2f | Z: %.2f", posicionLobo.x, posicionLobo.y, posicionLobo.z);
    •         int tamTexto = 24;
    •         int anchoCaja = MeasureText(textoCoords, tamTexto) + 16;
    •         DrawRectangle(14, 66, anchoCaja, tamTexto + 8, Fade(RAYWHITE, 0.85f));
    •         DrawText(textoCoords, 22, 70, tamTexto, BLUE);

    •         EndDrawing();
    •     }

    •     // 6. Liberar memoria
    •     UnloadShader(shaderLuz);
    •     UnloadTexture(texEscenario);
    •     UnloadModel(modeloEscenario);
    •     UnloadTexture(texSuelo);
    •     UnloadModel(modeloSuelo);
    •     UnloadTexture(texPared);
    •     UnloadModel(modeloPared);
    •     if (animsCount > 0) {
    •         UnloadModelAnimations(animaciones, animsCount);
    •     }
    •     UnloadModel(modeloLobo);

    •     CloseWindow();
    •     return 0;
    • }


    viernes, 20 de noviembre de 2026

    Cambio de textura de personaje y explicacion de colisiones y de escenario, c++ y CodeBlocks.;


    E conseguido añadir un escenario en el prollecto echo con c++ y CodeBlocks, echo en blender en formato .obj y ahora estoy calculando la forma de poner las colisiones mediante esos cubos de color verde  que se ven en la escena, en el codigo hay unas cordenadas que al ejecutar el juego y moviendo al personaje, salen marcadas arriba en un texto azul, desde el codigo se cambia la numeraciuon de las cordenadas -y--z--x- y se ajustan esas cajas para que  el personaje al chocar con ellas  no traspase y sea  como una pared.................mucho muchisimo trabajo falta aqui para hacer algo interesante,,,,pero a por ello boy¡¡¡¡ y ahora quiero meterme  con la iluminacion , eso aqui es un hueso, pero lo boy a roer todo lo que me sea posible.



     tambien e añadido,,,,,bueno lo izo la IA pero se lo pedi yo, que fuera la pantalla escalable con el mouse y que cambiase el tamaño del texto donde se ven las cordenadas....hay muchos detalles nuevos....como la textura del escenario....aplicada desde blender al igual que la textura del personaje,,,le puse una  nueva,,,,para disimular un desnudo explicito que hoy en dia esta mal visto con temas de videojuegos...... cuando descargeis el juego funciona con teclas w--a-s-d-e y con flechas del teclado


    pasare el codigo c++ de este estudio de juego y un enlace para descargarse este ejemplo.


    tambien boy a procurar ampliar las opciones de descarga, desde mediafire.com desde ko-fi.com y desde 
    GitHub



    // Parche definitivo de compatibilidad para MinGW
    extern "C" {
        int stat64(const char *path, void *buffer) { return 0; }
        int stat6432(const char *path, void *buffer) { return 0; }
        int stat64i32(const char *path, void *buffer) { return 0; }
        int _stat64(const char *path, void *buffer) { return 0; }
    }

    #include "raylib.h"
    #include <stdio.h>
    #include <string.h>

    int main() {
        // 1. Inicializamos la ventana redimensionable con el ratón
        SetConfigFlags(FLAG_WINDOW_RESIZABLE);
        const int ancho = 1000;
        const int alto = 700;
        InitWindow(ancho, alto, "Prueba Lobo 3D - Camara Seguidora y Colisiones");

        // 2. Configuramos la cámara 3D que seguirá al personaje
        Camera3D camera = { 0 };
        Vector3 offsetCamara = { 0.0f, 5.0f, 9.0f };
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
        camera.fovy = 45.0f;
        camera.projection = CAMERA_PERSPECTIVE;

        // Posición inicial del lobo.
        // NOTA: Ponemos Y en -0.9f para compensar el centro del modelo de Blender y que pise el suelo.
        Vector3 posicionLobo = { 0.0f, -0.9f, 2.0f };
        float anguloRotacion = 0.0f;
        float escalaLobo = 1.0f;
        float velocidadTraslado = 4.0f;
        float velocidadAnimacion = 1.0f;
        float frameAnimacionCaminar = 0.0f;
        float frameAnimacionCintura = 0.0f;

        // 3. Cargar el modelo correcto y sus animaciones
        Model modeloLobo = LoadModel("loboescalado10.glb");

        int animsCount = 0;
        ModelAnimation *animaciones = LoadModelAnimations("loboescalado10.glb", &animsCount);
        int indiceAnimCintura = (animsCount > 1) ? 1 : 0;

        // 3b. Cargar escenario con arco y su textura PNG
        Vector3 posicionEscenario = { 0.0f, 0.0f, 0.0f };
        float escalaEscenario = 28.0f;
        Model modeloEscenario = LoadModel("escenario arco..obj");
        Texture2D texEscenario = LoadTexture("arcotextura.png");
        for (int i = 0; i < modeloEscenario.materialCount; i++) {
            modeloEscenario.materials[i].maps[MATERIAL_MAP_DIFFUSE].texture = texEscenario;
        }

        // 4. Crear el Suelo de baldosas y la Pared de ladrillos
        Mesh mallaSuelo = GenMeshPlane(20.0f, 20.0f, 1, 1);
        Model modeloSuelo = LoadModelFromMesh(mallaSuelo);
        Image imgSuelo = GenImageChecked(512, 512, 32, 32, LIGHTGRAY, DARKGRAY);
        Texture2D texSuelo = LoadTextureFromImage(imgSuelo);
        UnloadImage(imgSuelo);
        modeloSuelo.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texSuelo;

        Vector3 posicionPared = { 0.0f, 1.0f, -3.0f };
        Vector3 tamanoPared = { 5.0f, 2.0f, 0.6f };
        Mesh mallaPared = GenMeshCube(tamanoPared.x, tamanoPared.y, tamanoPared.z);
        Model modeloPared = LoadModelFromMesh(mallaPared);
        Image imgPared = GenImageChecked(256, 256, 16, 16, RED, MAROON);
        Texture2D texPared = LoadTextureFromImage(imgPared);
        UnloadImage(imgPared);
        modeloPared.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texPared;

        // Cajas de colisión sólidas (paredes y laterales del arco; deja libre el hueco del arco)
        BoundingBox cajasColision[] = {
            // Pared procedural de prueba
            (BoundingBox){
                (Vector3){ posicionPared.x - tamanoPared.x/2.0f, posicionPared.y - tamanoPared.y/2.0f, posicionPared.z - tamanoPared.z/2.0f },
                (Vector3){ posicionPared.x + tamanoPared.x/2.0f, posicionPared.y + tamanoPared.y/2.0f, posicionPared.z + tamanoPared.z/2.0f }
            },
            // Ejemplo de pilar/muro izquierdo del arco (ajusta min y max según tu escenario)
            (BoundingBox){
                (Vector3){ -4.0f, -1.0f, -1.0f },
                (Vector3){ -1.2f,  3.0f,  1.0f }
            },
            // Ejemplo de pilar/muro derecho del arco (entre -1.2 y +1.2 en X queda hueco para pasar)
            (BoundingBox){
                (Vector3){  1.2f, -1.0f, -1.0f },
                (Vector3){  4.0f,  3.0f,  1.0f }
            }
        };
        const int numCajasColision = sizeof(cajasColision) / sizeof(cajasColision[0]);

        SetTargetFPS(60);

        // 5. Bucle principal
        while (!WindowShouldClose()) {
            float deltaTime = GetFrameTime();
            bool estaMoviendo = false;
            bool reproduciendoCintura = false;

            // Ajustar distancia/altura de seguimiento de la cámara con las flechas
            if (IsKeyDown(KEY_UP))    offsetCamara.y += 4.0f * deltaTime;
            if (IsKeyDown(KEY_DOWN))  offsetCamara.y -= 4.0f * deltaTime;
            if (IsKeyDown(KEY_LEFT))  offsetCamara.z += 6.0f * deltaTime;
            if (IsKeyDown(KEY_RIGHT)) offsetCamara.z -= 6.0f * deltaTime;

            // Guardamos la posición anterior por si colisiona con alguna pared
            Vector3 posicionAntigua = posicionLobo;

            // --- CONTROL DE TECLADO (W-A-S-D y E fluido) ---
            if (IsKeyDown(KEY_E)) {
                reproduciendoCintura = true;
            }
            else {
                if (IsKeyDown(KEY_W)) { posicionLobo.z -= velocidadTraslado * deltaTime; anguloRotacion = 180.0f; estaMoviendo = true; }
                if (IsKeyDown(KEY_S)) { posicionLobo.z += velocidadTraslado * deltaTime; anguloRotacion = -180.0f; estaMoviendo = true; }
                if (IsKeyDown(KEY_A)) { posicionLobo.x -= velocidadTraslado * deltaTime; anguloRotacion = -90.0f;  estaMoviendo = true; }
                if (IsKeyDown(KEY_D)) { posicionLobo.x += velocidadTraslado * deltaTime; anguloRotacion = 90.0f; estaMoviendo = true; }
            }

            // --- SISTEMA DE COLISIONES ---
            // La caja de colisión se adapta a la altura real del personaje asentado en el suelo
            BoundingBox cajaLobo = {
                (Vector3){ posicionLobo.x - 0.4f, posicionLobo.y, posicionLobo.z - 0.4f },
                (Vector3){ posicionLobo.x + 0.4f, posicionLobo.y + 1.8f, posicionLobo.z + 0.4f }
            };

            // Comprueba colisión contra todas las cajas sólidas definidas
            for (int i = 0; i < numCajasColision; i++) {
                if (CheckCollisionBoxes(cajaLobo, cajasColision[i])) {
                    posicionLobo = posicionAntigua;
                    break;
                }
            }

            // --- ACTUALIZAR CÁMARA PARA QUE SIGA AL LOBO ---
            camera.target = (Vector3){ posicionLobo.x, posicionLobo.y + 1.5f, posicionLobo.z };
            camera.position = (Vector3){
                posicionLobo.x + offsetCamara.x,
                posicionLobo.y + offsetCamara.y,
                posicionLobo.z + offsetCamara.z
            };

            // --- SELECCIÓN Y ACTUALIZACIÓN DE ANIMACIÓN ---
            if (animsCount > 0) {
                if (reproduciendoCintura) {
                    frameAnimacionCintura += 24.0f * velocidadAnimacion * deltaTime;
                    if (frameAnimacionCintura >= 60.0f) frameAnimacionCintura = 0.0f;
                    UpdateModelAnimation(modeloLobo, animaciones[indiceAnimCintura], (int)frameAnimacionCintura);
                    frameAnimacionCaminar = 0.0f;
                }
                else if (estaMoviendo) {
                    frameAnimacionCaminar += 24.0f * velocidadAnimacion * deltaTime;
                    if (frameAnimacionCaminar >= 60.0f) frameAnimacionCaminar = 0.0f;
                    UpdateModelAnimation(modeloLobo, animaciones[0], (int)frameAnimacionCaminar);
                    frameAnimacionCintura = 0.0f;
                }
                else {
                    frameAnimacionCaminar = 0.0f;
                    frameAnimacionCintura = 0.0f;
                    UpdateModelAnimation(modeloLobo, animaciones[0], 0);
                }
            }

            // --- DIBUJO 3D ---
            BeginDrawing();
            ClearBackground(RAYWHITE);

            BeginMode3D(camera);
                // Dibujar suelo
                DrawModel(modeloSuelo, (Vector3){ 0.0f, 0.0f, 0.0f }, 1.0f, WHITE);

                // Dibujar escenario importado escalado y texturizado ("escenario arco..obj")
                DrawModelEx(modeloEscenario, posicionEscenario, (Vector3){ 0.0f, 1.0f, 0.0f }, 0.0f,
                            (Vector3){ escalaEscenario, escalaEscenario, escalaEscenario }, WHITE);

                // Dibujar pared de ladrillos
                DrawModel(modeloPared, posicionPared, 1.0f, WHITE);

                // Dibujar el lobo apoyado correctamente en el suelo con la posición acumulada
                DrawModelEx(modeloLobo, posicionLobo, (Vector3){ 0.0f, 1.0f, 0.0f }, anguloRotacion, (Vector3){ escalaLobo, escalaLobo, escalaLobo }, WHITE);

                // Cajas de colisión visibles para ajustarlas
                for (int i = 0; i < numCajasColision; i++) DrawBoundingBox(cajasColision[i], LIME);
            EndMode3D();

            // --- TEXTO INFORMATIVO ---
            DrawText("W-A-S-D: Mover | [E]: Cintura | Flechas: Ajustar camara", 20, 20, 16, DARKGRAY);
            DrawText("El personaje ahora camina apoyado en las baldosas.", 20, 45, 14, RED);

            const char *textoCoords = TextFormat("Posicion X: %.2f | Y: %.2f | Z: %.2f", posicionLobo.x, posicionLobo.y, posicionLobo.z);
            int tamTexto = 24;
            int anchoCaja = MeasureText(textoCoords, tamTexto) + 16;
            DrawRectangle(14, 66, anchoCaja, tamTexto + 8, Fade(RAYWHITE, 0.85f));
            DrawText(textoCoords, 22, 70, tamTexto, BLUE);

            EndDrawing();
        }

        // 6. Liberar memoria
        UnloadTexture(texEscenario);
        UnloadModel(modeloEscenario);
        UnloadTexture(texSuelo);
        UnloadModel(modeloSuelo);
        UnloadTexture(texPared);
        UnloadModel(modeloPared);
        if (animsCount > 0) {
            UnloadModelAnimations(animaciones, animsCount);
        }
        UnloadModel(modeloLobo);

        CloseWindow();
        return 0;
    }

    -------------------------------------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------------------------------------
    Tres enlaces para que elijais desde donde descargar el ejemplo, los tres de confianza y conocidos, sujiero descargeis desde ko-fi y me imbiteis a un cafe.¡¡¡




    https://ko-fi.com/s/29822abe14 



    https://github.com/tozudo/Ejemplo-de-juego-en-c-y-codeblocks/releases/tag/ejemplo_en_c%2B%2B_con_ejecutables


    Mi blog¡¡ lo ven desde Nueva York¡¡¡; fantastico¡¡¡;

     


    Gracias Nueva York¡¡¡ anda que no e visto cine vasado en esa ciudad¡¡¡¡  cine que me inspira y ayuda en mi aficion a desarrollar ideas¡¡¡¡

    Aqui desde España que ilusion me hace.......porque se que jamas pisare esa carismatica ciudad¡¡¡¡

    jueves, 19 de noviembre de 2026

    desarrollando videojuegos con c++ y CodeBlocks.;

    Sigo practicando con la IA, con c++ y CodeBlocks, Esta vez añado personaje animado en blender un ejemplo muy sencillo, personaje en glb y su textura de piel, estos archivos , se inclullen en la carpeta Debug para que se reflejen en pantalla cuando se  ejecute el .exe, la textura esta en .png,

    Dificultades con el personaje en un principio salia deformado al animarse hay que ir ajustando desde Blender el esqueleto y la malla, como se ve en esta imagen a de quedar

    y sobre todo un esqueleto simple no excesibamente elavorado. Atencion a las proporciones escala a  1.000, para ajustarlo a de quedar como sale aqui, si el cuerpo esta alejado de esa base del hueso grande al compilarlo con CodeBlocks el personaje se deforma y la base donde pisa no se consige quede realista pues esta como  flotando o undido en el suelo, esto son pruebas y todavia habria que retocar desde blender....para hacerlo perfecto, luego la animacion solo es una muestra rapida que hice para probar el codigo,

    Le pedi a la IA tambien hiciese como un bloque para que el personaje no pudiese traspasarlo y lo hizo en el codigo perfectamente, tambien el suelo en forma de damero esta realizado por codigo c++....añado el codigo y ñado el ejemplo para quien quiera descargarlo.....
    Otros detalles de este juego prueba , las teclas flechas sirven para mover la camara, -w-a-s-d para mover personaje -e- para animar solamente

    // Parche definitivo de compatibilidad para MinGW
    extern "C" {
        int stat64(const char *path, void *buffer) { return 0; }
        int stat6432(const char *path, void *buffer) { return 0; }
        int stat64i32(const char *path, void *buffer) { return 0; }
        int _stat64(const char *path, void *buffer) { return 0; }
    }

    #include "raylib.h"
    #include <stdio.h>
    #include <string.h>

    int main() {
        // 1. Inicializamos la ventana
        const int ancho = 1000;
        const int alto = 700;
        InitWindow(ancho, alto, "Prueba Lobo 3D - Suelo, Pared y Movimiento en Suelo");

        // 2. Configuramos la cámara 3D
        Camera3D camera = { 0 };
        camera.position = (Vector3){ 0.0f, 3.0f, 8.0f };
        camera.target = (Vector3){ 0.0f, 0.8f, 0.0f };
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
        camera.fovy = 45.0f;
        camera.projection = CAMERA_PERSPECTIVE;

        // Posición inicial del lobo.
        // NOTA: Ponemos Y en -0.9f (o lo que necesites) para compensar el centro del modelo de Blender y que pise el suelo.
        Vector3 posicionLobo = { 0.0f, -0.9f, 2.0f };
        float anguloRotacion = 0.0f;
        float escalaLobo = 1.0f;
        float velocidadTraslado = 4.0f;
        float velocidadAnimacion = 1.0f;
        float frameAnimacionCaminar = 0.0f;
        float frameAnimacionCintura = 0.0f;

        // 3. Cargar el modelo correcto y sus animaciones
        Model modeloLobo = LoadModel("loboescalado6.glb");

        int animsCount = 0;
        ModelAnimation *animaciones = LoadModelAnimations("loboescalado6.glb", &animsCount);
        int indiceAnimCintura = (animsCount > 1) ? 1 : 0;

        // 4. Crear el Suelo de baldosas y la Pared de ladrillos
        Mesh mallaSuelo = GenMeshPlane(20.0f, 20.0f, 1, 1);
        Model modeloSuelo = LoadModelFromMesh(mallaSuelo);
        Image imgSuelo = GenImageChecked(512, 512, 32, 32, LIGHTGRAY, DARKGRAY);
        Texture2D texSuelo = LoadTextureFromImage(imgSuelo);
        UnloadImage(imgSuelo);
        modeloSuelo.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texSuelo;

        Vector3 posicionPared = { 0.0f, 1.0f, -3.0f };
        Vector3 tamanoPared = { 5.0f, 2.0f, 0.6f };
        Mesh mallaPared = GenMeshCube(tamanoPared.x, tamanoPared.y, tamanoPared.z);
        Model modeloPared = LoadModelFromMesh(mallaPared);
        Image imgPared = GenImageChecked(256, 256, 16, 16, RED, MAROON);
        Texture2D texPared = LoadTextureFromImage(imgPared);
        UnloadImage(imgPared);
        modeloPared.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texPared;

        // Caja de colisión de la pared
        BoundingBox cajaPared = {
            (Vector3){ posicionPared.x - tamanoPared.x/2.0f, posicionPared.y - tamanoPared.y/2.0f, posicionPared.z - tamanoPared.z/2.0f },
            (Vector3){ posicionPared.x + tamanoPared.x/2.0f, posicionPared.y + tamanoPared.y/2.0f, posicionPared.z + tamanoPared.z/2.0f }
        };

        SetTargetFPS(60);

        // 5. Bucle principal
        while (!WindowShouldClose()) {
            float deltaTime = GetFrameTime();
            bool estaMoviendo = false;
            bool reproduciendoCintura = false;

            // Control de cámara con flechas
            if (IsKeyDown(KEY_UP)) camera.target.y += 1.0f * deltaTime;
            if (IsKeyDown(KEY_DOWN)) camera.target.y -= 1.0f * deltaTime;

            // Guardamos la posición anterior por si colisiona con la pared
            Vector3 posicionAntigua = posicionLobo;

            // --- CONTROL DE TECLADO (W-A-S-D y E fluido) ---
            if (IsKeyDown(KEY_E)) {
                reproduciendoCintura = true;
            }
            else {

               // if (IsKeyDown(KEY_W)) { posicionLobo.z -= velocidadTraslado * deltaTime; anguloRotacion = 0.0f;   estaMoviendo = true; }
                if (IsKeyDown(KEY_W)) { posicionLobo.z -= velocidadTraslado * deltaTime; anguloRotacion = 180.0f; estaMoviendo = true;}
                if (IsKeyDown(KEY_S)) { posicionLobo.z += velocidadTraslado * deltaTime; anguloRotacion = -180.0f; estaMoviendo = true; }
                if (IsKeyDown(KEY_A)) { posicionLobo.x -= velocidadTraslado * deltaTime; anguloRotacion = -90.0f;  estaMoviendo = true; }
                if (IsKeyDown(KEY_D)) { posicionLobo.x += velocidadTraslado * deltaTime; anguloRotacion = 90.0f; estaMoviendo = true; }
            }

            // --- SISTEMA DE COLISIONES ---
            // La caja de colisión se adapta a la altura real del personaje asentado en el suelo
            BoundingBox cajaLobo = {
                (Vector3){ posicionLobo.x - 0.4f, posicionLobo.y, posicionLobo.z - 0.4f },
                (Vector3){ posicionLobo.x + 0.4f, posicionLobo.y + 1.8f, posicionLobo.z + 0.4f }
            };

            // Si choca con la pared, vuelve exactamente a la posición donde estaba sin dar saltos
            if (CheckCollisionBoxes(cajaLobo, cajaPared)) {
                posicionLobo = posicionAntigua;
            }

            // --- SELECCIÓN Y ACTUALIZACIÓN DE ANIMACIÓN ---
            if (animsCount > 0) {
                if (reproduciendoCintura) {
                    frameAnimacionCintura += 24.0f * velocidadAnimacion * deltaTime;
                    if (frameAnimacionCintura >= 60.0f) frameAnimacionCintura = 0.0f;
                    UpdateModelAnimation(modeloLobo, animaciones[indiceAnimCintura], (int)frameAnimacionCintura);
                    frameAnimacionCaminar = 0.0f;
                }
                else if (estaMoviendo) {
                    frameAnimacionCaminar += 24.0f * velocidadAnimacion * deltaTime;
                    if (frameAnimacionCaminar >= 60.0f) frameAnimacionCaminar = 0.0f;
                    UpdateModelAnimation(modeloLobo, animaciones[0], (int)frameAnimacionCaminar);
                    frameAnimacionCintura = 0.0f;
                }
                else {
                    frameAnimacionCaminar = 0.0f;
                    frameAnimacionCintura = 0.0f;
                    UpdateModelAnimation(modeloLobo, animaciones[0], 0);
                }
            }

            // --- DIBUJO 3D ---
            BeginDrawing();
            ClearBackground(RAYWHITE);

            BeginMode3D(camera);
                // Dibujar suelo
                DrawModel(modeloSuelo, (Vector3){ 0.0f, 0.0f, 0.0f }, 1.0f, WHITE);

                // Dibujar pared de ladrillos
                DrawModel(modeloPared, posicionPared, 1.0f, WHITE);

                // Dibujar el lobo apoyado correctamente en el suelo con la posición acumulada
                DrawModelEx(modeloLobo, posicionLobo, (Vector3){ 0.0f, 1.0f, 0.0f }, anguloRotacion, (Vector3){ escalaLobo, escalaLobo, escalaLobo }, WHITE);
            EndMode3D();

            // --- TEXTO INFORMATIVO ---
            DrawText("W-A-S-D: Mover fluido | [E]: Animación de cintura", 20, 20, 16, DARKGRAY);
            DrawText("El personaje ahora camina apoyado en las baldosas.", 20, 45, 14, RED);
            DrawText(TextFormat("Posicion X: %.2f | Y: %.2f | Z: %.2f", posicionLobo.x, posicionLobo.y, posicionLobo.z), 20, 70, 14, BLUE);

            EndDrawing();
        }

        // 6. Liberar memoria
        UnloadTexture(texSuelo);
        UnloadModel(modeloSuelo);
        UnloadTexture(texPared);
        UnloadModel(modeloPared);
        if (animsCount > 0) {
            UnloadModelAnimations(animaciones, animsCount);
        }
        UnloadModel(modeloLobo);

        CloseWindow();
        return 0;
    }



     https://www.mediafire.com/file/x9emubdg9scnybw/TRIANGULO_Y_W-A-S-D_-_personaje_para_en_cubo_y_HUMANO_MUEVE.zip/file








    continuo trabajando el tema........(continuara....)


    lunes, 16 de noviembre de 2026

    IA; c++; CodeBlocks; 3d; fbx; gltf;glb;

     Estoy estudiando y practicando otras formas de desarrollar videojuegos; aprovechando la enorme ayuda de la IA y con mi tremenda curiosidad de estos temas.....boi a contar algunos logros que estoy consiguiendo con programacion en  c++,

    Pongo un video de algun trasteo que estoy haciendo.



    Descargate el ejemplo desde aqui ☝☝☝




    Codigo en c++ generado por la IA del ejemplo alguna cosa como se ve en el video se puede entender y trastear rapidamente;

    le pedi a la IA un codigo para mover unos objetos por este escenario, con teclas  w-a-s-d para mover un cubo en 3d, y lo dibujo el propio codigo, funciona de maravilla y unos slaiders para calibrar velocidades de traslado y otro slaider especial para exclusibamente alterar la velocidad de una animacion de muñequito que hice rapidamente en blender y al que le asigne un esqueleto y le grave unas sencillisima animacion. 
    En el video se ve como localizo rapidamente algunas lineas por las cuales se pueden manipular aspectos del codigo.


    Todo empezo por la ocurrencia de pedirle a la IA que me generase un motor de videojuegos, casi nada, anda que no da trabajo el tema, en principio para html. y empezaba a arrancar algun tema, pero al final daba tantos fallos y habia que trabajar tantisimas pruebas que lo deje correr. 
    Y pense en programar con codigo escrito en -c-   tambien se me complicaba un monton , al final  le pedi trabajar con c++ y me sugirio utilizar CodeBlocks, para prepararlo cuesta un poquito, como todo lo que es nuevo, pero veo que habanzo gracias a las explicaciones de la IA y que se pueden hacer cosas, para poder hacer lo del video se necesita instalar CodeBlocks y raylib-6.2_win64_mingw-w64, para poder trabajar en 3d,

    Estoy muy muy verde aun, me entusiasme cuando hizo el cubo en 3d y logre moverlo por el escenario con teclas w-a-s-d-, y cuando le pregunte como pasar modelados mios desde blender a CodeBlocks y me dijo que funcionaban unos 3 o 4 formatos entre ellos fbx, muy popular y glb gltf y lo probe .....
    Pues que alegria ademas controla por teclaro las animaciones, como se ve en el video, ayer domingo estuve toda la mañana haciendo pruebas, paso aqui el  codigo escrito en c++:



    // Parche definitivo de compatibilidad para MinGW

    extern "C" {

        int stat64(const char *path, void *buffer) { return 0; }

        int stat6432(const char *path, void *buffer) { return 0; }

        int stat64i32(const char *path, void *buffer) { return 0; }

        int _stat64(const char *path, void *buffer) { return 0; }

    }


    #include "raylib.h"

    #include <stdio.h>


    int main() {

        // 1. Inicializamos la ventana

        const int ancho = 1500;

        const int alto = 700;

        InitWindow(ancho, alto, "Control de Velocidades con Sliders y Teclado");


        // 2. Configuramos la cámara 3D

        Camera3D camera = { 0 };

        camera.position = (Vector3){ 0.0f, 6.0f, 12.0f };

        camera.target = (Vector3){ 0.0f, 1.0f, 0.0f };

        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };

        camera.fovy = 45.0f;

        camera.projection = CAMERA_PERSPECTIVE;


        // Posiciones iniciales

        Vector3 posicionCubo = { -3.0f, 1.0f, 0.0f };

        Vector3 posicionAra  = {  3.0f, 0.0f, 0.0f };


        // --- VARIABLES DE VELOCIDAD (Sliders ajustables) ---

        float velocidadTrasladoCubo = 4.0f;

        float velocidadTrasladoAra  = 4.0f;

        float velocidadAnimacionAra = 1.0f;


        // Acumulador flotante para la animación de la ara

        float frameAnimacionFloat = 0.0f;


        // --- 3. CARGAR EL MODELO "ara.glb" Y SUS ANIMACIONES ---

        Model modeloAra = LoadModel("ara.glb");


        int animsCount = 0;

        ModelAnimation *animaciones = LoadModelAnimations("ara.glb", &animsCount);


        SetTargetFPS(60);


        // 4. Bucle principal del juego

        while (!WindowShouldClose()) {


            float deltaTime = GetFrameTime();


            // --- GESTIÓN DE SLIDER / CAMBIO DE VELOCIDADES CON TECLADO ---

            if (IsKeyPressed(KEY_UP))    velocidadTrasladoAra += 0.5f;

            if (IsKeyPressed(KEY_DOWN))  velocidadTrasladoAra -= 0.5f;

            if (IsKeyPressed(KEY_RIGHT)) velocidadTrasladoCubo += 0.5f;

            if (IsKeyPressed(KEY_LEFT))  velocidadTrasladoCubo -= 0.5f;


            // Límites lógicos

            if (velocidadTrasladoAra < 0.5f) velocidadTrasladoAra = 0.5f;

            if (velocidadTrasladoCubo < 0.5f) velocidadTrasladoCubo = 0.5f;


            // Control con ratón para los Sliders visuales en pantalla

            Vector2 mousePos = GetMousePosition();

            if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {

                if (mousePos.x >= 20 && mousePos.x <= 220 && mousePos.y >= 540 && mousePos.y <= 560) {

                    velocidadTrasladoAra = ((mousePos.x - 20) / 200.0f) * 10.0f;

                }

                if (mousePos.x >= 340 && mousePos.x <= 540 && mousePos.y >= 540 && mousePos.y <= 560) {

                    velocidadAnimacionAra = ((mousePos.x - 340) / 200.0f) * 4.0f;

                }

                if (mousePos.x >= 660 && mousePos.x <= 860 && mousePos.y >= 540 && mousePos.y <= 560) {

                    velocidadTrasladoCubo = ((mousePos.x - 660) / 200.0f) * 10.0f;

                }

            }


            // --- GESTIÓN DE ENTRADAS: Cubo con WASD ---

            if (IsKeyDown(KEY_W)) posicionCubo.z -= velocidadTrasladoCubo * deltaTime;

            if (IsKeyDown(KEY_S)) posicionCubo.z += velocidadTrasladoCubo * deltaTime;

            if (IsKeyDown(KEY_A)) posicionCubo.x -= velocidadTrasladoCubo * deltaTime;

            if (IsKeyDown(KEY_D)) posicionCubo.x += velocidadTrasladoCubo * deltaTime;


            // --- GESTIÓN DE ENTRADAS Y ANIMACIÓN: Ara.glb con U-H-J-K ---

            bool estaMoviendoAra = false;


            if (IsKeyDown(KEY_U)) { posicionAra.z -= velocidadTrasladoAra * deltaTime; estaMoviendoAra = true; }

            if (IsKeyDown(KEY_J)) { posicionAra.z += velocidadTrasladoAra * deltaTime; estaMoviendoAra = true; }

            if (IsKeyDown(KEY_H)) { posicionAra.x -= velocidadTrasladoAra * deltaTime; estaMoviendoAra = true; }

            if (IsKeyDown(KEY_K)) { posicionAra.x += velocidadTrasladoAra * deltaTime; estaMoviendoAra = true; }


            // Si se está moviendo, avanzamos la animación de forma fluida

            if (animsCount > 0) {

                if (estaMoviendoAra) {

                    frameAnimacionFloat += 150.0f * velocidadAnimacionAra * deltaTime;


                    // Bucle estándar de seguridad (asumiendo 60 frames por ciclo de animación)

                    if (frameAnimacionFloat >= 60.0f) {

                        frameAnimacionFloat = 0.0f;

                    }

                }

                // Actualizamos el modelo sin depender de propiedades privadas de la estructura

                UpdateModelAnimation(modeloAra, animaciones[0], (int)frameAnimacionFloat);

            }


            // --- DIBUJO ---

            BeginDrawing();

            ClearBackground(RAYWHITE);


            BeginMode3D(camera);


                // Dibujamos el cubo azul

                DrawCube(posicionCubo, 2.0f, 2.0f, 2.0f, BLUE);

                DrawCubeWires(posicionCubo, 2.0f, 2.0f, 2.0f, DARKGRAY);


                // Dibujamos ara.glb

                DrawModelEx(modeloAra, posicionAra, (Vector3){ 0.0f, 1.0f, 0.0f }, 0.0f, (Vector3){ 1.0f, 1.0f, 1.0f }, WHITE);


                // Rejilla de suelo

                DrawGrid(10, 1.0f);


            EndMode3D();


            // --- INTERFAZ / SLIDERS VISUALES EN 2D ---

            DrawRectangle(0, 500, ancho, 150, LIGHTGRAY);

            DrawRectangleLines(0, 500, ancho, 150, DARKGRAY);


            DrawText("PANEL DE CONTROL DE VELOCIDADES (Haz clic en las barras o usa Flechas/WASD)", 20, 510, 15, DARKGRAY);


            // 1. Slider Velocidad Traslado Ara

            DrawText(TextFormat("Vel. Traslado Ara: %.1f", velocidadTrasladoAra), 20, 535, 10, DARKGRAY);

            DrawRectangle(20, 550, 200, 10, WHITE);

            DrawRectangle(20, 550, (int)((velocidadTrasladoAra / 10.0f) * 200), 10, RED);


            // 2. Slider Velocidad Animación Ara

            DrawText(TextFormat("Vel. Animacion Ara: %.1f", velocidadAnimacionAra), 340, 535, 10, DARKGRAY);

            DrawRectangle(340, 550, 200, 10, WHITE);

            DrawRectangle(340, 550, (int)((velocidadAnimacionAra / 4.0f) * 200), 10, GREEN);


            // 3. Slider Velocidad Traslado Cubo

            DrawText(TextFormat("Vel. Traslado Cubo: %.1f", velocidadTrasladoCubo), 660, 535, 10, DARKGRAY);

            DrawRectangle(660, 550, 200, 10, WHITE);

            DrawRectangle(660, 550, (int)((velocidadTrasladoCubo / 10.0f) * 200), 10, BLUE);


            // Instrucciones en texto

            DrawText("Cubo: W-A-S-D   |   Ara: U-H-J-K", 20, 580, 12, DARKGRAY);


            EndDrawing();

        }


        // --- DESCARGAR RECURSOS DE LA MEMORIA AL SALIR ---

        if (animsCount > 0) {

            UnloadModelAnimations(animaciones, animsCount);

        }

        UnloadModel(modeloAra);


        CloseWindow();

        return 0;

    }