wip

12 files changed, 332 insertions, 195 deletions

diff --git a/src/objects/effect.cc b/src/objects/effect.cc
index bc94c17..fb1f4e3 100644
--- a/src/objects/effect.cc
+++ b/src/objects/effect.cc
@@ -16,15 +16,15 @@
 
 using namespace Mauri;
 
-Effect::Effect(json root)
+Effect::Effect(Parser &p, json &root)
 {
-    id = get_value<u32>(root["id"], INT);
+    p.get_value<u32>(root, "id", &id, 0);
 
-    visible = get_value<bool>(root["visible"], BOOL);
+    p.get_value<bool>(root, "visible", &visible, true);
 
     for (auto &pass0 : root["passes"])
     {
-        passes0.emplace_back(new Pass(pass0, EFFECT0_PASS));
+        passes0.emplace_back(new Pass(p, pass0, EFFECT0_PASS));
     }
 
     auto asset = asset_manager()->get_file(root["file"], NONE);
@@ -34,11 +34,11 @@ Effect::Effect(json root)
 
     auto file = json::parse(asset->as_string());
 
-    name = get_value<std::string>(file["name"], STRING);
+    p.get_value<std::string>(file, "name", &name, "");
 
     for (auto &pass1 : file["passes"])
     {
-        passes1.emplace_back(new Pass(pass1, EFFECT1_PASS));
+        passes1.emplace_back(new Pass(p, pass1, EFFECT1_PASS));
     }
 
     for (auto &fbo : file["fbos"])
@@ -49,14 +49,15 @@ Effect::Effect(json root)
 
 void Effect::load(Engine *engine, Object *object, bool last_effect)
 {
-    buffer_id = fmt::format("{}_{}", id.value, object->id.value);
+    buffer_id = fmt::format("_{}_{}", object->id, id);
 
     for (auto &fbo : fbos)
     {
-        engine->create_framebuffer(fbo.name + buffer_id, object->size.value[0],
-            object->size.value[1], fbo.scale);
+        engine->create_framebuffer(fbo.name + buffer_id, object->size[0],
+            object->size[1], fbo.scale);
     }
 
+    /*
     for (u32 i = 0; i < passes0.size(); i++)
     {
         Pass *pass = new Pass(); 
@@ -71,11 +72,35 @@ void Effect::load(Engine *engine, Object *object, bool last_effect)
 
         this->passes.push_back(new RenderPass(engine, pass));
     }
+    */
+    
+    u32 index = 0;
+    
+    for (u32 i = 0; i < passes1.size(); i++)
+    {
+        Pass *pass = new Pass(); 
+        
+        pass->combine = (i == (passes1.size() - 1)) && last_effect;
+
+        pass->object = object;
+        pass->effect = this;
+
+        if (passes1[i]->command == COPY)
+            passes1[i]->load(engine, EFFECT1_PASS, pass);
+        else
+        {
+            passes0[index]->load(engine, EFFECT0_PASS, pass);
+            passes1[i]->load(engine, EFFECT1_PASS, pass);
+            index++;
+        }
+
+        this->passes.push_back(new RenderPass(engine, pass));
+    }
 }
 
 void Effect::draw(Engine *engine)
 {
-    if (!visible.value)
+    if (!visible)
         return;
     
     for (auto &pass : passes)
diff --git a/src/objects/effect.h b/src/objects/effect.h
index 29b4bb7..713c36f 100644
--- a/src/objects/effect.h
+++ b/src/objects/effect.h
@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "engine.h"
+#include "texture.h"
 
 namespace Mauri
 {
@@ -20,11 +21,11 @@ struct EffectBuffer
 class Effect
 {
   public:
-    Effect(json root);
+    Effect(Parser &p, json &root);
     ~Effect();
 
-    JsonValue<u32> id;
-    JsonValue<std::string> name;
+    u32 id;
+    std::string name;
 
     std::string buffer_id;
 
@@ -32,7 +33,7 @@ class Effect
     void draw(Engine *engine);
 
   private:
-    JsonValue<bool> visible;
+    bool visible;
 
     std::vector<Pass *> passes0;
     std::vector<Pass *> passes1;
diff --git a/src/objects/material.cc b/src/objects/material.cc
index 699c603..ae25cee 100644
--- a/src/objects/material.cc
+++ b/src/objects/material.cc
@@ -11,7 +11,7 @@
 
 using namespace Mauri;
 
-Material::Material(std::string path)
+Material::Material(Parser &p, const std::string &path)
 {
     auto asset = asset_manager()->get_file(path, NONE);
 
@@ -25,7 +25,7 @@ Material::Material(std::string path)
 
     for (auto &pass : root["passes"])
     {
-        passes0.push_back(new Pass(pass, MATERIAL_PASS));
+        passes0.push_back(new Pass(p, pass, MATERIAL_PASS));
     }
 }
 
diff --git a/src/objects/material.h b/src/objects/material.h
index c27c720..0e46f7f 100644
--- a/src/objects/material.h
+++ b/src/objects/material.h
@@ -20,7 +20,7 @@ enum MaterialType
 class Material
 {
   public:
-    Material(std::string path);
+    Material(Parser &p, const std::string &path);
     ~Material();
 
     void load(Engine *engine, Object *object, MaterialType type, Pass *pass, bool no_effects);
diff --git a/src/objects/model.cc b/src/objects/model.cc
index 0574a92..f450d34 100644
--- a/src/objects/model.cc
+++ b/src/objects/model.cc
@@ -9,7 +9,7 @@
 
 using namespace Mauri;
 
-Model::Model(std::string path)
+Model::Model(Parser &p, const std::string &path)
 {
     auto asset = asset_manager()->get_file(path, NONE);
 
@@ -21,11 +21,17 @@ Model::Model(std::string path)
 
     auto root = json::parse(asset->as_string());
 
-    autosize = get_value<bool>(root["autosize"], BOOL);
-    fullscreen = get_value<bool>(root["fullscreen"], BOOL);
-    passthrough = get_value<bool>(root["passthrough"], BOOL);
+    p.get_value<bool>(root, "autosize", &autosize, false);
+    p.get_value<bool>(root, "fullscreen", &fullscreen, false);
+    p.get_value<bool>(root, "passthrough", &passthrough, false);
 
-    material = new Material(root["material"]);
+    p.get_value<f32>(root, "width", &width, 0.f);
+    p.get_value<f32>(root, "height", &height, 0.f);
+
+    auto _material = root["material"];
+
+    if (_material.is_string())
+        material = new Material(p, _material);
 }
 
 void Model::load(Engine *engine, Object *object, bool no_effects)
diff --git a/src/objects/model.h b/src/objects/model.h
index 9e67f07..e4a55ea 100644
--- a/src/objects/model.h
+++ b/src/objects/model.h
@@ -14,12 +14,15 @@ namespace Mauri
 class Model
 {
   public:
-    Model(std::string path);
+    Model(Parser &p, const std::string &path);
     ~Model();
 
-    JsonValue<bool> autosize;
-    JsonValue<bool> fullscreen;
-    JsonValue<bool> passthrough;
+    bool autosize = true;
+    bool fullscreen = false;
+    bool passthrough = false;
+
+    f32 width;
+    f32 height;
 
     void load(Engine *engine, Object *object, bool no_effects);
 
diff --git a/src/objects/object.cc b/src/objects/object.cc
index a41cfaa..efd3155 100644
--- a/src/objects/object.cc
+++ b/src/objects/object.cc
@@ -12,6 +12,7 @@
 #include "../json.h"
 #include "../log.h"
 
+#include "fmt/format.h"
 #include "objects/effect.h"
 #include "objects/model.h"
 #include "objects/object.h"
@@ -20,34 +21,37 @@
 
 using namespace Mauri;
 
-Object::Object(json root)
+Object::Object(Parser &p, json &root)
 {
-    id = get_value<u32>(root["id"], INT);
-    name = get_value<std::string>(root["id"], STRING);
+    p.get_value<u32>(root, "id", &id, 0);
+    p.get_value<std::string>(root, "name", &name, "");
 
     for (auto &id : root["dependencies"])
         deps.push_back(id);
 
-    angles = get_value<vec3>(root["angles"], VEC3);
-    color = get_value<vec3>(root["colors"], VEC3);
-    size = get_value<vec2>(root["size"], VEC2);
-    scale = get_value<vec3>(root["size"], VEC3);
-    origin = get_value<vec3>(root["origin"], VEC3);
+    p.get_value<vec3>(root, "angles", &angles, vec3(0.f));
+    p.get_value<vec3>(root, "color", &color, vec3(0.f));
+    p.get_value<vec2>(root, "size", &size, vec2(0.f));
+    p.get_value<vec3>(root, "scale", &scale, vec3(0.f));
+    p.get_value<vec3>(root, "origin", &origin, vec3(0.f));
 
-    color_blend_mode = (BlendMode)root["colorblendmode"];
+    p.get_value<u32>(root, "colorblendmode", &color_blend_mode, 0);
 
-    visible = get_value<bool>(root["visible"], BOOL);
+    p.get_value<bool>(root, "visible", &visible, true);
 
-    image = new Model(root["image"]);
+    auto _image = root["image"];
+
+    if (_image.is_string())
+        image = new Model(p, _image);
 
     auto config = root["config"];
 
     if (!config.is_null())
-        passthrough = get_value<bool>(config["passthrough"], BOOL);
+        p.get_value<bool>(config, "passthrough", &passthrough, false);
 
     for (auto &effect : root["effects"])
     {
-        effects.emplace_back(new Effect(effect));
+        effects.emplace_back(new Effect(p, effect));
     }
 }
 
@@ -57,13 +61,13 @@ void Object::get_model(f32 width, f32 height, bool flip)
 
     model = glm::translate(model, (vec3){-width, -height, 0.f});
 
-    model = glm::translate(model, origin.value * 2.f);
+    model = glm::translate(model, origin * 2.f);
 
-    model = glm::scale(model, scale.value);
+    model = glm::scale(model, scale);
 
-    model = glm::rotate(model, angles.value[0], (vec3){1.f, 0.f, 0.f});
-    model = glm::rotate(model, angles.value[1], (vec3){0.f, 1.f, 0.f});
-    model = glm::rotate(model, angles.value[2], (vec3){0.f, 0.f, 1.f});
+    model = glm::rotate(model, angles[0], (vec3){1.f, 0.f, 0.f});
+    model = glm::rotate(model, angles[1], (vec3){0.f, 1.f, 0.f});
+    model = glm::rotate(model, angles[2], (vec3){0.f, 0.f, 1.f});
 
     mat4x4 _ortho = glm::ortho(-width, width, height, -height, 0.f, 1.f);
 
@@ -80,32 +84,47 @@ void Object::load(Engine *engine)
     if (loaded)
         return;
 
+    for (auto &dep : deps)
+    {
+        if (dep == id)
+            continue;
+        auto dep_object = engine->scene->get_object_by_id(dep);
+        if (dep_object != nullptr)
+            dep_object->load(engine);
+    }
+          
+
     if (image != nullptr)
     {
-        if (image->passthrough.value)
+        if (image->passthrough)
             passthrough = true;
 
-        if (image->fullscreen.value || passthrough.value)
-        {
-            if (size.value[0] == 0 && size.value[1] == 0)
-            {
-                size.value[0] = engine->view.width;
-                size.value[1] = engine->view.height;
-                origin.value[0] = size.value[0] / 2.f;
-                origin.value[1] = size.value[1] / 2.f;
-            }
+        if (image->fullscreen)
             fullscreen = true;
+
+        if (image->width != 0.f && image->height != 0.f)
+        {
+            size[0] = image->width;
+            size[1] = image->height;
         }
     }
 
-    auto width = size.value[0];
-    auto height = size.value[1];
+    if (size[0] == 0 && size[1] == 0)
+    {
+        size[0] = engine->view.width;
+        size[1] = engine->view.height;
+        origin[0] = size[0] / 2.f;
+        origin[1] = size[1] / 2.f;
+    }
 
-    abuffer = fmt::format("_rt_imageLayerComposite_{}_a", this->id.value);
-    bbuffer = fmt::format("_rt_imageLayerComposite_{}_b", this->id.value);
+    auto width = size[0];
+    auto height = size[1];
 
-    engine->create_framebuffer(abuffer, width, height, 1.f);
-    engine->create_framebuffer(bbuffer, width, height, 1.f);
+    buffer_a = fmt::format("_rt_imageLayerComposite_{}_a", id);
+    buffer_b = fmt::format("_rt_imageLayerComposite_{}_b", id);
+
+    engine->create_framebuffer(buffer_a, width, height, 1.f);
+    engine->create_framebuffer(buffer_b, width, height, 1.f);
 
     get_model(engine->view.width, engine->view.height, effects.size() == 0);
 
@@ -114,7 +133,8 @@ void Object::load(Engine *engine)
     gl_object = new RenderObject(OBJECT, width, height);
     gl_uv_object = new RenderObject(UV_SCALE, width, height);
 
-    image->load(engine, this, effects.size() == 0);
+    if (image != nullptr)
+        image->load(engine, this, effects.size() == 0);
 
     for (u32 i = 0; i < effects.size(); i++)
     {
@@ -133,8 +153,14 @@ void Object::update(Engine *engine)
 
 void Object::draw(Engine *engine)
 {
-    if (!visible.value)
-        return;
+    //for (auto &dep : deps)
+    //{
+    //    if (dep == id)
+    //        continue;
+    //    auto dep_object = engine->scene->get_object_by_id(dep);
+    //    if (dep_object != nullptr)
+    //        dep_object->draw(engine);
+    //}
 
     for (auto &pass : passes)
     {
@@ -149,12 +175,12 @@ void Object::draw(Engine *engine)
 
 std::string Object::get_target_buffer() const
 {
-    return (buffer_switch) ? abuffer : bbuffer;
+    return (buffer_switch) ? buffer_a : buffer_b;
 }
 
 std::string Object::get_texture_buffer() const
 {
-    return (buffer_switch) ? bbuffer : abuffer;
+    return (buffer_switch) ? buffer_b : buffer_a;
 }
 
 Object::~Object()
diff --git a/src/objects/object.h b/src/objects/object.h
index 14b6615..37dd2df 100644
--- a/src/objects/object.h
+++ b/src/objects/object.h
@@ -28,18 +28,20 @@ enum BlendMode
 class Object
 {
   public:
-    Object(json root);
+    Object(Parser &p, json &root);
     ~Object();
 
-    JsonValue<u32> id;
-    JsonValue<std::string> name;
+    u32 id;
+    std::string name;
+
+    bool visible;
 
     std::vector<int> deps;
 
-    JsonValue<bool> passthrough;
-    JsonValue<bool> fullscreen;
+    bool passthrough = false;
+    bool fullscreen = false;
 
-    JsonValue<vec2> size;
+    vec2 size;
 
     void get_model(f32 width, f32 height, bool flip);
 
@@ -49,7 +51,7 @@ class Object
     RenderObject *gl_uv_object = nullptr;
     RenderObject *gl_object = nullptr;
 
-    BlendMode color_blend_mode;
+    u32 color_blend_mode;
 
     std::string get_target_buffer() const;
     std::string get_texture_buffer() const;
@@ -66,18 +68,16 @@ class Object
     void draw(Engine *engine);
 
   private:
-    JsonValue<bool> visible;
-
     Model *image = nullptr;
 
-    JsonValue<vec3> angles;
-    JsonValue<vec3> color;
+    vec3 angles;
+    vec3 color;
 
-    JsonValue<vec3> origin;
-    JsonValue<vec3> scale;
+    vec3 origin;
+    vec3 scale;
 
-    std::string abuffer;
-    std::string bbuffer;
+    std::string buffer_a;
+    std::string buffer_b;
 
     bool buffer_switch = false;
 
diff --git a/src/objects/pass.cc b/src/objects/pass.cc
index 333694a..24fc868 100644
--- a/src/objects/pass.cc
+++ b/src/objects/pass.cc
@@ -1,6 +1,8 @@
+#include <cstdio>
 #include <fmt/core.h>
 #include <glm/fwd.hpp>
 #include <glm/gtc/type_ptr.hpp>
+#include <stdint.h>
 #include <thread>
 #include <type_traits>
 
@@ -20,28 +22,48 @@
 
 using namespace Mauri;
 
-Pass::Pass(json root, PassStage stage)
+Pass::Pass(Parser &p, json &root, PassStage stage)
 {
     switch (stage)
     {
     case EFFECT0_PASS: {
-        for (auto &value : root["constantshadervalues"].items())
+        auto _uniforms = root["constantshadervalues"];
+
+        for (auto &value : _uniforms.items())
         {
-            // In this case type and uname are irrelevant because this is only used to
-            // override the value stored on the shader which contains the type and uname.
-            uniforms.push_back(Uniform(value.key(), get_value<vec4>(value.value(), VEC4)));
+            // Type and uname don't matter because they are stored on the shader.
+            uniforms.emplace_back(
+                new UniformOverride({ vec4(0.f), value.key() })
+            );
+            p.get_value<vec4>(_uniforms, value.key(), &uniforms.back()->value, vec4(0.f));
         }
 
         break;
     }
     case EFFECT1_PASS: {
-        material = new Material(root["material"]);
+        auto _material = root["material"];
+
+        if (_material.is_string())
+            material = new Material(p, _material);
+
+        auto _command = root["command"];
+
+        if (_command.is_string())
+        {
+            if (_command == "copy")
+                command = COPY;
+        }
 
         auto _target = root["target"];
 
         if (_target.is_string())
             target = _target;
 
+        auto _source = root["source"];
+
+        if (_source.is_string())
+            source = _source;
+
         for (auto &bind : root["bind"])
         {
             u32 index = bind["index"];
@@ -53,36 +75,20 @@ Pass::Pass(json root, PassStage stage)
     case MATERIAL_ONLY_PASS:
         target = "previous";
         [[fallthrough]];
-    case MATERIAL_PASS: {
+    case MATERIAL_PASS: 
         shader = root["shader"];
-
-        //auto blending = root.get("blending", "normal").asString();
-
-        //if (blending == "normal")
-        //    blend = NORMAL;
-        //else if (blending == "translucent")
-        //    blend = TRANSLUCENT;
-
         break;
     }
-    }
 
-    for (int i = 0; i < 8; i++)
+    auto _textures = root["textures"];
+
+    for (int i = 0; i < _textures.size(); i++)
     {
-        auto texture = root["textures"][i];
-        if (texture.is_string())
-            textures[i] = texture;
+        auto _texture = _textures[i];
+        if (_texture.is_string())
+            textures[i] = _texture;
     }
 
-    //auto _textures = root["textures"];
-
-    //for (int i = 0; i < _textures.size(); i++)
-    //{
-    //    auto texture = _textures[i];
-    //    if (texture.is_string())
-    //        textures[i] = texture;
-    //}
-
     for (auto &combo : root["combos"].items())
     {
         combos.emplace_back((Combo) { combo.key(), combo.value() });
@@ -97,6 +103,8 @@ void Pass::load(Engine *engine, PassStage stage, Pass *pass)
             continue;
 
         pass->textures[i] = textures[i];
+
+        //engine->max_texture_count++;
     }
 
     for (auto &combo : combos)
@@ -113,6 +121,9 @@ void Pass::load(Engine *engine, PassStage stage, Pass *pass)
         }
         break;
     case EFFECT1_PASS:
+        pass->command = command;
+
+        pass->source = source + pass->effect->buffer_id;
         pass->target = target;
 
         if (pass->target == "previous")
@@ -168,10 +179,22 @@ Pass::~Pass()
 
 RenderPass::RenderPass(Engine *engine, Pass *pass)
 {
+    command = pass->command;
+
+    if (command == COPY)
+    {
+        target = engine->get_framebuffer(pass->target);
+        source = engine->get_framebuffer(pass->source);
+
+        return;
+    }
+
+    object = pass->object;
+
     combine = pass->combine;
-    combine_blend = pass->object->color_blend_mode;
+    combine_blend = (BlendMode)pass->object->color_blend_mode;
 
-    shader = new Shader(pass->shader);
+    shader = new Shader(engine->parser, pass->shader);
 
     for (int i = 0; i < 8; i++)
     {
@@ -184,36 +207,62 @@ RenderPass::RenderPass(Engine *engine, Pass *pass)
         auto asset = asset_manager()->get_file(pass->textures[i], TEXTURE);
 
         if (asset->type != ASSET_VOID)
-            textures[i] = engine->create_texture(asset);
+            textures[i] = engine->get_texture(asset);
         else
             textures[i] = engine->get_framebuffer_texture(pass->textures[i]);
     }
 
-    for (auto &uniform : shader->uniforms)
+    for (auto &shader_uniform : shader->uniforms)
     {
-        // ex: g_Texture2Resolution (vec4)
-        //              ^ index
-        if (uniform.uname.compare(0, 9, "g_Texture") == 0 &&
-            uniform.uname.compare(10, 10, "Resolution") == 0)
+        auto default_value = true;
+        for (auto &uniform_override : pass->uniforms)
         {
-            auto index = uniform.uname[9] - '0';
-            if (textures[index] != nullptr)
-                uniform.value = textures[index]->texture_resolution;
+            if (shader_uniform->name.empty())
+                continue;
+            if (shader_uniform->name == uniform_override->name)
+            {
+                shader_uniform->value = &uniform_override->value;
+                default_value = false;
+                break;
+            }
         }
+        if (default_value)
+            shader_uniform->value = &shader_uniform->default_value;
     }
 
-    for (auto &pass_uniform : pass->uniforms)
+    /*
+    for (auto &shader_uniform : shader->uniforms)
     {
-        for (auto &shader_uniform : shader->uniforms)
+        auto add = true;
+        for (auto &pass_uniform : pass->uniforms)
         {
-            if (shader_uniform.name.empty())
+            if (shader_uniform->name.empty())
                 continue;
-            if (pass_uniform.name == shader_uniform.name)
+            if (pass_uniform->name == shader_uniform->name)
             {
-                shader_uniform.value = pass_uniform.value;
+                pass_uniform->uname = shader_uniform->uname;
+                pass_uniform->type  = shader_uniform->type;
+                add = false;
+                delete shader_uniform;
                 break;
             }
         }
+        if (add)
+            pass->uniforms.push_back(shader_uniform);
+    }
+    */
+
+    for (auto &uniform : shader->uniforms)
+    {
+        // ex: g_Texture2Resolution (vec4)
+        //              ^ index
+        if (uniform->uname.compare(0, 9, "g_Texture") == 0 &&
+            uniform->uname.compare(10, 10, "Resolution") == 0)
+        {
+            auto index = uniform->uname[9] - '0';
+            if (textures[index] != nullptr)
+                uniform->value = &textures[index]->texture_resolution;
+        }
     }
 
     for (auto &combo : shader->combos)
@@ -247,19 +296,23 @@ RenderPass::RenderPass(Engine *engine, Pass *pass)
 
     if (pass->effect == nullptr)
     {
-        if (pass->object->passthrough.value || combine)
+        if (pass->object->fullscreen)
+            model = &engine->default_model;
+        else if (pass->object->passthrough || combine)
             model = &pass->object->model;
         else
             model = &pass->object->ortho;
 
-        if (pass->object->passthrough.value)
+        if (pass->object->fullscreen)
+            robject = engine->default_object;
+        else if (pass->object->passthrough)
             robject = pass->object->gl_object;
         else
             robject = pass->object->gl_uv_object;
     }
     else
     {
-        if (combine)
+        if (combine && !pass->object->fullscreen)
         {
             robject = pass->object->gl_object;
             model = &pass->object->model;
@@ -274,45 +327,55 @@ RenderPass::RenderPass(Engine *engine, Pass *pass)
 
 void RenderPass::draw(Engine *engine)
 {
-    target->buffer->bind();
-    shader->bind(engine, model);
+    switch (command) {
+    case DRAW: {
+        target->buffer->bind();
 
-    robject->bind();
+        shader->bind(engine, model);
+        robject->bind();
 
-    for (int i = 0; i < shader->texture_count; i++)
-    {
-        if (textures[i] != nullptr)
-            textures[i]->bind(i);
-    }
+        for (int i = 0; i < shader->texture_count; i++)
+        {
+            if (textures[i] != nullptr)
+                textures[i]->bind(i);
+        }
 
-    BlendMode blend;
+        BlendMode blend;
 
-    if (combine)
-        blend = combine_blend;
-    else
-        blend = NORMAL;
+        if (combine)
+            blend = 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;
-    }
+        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;
+        }
 
-    engine->view.default_viewport(target->buffer->width, target->buffer->height);
+        engine->view.default_viewport(target->buffer->width, target->buffer->height);
 
-    glDrawArrays(GL_TRIANGLES, 0, 6);
+        glDrawArrays(GL_TRIANGLES, 0, 6);
 
 #if 0
-    target->buffer->blit(0, engine->context->width, engine->context->height);
-    engine->context->swap_buffers();
-    std::this_thread::sleep_for(std::chrono::seconds(1));
+        target->buffer->blit(0, engine->context->width, engine->context->height);
+            
+        engine->context->swap_buffers();
+        std::this_thread::sleep_for(std::chrono::seconds(1));
 #endif
+
+        break;
+    }
+    case COPY:
+        source->buffer->blit(target->buffer->id, source->buffer->width, source->buffer->height);
+        break;
+    }
 }
 
 RenderPass::~RenderPass()
diff --git a/src/objects/pass.h b/src/objects/pass.h
index 78de015..ff03a05 100644
--- a/src/objects/pass.h
+++ b/src/objects/pass.h
@@ -24,17 +24,32 @@ enum PassStage
     MATERIAL_ONLY_PASS
 };
 
+enum PassCommand
+{
+    DRAW,
+    COPY
+};
+
+struct UniformOverride
+{
+    vec4 value;
+    std::string name;
+};
+
 class RenderPass;
 
 class Pass
 {
   public:
     Pass() {}
-    Pass(json root, PassStage stage);
+    Pass(Parser &p, json &root, PassStage stage);
 
     ~Pass();
 
-    std::string target;
+    PassCommand command = DRAW;
+    
+    std::string target = "previous";
+    std::string source;
 
     Object *object;
     Effect *effect;
@@ -46,7 +61,7 @@ class Pass
 
     bool combine;
 
-    std::vector<Uniform> uniforms;
+    std::vector<UniformOverride *> uniforms;
     std::vector<Combo> combos;
 
     void load(Engine *engine, PassStage stage, Pass *pass);
@@ -64,8 +79,14 @@ class RenderPass
     void draw(Engine *engine);
 
   private:
-    Shader *shader;
+    PassCommand command;
+
+    Object *object;
+
+    Shader *shader = nullptr;
+
     Framebuffer *target;
+    Framebuffer *source;
 
     mat4x4 *model;
     RenderObject *robject;
diff --git a/src/objects/scene.cc b/src/objects/scene.cc
index 1e95f4b..afb1e69 100644
--- a/src/objects/scene.cc
+++ b/src/objects/scene.cc
@@ -11,7 +11,7 @@
 
 using namespace Mauri;
 
-Scene::Scene(std::string path)
+Scene::Scene(Parser &p, const std::string &path)
 {
     auto asset = asset_manager()->get_file(path, NONE);
 
@@ -25,25 +25,23 @@ Scene::Scene(std::string path)
 
     auto camera = root["camera"];
 
-    cam.center = get_value<vec3>(camera["center"], VEC3);
-    cam.eye = get_value<vec3>(camera["eye"], VEC3);
-    cam.up = get_value<vec3>(camera["up"], VEC3);
+    p.get_value<vec3>(camera, "center", &cam.center, vec3(0.f));
+    p.get_value<vec3>(camera, "eye", &cam.eye, vec3(0.f));
+    p.get_value<vec3>(camera, "up", &cam.up, vec3(0.f));
 
     auto general = root["general"];
 
-    clear_enabled = get_value<bool>(general["clearenabled"], BOOL);
-
-    clear_color = get_value<vec4>(general["clearcolor"], VEC3);
-    clear_color.value[3] = 1.f;
+    p.get_value<bool>(general, "clearenabled", &clear_enabled, true);
+    p.get_value<vec4>(general, "clearcolor", &clear_color, vec4(1.f));
 
     auto ortho = general["orthogonalprojection"];
 
-    width = get_value<float>(ortho["width"], FLOAT);
-    height = get_value<float>(ortho["height"], FLOAT);
+    p.get_value<f32>(ortho, "width", &width, 0.f);
+    p.get_value<f32>(ortho, "height", &height, 0.f);
 
     for (auto &object : root["objects"])
     {
-        objects.emplace_back(new Object(object));
+        objects.emplace_back(new Object(p, object));
     }
 }
 
@@ -51,7 +49,7 @@ Object *Scene::get_object_by_id(u32 id)
 {
     for (auto &object : objects)
     {
-        if (object->id.value == id)
+        if (object->id == id)
         {
             return object;
         }
@@ -62,18 +60,11 @@ Object *Scene::get_object_by_id(u32 id)
 
 void Scene::load(Engine *engine)
 {
-    engine->view.width = width.value;
-    engine->view.height = height.value;
+    engine->view.width = width;
+    engine->view.height = height;
 
     for (auto &object : objects)
     {
-        for (auto &dep : object->deps)
-        {
-            auto dep_object = get_object_by_id(dep);
-            if (dep_object != nullptr)
-                dep_object->load(engine);
-        }
-
         object->load(engine);
     }
 }
diff --git a/src/objects/scene.h b/src/objects/scene.h
index 43a4442..bd8d1b1 100644
--- a/src/objects/scene.h
+++ b/src/objects/scene.h
@@ -17,26 +17,27 @@ namespace Mauri
 {
 
 struct Camera {
-    JsonValue<vec3> center;
-    JsonValue<vec3> eye;
-    JsonValue<vec3> up;
-
-    JsonValue<float> farz;
-    JsonValue<float> nearz;
-    JsonValue<float> fov;
+    vec3 center;
+    vec3 eye;
+    vec3 up;
+    float farz;
+    float nearz;
+    float fov;
 };
 
 class Scene
 {
   public:
-    Scene(std::string path);
+    Scene(Parser &p, const std::string &path);
     ~Scene();
 
-    JsonValue<f32> width;
-    JsonValue<f32> height;
+    Camera cam;
+
+    f32 width;
+    f32 height;
 
-    JsonValue<bool> clear_enabled;
-    JsonValue<vec4> clear_color;
+    bool clear_enabled;
+    vec4 clear_color;
 
     void load(Engine *engine);
     void draw(Engine *engine);
@@ -48,7 +49,7 @@ class Scene
     std::vector<Object *> objects;
 
   private:
-    Camera cam;
+    std::vector<RenderPass *> passes;
 };
 
 } // namespace Mauri