VOLO.LAT TECH 24 CLASES 120+ MÉTODOS

API.reference

Catálogo técnico de clases, structs, componentes y métodos públicos de Mei Engine en C++20 con firmas completas, parámetros y ejemplos.

24 CLASES 120+ MÉTODOS C++20 SPEC

Catálogo Completo de la API C++20

Índice exhaustivo de clases, structs, componentes y métodos públicos con firmas, tablas de parámetros y ejemplos.

namespace Mei Zero-Allocation Hot Path
Mostrando todas las clases y subsistemas

Módulo Scene & ECS

Header: <Mei/scene/*>
Entidad Principal

Mei::GameObject

Representa cualquier entidad viva en el grafo de la escena. Posee un Transform obligatorio, un ID numérico de 32-bits y una colección polimórfica de componentes.

Clase std::enable_shared_from_this

Métodos Principales

Firma C++20 Retorno Descripción y Complejidad
template<typename T, typename... Args> std::shared_ptr<T> AddComponent(Args&&... args) std::shared_ptr<T> Instancia y asocia un componente a la entidad, asignando su puntero gameObject y llamando a Awake().
template<typename T> std::shared_ptr<T> GetComponent() const std::shared_ptr<T> Busca el primer componente de tipo T mediante dynamic_pointer_cast. Retorna nullptr si no existe.
template<typename T> std::vector<std::shared_ptr<T>> GetComponents() const std::vector<std::shared_ptr<T>> Retorna todos los componentes del tipo especificado (ideal para múltiples scripts en la misma entidad).
uint32_t GetID() const noexcept uint32_t Identificador numérico único auto-incrementable de la entidad. O(1).
Transform& GetTransform() noexcept Transform& Acceso directo por referencia al Transform de la entidad. O(1) Zero-Allocation.
Ejemplo de Uso C++20
auto player = scene->CreateGameObject("Player");
player->GetTransform().SetPosition({0.0f, 2.0f, 0.0f});
auto rb = player->AddComponent<Mei::RigidBodyComponent>();
rb->SetMass(1.5f);
auto script = player->AddComponent<PlayerControllerScript>();
Base de Scripting de Usuario

Mei::ScriptComponent

Clase base recomendada para toda la lógica de juego del usuario. Provee ciclo de vida seguro, helpers directos de búsqueda, instanciación diferida y serialización con MEI_FIELD.

Herencia: Component Seguridad Play Mode

Ciclo de Vida y Métodos Helper

Método / Helper Firma Descripción
Awake() virtual void Awake() Llamado al añadirse el componente a la entidad, antes de cualquier inicialización de escena.
Start() virtual void Start() Llamado una sola vez al iniciar el Play Mode o al nacer la entidad vía Instantiate.
Update() virtual void Update(float deltaTime) Llamado en cada frame de la simulación. deltaTime está sujeto a la escala temporal.
Instantiate() std::shared_ptr<GameObject> Instantiate(const std::shared_ptr<GameObject>& original, const glm::vec3& pos, const glm::vec3& rot) Clona una entidad de forma diferida. La nueva entidad se añade al final del frame llamando automáticamente a su Start().
Destroy() void Destroy(std::shared_ptr<GameObject> obj, float delay = 0.0f) Encola la destrucción segura de la entidad. Nunca invalida iteradores durante la física o el render.
PhysicsRaycast() bool PhysicsRaycast(const glm::vec3& origin, const glm::vec3& dir, float maxDist, RaycastHit& hit) Lanza un rayo en el espacio 3D consultando el árbol de colisiones del PhysicsSystem.
Ejemplo de Script de Usuario con MEI_FIELD
#pragma once
#include <Mei/scene/ScriptComponent.h>
#include <Mei/core/Input.h>

class TurretScript : public Mei::ScriptComponent {
public:
    MEI_FIELD(float, fireRate, 0.25f);
    MEI_FIELD(float, bulletSpeed, 20.0f);

    void Update(float dt) override {
        if (Mei::Input::IsKeyPressed(Mei::Key::Space)) {
            RaycastHit hit;
            if (PhysicsRaycast(GetTransform().GetPosition(), GetTransform().GetForward(), 50.0f, hit)) {
                Mei::Console::Info("Impacto en: " + hit.collider->GetGameObject()->GetName());
            }
        }
    }
};
MEI_REGISTER_SCRIPT(TurretScript)
Contenedor del Mundo

Mei::Scene

Administra el árbol jerárquico de entidades, los snapshots en RAM del Play Mode, la serialización a formato .mei y la cola diferida de comandos de ciclo de vida.

Clase RAM Snapshots
Método Firma Descripción
CreateGameObject std::shared_ptr<GameObject> CreateGameObject(const std::string& name = "GameObject") Crea una entidad limpia con Transform e ID auto-incrementable y la añade a la jerarquía raíz.
FindObjectByName std::shared_ptr<GameObject> FindObjectByName(const std::string& name) const Busca la primera entidad con el nombre exacto en todo el árbol de la escena.
Play / Pause / Stop void Play(); void Pause(); void Stop(); Controla el estado de simulación. Play() guarda snapshot en RAM; Stop() restaura la escena al estado exacto inicial.
SaveToFile / LoadFromFile bool SaveToFile(const std::string& path); bool LoadFromFile(const std::string& path); Serializa y deserializa recursivamente todas las entidades, jerarquías y componentes en formato JSON .mei.

Módulo Physics

Header: <Mei/physics/*>
Dinámica de Cuerpos Rígidos

Mei::RigidBodyComponent

Aplica física newtoniana determinista con warm starting, integración semi-implícita de Euler y sistema de reposo (sleep) para optimización extrema de CPU.

Física Determinista Warm Starting
Método Firma Descripción
AddForce void AddForce(const glm::vec3& force) Añade una fuerza continua en Newtons que acelera la masa del cuerpo durante el sub-step. Despierta el cuerpo si está dormido.
AddImpulse void AddImpulse(const glm::vec3& impulse) Modifica instantáneamente la velocidad lineal: v += impulse / mass. Ideal para saltos y proyectiles.
SetKinematic void SetKinematic(bool kinematic) Si es true, el cuerpo ignora la gravedad y las fuerzas de colisión, pero puede empujar otros cuerpos vía código.
IsSleeping bool IsSleeping() const noexcept Retorna si el cuerpo ha entrado en reposo por baja energía cinética (ahorrando tiempo de CPU en SAT).
Locomoción de Personajes

Mei::CharacterControllerComponent

Controlador cinemático de personajes para juegos en primera y tercera persona. Maneja subida automática de escalones (Step Offset), límites de pendiente (Slope Limit) y detección de suelo (IsGrounded).

Cinemático Sin Fricción Indeseada
Método Firma Descripción
Move void Move(const glm::vec3& displacement, float deltaTime) Desplaza al personaje resolviendo colisiones continuas y deslizamientos contra paredes sin atascarse.
IsGrounded bool IsGrounded() const noexcept Retorna true si la cápsula del personaje está en contacto estable con una superficie inferior transitable.
SetStepOffset void SetStepOffset(float offset) Altura máxima en metros que el personaje puede subir de forma continua sin necesidad de saltar (ej: escaleras).
Consultas Espaciales

Mei::Physics

Fachada estática para consultas de raycasting sin necesidad de acceder a punteros del sistema de físicas.

Static Facade
static bool Raycast(const glm::vec3& origin, const glm::vec3& direction, float maxDistance, RaycastHit& outHit);

Traza un rayo en la escena activa. Si impacta contra un BoxColliderComponent, SphereColliderComponent o CapsuleColliderComponent, almacena en outHit el punto de impacto exacto en el mundo, la normal de la superficie, la distancia y el puntero al collider.

Módulo Render

Header: <Mei/render/*>
Entorno y Atmósfera

Mei::Skybox

Cúpula de fondo 360° con soporte para cubemaps de 6 caras (GL_TEXTURE_CUBE_MAP) o gradiente hemisférico procedural en tiempo real con control de tintes.

OpenGL 4.6 Zero Depth Leak
Método Firma Descripción
LoadCubemap bool LoadCubemap(const std::vector<std::string>& faces) Carga 6 texturas en orden (+X, -X, +Y, -Y, +Z, -Z) para crear un cubemap completo de alta resolución.
Draw void Draw(const glm::mat4& view, const glm::mat4& proj) Renderiza el cubo unitario eliminando la traslación de la matriz de vista y con glDepthFunc(GL_LEQUAL).
SetProceduralColors void SetProceduralColors(const glm::vec3& top, const glm::vec3& horizon, const glm::vec3& bottom) Configura los 3 colores para el gradiente hemisférico cuando no se utiliza un cubemap estático.
Pipeline Programable

Mei::Shader

Encapsula programas de shader GLSL con caché de localizaciones de uniforms (glGetUniformLocation) para evitar llamadas costosas al driver durante el render loop.

Cached Uniforms Hot-Reloading
Método Firma Descripción
Bind / Unbind void Bind() const; void Unbind() const; Activa el programa en el pipeline de OpenGL vía glUseProgram.
SetMat4 void SetMat4(const std::string& name, const glm::mat4& matrix) Carga una matriz 4x4 consultando la caché interna de hashes de uniforms.
SetVec3 / SetFloat void SetVec3(const std::string& name, const glm::vec3& val); void SetFloat(const std::string& name, float val); Carga vectores y floats directamente en los buffers de la GPU.

Módulo Core & Telemetría

Header: <Mei/core/*>
Telemetría de Rendimiento

Mei::Profiler

Sistema de instrumentación zero-allocation en tiempo real con Ring Buffer estático (120 muestras), cálculo del percentil 99 (1% Lows) y clasificación por categorías.

0 Allocs Hot Path MEI_PROFILE_SCOPE
Método / Macro Firma Descripción
MEI_PROFILE_SCOPE(name, cat) Macro RAII Crea un ScopedTimer que mide el tiempo de ejecución del bloque de código actual mediante std::chrono::steady_clock.
GetFPS float GetFPS() const noexcept Tasa de cuadros por segundo promedio calculada sobre la ventana del buffer circular.
GetOnePercentLowFPS float GetOnePercentLowFPS() const noexcept Métrica crítica de fluidez que mide el percentil 99 de los peores frames (detección precisa de micro-stutters).
GetCategoryTime float GetCategoryTime(ProfileCategory category) const noexcept Tiempo en milisegundos consumido en el último frame por categoría: Physics, Render, Scripts, Audio, etc.
Ejemplo de Instrumentación de Código
void EnemyAI::CalculatePath() {
    MEI_PROFILE_SCOPE("EnemyAI::CalculatePath", Mei::ProfileCategory::Scripts);
    // Algoritmo A* o Raycasts...
}
Entrada de Usuario

Mei::Input

Fachada estática para sondeo directo del teclado, ratón y scroll sin dependencias directas con GLFW en la lógica del juego.

Input Polling
Método Firma Descripción
IsKeyPressed static bool IsKeyPressed(KeyCode key) noexcept Retorna true mientras la tecla especificada (ej: Mei::Key::W) esté presionada.
IsMouseButtonPressed static bool IsMouseButtonPressed(MouseButton button) noexcept Retorna true si el botón del ratón (Left, Right, Middle) está presionado.
GetMousePosition static glm::vec2 GetMousePosition() noexcept Coordenadas absolutas del cursor en la ventana en píxeles.

Módulo Audio & FX

Header: <Mei/audio/*>, <Mei/scene/*>
Audio Espacial 3D

Mei::AudioSourceComponent

Emisor de sonido con posicionamiento tridimensional, atenuación logarítmica y control de volumen y tono impulsado por miniaudio.

miniaudio Audio 3D
Método Firma Descripción
Play / Pause / Stop void Play(); void Pause(); void Stop(); Control de reproducción del clip de audio cargado en el componente.
SetSpatial3D void SetSpatial3D(bool enabled) Activa o desactiva la atenuación y paneo según la posición del AudioListenerComponent de la cámara.
SetVolume / SetPitch void SetVolume(float volume); void SetPitch(float pitch); Ajusta la ganancia lineal [0.0 - 1.0] y la velocidad de reproducción.
Efectos Visuales (FX)

Mei::ParticleSystemComponent

Emisor de partículas con pool pre-asignado en RAM (cero allocaciones en el bucle principal), integración por gravedad, interpolación de color y reciclaje circular.

Zero-Allocation Pool Color Lerp
Método Firma Descripción
SetMaxParticles void SetMaxParticles(uint32_t count) Pre-aloja el buffer estático de partículas. No causa reasignaciones durante el Play Mode.
SetEmissionRate void SetEmissionRate(float rate) Cantidad de partículas emitidas continuamente por segundo.
SetStartEndColors void SetStartColor(const glm::vec4& col); void SetEndColor(const glm::vec4& col); Define el gradiente RGBA interpolado linealmente a lo largo del tiempo de vida de cada partícula.