Mercurial > hg > ascension / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright 2023 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "ascension/scene.h"

#include "ascension/context.h"

#include "ascension/2d.h"

#include <cx/tree.h>
#include <cx/linked_list.h>
#include <cx/array_list.h>
#include <cx/utils.h>

#include <GL/glew.h>

#include <assert.h>

void asc_scene_init(AscScene *scene) {
    asc_dprintf("Initialized scene %"PRIxPTR, (uintptr_t) scene);
    // TODO: how should we initialize the camera?
    scene->root = asc_scene_node_empty();
}

void asc_scene_destroy(AscScene *scene) {
    asc_dprintf("Destroyed scene %"PRIxPTR, (uintptr_t) scene);
    asc_scene_node_free(scene->root);
}

void asc_scene_draw(AscScene *scene, asc_recti viewport) {
    // create render groups
    CxList *render_group[ASC_RENDER_GROUP_COUNT];
    cx_for_n(i, ASC_RENDER_GROUP_COUNT) {
        render_group[i] = cxArrayListCreateSimple(CX_STORE_POINTERS, 32);
    }

    // skip the root node deliberately; we know it's just the container
    CxTreeVisitor iter = cx_tree_visitor(scene->root,
            offsetof(AscSceneNode, children),
            offsetof(AscSceneNode, next)
    );
    cxIteratorNext(iter);

    // update the children and add them to the render groups
    cx_foreach(AscSceneNode*, node, iter) {
        node->depth = iter.depth;

        // skip hidden nodes (and all their children)
        if (asc_test_flag(node->flags, ASC_SCENE_NODE_HIDDEN)) {
            cxTreeVisitorContinue(iter);
        }

        // execute behaviors, first
        if (node->behaviors != NULL) {
            CxIterator behavior_iter = cxListIterator(node->behaviors);
            cx_foreach(asc_scene_update_func, behavior, behavior_iter) {
                behavior(node);
            }
        }

        // TODO: implement culling

        // check if geometry needs update
        asc_clear_flag(node->flags,
                       ASC_SCENE_NODE_GRAPHICS_UPDATED
                       | ASC_SCENE_NODE_TRANSFORM_UPDATED);
        if (asc_test_flag(node->flags, ASC_SCENE_NODE_UPDATE_GRAPHICS)) {
            asc_set_flag(node->flags, ASC_SCENE_NODE_GRAPHICS_UPDATED);
            asc_clear_flag(node->flags, ASC_SCENE_NODE_UPDATE_GRAPHICS);
            assert(node->update_func != NULL);
            node->update_func(node);
        }
        if (asc_test_flag(node->flags, ASC_SCENE_NODE_UPDATE_TRANSFORM)) {
            asc_set_flag(node->flags, ASC_SCENE_NODE_TRANSFORM_UPDATED);
            asc_clear_flag(node->flags, ASC_SCENE_NODE_UPDATE_TRANSFORM);
            asc_transform_from_parts(
                    node->transform,
                    node->position,
                    node->scale,
                    node->rotation
            );
            asc_mat4f_mulst(
                    node->world_transform,
                    node->transform,
                    node->parent->world_transform
            );
        }

        // add to render group
        if (node->render_group >= 0) {
            cxListAdd(render_group[node->render_group], node);
        }
    }

    // set the viewport (in OpenGL we need to invert the Y axis)
    glViewport(
            viewport.pos.x,
            -viewport.pos.y,
            viewport.size.width,
            viewport.size.height
    );

    // -------------------------
    // process the render groups
    // -------------------------
    CxIterator render_iter;

    // 2D Elements
    // ===========
    glEnable(GL_DEPTH_TEST);
    glClear(GL_DEPTH_BUFFER_BIT);

    // Sprites
    // -------
    size_t sprite_count = cxListSize(render_group[ASC_RENDER_GROUP_SPRITE_OPAQUE])
        + cxListSize(render_group[ASC_RENDER_GROUP_SPRITE_BLEND]);
    if (sprite_count > 0) {
        AscShaderProgram *shader = &ASC_SHADER_SPRITE->program;
        glUseProgram(shader->id);
        glUniformMatrix4fv(shader->projection, 1,
                           GL_FALSE, scene->camera.projection);
        glUniformMatrix4fv(shader->view, 1,
                               GL_FALSE, scene->camera.view);

        // render opaque sprites from front to back
        glDisable(GL_BLEND);
        render_iter = cxListBackwardsIterator(render_group[ASC_RENDER_GROUP_SPRITE_OPAQUE]);
        cx_foreach(AscSprite const *, node, render_iter) {
            asc_sprite_draw(node);
        }

        // render sprites with alpha value from back to front
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        render_iter = cxListIterator(render_group[ASC_RENDER_GROUP_SPRITE_BLEND]);
        cx_foreach(AscSprite const *, node, render_iter) {
            asc_sprite_draw(node);
        }
    }

    // deallocate render groups
    cx_for_n(i, ASC_RENDER_GROUP_COUNT) {
        cxListFree(render_group[i]);
    }
}

void asc_scene_add_node(AscScene *scene, AscSceneNode *node) {
    asc_scene_node_link(scene->root, node);
}

void asc_scene_remove_node(AscSceneNode *node) {
    asc_scene_node_unlink(node);
}