handle blending modes and refactor

12 files changed, 219 insertions, 124 deletions

diff --git a/src/objects/c b/src/objects/c
deleted file mode 100644
index 8b13789..0000000
--- a/src/objects/c
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/src/objects/effect.c b/src/objects/effect.c
index 1bc0726..cb37281 100644
--- a/src/objects/effect.c
+++ b/src/objects/effect.c
@@ -5,6 +5,8 @@
 #include "../log.h"
 
 #include "cglm/mat4.h"
+#include "moro_str.h"
+#include "moro_vec.h"
 #include "src/objects/pass.h"
 #include "src/objects/types.h"
 #include <jansson.h>
@@ -14,6 +16,8 @@ void mri_effect_parse(mri_effect *effect, json_t *root) {
   mvec_init(effect->passes0);
   mvec_init(effect->passes1);
 
+  json_get_int(&effect->id, root, "id");
+
   json_t *pass0;
   json_t *passes0 = json_object_get(root, "passes");
   json_array(pass0, passes0) {
@@ -36,6 +40,18 @@ void mri_effect_parse(mri_effect *effect, json_t *root) {
     json_array(pass1, passes1) {
       mri_pass_parse(mvec_next(effect->passes1), pass1, EFFECT1_PASS);
     }
+
+    mvec_init(effect->fbos);
+
+    json_t *fbo;
+    json_t *fbos = json_object_get(_root, "fbos");
+    json_array(fbo, fbos) {
+      mri_effect_buffer buffer = {
+        .name = mstr_from(json_string_value(json_object_get(fbo, "name"))),
+        .scale = json_number_value(json_object_get(fbo, "scale"))
+      };
+      mvec_push(effect->fbos, buffer);
+    }
   }
 }
 
@@ -46,19 +62,35 @@ mri_render_pass *mri_effect_next_pass(mri_effect *effect) {
   return pass;
 }
 
-void mri_effect_load(mri_engine *engine, mri_effect *effect) {
+void mri_effect_load(mri_engine *engine, mri_effect *effect, bool last_effect) {
+  mri_effect_buffer *buffer;
+  mvec_loop_ptr(effect->fbos, buffer, i) {
+    mri_object *object = engine->current_object;
+
+    mstr *effect_buffer_id = mstr_sprintf("%i_%i", effect->id, object->id);
+    mstr_cat(buffer->name, effect_buffer_id);
+    mstr_free(effect_buffer_id);
+
+    mri_engine_get_or_new_framebuffer(engine, buffer->name,
+      object->size[0],  object->size[1], buffer->scale);
+  }
+
   for (unsigned int i = 0; i < mvec_size(effect->passes0); i++) {
     mri_render_pass *pass = mri_effect_next_pass(effect);
 
-    if (i == mvec_size(effect->passes0) - 1) {
-      pass->combine = true;
-    }
-
     pass->object = engine->current_object;
-    pass->gl_object = &engine->default_gl_object;
+    pass->effect = effect;
 
-    glm_mat4_identity(pass->model);
+    pass->combine = (i == mvec_size(effect->passes0) - 1) && last_effect;
 
+    if (pass->combine) {
+      pass->gl_object = &engine->current_object->gl_object;
+      glm_mat4_copy(engine->current_object->model, pass->model);
+    } else {
+      pass->gl_object = &engine->default_gl_object;
+      glm_mat4_identity(pass->model);
+    }
+    
     mri_pass_load(engine, mvec_at(effect->passes0, i), EFFECT0_PASS, pass);
     mri_pass_load(engine, mvec_at(effect->passes1, i), EFFECT1_PASS, pass);
   }
@@ -67,8 +99,8 @@ void mri_effect_load(mri_engine *engine, mri_effect *effect) {
 void mri_effect_draw(mri_engine *engine, mri_effect *effect) {
   mri_render_pass *pass;
   mvec_loop_ptr(effect->passes, pass, i) {
-    log_debug("effect (%.*s): %.*s %i", pass->object->name->len, pass->object->name->ptr,
-      effect->name->len, effect->name->ptr, i + 1);
+    //log_debug("effect (%.*s): %.*s %i", pass->object->name->len, pass->object->name->ptr,
+    //  effect->name->len, effect->name->ptr, i + 1);
     mri_render_pass_draw(engine, pass);
   }
 }
@@ -88,4 +120,12 @@ void mri_effect_unload(mri_effect *effect) {
 
   mvec_free(effect->passes0);
   mvec_free(effect->passes1);
+
+  mri_effect_buffer *buffer;
+  mvec_loop_ptr(effect->fbos, buffer, i) {
+    if (buffer->name)
+      mstr_free(buffer->name);
+  }
+
+  mvec_free(effect->fbos);
 }
diff --git a/src/objects/effect.h b/src/objects/effect.h
index 9570fde..374a39f 100644
--- a/src/objects/effect.h
+++ b/src/objects/effect.h
@@ -6,16 +6,24 @@
 #include "types.h"
 #include "pass.h"
 
+typedef struct {
+  mstr *name;
+  float scale;
+} mri_effect_buffer;
+
 struct mri_effect {
   mstr *name;
+  int id;
 
   mvec(mri_pass) passes0;
   mvec(mri_pass) passes1;
   mvec(mri_render_pass) passes;
+
+  mvec(mri_effect_buffer) fbos;
 };
 
 void mri_effect_parse(mri_effect *effect, json_t *root);
-void mri_effect_load(mri_engine *engine, mri_effect *effect);
+void mri_effect_load(mri_engine *engine, mri_effect *effect, bool last_effect);
 void mri_effect_draw(mri_engine *engine, mri_effect *effect);
 void mri_effect_unload(mri_effect *effect);
 
diff --git a/src/objects/material.c b/src/objects/material.c
index c340463..75422d1 100644
--- a/src/objects/material.c
+++ b/src/objects/material.c
@@ -39,7 +39,7 @@ mri_render_pass *mri_material_next_pass(mri_material *material) {
 }
 
 void mri_material_load(mri_engine *engine, mri_material *material, mri_material_type t,
-  mri_render_pass *pass) {
+  mri_render_pass *pass, bool no_effects) {
   mri_pass *pass0;
   mvec_loop_ptr(material->passes0, pass0, i) {
     switch (t) {
@@ -50,15 +50,20 @@ void mri_material_load(mri_engine *engine, mri_material *material, mri_material_
       pass = mri_material_next_pass(material);
 
       pass->object = engine->current_object;
+      pass->combine = no_effects;
 
-      if (engine->current_object->passthrough) {
-        pass->gl_object = &engine->current_object->gl_object;
+      if (engine->current_object->passthrough || no_effects) {
         glm_mat4_copy(engine->current_object->model, pass->model);
       } else {
-        pass->gl_object = &engine->current_object->gl_uv_object;
         glm_mat4_copy(engine->current_object->ortho, pass->model);
       }
 
+      if (engine->current_object->passthrough) {
+        pass->gl_object = &engine->current_object->gl_object;
+      } else {
+        pass->gl_object = &engine->current_object->gl_uv_object;
+      }
+        
       mri_pass_load(engine, pass0, MATERIAL_ONLY_PASS, pass);
       break;
     }
diff --git a/src/objects/material.h b/src/objects/material.h
index 5c8f7b5..e8bc13d 100644
--- a/src/objects/material.h
+++ b/src/objects/material.h
@@ -17,7 +17,8 @@ struct mri_material {
 };
 
 void mri_material_parse(mri_material *material, json_t *value);
-void mri_material_load(mri_engine *engine, mri_material *material, mri_material_type t, mri_render_pass *pass);
+void mri_material_load(mri_engine *engine, mri_material *material, mri_material_type t, mri_render_pass *pass,
+  bool no_effects);
 void mri_material_draw(mri_engine *engine, mri_material *material);
 void mri_material_unload(mri_material *material);
 
diff --git a/src/objects/model.c b/src/objects/model.c
index 81cd0b0..45317f2 100644
--- a/src/objects/model.c
+++ b/src/objects/model.c
@@ -30,8 +30,8 @@ void mri_model_parse(mri_model *model, json_t *value) {
   }
 }
 
-void mri_model_load(mri_engine *engine, mri_model *model) {
-  mri_material_load(engine, &model->material, MATERIAL_MODEL, NULL);
+void mri_model_load(mri_engine *engine, mri_model *model, bool no_effects) {
+  mri_material_load(engine, &model->material, MATERIAL_MODEL, NULL, no_effects);
 }
 
 void mri_model_draw(mri_engine *engine, mri_model *model) {
diff --git a/src/objects/model.h b/src/objects/model.h
index 4d17c72..9daed21 100644
--- a/src/objects/model.h
+++ b/src/objects/model.h
@@ -15,7 +15,7 @@ struct mri_model {
 };
 
 void mri_model_parse(mri_model *model, json_t *value);
-void mri_model_load(mri_engine *engine, mri_model *model);
+void mri_model_load(mri_engine *engine, mri_model *model, bool no_effects);
 void mri_model_draw(mri_engine *engine, mri_model *model);
 void mri_model_unload(mri_model *model);
 
diff --git a/src/objects/object.c b/src/objects/object.c
index d525d3a..6a67bea 100644
--- a/src/objects/object.c
+++ b/src/objects/object.c
@@ -84,22 +84,17 @@ void mri_object_load(mri_engine *engine, mri_object *object) {
   float width = object->size[0];
   float height = object->size[1];
 
-  // mstr_sprintf
-  char *abuffer, *bbuffer;
-
-  asprintf(&abuffer, "_rt_imageLayerComposite_%i_a", object->id);
-  asprintf(&bbuffer, "_rt_imageLayerComposite_%i_b", object->id);
+  mstr *abuffer = mstr_sprintf("_rt_imageLayerComposite_%i_a", object->id);
+  mstr *bbuffer = mstr_sprintf("_rt_imageLayerComposite_%i_b", object->id);
 
   object->abuffer = mri_engine_get_or_new_framebuffer(engine,
-    mstr_c(abuffer), width, height, 1.f,
-    engine->scene->clear_color);
+    abuffer, width, height, 1.f);
 
   object->bbuffer = mri_engine_get_or_new_framebuffer(engine,
-    mstr_c(bbuffer), width, height, 1.f,
-    engine->scene->clear_color);
+    bbuffer, width, height, 1.f);
 
-  free(abuffer);
-  free(bbuffer);
+  mstr_free(abuffer);
+  mstr_free(bbuffer);
 
   object->buffer_switch = false;
 
@@ -115,7 +110,7 @@ void mri_object_load(mri_engine *engine, mri_object *object) {
   create_gl_object(&engine->current_object->gl_object,
     OBJECT, width, height);
 
-  mri_model_load(engine, &object->image);
+  mri_model_load(engine, &object->image, mvec_size(object->effects) == 0);
 
   if (object->image.fullscreen) {
     object->fullscreen = true;
@@ -131,23 +126,20 @@ void mri_object_load(mri_engine *engine, mri_object *object) {
 
   mri_effect *effect;
   mvec_loop_ptr(object->effects, effect, i) {
-    mri_effect_load(engine, effect);
+    mri_effect_load(engine, effect, i == (mvec_size(object->effects) - 1));
   }
 }
 
-static void center_scale(float w0, float h0, float w1, float h1) {
-  float w_scale = w1 / w0;
-  float h_scale = h1 / h0;
-
-  float scale = (w_scale > h_scale) ? w_scale : h_scale;
-
-  float width = w0 * scale;
-  float height = h0 * scale;
+void mri_object_switch_buffer(mri_object *object) {
+  object->buffer_switch = !object->buffer_switch;
+}
 
-  float wpad = (width - w1) / -2.f;
-  float hpad = (height - h1) / -2.f;
+mri_framebuffer *mri_object_get_target_buffer(mri_object *object) {
+  return (object->buffer_switch) ? object->abuffer : object->bbuffer;
+}
 
-  glViewport(wpad, hpad, width, height);
+mri_texture *mri_object_get_texture_buffer(mri_object *object) {
+  return &((object->buffer_switch) ? object->bbuffer : object->abuffer)->texture;
 }
 
 void mri_object_draw(mri_engine *engine, mri_object *object) {
@@ -157,25 +149,6 @@ void mri_object_draw(mri_engine *engine, mri_object *object) {
   mvec_loop_ptr(object->effects, effect, i) {
     mri_effect_draw(engine, effect);
   }
-
-  mri_framebuffer_bind(engine->combine_buffer, false);
-
-  if (object->buffer_switch) {
-    mri_texture_bind(&object->bbuffer->texture, 0);
-  } else {
-    mri_texture_bind(&object->abuffer->texture, 0);
-  }
-
-  mri_shader_bind(engine, &engine->mininal_shader, object->model);
-
-  bind_gl_object(&object->gl_object);
-
-  center_scale(engine->width, engine->height, engine->context->width, engine->context->height);
-
-  glDrawArrays(GL_TRIANGLES, 0, 6);
-
-
-  //log_debug("combine (%.*s)", object->name->len, object->name->ptr);
 }
 
 void mri_object_unload(mri_object *object) {
diff --git a/src/objects/object.h b/src/objects/object.h
index c7bb883..6431237 100644
--- a/src/objects/object.h
+++ b/src/objects/object.h
@@ -62,6 +62,10 @@ struct mri_object {
 
 void mri_object_get_model(mri_object *object, mat4 model, float width, float height);
 
+void mri_object_switch_buffer(mri_object *object);
+mri_framebuffer *mri_object_get_target_buffer(mri_object *object);
+mri_texture *mri_object_get_texture_buffer(mri_object *object);
+
 void mri_object_parse(mri_object *object, json_t *root);
 void mri_object_load(mri_engine *engine, mri_object *object);
 void mri_object_draw(mri_engine *engine, mri_object *object);
diff --git a/src/objects/pass.c b/src/objects/pass.c
index e5604e6..4820065 100644
--- a/src/objects/pass.c
+++ b/src/objects/pass.c
@@ -2,6 +2,7 @@
 #include <unistd.h>
 
 #include "moro_str.h"
+#include "moro_vec.h"
 #include "pass.h"
 #include "material.h"
 #include "model.h"
@@ -13,8 +14,8 @@
 #include "../engine.h"
 #include "../assets.h"
 #include "../gl.h"
-#include "src/objects/types.h"
-#include "src/shader.h"
+#include "../objects/types.h"
+#include "../shader.h"
 
 void mri_pass_parse(mri_pass *pass, json_t *root, mri_pass_stage stage) {
   memset(pass, 0, sizeof(mri_pass));
@@ -76,6 +77,16 @@ void mri_pass_parse(mri_pass *pass, json_t *root, mri_pass_stage stage) {
         pass->shader = (mri_shader *)calloc(1, sizeof(mri_shader));
         mri_shader_load(pass->shader, mstr_c(json_string_value(shader)));
       }
+
+      json_t *blend = json_object_get(root, "blending");
+      if (json_is_string(blend)) {
+        if (mstr_eq(mstr_c(json_string_value(blend)), mstr_c("normal"))) {
+          pass->blend = NORMAL;
+        } else if (mstr_eq(mstr_c(json_string_value(blend)), mstr_c("translucent"))) {
+          pass->blend = TRANSLUCENT;
+        }
+      }
+
       break;
     }
   }
@@ -119,7 +130,7 @@ void mri_pass_parse(mri_pass *pass, json_t *root, mri_pass_stage stage) {
 void mri_pass_load(mri_engine *engine, mri_pass *pass, mri_pass_stage stage, mri_render_pass *rpass) {
   mri_object *object = engine->current_object;
 
-  for (int i = 1; i < 7; i++) {
+  for (int i = 0; i < 7; i++) {
     if (pass->textures[i]) rpass->textures[i] = pass->textures[i];
   }
 
@@ -138,57 +149,59 @@ void mri_pass_load(mri_engine *engine, mri_pass *pass, mri_pass_stage stage, mri
     }
     case EFFECT1_PASS:
       // If there is an explicit target framebuffer, set it.
-      if (pass->target) {
-        rpass->target = mri_engine_get_or_new_framebuffer(engine,
-          pass->target, engine->width, engine->height, 2.f,
-          (vec4){0.f, 0.f, 0.f, 0.4f});
-      } else {
-        // If no target was specified pick the next buffer in the
-        // alternating AB buffers.
-        if (object->buffer_switch) {
-          rpass->target = object->abuffer;
-          rpass->textures[0] = &object->bbuffer->texture;
+      if (!pass->target) {
+        if (rpass->combine) {
+          rpass->target = engine->combine_buffer;
         } else {
-          rpass->target = object->bbuffer;
-          rpass->textures[0] = &object->abuffer->texture;
+          // If no target was specified pick the next buffer in the
+          // alternating AB buffers.
+          rpass->target = mri_object_get_target_buffer(object);
         }
+        rpass->textures[0] = mri_object_get_texture_buffer(object);
+      } else {
+        mstr *effect_buffer_id = mstr_sprintf("%i_%i", rpass->effect->id, rpass->object->id);
+        mstr_cat(pass->target, effect_buffer_id);
+        mstr_free(effect_buffer_id);
+
+        rpass->target = mri_engine_get_framebuffer(engine, pass->target);
       }
+
       for (int i = 0; i < 7; i++) {
         if (!pass->binds[i]) continue;
         // If there are explicit binds given for this pass, set them.
         if (mstr_eq(pass->binds[i], mstr_c("previous"))) {
-          if (object->buffer_switch) {
-            rpass->textures[i] = &object->bbuffer->texture;
-          } else {
-            rpass->textures[i] = &object->abuffer->texture;
-          }
+          rpass->textures[i] = mri_object_get_texture_buffer(object);
         } else {
+          mstr *effect_buffer_id = mstr_sprintf("%i_%i", rpass->effect->id, rpass->object->id);
+          mstr_cat(pass->binds[i], effect_buffer_id);
+          mstr_free(effect_buffer_id);
+
           rpass->textures[i] = &mri_engine_get_framebuffer(engine, pass->binds[i])->texture;
         }
       }
-      // If we selected one of the AB buffers, switch the flag after
+
+      // If we selected one of the AB buffers, switch the flag _after_
       // setting binds to keep the ordering correct.
-      if (!pass->target) 
-        object->buffer_switch = !object->buffer_switch;
-      mri_material_load(engine, pass->material, MATERIAL_EFFECT, rpass);
+      if (!pass->target) mri_object_switch_buffer(object);
+
+      // EFFECT1 passes has the material with the final draw passes.
+      mri_material_load(engine, pass->material, MATERIAL_EFFECT, rpass, false);
       break;
-    case MATERIAL_ONLY_PASS:
-      // This object has no effects so Texture0 is an image and draw on the A buffer.
-      rpass->target = object->abuffer;
-      rpass->textures[0] = pass->textures[0];
+    case MATERIAL_ONLY_PASS: 
+      // There is no EFFECT1 pass before this to set the target, so set it here.
+      if (rpass->combine) {
+        rpass->target = engine->combine_buffer;
+      } else {
+        rpass->target = mri_object_get_target_buffer(object);
+        mri_object_switch_buffer(object);
+      }
+      rpass->combine_blend = pass->blend;
+      __attribute__ ((fallthrough));
     case MATERIAL_PASS: {
-      memcpy(&rpass->shader, pass->shader, sizeof(mri_shader));
+      rpass->shader = *pass->shader;
 
-      // mvec_clone
-      mvec_ptr(rpass->shader.uniforms) = (mri_uniform *)malloc(
-        sizeof(mri_uniform) * mvec_alloc(pass->shader->uniforms));
-      memcpy(mvec_ptr(rpass->shader.uniforms), mvec_ptr(pass->shader->uniforms),
-        sizeof(mri_uniform) * mvec_alloc(pass->shader->uniforms));
-
-      mvec_ptr(rpass->shader.combos) = (mri_combo *)malloc(
-        sizeof(mri_combo) * mvec_alloc(pass->shader->combos));
-      memcpy(mvec_ptr(rpass->shader.combos), mvec_ptr(pass->shader->combos),
-        sizeof(mri_combo) * mvec_alloc(pass->shader->combos));
+      mvec_clone(rpass->shader.uniforms, pass->shader->uniforms);
+      mvec_clone(rpass->shader.combos, pass->shader->combos);
 
       for (int i = 0; i < 7; i++) {
         // As the last step for shaders, set any unset texture slots
@@ -196,7 +209,8 @@ void mri_pass_load(mri_engine *engine, mri_pass *pass, mri_pass_stage stage, mri
         if (!rpass->textures[i] && rpass->shader.textures[i]) {
           rpass->textures[i] = rpass->shader.textures[i];
         }
-        // Set TEX0FORMAT incase extra steps are needed when sampling,
+
+        // Set TEX0FORMAT in-case extra steps are needed when sampling,
         // see "common_fragment.h".
         if (rpass->textures[i] && i == 0) {
           mri_combo c = {
@@ -262,8 +276,27 @@ void mri_pass_load(mri_engine *engine, mri_pass *pass, mri_pass_stage stage, mri
   }
 }
 
+static void viewport_center_scale(float w0, float h0, float w1, float h1) {
+  float w_scale = w1 / w0;
+  float h_scale = h1 / h0;
+
+  float scale = (w_scale > h_scale) ? w_scale : h_scale;
+
+  float width = w0 * scale;
+  float height = h0 * scale;
+
+  float wpad = (width - w1) / -2.f;
+  float hpad = (height - h1) / -2.f;
+
+  glViewport(wpad, hpad, width, height);
+}
+
+static void viewport_default(float w0, float h0) {
+  glViewport(0, 0, w0, h0);
+}
+
 void mri_render_pass_draw(mri_engine *engine, mri_render_pass *pass) {
-  mri_framebuffer_bind(pass->target, false);
+  mri_framebuffer_bind(pass->target);
   mri_shader_bind(engine, &pass->shader, pass->model);
 
   bind_gl_object(pass->gl_object);
@@ -272,27 +305,50 @@ void mri_render_pass_draw(mri_engine *engine, mri_render_pass *pass) {
     if (pass->textures[i]) mri_texture_bind(pass->textures[i], i);
   }
 
-  glViewport(0, 0, pass->target->width, pass->target->height);
-  glDrawArrays(GL_TRIANGLES, 0, 6);
+  mri_pass_blend_mode blend;
 
+  if (pass->combine) {
+    blend = pass->combine_blend;
+  } else {
+    blend = NORMAL;
+  }
+
+  switch (blend) {
+  case NORMAL:
+    glBlendFunc(GL_ONE, GL_ZERO);
+    glColorMask(1.f, 1.f, 1.f, 1.f);
+    break;
+  case TRANSLUCENT:
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glColorMask(1.f, 1.f, 1.f, 0.f);
+    break;
+  }
+
+  if (pass->combine) {
+    viewport_center_scale(engine->width, engine->height, engine->context->width, engine->context->height);
+  } else {
+    viewport_default(pass->target->width, pass->target->height);
+  }
+
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+    
   for (int i = 0; i < pass->shader.texture_count; i++) {
     glActiveTexture(GL_TEXTURE0 + i);
     glBindTexture(GL_TEXTURE_2D, 0);
   }
 
-  if (0) {
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, pass->target->buffer.id);
+#if 0
+  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+  glBindFramebuffer(GL_READ_FRAMEBUFFER, pass->target->buffer.id);
 
-    // Drawing past the dimensions of the read buffer is an error.
-    glBlitFramebuffer(0, engine->context->height, engine->context->width, 0, 0, 0,
-      engine->context->width, engine->context->height,
-      GL_COLOR_BUFFER_BIT, GL_NEAREST);
+  glBlitFramebuffer(0, engine->context->height, engine->context->width, 0, 0, 0,
+    engine->context->width, engine->context->height,
+    GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
-    engine->context->swap_buffers(engine->context);
+  engine->context->swap_buffers(engine->context);
 
-    usleep(5000000);
-  }
+  usleep(1400000);
+#endif
 }
 
 void mri_pass_unload(mri_pass *pass) {
diff --git a/src/objects/pass.h b/src/objects/pass.h
index 37c0997..64947c9 100644
--- a/src/objects/pass.h
+++ b/src/objects/pass.h
@@ -25,6 +25,10 @@ typedef enum {
   PASS,
 } mri_render_pass_stage;
 
+typedef enum {
+  TRANSLUCENT,
+  NORMAL
+} mri_pass_blend_mode;
 
 struct mri_pass {
   int id;
@@ -37,6 +41,8 @@ struct mri_pass {
   mstr *target;
   mstr *binds[7];
 
+  mri_pass_blend_mode blend;
+
   mvec(mri_uniform) uniforms;
   mvec(mri_combo) combos;
 };
@@ -45,6 +51,7 @@ struct mri_render_pass {
   mri_shader shader;
 
   mri_object *object;
+  mri_effect *effect;
 
   mat4 model;
   gl_object *gl_object;
@@ -54,6 +61,8 @@ struct mri_render_pass {
 
   bool combine;
 
+  mri_pass_blend_mode combine_blend;
+
   mri_render_pass_stage stage;
 
   mvec(mri_uniform) uniforms;
diff --git a/src/objects/scene.c b/src/objects/scene.c
index e320acf..62c70b2 100644
--- a/src/objects/scene.c
+++ b/src/objects/scene.c
@@ -82,15 +82,15 @@ void mri_scene_load(mri_engine *engine, mri_scene *scene) {
 void mri_scene_draw(mri_engine *engine, mri_scene *scene) {
   mri_object *object;
   mvec_loop_ptr(scene->objects, object, i) {
-    int dep;
-    mvec_loop(object->deps, dep, s) {
-      mri_object *dep_object;
-      mvec_loop_ptr(scene->objects, dep_object, j) {
-        if (dep_object->id == dep) {
-          mri_object_draw(engine, dep_object);
-        }
-      }
-    }
+    //int dep;
+    //mvec_loop(object->deps, dep, s) {
+    //  mri_object *dep_object;
+    //  mvec_loop_ptr(scene->objects, dep_object, j) {
+    //    if (dep_object->id == dep) {
+    //      mri_object_draw(engine, dep_object);
+    //    }
+    //  }
+    //}
     mri_object_draw(engine, object);
   }
 }