tests/test_postprocessing.c - master - Zamar_Terrier/TigorEngine

tests/test_postprocessing.c
243 строки11 KB
Zamar_Terrier
Офигенное обновление движка
31 июл 2026, 21:03
31 июл 2026, 21:031682686
#include <TigorEngine.h>
#include <Core/e_postprocessing.h>
#include <Objects/primitiveObject.h>
#include <Objects/light_object.h>

extern TEngine engine;

static PrimitiveObject cube;
static PostProcessingPipeline pp;

void updateScene(float dt) {
    static float angle = 0.0f;
    angle += dt * 30.0f;
    if (angle > 360.0f) angle -= 360.0f;
    Transform3DSetRotation((GameObject3D*)&cube, angle, angle * 0.5f, angle * 0.3f);

    Camera3DRotationUpdate(&PostProcessingGetRenderTarget(&pp)->cam3D, dt);
}

void drawScene() {
    // Сначала рисуем сцену в offscreen-рендер
    GameObjectDraw((GameObject*)&cube);
    // Затем рисуем полноэкранный квад с пост-обработкой
    GameObjectDraw((GameObject*)PostProcessingGetQuad(&pp));
}

void recreateScene(int width, int height){
    PostProcessingRecreate(&pp, width, height);
}

static void changeExposure(float delta) {
    pp.uniforms.uExposure += delta;
    if (pp.uniforms.uExposure < 0.0f) pp.uniforms.uExposure = 0.0f;
    printf("Exposure: %.2f\n", pp.uniforms.uExposure);
}

static void changeGamma(float delta) {
    pp.uniforms.uGamma += delta;
    if (pp.uniforms.uGamma < 0.1f) pp.uniforms.uGamma = 0.1f;
    printf("Gamma: %.2f\n", pp.uniforms.uGamma);
}

static void changePixelSize(float delta) {
    pp.uniforms.uPixelSize += delta;
    if (pp.uniforms.uPixelSize < 1.0f) pp.uniforms.uPixelSize = 1.0f;
    printf("Pixel Size: %.1f\n", pp.uniforms.uPixelSize);
}

static void changeGrainIntensity(float delta) {
    pp.uniforms.uGrainIntensity += delta;
    if (pp.uniforms.uGrainIntensity < 0.0f) pp.uniforms.uGrainIntensity = 0.0f;
    if (pp.uniforms.uGrainIntensity > 1.0f) pp.uniforms.uGrainIntensity = 1.0f;
    printf("Grain Intensity: %.2f\n", pp.uniforms.uGrainIntensity);
}

static void changeSepiaIntensity(float delta) {
    pp.uniforms.uSepiaIntensity += delta;
    if (pp.uniforms.uSepiaIntensity < 0.0f) pp.uniforms.uSepiaIntensity = 0.0f;
    if (pp.uniforms.uSepiaIntensity > 1.0f) pp.uniforms.uSepiaIntensity = 1.0f;
    printf("Sepia Intensity: %.2f\n", pp.uniforms.uSepiaIntensity);
}

static void changeEdgeThreshold(float delta) {
    pp.uniforms.uEdgeThreshold += delta;
    if (pp.uniforms.uEdgeThreshold < 0.01f) pp.uniforms.uEdgeThreshold = 0.01f;
    if (pp.uniforms.uEdgeThreshold > 0.5f) pp.uniforms.uEdgeThreshold = 0.5f;
    printf("Edge Threshold: %.3f\n", pp.uniforms.uEdgeThreshold);
}

static void changeChromaticAmount(float delta) {
    pp.uniforms.uChromaticAberration += delta;
    if (pp.uniforms.uChromaticAberration < 0.0f) pp.uniforms.uChromaticAberration = 0.0f;
    printf("Chromatic Aberration: %.1f\n", pp.uniforms.uChromaticAberration);
}

void handleInput() {
    // ===== ПЕРЕКЛЮЧЕНИЕ ЭФФЕКТОВ (цифры 1–0, F1, F2) =====
    // 1 – Color Grading
    if (TEngineGetKeyPress(TIGOR_KEY_1)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_COLOR_GRADING);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_COLOR_GRADING, !enabled);
        printf("Color Grading: %s\n", !enabled ? "ON" : "OFF");
    }
    // 2 – Tonemap
    if (TEngineGetKeyPress(TIGOR_KEY_2)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_TONEMAP);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_TONEMAP, !enabled);
        printf("Tonemap: %s\n", !enabled ? "ON" : "OFF");
    }
    // 3 – Blur
    if (TEngineGetKeyPress(TIGOR_KEY_3)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLUR);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLUR, !enabled);
        printf("Blur: %s\n", !enabled ? "ON" : "OFF");
    }
    // 4 – Vignette
    if (TEngineGetKeyPress(TIGOR_KEY_4)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_VIGNETTE);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_VIGNETTE, !enabled);
        printf("Vignette: %s\n", !enabled ? "ON" : "OFF");
    }
    // 5 – Bloom
    if (TEngineGetKeyPress(TIGOR_KEY_5)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLOOM);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLOOM, !enabled);
        printf("Bloom: %s\n", !enabled ? "ON" : "OFF");
    }
    // 6 – Sharpen
    if (TEngineGetKeyPress(TIGOR_KEY_6)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_SHARPEN);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_SHARPEN, !enabled);
        printf("Sharpen: %s\n", !enabled ? "ON" : "OFF");
    }
    // 7 – Pixelate
    if (TEngineGetKeyPress(TIGOR_KEY_7)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_PIXELATE);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_PIXELATE, !enabled);
        printf("Pixelate: %s\n", !enabled ? "ON" : "OFF");
    }
    // 8 – Grain
    if (TEngineGetKeyPress(TIGOR_KEY_8)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAIN);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAIN, !enabled);
        printf("Grain: %s\n", !enabled ? "ON" : "OFF");
    }
    // 9 – Sepia
    if (TEngineGetKeyPress(TIGOR_KEY_9)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_SEPIA);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_SEPIA, !enabled);
        printf("Sepia: %s\n", !enabled ? "ON" : "OFF");
    }
    // 0 – Grayscale
    if (TEngineGetKeyPress(TIGOR_KEY_0)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAYSCALE);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAYSCALE, !enabled);
        printf("Grayscale: %s\n", !enabled ? "ON" : "OFF");
    }
    // F1 – Edge Detection
    if (TEngineGetKeyPress(TIGOR_KEY_F1)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_EDGE);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_EDGE, !enabled);
        printf("Edge Detection: %s\n", !enabled ? "ON" : "OFF");
    }
    // F2 – Chromatic Aberration
    if (TEngineGetKeyPress(TIGOR_KEY_F2)) {
        bool enabled = PostProcessingIsEffectEnabled(&pp, POST_PROCESSING_EFFECT_CHROMATIC);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_CHROMATIC, !enabled);
        printf("Chromatic Aberration: %s\n", !enabled ? "ON" : "OFF");
    }

    // ===== УПРАВЛЕНИЕ ПАРАМЕТРАМИ =====
    // Q / W – Exposure (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_Q)) changeExposure(0.5f);
    if (TEngineGetKeyPress(TIGOR_KEY_W)) changeExposure(-0.5f);

    // E / R – Gamma (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_E)) changeGamma(0.1f);
    if (TEngineGetKeyPress(TIGOR_KEY_R)) changeGamma(-0.1f);

    // T / Y – Pixel Size (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_T)) changePixelSize(1.0f);
    if (TEngineGetKeyPress(TIGOR_KEY_Y)) changePixelSize(-1.0f);

    // U / I – Grain Intensity (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_U)) changeGrainIntensity(0.05f);
    if (TEngineGetKeyPress(TIGOR_KEY_I)) changeGrainIntensity(-0.05f);

    // O / P – Sepia Intensity (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_O)) changeSepiaIntensity(0.1f);
    if (TEngineGetKeyPress(TIGOR_KEY_P)) changeSepiaIntensity(-0.1f);

    // A / S – Edge Threshold (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_A)) changeEdgeThreshold(0.01f);
    if (TEngineGetKeyPress(TIGOR_KEY_S)) changeEdgeThreshold(-0.01f);

    // D / F – Chromatic Amount (+/-)
    if (TEngineGetKeyPress(TIGOR_KEY_D)) changeChromaticAmount(0.5f);
    if (TEngineGetKeyPress(TIGOR_KEY_F)) changeChromaticAmount(-0.5f);

    // ===== ВСЕ ЭФФЕКТЫ ON/OFF =====
    if (TEngineGetKeyPress(TIGOR_KEY_LEFT_SHIFT) && TEngineGetKeyPress(TIGOR_KEY_9)) {
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_COLOR_GRADING, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_TONEMAP, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLUR, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_VIGNETTE, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLOOM, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_SHARPEN, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_PIXELATE, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAIN, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_SEPIA, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAYSCALE, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_EDGE, true);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_CHROMATIC, true);
        printf("All effects ON\n");
    }
    if (TEngineGetKeyPress(TIGOR_KEY_LEFT_SHIFT) && TEngineGetKeyPress(TIGOR_KEY_0)) {
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_COLOR_GRADING, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_TONEMAP, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLUR, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_VIGNETTE, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_BLOOM, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_SHARPEN, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_PIXELATE, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAIN, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_SEPIA, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_GRAYSCALE, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_EDGE, false);
        PostProcessingSetEffectEnabled(&pp, POST_PROCESSING_EFFECT_CHROMATIC, false);
        printf("All effects OFF\n");
    }
}

int main() {
    TEngineInitSystem(800, 600, "PostProcessing Demo");

    // Устанавливаем колбэки
    TEngineSetUpdater(updateScene);
    TEngineSetDrawer(drawScene);
    TEngineSetKeyCallback(handleInput);
    TEngineSetRecreateFunc(recreateScene);

    // Создаём пост-обработку
    PostProcessingCreate(&pp, engine.width, engine.height);

    // Создаём куб и настраиваем его рендер в offscreen
    DrawParam dParam = {0};
    PrimitiveObjectInit(&cube, &dParam, TIGOR_PRIMITIVE3D_CUBE, NULL);
    Transform3DSetPosition((GameObject3D*)&cube, 0.0f, 0.0f, -7.0f);
    Transform3DSetScale((GameObject3D*)&cube, 2.0f, 2.0f, 2.0f);

    // Устанавливаем, что куб рендерится в offscreen-рендер пайплайна
    GameObject3DSetRender((GameObject3D*)&cube, PostProcessingGetRenderTarget(&pp));

    // Регистрируем offscreen-рендер в движке (чтобы он обрабатывался)
    TEngineSetRender(PostProcessingGetRenderTarget(&pp), 1);

    TEngineStartRender();

    PostProcessingDestroy(&pp);
    GameObjectDestroy((GameObject*)&cube);
    TEngineCleanUp();
    return 0;
}