src/scene.c - master - Zamar_Terrier/TEngineEditor

src/scene.c
244 строки9 KB
Zamar_Terrier
checkpoint
23 июл 2026, 18:41
23 июл 2026, 18:4110276a6
#include "scene.h"
#include "object.h"
#include "render_window.h"
#include "tool_bar.h"

#include <TigorEngine.h>
#include <Objects/gameObject2D.h>
#include <Objects/shape_object.h>
#include <Objects/render_texture.h>
#include <Objects/primitiveObject.h>
#include <stdlib.h>
#include <string.h>

// Глобальный буфер сцены
extern RenderTexture scene_buffer;

// Глобальная сцена - не static, чтобы быть доступной из других модулей
Scene global_scene;

void SceneInit(){
    SObjSceneInit(&global_scene);
    
    // Создание начальных объектов
    SceneAddObjectInternal(&global_scene, "default_cube", OBJECT_TYPE_3D_CUBE);
    SceneAddObjectInternal(&global_scene, "default_quad", OBJECT_TYPE_2D_QUAD);
}

void SceneUpdate(float dTime){
    SObjSceneUpdate(&global_scene, dTime);
}

void SceneDraw(){
    SObjSceneDraw(&global_scene);
}

void SceneCleanUp(){
    SObjSceneCleanUp(&global_scene);
}

// Инициализация сцены
void SceneInitSceneInternal(Scene* scene){
    if (!scene) return;
    
    SObjSceneInit(scene);
}

// Очистка сцены
void SceneCleanUpSceneInternal(Scene* scene){
    if (!scene) return;
    
    SObjSceneCleanUp(scene);
}

// Добавление объекта
SceneObject* SceneAddObjectInternal(Scene* scene, const char* name, ObjectType type){
    if (!scene) return NULL;
    
    SceneObject* object = SceneObjectCreate(name, type);
    if (!object) return NULL;
    
    // Инициализация ресурсов движка
    if (type == OBJECT_TYPE_2D_QUAD) {
        ShapeObject* shape = (ShapeObject*)malloc(sizeof(ShapeObject));
        if (shape) {
            ShapeObject* shape = (ShapeObject*)malloc(sizeof(ShapeObject));
            if (shape) {
                ShapeObjectInit(shape, NULL, TIGOR_SHAPE_OBJECT_QUAD, NULL);
                Transform2DSetScale((GameObject2D*)shape, 100, 100);
                Transform2DSetPosition((GameObject2D*)shape, 100, 100); // центр текстуры 800x600
                GameObject2DSetRender((GameObject2D*)shape, &scene_buffer);
                object->render_object.shape = shape;
                // Синхронизация transform.position
                vec2 pos2d = Transform2DGetPosition((GameObject2D*)shape);
                object->transform.position = vec3_f(pos2d.x, pos2d.y, 0);
                vec2 scale2d = Transform2DGetScale((GameObject2D*)shape);
                object->transform.scale = vec3_f(scale2d.x, scale2d.y, 1);
            }
        }
    } else {
        PrimitiveObject* primitive = (PrimitiveObject*)malloc(sizeof(PrimitiveObject));
        if (primitive) {
            int prim_type = TIGOR_PRIMITIVE3D_CUBE;
            if (type == OBJECT_TYPE_3D_SPHERE) prim_type = TIGOR_PRIMITIVE3D_SPHERE;
            else if (type == OBJECT_TYPE_3D_PLANE) prim_type = TIGOR_PRIMITIVE3D_PLANE;
            else if (type == OBJECT_TYPE_3D_CYLINDER) prim_type = TIGOR_PRIMITIVE3D_CYLINDER;
            else if (type == OBJECT_TYPE_3D_CONE) prim_type = TIGOR_PRIMITIVE3D_CONE;
            else if (type == OBJECT_TYPE_3D_CAPSULE) prim_type = TIGOR_PRIMITIVE3D_CAPSULE;
            
            // Инициализация примитива с параметрами
            // Примитивы уже имеют инициализированные параметры в SceneObjectCreate
            if (type == OBJECT_TYPE_3D_SPHERE) {
                PrimitiveObjectInit(primitive, NULL, prim_type, &object->primitiveParams->sphere);
            } else if (type == OBJECT_TYPE_3D_CONE) {
                PrimitiveObjectInit(primitive, NULL, prim_type, &object->primitiveParams->cone);
            } else if (type == OBJECT_TYPE_3D_CYLINDER) {
                PrimitiveObjectInit(primitive, NULL, prim_type, &object->primitiveParams->cylinder);
            } else if (type == OBJECT_TYPE_3D_CAPSULE) {
                PrimitiveObjectInit(primitive, NULL, prim_type, &object->primitiveParams->capsule);
            } else if (type == OBJECT_TYPE_3D_CUBE) {
                PrimitiveObjectInit(primitive, NULL, prim_type, NULL);
            }
            
            Transform3DSetPosition((GameObject3D*)primitive, 0, 0, -5);
            GameObject3DSetRender((GameObject3D*)primitive, &scene_buffer);
            object->render_object.primitive = primitive;
        }
    }
    
    // Добавление в список
    object->next = scene->first_object;
    if (scene->first_object) {
        scene->first_object->prev = object;
    }
    object->prev = NULL;
    scene->first_object = object;
    scene->object_count++;
    
    SceneObjectUpdatePrimitiveParams(object);

    return object;
}

// Удаление объекта
void SceneRemoveObjectInternal(Scene* scene, SceneObject* object){
    if (!scene || !object) return;
    
    // Очистка ресурсов движка
    if (object->type == OBJECT_TYPE_2D_QUAD && object->render_object.shape) {
        GameObjectDestroy((GameObject*)object->render_object.shape);
        free(object->render_object.shape);
    } else if (object->type != OBJECT_TYPE_2D_QUAD && object->render_object.primitive) {
        GameObjectDestroy((GameObject*)object->render_object.primitive);
        free(object->render_object.primitive);
    }
    
    // Очистка параметров примитива
    if (object->primitiveParams) {
        free(object->primitiveParams);
        object->primitiveParams = NULL;
    }
    
    // Обновление связей списка
    if (object->prev) {
        object->prev->next = object->next;
    } else {
        scene->first_object = object->next;
    }
    
    if (object->next) {
        object->next->prev = object->prev;
    }
    
    // Если удаленный объект был выбран, сброс выделения
    if (scene->selected_object == object) {
        scene->selected_object = NULL;
    }
    
    free(object);
    scene->object_count--;
}

// Получение выбранного объекта
SceneObject* SceneGetSelectedObjectInternal(Scene* scene){
    if (!scene) return NULL;
    return scene->selected_object;
}

// Выделение объекта
void SceneSelectObjectInternal(Scene* scene, SceneObject* object){
    if (!scene) return;
    scene->selected_object = object;
    
    // Вызвать обновление UI
    ToolBarUpdateSelectedObject(object);
}

// Обновление сцены
void SceneUpdateSceneInternal(Scene* scene, float dTime){
    if (!scene) return;
    
    SceneObject* current = scene->first_object;
    while (current) {
        // Обновление трансформации
        Transform* transform = SceneObjectGetTransform(current);
        if (transform) {
            SceneObjectUpdateTransform(current, transform);
        }
        current = current->next;
    }
}

// Отрисовка сцены
void SceneDrawSceneInternal(Scene* scene){
    if (!scene) return;
    
    SceneObject* current = scene->first_object;
    while (current) {
        if (current->type == OBJECT_TYPE_2D_QUAD && current->render_object.shape) {
            GameObjectDraw((GameObject*)current->render_object.shape);
        } else if (current->type != OBJECT_TYPE_2D_QUAD && current->render_object.primitive) {
            GameObjectDraw((GameObject*)current->render_object.primitive);
        }
        current = current->next;
    }
}

// Создание примитива на сцене
SceneObject* SceneCreatePrimitive(Scene* scene, const char* name, ObjectType type, vec3* position, vec3* scale){
    SceneObject* object = SceneAddObjectInternal(scene, name, type);
    if (!object) return NULL;
    
    // Настройка начальной трансформации
    if (position) {
        object->transform.position = *position;
    } else {
        object->transform.position = vec3_f(0, 0, 0);
    }
    
    if (scale) {
        object->transform.scale = *scale;
    } else {
        object->transform.scale = vec3_f(1, 1, 1);
    }
    
    // Обновление трансформации в движке
    SceneObjectUpdateTransform(object, &object->transform);
    
    return object;
}

// Удаление объекта
void SceneRemoveObject(Scene* scene, SceneObject* object){
    SceneRemoveObjectInternal(scene, object);
}

// Выделение объекта
void SceneSelectObject(Scene* scene, SceneObject* object){
    SceneSelectObjectInternal(scene, object);
}

// Получение выбранного объекта
SceneObject* SceneGetSelectedObject(Scene* scene){
    return SceneGetSelectedObjectInternal(scene);
}