Cramion Engine v0.5.1

Cramion 0.5.1

Todo lo nuevo desde la 0.2. El zip Cramion-win64.zip trae el editor, el player, el puente MCP, el runtime de C++ y la documentación: descomprimir y abrir CramionEditor.exe. La lista detallada de la 0.5 y la 0.5.1 está en CHANGELOG.md.

---

🎯 Gizmos y editor (0.5.1)

• El gizmo de mover, rotar y escalar se dibuja siempre encima, opaco y sin iluminación, como en Unreal: ya no se destiñe dentro del objeto seleccionado.
• Más grueso y más grande, fácil de agarrar.
• Rotar: sin el círculo blanco que estorbaba y con una bola central de giro libre (arrástrala y el objeto gira siguiendo el ratón).
• El Mesh Collider se dibuja completo, aunque la malla tenga cientos de miles de triángulos.

🪨 Materiales (0.5.1)

• Nuevos mapas en el .crmat: Displacement (parallax occlusion mapping, profundidad en metros), Cavidad, Specular, Gloss y Bump, además de color, normal, rugosidad, metal, AO y emisión.
• Arrastra el BaseColor de un pack de Megascans y el material encuentra solo los demás mapas por su nombre.

🧱 Mundo de bloques

• Componente VoxelWorld: mundo infinito de bloques como Minecraft, con biomas, cuevas, árboles, mar, luz de antorchas, texturas generadas y colisión con la física.
• Plantilla Mundo de bloques en el Hub (con HUD, inventario y romper bloques).
• API Lua Voxel: getBlock, setBlock, raycast, blockInfo… La luz, la malla y la colisión se rehacen solas.

🧭 Navegación e IA

• Volumen de NavMesh como en Unreal: la malla de navegación se genera sola a partir de los colliders y se actualiza en tiempo real al moverlos (se ve en verde, tecla P).
• Componente NavAgent: moveTo, stopMoving, esquiva obstáculos y a otros agentes, con o sin Rigidbody.
• Plantilla IA y navegación en el Hub.

🤖 IA dentro del editor (MCP)

• Servidor MCP integrado (127.0.0.1:7777) + CramionMcp.exe para Claude, Cursor o Copilot. La IA crea escenas y objetos, escribe scripts Lua y shaders, hace materiales, pulsa Play, lee la consola y mira capturas. Todo se ve en el editor y se deshace con Ctrl+Z.
• Más de 40 herramientas; ahora también graphics_settings, performance_stats, reimport_model y set_gizmo.

🎨 Shaders, prefabs y mallas por código

• Shaders de superficie (.crshader, GLSL) como los surface shaders de Unity: tú decides el color, el brillo, el relieve y el movimiento, y el motor pone la luz, las sombras, los reflejos, la niebla y la lluvia. Se recompilan al guardar, también en Play, y marcan la línea del error.
• Prefabs (.crprefab): instancias enlazadas, aplicar, revertir y cambios propios.
• Mallas en tiempo de ejecución (Mesh en Lua): cubos, planos, esferas, cilindros, cápsulas o geometría propia, con sombras y MeshCollider.
• Matemáticas en Lua: Vec3, Quat, Mathf, Random.

⚡ Rendimiento (0.5)

• Presupuesto adaptativo: detecta el hardware (Bajo, Medio, Alto o Ultra) y un gobernador baja o sube la calidad por pasadas para llegar a los FPS pedidos, con costes medidos en tu PC. En la prueba con una GPU simulada 3 veces más lenta pasa de 21 a 60 FPS.
• LODs automáticos con criterio de error en pantalla de 1 píxel (el de Nanite). Las sombras usan el mismo nivel.
• Static batching al exportar, batching de sombras y del pase de cámara, y clusteres independientes de la escala.

💡 Iluminación (0.5)

• Caché de radiancia en el mundo (como SHaRC o la surface cache de Lumen): rebotes infinitos y sin fugas de cielo en interiores.
• Sombras de contacto, compensación de energía por dispersión múltiple, sol con tamaño angular real y oclusión del horizonte.

🌊 Agua

• Oleaje con espectro JONSWAP (24 ondas), reflejo del cielo real con nubes, luz a través de las crestas, niebla y luz volumétrica.
• Corregida la espuma "pixelada" y los triángulos en la normal del oleaje.

🌍 Mundos grandes (0.5)

• Origen flotante (el World Origin Rebasing de Unreal): a más de 2 km el mundo se desplaza solo, con física, navegación, bloques, partículas, audio y cinemáticas. En Lua: Scene.origin(), Scene.toAbsolute(), Scene.toLocal() y OnOriginShift.

🛠️ Editor, Hub y juego exportado

• Hub de proyectos con plantillas (Vacío, Tercera persona, IA y navegación, Mundo de bloques) y miniatura de cada proyecto.
• Componente Profiler (FPS, CPU, GPU, RAM y gráfica).
• Importación con barra de progreso y Reimportar (combinar mallas) para modelos muy troceados.
• Juego exportado: carga de escenas por etapas con pantalla de carga, mensaje claro si falta memoria de vídeo y cámara orbital si la escena no tiene cámara.
• Manual nuevo: 37 páginas con buscador y ejemplos (jugador, cámara, disparo, vehículo, IA, menú, monedas, terreno…).

---

Notas

• Un objeto marcado Static no debe moverse, ocultarse ni cambiar de material por script en el juego exportado: su malla va dentro del lote.
• Los scripts que guardan posiciones del mundo deben usar OnOriginShift (o Scene.toAbsolute al guardar partidas).
• Los shaders propios (.crshader) todavía no usan el parallax del mapa de alturas.

💬 Dudas, ideas y lo que estés creando: Discord

Cramion Engine v0.2.0

Cramion Engine v0.2.0

Esta versión añade navegación con NavMesh al estilo de Unreal, un Hub rediseñado con plantillas de proyecto y mejoras en el agua y el escalado.

Descarga

Archivo	Contenido
Cramion-win64.zip (~11 MB)	Editor, player para juegos exportados, demo de render, shaders y runtime de Visual C++

Descomprime, abre CramionEditor.exe y crea un proyecto desde una plantilla.

Requisitos: Windows 10/11 x64 y una GPU con Vulkan 1.3.

---

Novedades

🧭 Navegación (NavMesh)

Basada en Recast/Detour, la misma biblioteca que usa Unreal Engine.

• Volumen de NavMesh (Crear > Navegación): la malla se genera dentro y se ajusta sola a la escena.
• Visible en el editor en verde, con su borde. Se activa con la tecla P o con el botón Nav de la barra.
• Generación en tiempo real por baldosas en hilos de fondo: al mover un collider solo se rehacen las baldosas que toca. Funciona en el editor, en Play y en el juego exportado.
• Modificadores de navegación: Bloquear quita la zona y Evitar la encarece para que los caminos la rodeen.
• Agentes (NavAgent) con DetourCrowd: velocidad, aceleración, giro y evitación entre agentes. Sin Rigidbody se mueven pegados a la malla; con Rigidbody dinámico, por velocidad.
• Ventana Navegación: radio, altura, escalón y pendiente del agente, resolución de la malla y estadísticas. Se guarda en ProjectSettings/Navigation.json.
• La malla sale de la geometría de colisión, como en Unreal: colliders de caja, esfera, cápsula, malla y plano, y terrenos.

Rendimiento medido: 400 × 400 m con 3000 obstáculos se genera en 1,5 s, y mover un obstáculo rehace 2 baldosas en unos 15 ms.

Scripting:

self.entity:moveTo(destino)           -- también stopMoving(), isMoving, remainingDistance
local camino = Navigation.findPath(a, b)
local punto  = Navigation.randomPoint(centro, radio)
local libre  = Navigation.raycast(desde, hasta)

🏠 Hub y plantillas de proyecto

• Hub rediseñado: barra lateral, tarjetas de proyectos con búsqueda y fecha relativa, y menú contextual (Abrir, Mostrar en el Explorador, Quitar de la lista).
• Galería de plantillas con miniaturas, filtros y panel de detalles.
• 3 plantillas integradas, que se pueden jugar nada más crearlas:

Plantilla	Incluye
Vacío	Cielo físico, sol, cámara, post-proceso y suelo
Tercera persona	Jugador con Rigidbody (WASD, Shift, Espacio), cámara orbital, plataformas, rampa y monedas con marcador en el HUD
IA y navegación	Laberinto con NavMesh, 3 guardias que patrullan y persiguen, meta, HUD y reinicio del nivel

• Plantillas propias: Archivo > Guardar proyecto como plantilla. Aparecen en Mis plantillas.
• Los selectores de carpeta del Hub ya no bloquean el editor.

🌊 Agua

• La espuma ya no se ve pixelada. Usa un hash de ruido estable con coordenadas grandes y una textura de burbujas con bordes suaves que se deshace de forma natural.
• Normal y crestas por píxel: sin facetas triangulares.
• Filtrado por tamaño de píxel: a lo lejos las ondas pasan a ser rugosidad y el agua deja de centellear.

🖥️ Render

• Arreglado el parpadeo en negro con AMD FSR 1. El disco del sol desbordaba el half float a infinito y FSR lo convertía en NaN, que el bloom y los rayos de luz extendían por la pantalla.

📚 Documentación

• Referencia de scripting ampliada con la API de navegación y un ejemplo de IA (patrullar y perseguir).
• Autocompletado del editor con moveTo, Navigation.*, etc.

---

Compilar desde el código

cmake --preset clang-ninja-release
cmake --build --preset clang-ninja-release
cmake --build --preset clang-ninja-release --target cramion_package   # zip

Nueva dependencia (se descarga sola): recastnavigation 1.6.0.

Limitaciones conocidas

• Solo Windows.
• La navegación genera la malla para un único tipo de agente, con el radio y la altura de los ajustes del proyecto.
• El volumen de NavMesh es una caja alineada con los ejes: su giro no cuenta.
• Las escenas de demostración de cramion.exe no se incluyen (ver README).

---

¿Encontraste un error? Abre un issue. ¡Gracias por probar Cramion! 💙

Cramion-win64 Release 0.1

Cramion Engine v0.1.0

Primera versión pública de Cramion, un motor de juegos para Windows escrito desde cero en C++20: renderizador diferido en Vulkan 1.3 con iluminación física, editor de escenas, física, terreno, agua, audio y scripting en Lua.

Descarga

Archivo	Contenido
Cramion-win64.zip (~10 MB)	Editor, player para juegos exportados, demo de render, shaders y runtime de Visual C++

1. Descomprime el zip en cualquier carpeta.
2. Abre CramionEditor.exe.
3. Crea un proyecto desde el Hub y pulsa *

Requisitos: Windows 10/11 x64 y una GPU con controlador Vulkan 1.3.
No separes los .exe de las carpetas `s

---

Novedades

Render — CramionFX

• Renderizador diferido con G-buffer y materiales PBR metal/rugosidad (albedo, normales, rugosidad, metal,
  emisión, oclusión).
• Cielo atmosférico físico con ciclo de día y noche; la luz ambiente y los reflejos (IBL) salen del propio cielo.
• Sombras en cascada (CSM) para el sol y mapas de sombra para luces puntuales y focos, con recorte por alfa.
• SSAO e iluminación global en espacio de pantalla (SSGI).
• Reflejos en espacio de pantalla (SSR), sondas de reflexión y trazado de rayos.
• Post-proceso HDR: bloom, auto-expoyos de luz volumétricos, tonemappingACES/Neutral y FXAA.
• Lluvia con charcos y superficies mojadas, nubes volumétricas, niebla de altura y agua.
• Escalado de resolución con TAA y An 1 (EASU + RCAS).
• Escenas grandes: lector de OBJ en paralelo, caché binaria y culling por clústeres y Hi-Z. San Miguel (~10 M de triángulos) carga en segundos.
• Formatos: OBJ, glTF/GLB y FBX (vía assim

Motor — CramionCore

• ECS (EnTT) con jerarquía, etiquetas enas en .crscene.
• Física con Jolt: cuerpos rígidos, colisionadores (caja, esfera, cápsula, malla, plano), triggers, raycasts y vehículos con WheelCollider, motor y marchas.
• Terreno con herramientas de esculpid
• Agua con superficies configurables.
• Animación: esqueletos, clips y un Animator con parámetros (float, bool, trigger).
• Cinemáticas: cámaras virtuales, *dol
• Audio 3D (miniaudio), sistemas de partículas y decals.
• UI de juego: canvas, imágenes, textos, botones, sliders, campos de texto y casillas.
• Proyectos con base de datos de assets y

Scripting en Lua 5.4

Scripts al estilo de los MonoBehaviour d

local Jugador = { properties = { velocidad

function Jugador:Update(dt)
    local mover = Vec3(Input.getAxis("HoriVertical"))
    self.entity:translate(mover * self.velocidad * dt)
end

function Jugador:OnTriggerEnter(other)
    if other.tag == "Moneda" then other:destroy() end
end

return Jugador

• Ciclo de vida completo: Awake, StartxedUpdate, OnCollision*, OnTrigger*,OnDestroy`.
• API: Vec3, Entity, Scene, Input, Time, Physics, Audio, Prefs, Game, Debug, Mathf.
• Propiedades editables desde el Inspector.
• Recarga en caliente: al guardar un script en Play, las instancias conservan su estado.
• Eventos de UI conectados a métodos del s
• Consola Lua en el editor y entorno aislado (sin acceso al sistema de archivos).

📖 Documentación completa con 10 ejemplos:/scripting.html)

Editor — CramionEditor

• Interfaz con paneles acoplables (Dear Imista de escena y de juego, consola.
• Gizmos de transformación, edición múltiple y miniaturas de modelos.
• Editores de materiales, terreno, agua, animación, UI y cinemáticas.
• Modo Play dentro del editor.
• Exportar juego: genera un .exe con CramionPlayer, los shaders y los assets empaquetados.

---

Compilar desde el código

Requisitos: Windows SDK, Vulkan SDK (VULKAN_SDK definido), CMake ≥ 3.21, Clang (LLVM) y Ninja.

cmake --preset clang-ninja-release
cmake --build --preset clang-ninja-release

# Genera build-release/Cramion-win64.zip
cmake --build --preset clang-ninja-release --target cramion_package

Las dependencias (assimp, stb, EnTT, Jolt, Lua, sol2, miniaudio, Dear ImGui, FidelityFX FSR) se descargan solas al
configurar.

Limitaciones conocidas

• Solo Windows (Win32 + DirectX 12 en la c
• La SSGI es de pantalla: lo que queda fuera de la vista no rebota luz.
• En interiores, la luz del cielo queda algo más clara de lo real.
• Si el programa arranca con la ventana mi
• Las escenas de demostración (Šibenik, San Miguel, Bistro) no se incluyen: pesan mucho y sus licencias no permiten redistribuirlas. cramion.exe las necesita; consulta el README para descargarlas.

Créditos

Escenas de la McGuire Computer Graphics Archive y Amazon Lumberyard Bistro. AMD FidelityFX Super Resolution © AMD.