ascension: comparison src/scene.c

-:d3285aed65b3
+:44457f6cb0a2
 #include "ascension/scene.h"
 #include "ascension/error.h"
 #include "ascension/context.h"
+#include <cx/linked_list.h>
+#include <cx/array_list.h>
 #include <cx/tree.h>
 #include <cx/utils.h>
 #include "ascension/shader.h"
 #include <GL/glew.h>
 offsetof(AscSceneNode, children),
 offsetof(AscSceneNode, next)
 );
 }
-void asc_scene_init(AscScene *scene) {
+struct asc_render_group_entry {
-if (scene->root != NULL) {
+asc_scene_draw_func draw;
-asc_error("Scene is already initialized.");
+AscSceneNode const *node;
-return;
+};
-}
+#define asc_draw_render_group(iter) \
-// zero everything, first
+cx_foreach(struct asc_render_group_entry*, entry, iter) { \
-memset(scene, 0, sizeof(AscScene));
+entry->draw(entry->node); \
+}
-// default viewport is the entire viewport of the active window
-scene->viewport.size = asc_context.active_window->dimensions;
+void asc_scene_draw(AscSceneNode *root, asc_recti viewport, AscCamera *camera) {
+// create render groups
-// create the root node
+CxList *render_group[ASC_RENDER_GROUP_COUNT];
-scene->root = asc_scene_node_empty();
+cx_for_n(i, ASC_RENDER_GROUP_COUNT) {
+render_group[i] = cxArrayListCreateSimple(
-// initialize the render groups
+sizeof(struct asc_render_group_entry), 32);
-cx_array_initialize(scene->rg_sprites_opaque, 8);
+}
-cx_array_initialize(scene->rg_sprites_blended, 8);
-}
-void asc_scene_destroy(AscScene *scene) {
-asc_scene_node_free(scene->root);
-}
-void asc_scene_add(AscScene *scene, AscSceneNode *node) {
-asc_scene_node_link(scene->root, node);
-asc_node_update(node);
-}
-#define asc_scene_draw_render_group(rg) \
-cx_for_n(i, rg##_size) { \
-rg[i].draw(rg[i].node); \
-} (void)0
-#define asc_scene_draw_render_group_reversed(rg) \
-for(size_t i = rg##_size ; i > 0 ; i--) { \
-rg[i-1].draw(rg[i-1].node); \
-} (void)0
-void asc_scene_draw(AscScene *scene) {
-// reset render groups
-// TODO: avoid recalculating the groups, if possible
-scene->rg_sprites_opaque_size = 0;
-scene->rg_sprites_blended_size = 0;
 // skip the root node deliberately, we know it's just the container
-CxTreeVisitor iter = asc_scene_node_visitor(scene->root);
+CxTreeVisitor iter = asc_scene_node_visitor(root);
 cxIteratorNext(iter);
 // update the children and add them to the render groups
 cx_foreach(AscSceneNode*, node, iter) {
 node->depth = iter.depth;
 // execute behaviors, first
-AscBehaviorNode *behavior = node->behaviors;
+if (node->behaviors != NULL) {
-while (behavior) {
+CxIterator behavior_iter = cxListIterator(node->behaviors);
-behavior->func(node);
+cx_foreach(asc_scene_update_func, behavior, behavior_iter) {
-behavior = behavior->next;
+behavior(node);
 }
+}
+// TODO: implement culling
+// TODO: implement a hidden flag (requires UCX tree-continue function)
 // check if geometry needs update
 if (node->need_graphics_update) {
 assert(node->update_func != NULL);
 node->need_graphics_update = false;
 // add to render group
 if (node->draw_func != NULL) {
 struct asc_render_group_entry entry = {
 node->draw_func, node
 };
-switch (node->render_group) {
+cxListAdd(render_group[node->render_group], &entry);
-case ASC_RENDER_GROUP_SPRITE_OPAQUE:
-cx_array_simple_add(scene->rg_sprites_opaque, entry);
-break;
-case ASC_RENDER_GROUP_SPRITE_BLEND:
-cx_array_simple_add(scene->rg_sprites_blended, entry);
-break;
-}
 }
 }
 // set the viewport (in OpenGL we need to invert the Y axis)
 glViewport(
-scene->viewport.pos.x,
+viewport.pos.x,
--scene->viewport.pos.y,
+-viewport.pos.y,
-scene->viewport.size.width,
+viewport.size.width,
-scene->viewport.size.height
+viewport.size.height
 );
-glClear(GL_COLOR_BUFFER_BIT);
+// -------------------------
-// -----------------------------------------
+// process the render groups
-// process the render groups for each camera
+// -------------------------
-// -----------------------------------------
 AscShaderProgram *shader;
-cx_for_n(cam_id, ASC_SCENE_CAMERAS_MAX) {
+CxIterator render_iter;
-// update camera parameters, first
-AscCamera *camera = &scene->cameras[cam_id];
+// 2D Elements
-if (camera->update == NULL) continue;
+// ===========
-camera->update(camera);
+glEnable(GL_DEPTH_TEST);
+glClear(GL_DEPTH_BUFFER_BIT);
-// 2D Elements
-// ===========
+// Sprites
-glEnable(GL_DEPTH_TEST);
+// -------
-glClear(GL_DEPTH_BUFFER_BIT);
+// TODO: implement view matrix for 2D worlds
+shader = &asc_context.active_window->glctx.shader.sprite.base;
-// Sprites
+glUseProgram(shader->id);
-// -------
+glUniformMatrix4fv(shader->projection, 1,
-// TODO: see if we can really always ignore the view matrix
+GL_FALSE, camera->projection);
-shader = &asc_context.active_window->glctx.shader.sprite.base;
-glUseProgram(shader->id);
+// render opaque sprites from front to back
-glUniformMatrix4fv(shader->projection, 1,
+glDisable(GL_BLEND);
-GL_FALSE, camera->projection);
+render_iter = cxListBackwardsIterator(render_group[ASC_RENDER_GROUP_SPRITE_OPAQUE]);
+asc_draw_render_group(render_iter);
-// render opaque sprites from front to back
-glDisable(GL_BLEND);
+// render sprites with alpha value from back to front
-asc_scene_draw_render_group_reversed(scene->rg_sprites_opaque);
+glEnable(GL_BLEND);
-// render sprites with alpha value from back to front
+glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-glEnable(GL_BLEND);
+render_iter = cxListIterator(render_group[ASC_RENDER_GROUP_SPRITE_BLEND]);
-glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+asc_draw_render_group(render_iter);
-asc_scene_draw_render_group(scene->rg_sprites_blended);
+// destroy render groups
+cx_for_n(i, ASC_RENDER_GROUP_COUNT) {
+cxListDestroy(render_group[i]);
 }
 }
 AscSceneNode *asc_scene_node_empty(void) {
 AscSceneNode *node = calloc(1, sizeof(AscSceneNode));
 // free the entire subtree
 CxTreeIterator iter = asc_scene_node_iterator(node, true);
 cx_foreach(AscSceneNode*, child, iter) {
 if (!iter.exiting) continue;
+if (child->behaviors != NULL) {
+cxListDestroy(child->behaviors);
+}
 if (child->free_func != NULL) {
 child->free_func(child);
 } else {
 free(child);
 }
 offsetof(AscSceneNode, prev),
 offsetof(AscSceneNode, next)
 );
 }
-AscBehaviorNode *asc_scene_add_behavior(AscSceneNode *node, asc_scene_update_func behavior) {
+void asc_scene_add_behavior(
-AscBehaviorNode *behavior_node = calloc(1, sizeof(AscBehaviorNode));
+AscSceneNode *node,
-behavior_node->func = behavior;
+asc_scene_update_func behavior
-cx_tree_link(
+) {
-node,
+if (node->behaviors == NULL) {
-behavior_node,
+node->behaviors = cxLinkedListCreateSimple(CX_STORE_POINTERS);
-offsetof(AscBehaviorNode, parent),
+}
-offsetof(AscSceneNode, behaviors),
+cxListAdd(node->behaviors, behavior);
-offsetof(AscBehaviorNode, prev),
+}
-offsetof(AscBehaviorNode, next)
-);
+void asc_scene_remove_behavior(
-return behavior_node;
+AscSceneNode *node,
-}
+asc_scene_update_func behavior
+) {
-void asc_scene_remove_behavior(AscBehaviorNode *node) {
+if (node->behaviors != NULL) {
-cx_tree_unlink(
+cxListFindRemove(node->behaviors, behavior);
-node,
+}
-offsetof(AscBehaviorNode, parent),
-offsetof(AscSceneNode, behaviors),
-offsetof(AscBehaviorNode, prev),
-offsetof(AscBehaviorNode, next)
-);
 }
 void asc_update_transform(AscSceneNode *node) {
 if (node->need_transform_update) return;

Mercurial > hg > ascension / file comparison

comparison: src/scene.c

src/scene.c