From 6f744cca9fd3afb1aec52e3ffe32285a45161f68 Mon Sep 17 00:00:00 2001
From: Andrew Opalach <andrew@akon.city>
Date: Sun, 4 Oct 2020 10:02:09 -0400
Subject: new json parsing

---
 meson.build             | 19 +++++++-------
 src/assets.h            |  7 -----
 src/context_x11.cc      |  2 +-
 src/engine.cc           | 16 ++++++------
 src/json.cc             | 64 ++++++++++++++++++++++++++++++++++++---------
 src/json.h              | 39 +++++++++++++++++++++++-----
 src/mauri.cc            |  2 +-
 src/objects/effect.cc   | 21 ++++++++-------
 src/objects/effect.h    |  8 +++---
 src/objects/material.cc |  2 +-
 src/objects/material.h  |  1 +
 src/objects/model.cc    | 10 +++----
 src/objects/model.h     |  7 ++---
 src/objects/object.cc   | 69 +++++++++++++++++++++++--------------------------
 src/objects/object.h    | 22 ++++++++--------
 src/objects/pass.cc     | 58 ++++++++++++++++++++---------------------
 src/objects/pass.h      |  3 ++-
 src/objects/scene.cc    | 34 ++++++++++++------------
 src/objects/scene.h     | 21 ++++++++-------
 src/shader.cc           | 58 ++++++++++++++---------------------------
 src/shader.h            | 15 +++++++++--
 src/util.h              |  3 +++
 22 files changed, 269 insertions(+), 212 deletions(-)

diff --git a/meson.build b/meson.build
index 76b54e7..fe291ec 100644
--- a/meson.build
+++ b/meson.build
@@ -23,17 +23,18 @@ fmt = cmake.subproject('fmt').dependency('fmt')
 
 dl = compiler.find_library('dl')
 
-lz4 = dependency('liblz4')
-glm = dependency('glm')
-glfw = dependency('glfw3')
-jsoncpp = dependency('jsoncpp')
+lz4 = dependency('liblz4', required: true)
+glm = dependency('glm', required: true)
+json = dependency('nlohmann_json', required: true)
 
-X11 = dependency('X11')
-Xrender = dependency('xrender')
-Xext = dependency('xext')
-GLX = dependency('glx')
+glfw = dependency('glfw3', required: false)
 
-deps = [dl, jsoncpp, glm, lz4, stbi, glad, glfw, fmt, s3tc, X11, Xrender, Xext, GLX]
+X11 = dependency('X11', required: false)
+Xrender = dependency('xrender', required: false)
+Xext = dependency('xext', required: false)
+GLX = dependency('glx', required: false)
+
+deps = [dl, json, glm, lz4, stbi, glad, glfw, fmt, s3tc, X11, Xrender, Xext, GLX]
 
 src = [
 	'src/assets.cc',
diff --git a/src/assets.h b/src/assets.h
index c6888ac..0c88a1a 100644
--- a/src/assets.h
+++ b/src/assets.h
@@ -78,13 +78,6 @@ class Asset
         return std::string((char *)this->ptr(), this->size);
     }
 
-    Json::Value as_json()
-    {
-        Json::Value root;
-        std::stringstream(std::string((char *)this->ptr(), this->size)) >> root;
-        return root;
-    }
-
   private:
     u32 pos;
     byte *data;
diff --git a/src/context_x11.cc b/src/context_x11.cc
index e08f7e7..b24eefb 100644
--- a/src/context_x11.cc
+++ b/src/context_x11.cc
@@ -190,7 +190,7 @@ ContextX11::ContextX11(int width, int height, std::string name, bool wallpaper)
 
     XSetWMProtocols(x11_d, window, &ATOM_WM_DELETE_WINDOW, 1);
     
-    //XMoveWindow(x11_d, window, 1080, 0);
+    XMoveWindow(x11_d, window, 1080, 0);
     
     XMapWindow(x11_d, window);
     XFlush(x11_d);
diff --git a/src/engine.cc b/src/engine.cc
index f20182d..2bca247 100644
--- a/src/engine.cc
+++ b/src/engine.cc
@@ -49,14 +49,14 @@ void View::center(f32 w1, f32 h1)
 Engine::Engine(Scene *scene, Context *context)
     : context(context), scene(scene)
 {
-    view.width = scene->width;
-    view.height = scene->height;
+    view.width = scene->width.value;
+    view.height = scene->height.value;
 
-    view.texel_size[0] = 1.f / scene->width;
-    view.texel_size[1] = 1.f / scene->height;
+    view.texel_size[0] = 1.f / view.width;
+    view.texel_size[1] = 1.f / view.height;
 
-    view.texel_half_size[0] = .5f / scene->width;
-    view.texel_half_size[1] = .5f / scene->height;
+    view.texel_half_size[0] = .5f / view.width;
+    view.texel_half_size[1] = .5f / view.height;
 
     view.center(context->width, context->height);
 
@@ -135,9 +135,9 @@ void Engine::draw()
             buffer.second->buffer->clear((vec4){0.f, 0.f, 0.f, 0.f});
     }
 
-    if (scene->clear_enabled)
+    if (scene->clear_enabled.value)
     {
-        combine_buffer->buffer->clear(scene->clear_color);
+        combine_buffer->buffer->clear(scene->clear_color.value);
     }
 
     scene->draw(this);
diff --git a/src/json.cc b/src/json.cc
index 2be9a0e..59c9a22 100644
--- a/src/json.cc
+++ b/src/json.cc
@@ -1,21 +1,61 @@
 #include "json.h"
+#include "util.h"
 
-namespace Mauri {
+namespace Mauri
+{
 
-Json::Value json_user_value(Json::Value value)
+template<typename T>
+JsonValue<T> get_value(json jvalue, JsonValueType type)
 {
-    if (value.isObject()) {
-        return value["value"];
+    JsonValue<T> value;
+    
+    if (jvalue.is_object())
+    {
+        value.user = jvalue["user"];
+        jvalue = value["value"];
+    }
+    else
+    {
+        value.user = "root";
     }
-    return value;
-}
 
-void json_number(Json::Value value, float *res)
-{
-    if (value.isNumeric())
-        *res = value.asFloat();
-    else if (value.isString())
-        sscanf_vec4(value.asCString(), res);
+    switch (type)
+    {
+    case INT:
+        if (jvalue.is_number())
+            value.value = jvalue.get<u32>();
+        break;
+    case FLOAT:
+        if (jvalue.is_number())
+            value.value = jvalue.get<f32>();
+        break;
+    case STRING:
+        if (jvalue.is_string())
+            value.value = jvalue.get<std::string>();
+        break;
+    case VEC2:
+        if (jvalue.is_string())
+            str_vec2(jvalue.get<std::string>(), value.value);
+        break;
+    case VEC3:
+        if (jvalue.is_string())
+            str_vec3(jvalue.get<std::string>(), value.value);
+        break;
+    case VEC4:
+        // special case for because VEC4 is used for all
+        // uniform values and some can be a single float
+        if (jvalue.is_number())
+            value.value[0] = jvalue.get<f32>();
+        else if (jvalue.is_string())
+            str_vec4(jvalue.get<std::string>(), value.value);
+        break;
+    case BOOL:
+        if (jvalue.is_boolean())
+            value.value = jvalue.get<bool>();
+        break;
+    }
+
+    return value;
 }
 
 }
diff --git a/src/json.h b/src/json.h
index 5736098..9ed44c9 100644
--- a/src/json.h
+++ b/src/json.h
@@ -1,16 +1,43 @@
 #ifndef _JSON_H
 #define _JSON_H
 
-#include <jsoncpp/json/json.h>
+#include <cstdio>
+#include <nlohmann/json.hpp>
+
+using namespace nlohmann;
+
+#define str_vec4(s, v) sscanf(s, "%f %f %f %f", &(v)[0], &(v)[1], &(v)[2], &(v)[3])
+#define str_vec3(s, v) sscanf(s, "%f %f %f", &(v)[0], &(v)[1], &(v)[2])
+#define str_vec2(s, v) sscanf(s, "%f %f", &(v)[0], &(v)[1])
 
 namespace Mauri {
 
-#define sscanf_vec4(s, v) sscanf(s, "%f %f %f %f", &(v)[0], &(v)[1], &(v)[2], &(v)[3])
-#define sscanf_vec3(s, v) sscanf(s, "%f %f %f", &(v)[0], &(v)[1], &(v)[2])
-#define sscanf_vec2(s, v) sscanf(s, "%f %f", &(v)[0], &(v)[1])
+enum JsonValueType
+{
+    FLOAT,
+    INT,
+    VEC2,
+    VEC3,
+    VEC4,
+    BOOL,
+    STRING
+};
+
+template <typename T>
+struct JsonValue
+{
+    JsonValue() {}
+    JsonValue(T value)
+        : user("root"), value(value)
+    {
+    }
+
+    std::string user;
+    T value;
+};
 
-extern Json::Value json_user_value(Json::Value value);
-extern void json_number(Json::Value value, float *res);
+template <typename T>
+extern JsonValue<T> get_value(json jvalue, JsonValueType type);
     
 } // namespace Mauri
 
diff --git a/src/mauri.cc b/src/mauri.cc
index cb6e840..e8a509e 100644
--- a/src/mauri.cc
+++ b/src/mauri.cc
@@ -26,7 +26,7 @@ s32 main(s32 argc, char *argv[])
     //Context *context = new ContextX11(2560, 1440, "mauri", true);
     //Context *context = new ContextGLFW(720, 1280, "mauri", false);
     //Context *context = new ContextGLFW(810, 1440, "mauri", false);
-    Context *context = new ContextX11(1920, 1080, "mauri", false);
+    Context *context = new ContextX11(2560, 1440, "mauri", true);
 
     if (argc == 2)
     {
diff --git a/src/objects/effect.cc b/src/objects/effect.cc
index cbe0b7f..bc94c17 100644
--- a/src/objects/effect.cc
+++ b/src/objects/effect.cc
@@ -16,25 +16,25 @@
 
 using namespace Mauri;
 
-Effect::Effect(Json::Value root)
+Effect::Effect(json root)
 {
-    id = root["id"].asInt();
+    id = get_value<u32>(root["id"], INT);
 
-    visible = json_user_value(root.get("visible", true)).asBool();
+    visible = get_value<bool>(root["visible"], BOOL);
 
     for (auto &pass0 : root["passes"])
     {
         passes0.emplace_back(new Pass(pass0, EFFECT0_PASS));
     }
 
-    auto asset = asset_manager()->get_file(root["file"].asString(), NONE);
+    auto asset = asset_manager()->get_file(root["file"], NONE);
 
     if (asset->type == ASSET_VOID)
         return;
 
-    Json::Value file = asset->as_json();
+    auto file = json::parse(asset->as_string());
 
-    name = file["name"].asString();
+    name = get_value<std::string>(file["name"], STRING);
 
     for (auto &pass1 : file["passes"])
     {
@@ -43,17 +43,18 @@ Effect::Effect(Json::Value root)
 
     for (auto &fbo : file["fbos"])
     {
-        fbos.emplace_back((EffectBuffer) { fbo["name"].asString(), fbo["scale"].asFloat() });
+        fbos.emplace_back((EffectBuffer) { fbo["name"], fbo["scale"] });
     }
 }
 
 void Effect::load(Engine *engine, Object *object, bool last_effect)
 {
-    buffer_id = fmt::format("{}_{}", id, object->id);
+    buffer_id = fmt::format("{}_{}", id.value, object->id.value);
 
     for (auto &fbo : fbos)
     {
-        engine->create_framebuffer(fbo.name + buffer_id, object->size[0], object->size[1], fbo.scale);
+        engine->create_framebuffer(fbo.name + buffer_id, object->size.value[0],
+            object->size.value[1], fbo.scale);
     }
 
     for (u32 i = 0; i < passes0.size(); i++)
@@ -74,7 +75,7 @@ void Effect::load(Engine *engine, Object *object, bool last_effect)
 
 void Effect::draw(Engine *engine)
 {
-    if (!visible)
+    if (!visible.value)
         return;
     
     for (auto &pass : passes)
diff --git a/src/objects/effect.h b/src/objects/effect.h
index 010634c..29b4bb7 100644
--- a/src/objects/effect.h
+++ b/src/objects/effect.h
@@ -20,11 +20,11 @@ struct EffectBuffer
 class Effect
 {
   public:
-    Effect(Json::Value root);
+    Effect(json root);
     ~Effect();
 
-    u32 id;
-    std::string name;
+    JsonValue<u32> id;
+    JsonValue<std::string> name;
 
     std::string buffer_id;
 
@@ -32,7 +32,7 @@ class Effect
     void draw(Engine *engine);
 
   private:
-    bool visible;
+    JsonValue<bool> visible;
 
     std::vector<Pass *> passes0;
     std::vector<Pass *> passes1;
diff --git a/src/objects/material.cc b/src/objects/material.cc
index a1c2146..699c603 100644
--- a/src/objects/material.cc
+++ b/src/objects/material.cc
@@ -21,7 +21,7 @@ Material::Material(std::string path)
         return;
     }
 
-    Json::Value root = asset->as_json();
+    auto root = json::parse(asset->as_string());
 
     for (auto &pass : root["passes"])
     {
diff --git a/src/objects/material.h b/src/objects/material.h
index 24c2ea0..c27c720 100644
--- a/src/objects/material.h
+++ b/src/objects/material.h
@@ -3,6 +3,7 @@
 
 #include <iostream>
 
+#include "json.h"
 #include "engine.h"
 
 namespace Mauri
diff --git a/src/objects/model.cc b/src/objects/model.cc
index c45ac12..0574a92 100644
--- a/src/objects/model.cc
+++ b/src/objects/model.cc
@@ -19,13 +19,13 @@ Model::Model(std::string path)
         return;
     }
 
-    Json::Value root = asset->as_json();
+    auto root = json::parse(asset->as_string());
 
-    autosize = root.get("autosize", true).asBool();
-    fullscreen = root.get("fullscreen", false).asBool();
-    passthrough = root.get("passthrough", false).asBool();
+    autosize = get_value<bool>(root["autosize"], BOOL);
+    fullscreen = get_value<bool>(root["fullscreen"], BOOL);
+    passthrough = get_value<bool>(root["passthrough"], BOOL);
 
-    material = new Material(root["material"].asString());
+    material = new Material(root["material"]);
 }
 
 void Model::load(Engine *engine, Object *object, bool no_effects)
diff --git a/src/objects/model.h b/src/objects/model.h
index bc6ea93..9e67f07 100644
--- a/src/objects/model.h
+++ b/src/objects/model.h
@@ -4,6 +4,7 @@
 #include <iostream>
 
 #include "engine.h"
+#include "json.h"
 
 #include "objects/material.h"
 
@@ -16,9 +17,9 @@ class Model
     Model(std::string path);
     ~Model();
 
-    bool autosize;
-    bool fullscreen;
-    bool passthrough;
+    JsonValue<bool> autosize;
+    JsonValue<bool> fullscreen;
+    JsonValue<bool> passthrough;
 
     void load(Engine *engine, Object *object, bool no_effects);
 
diff --git a/src/objects/object.cc b/src/objects/object.cc
index 0a57adf..a41cfaa 100644
--- a/src/objects/object.cc
+++ b/src/objects/object.cc
@@ -13,39 +13,37 @@
 #include "../log.h"
 
 #include "objects/effect.h"
+#include "objects/model.h"
 #include "objects/object.h"
 #include "objects/scene.h"
 #include "objects/pass.h"
 
 using namespace Mauri;
 
-Object::Object(Json::Value root)
+Object::Object(json root)
 {
-    id = root["id"].asInt();
-    name = root["name"].asString();
+    id = get_value<u32>(root["id"], INT);
+    name = get_value<std::string>(root["id"], STRING);
 
     for (auto &id : root["dependencies"])
-        deps.push_back(id.asInt());
+        deps.push_back(id);
 
-    sscanf_vec3(json_user_value(root.get("angles", "")).asCString(), angles);
-    sscanf_vec3(json_user_value(root.get("colors", "")).asCString(), color);
-    sscanf_vec2(json_user_value(root.get("size", "0 0")).asCString(), size);
-    sscanf_vec3(json_user_value(root.get("scale", "")).asCString(), scale);
-    sscanf_vec3(json_user_value(root.get("origin", "")).asCString(), origin);
+    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);
 
-    color_blend_mode = (BlendMode)root.get("colorblendmode", 0).asInt();
+    color_blend_mode = (BlendMode)root["colorblendmode"];
 
-    visible = json_user_value(root.get("visible", true)).asBool();
+    visible = get_value<bool>(root["visible"], BOOL);
 
-    auto _image = root["image"];
-
-    if (!_image.isNull())
-        image = new Model(_image.asString());
+    image = new Model(root["image"]);
 
     auto config = root["config"];
 
-    if (!config.isNull())
-        passthrough = config.get("passthrough", false).asBool();
+    if (!config.is_null())
+        passthrough = get_value<bool>(config["passthrough"], BOOL);
 
     for (auto &effect : root["effects"])
     {
@@ -59,13 +57,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 * 2.f);
+    model = glm::translate(model, origin.value * 2.f);
 
-    model = glm::scale(model, scale);
+    model = glm::scale(model, scale.value);
 
-    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});
+    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});
 
     mat4x4 _ortho = glm::ortho(-width, width, height, -height, 0.f, 1.f);
 
@@ -84,27 +82,27 @@ void Object::load(Engine *engine)
 
     if (image != nullptr)
     {
-        if (image->passthrough)
+        if (image->passthrough.value)
             passthrough = true;
 
-        if (image->fullscreen || passthrough)
+        if (image->fullscreen.value || passthrough.value)
         {
-            if (size[0] == 0 && size[1] == 0)
+            if (size.value[0] == 0 && size.value[1] == 0)
             {
-                size[0] = engine->view.width;
-                size[1] = engine->view.height;
-                origin[0] = size[0] / 2.f;
-                origin[1] = size[1] / 2.f;
+                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;
             }
             fullscreen = true;
         }
     }
 
-    auto width = size[0];
-    auto height = size[1];
+    auto width = size.value[0];
+    auto height = size.value[1];
 
-    abuffer = fmt::format("_rt_imageLayerComposite_{}_a", this->id);
-    bbuffer = fmt::format("_rt_imageLayerComposite_{}_b", this->id);
+    abuffer = fmt::format("_rt_imageLayerComposite_{}_a", this->id.value);
+    bbuffer = fmt::format("_rt_imageLayerComposite_{}_b", this->id.value);
 
     engine->create_framebuffer(abuffer, width, height, 1.f);
     engine->create_framebuffer(bbuffer, width, height, 1.f);
@@ -116,8 +114,7 @@ void Object::load(Engine *engine)
     gl_object = new RenderObject(OBJECT, width, height);
     gl_uv_object = new RenderObject(UV_SCALE, width, height);
 
-    if (image != nullptr)
-        image->load(engine, this, effects.size() == 0);
+    image->load(engine, this, effects.size() == 0);
 
     for (u32 i = 0; i < effects.size(); i++)
     {
@@ -136,7 +133,7 @@ void Object::update(Engine *engine)
 
 void Object::draw(Engine *engine)
 {
-    if (!visible)
+    if (!visible.value)
         return;
 
     for (auto &pass : passes)
diff --git a/src/objects/object.h b/src/objects/object.h
index 0b22122..14b6615 100644
--- a/src/objects/object.h
+++ b/src/objects/object.h
@@ -28,18 +28,18 @@ enum BlendMode
 class Object
 {
   public:
-    Object(Json::Value root);
+    Object(json root);
     ~Object();
 
-    u32 id;
-    std::string name;
+    JsonValue<u32> id;
+    JsonValue<std::string> name;
 
     std::vector<int> deps;
 
-    bool passthrough = false;
-    bool fullscreen = false;
+    JsonValue<bool> passthrough;
+    JsonValue<bool> fullscreen;
 
-    vec2 size;
+    JsonValue<vec2> size;
 
     void get_model(f32 width, f32 height, bool flip);
 
@@ -66,15 +66,15 @@ class Object
     void draw(Engine *engine);
 
   private:
-    bool visible;
+    JsonValue<bool> visible;
 
     Model *image = nullptr;
 
-    vec3 angles;
-    vec3 color;
+    JsonValue<vec3> angles;
+    JsonValue<vec3> color;
 
-    vec3 origin;
-    vec3 scale;
+    JsonValue<vec3> origin;
+    JsonValue<vec3> scale;
 
     std::string abuffer;
     std::string bbuffer;
diff --git a/src/objects/pass.cc b/src/objects/pass.cc
index f4c237a..333694a 100644
--- a/src/objects/pass.cc
+++ b/src/objects/pass.cc
@@ -20,39 +20,32 @@
 
 using namespace Mauri;
 
-Pass::Pass(Json::Value root, PassStage stage)
+Pass::Pass(json root, PassStage stage)
 {
     switch (stage)
     {
     case EFFECT0_PASS: {
-        auto _uniforms = root["constantshadervalues"];
-
-        for (auto &name : _uniforms.getMemberNames())
+        for (auto &value : root["constantshadervalues"].items())
         {
-            auto uniform = Uniform();
-
-            uniform.name = name;
-
-            auto value = json_user_value(_uniforms[name]);
-            json_number(value, glm::value_ptr(uniform.value));
-
-            uniforms.push_back(uniform);
+            // 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)));
         }
 
         break;
     }
     case EFFECT1_PASS: {
-        auto _material = root["material"];
+        material = new Material(root["material"]);
 
-        if (_material.isString())
-            material = new Material(_material.asString());
+        auto _target = root["target"];
 
-        target = root.get("target", "previous").asString();
+        if (_target.is_string())
+            target = _target;
 
         for (auto &bind : root["bind"])
         {
-            auto index = bind["index"].asInt();
-            binds[index] = bind["name"].asString();
+            u32 index = bind["index"];
+            binds[index] = bind["name"];
         }
 
         break;
@@ -61,7 +54,7 @@ Pass::Pass(Json::Value root, PassStage stage)
         target = "previous";
         [[fallthrough]];
     case MATERIAL_PASS: {
-        shader = root["shader"].asString();
+        shader = root["shader"];
 
         //auto blending = root.get("blending", "normal").asString();
 
@@ -73,21 +66,26 @@ Pass::Pass(Json::Value root, PassStage stage)
         break;
     }
     }
-        
-    auto _textures = root["textures"];
 
-    for (int i = 0; i < _textures.size(); i++)
+    for (int i = 0; i < 8; i++)
     {
-        auto texture = _textures[i];
-        if (texture.isString())
-            textures[i] = texture.asString();
+        auto texture = root["textures"][i];
+        if (texture.is_string())
+            textures[i] = texture;
     }
 
-    auto _combos = root["combos"];
+    //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 &name : _combos.getMemberNames())
+    for (auto &combo : root["combos"].items())
     {
-        combos.emplace_back((Combo){name, _combos[name].asInt()});
+        combos.emplace_back((Combo) { combo.key(), combo.value() });
     }
 }
 
@@ -249,12 +247,12 @@ RenderPass::RenderPass(Engine *engine, Pass *pass)
 
     if (pass->effect == nullptr)
     {
-        if (pass->object->passthrough || combine)
+        if (pass->object->passthrough.value || combine)
             model = &pass->object->model;
         else
             model = &pass->object->ortho;
 
-        if (pass->object->passthrough)
+        if (pass->object->passthrough.value)
             robject = pass->object->gl_object;
         else
             robject = pass->object->gl_uv_object;
diff --git a/src/objects/pass.h b/src/objects/pass.h
index 92aa3e5..78de015 100644
--- a/src/objects/pass.h
+++ b/src/objects/pass.h
@@ -4,6 +4,7 @@
 #include <glm/glm.hpp>
 #include <jsoncpp/json/json.h>
 
+#include "json.h"
 #include "context.h"
 #include "engine.h"
 #include "gl.h"
@@ -29,7 +30,7 @@ class Pass
 {
   public:
     Pass() {}
-    Pass(Json::Value root, PassStage stage);
+    Pass(json root, PassStage stage);
 
     ~Pass();
 
diff --git a/src/objects/scene.cc b/src/objects/scene.cc
index 3cab05c..1e95f4b 100644
--- a/src/objects/scene.cc
+++ b/src/objects/scene.cc
@@ -1,10 +1,10 @@
 #include <istream>
-#include <jsoncpp/json/json.h>
 #include <sstream>
 
 #include "assets.h"
 #include "json.h"
 #include "log.h"
+#include "util.h"
 
 #include "objects/scene.h"
 #include "objects/pass.h"
@@ -20,24 +20,26 @@ Scene::Scene(std::string path)
         log_error("err: failed to open scene.json");
         return;
     }
-
-    Json::Value root = asset->as_json();
+    
+    auto root = json::parse(asset->as_string());
 
     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);
+
     auto general = root["general"];
-    auto ortho = general["orthogonalprojection"];
-    
-    sscanf_vec3(json_user_value(camera.get("center", "")).asCString(), cam.center);
-    sscanf_vec3(json_user_value(camera.get("eye", "")).asCString(), cam.eye);
-    sscanf_vec3(json_user_value(camera.get("up", "")).asCString(), cam.up);
 
-    clear_enabled = general.get("clearenabled", true).asBool();
+    clear_enabled = get_value<bool>(general["clearenabled"], BOOL);
 
-    sscanf_vec3(json_user_value(general.get("clearcolor", "")).asCString(), clear_color);
-    clear_color[3] = 1.f;
+    clear_color = get_value<vec4>(general["clearcolor"], VEC3);
+    clear_color.value[3] = 1.f;
+
+    auto ortho = general["orthogonalprojection"];
 
-    width = json_user_value(ortho.get("width", 0.f)).asFloat();
-    height = json_user_value(ortho.get("height", 0.f)).asFloat();
+    width = get_value<float>(ortho["width"], FLOAT);
+    height = get_value<float>(ortho["height"], FLOAT);
 
     for (auto &object : root["objects"])
     {
@@ -49,7 +51,7 @@ Object *Scene::get_object_by_id(u32 id)
 {
     for (auto &object : objects)
     {
-        if (object->id == id)
+        if (object->id.value == id)
         {
             return object;
         }
@@ -60,8 +62,8 @@ Object *Scene::get_object_by_id(u32 id)
 
 void Scene::load(Engine *engine)
 {
-    engine->view.width = width;
-    engine->view.height = height;
+    engine->view.width = width.value;
+    engine->view.height = height.value;
 
     for (auto &object : objects)
     {
diff --git a/src/objects/scene.h b/src/objects/scene.h
index 2f6f210..43a4442 100644
--- a/src/objects/scene.h
+++ b/src/objects/scene.h
@@ -8,6 +8,7 @@
 #include "assets.h"
 #include "engine.h"
 
+#include "json.h"
 #include "objects/object.h"
 
 using namespace glm;
@@ -16,13 +17,13 @@ namespace Mauri
 {
 
 struct Camera {
-    vec3 center;
-    vec3 eye;
-    vec3 up;
+    JsonValue<vec3> center;
+    JsonValue<vec3> eye;
+    JsonValue<vec3> up;
 
-    float farz;
-    float nearz;
-    float fov;
+    JsonValue<float> farz;
+    JsonValue<float> nearz;
+    JsonValue<float> fov;
 };
 
 class Scene
@@ -31,11 +32,11 @@ class Scene
     Scene(std::string path);
     ~Scene();
 
-    f32 width;
-    f32 height;
+    JsonValue<f32> width;
+    JsonValue<f32> height;
 
-    bool clear_enabled;
-    vec4 clear_color;
+    JsonValue<bool> clear_enabled;
+    JsonValue<vec4> clear_color;
 
     void load(Engine *engine);
     void draw(Engine *engine);
diff --git a/src/shader.cc b/src/shader.cc
index 57a34d8..eae4820 100644
--- a/src/shader.cc
+++ b/src/shader.cc
@@ -2,7 +2,6 @@
 #include <glm/ext.hpp>
 #include <glm/fwd.hpp>
 #include <glm/matrix.hpp>
-#include <jsoncpp/json/json.h>
 
 #include <fmt/core.h>
 
@@ -63,7 +62,8 @@ std::string Shader::build_shader_source(std::string isource, bool root)
             auto type_string = line.substr(line.find(' ') + 1);
 
             auto type = TYPE_INVALID;
-            auto value = vec4(0.f);
+            
+            JsonValue<vec4> value;
 
             if (type_string.compare(0, 5, "float") == 0)
                 type = TYPE_FLOAT;
@@ -78,7 +78,7 @@ std::string Shader::build_shader_source(std::string isource, bool root)
             else if (type_string.compare(0, 9, "sampler2D") == 0)
             {
                 type = TYPE_SAMPLER2D;
-                value[0] = this->texture_count++;
+                value.value[0] = this->texture_count++;
             }
 
             auto open = type_string.find(' ') + 1;
@@ -92,9 +92,7 @@ std::string Shader::build_shader_source(std::string isource, bool root)
             {
                 auto combo_string = line.substr(combo_start + 2);
 
-                Json::Value root;
-
-                std::stringstream(combo_string) >> root;
+                json root = json::parse(combo_string);
 
                 // If material is present, it's always used to reference this
                 // uniform for setting its values. If material is not present,
@@ -102,67 +100,49 @@ std::string Shader::build_shader_source(std::string isource, bool root)
                 auto label = root["label"];
                 auto material = root["material"];
 
-                if (!material.isNull())
-                    name = material.asString();
-                else if (!label.isNull())
-                    name = label.asString();
+                if (!material.is_null())
+                    name = material;
+                else if (!label.is_null())
+                    name = label;
 
                 switch (type)
                 {
                 case TYPE_SAMPLER2D: {
-                    auto index = (int)value[0];
-
                     auto _default = root["default"];
 
-                    if (!_default.isNull())
-                        this->textures[index] = _default.asString();
+                    if (!_default.is_null())
+                        this->textures[(int)(value.value[0])] = _default;
 
                     auto combo = root["combo"];
 
-                    if (!combo.isNull())
-                        this->combos.emplace_back((Combo) { .name = combo.asString(), .value = 1 });
+                    if (!combo.is_null())
+                        this->combos.emplace_back((Combo) { .name = combo, .value = 1 });
 
                     break;
                 }
-                case TYPE_FLOAT: {
-                    auto _value = root["default"];
-                    if (_value.isString())
-                        sscanf_vec2(_value.asCString(), value);
-                    else if (_value.isNumeric())
-                        value[0] = _value.asFloat();
-                    break;
-                }
+                case TYPE_FLOAT:
                 case TYPE_VEC4:
-                    sscanf_vec4(root.get("default", "").asCString(), value);
-                    break;
                 case TYPE_VEC3:
-                    sscanf_vec3(root.get("default", "").asCString(), value);
-                    break;
                 case TYPE_VEC2:
-                    sscanf_vec2(root.get("default", "").asCString(), value);
+                    value = get_value<vec4>(root["default"], VEC4);
                     break;
                 case TYPE_MAT4:
                 case TYPE_INVALID:
-                    value = glm::vec4(0.f);
+                    value.value = glm::vec4(0.f);
                     break;
                 }
             }
 
-            this->uniforms.emplace_back((Uniform){type, name, uname, value});
+            this->uniforms.emplace_back(Uniform(name, uname, type, value));
         }
         else if (line.compare(0, 10, "// [COMBO]") == 0)
         {
             auto open = line.find('{');
             auto combo = line.substr(open, line.length() - open);
 
-            Json::Value root;
-
-            std::stringstream(combo) >> root;
-
-            auto _combo = root["combo"].asString();
-            auto _value = root["default"].asInt();
+            auto root = json::parse(combo);
 
-            this->combos.emplace_back((Combo) { _combo, _value });
+            this->combos.emplace_back((Combo) { root["combo"], root["default"] });
         }
 
         if (!cut_line) source << line << "\n";
@@ -218,7 +198,7 @@ void Shader::bind(Engine *engine, mat4x4 *model)
         if (uniform.uname.find('[') != std::string::npos)
             continue;
         //std::cout << uniform.uname << " " << uniform.value[0] << "\n";
-        this->rshader->set_uniform(uniform.uname, uniform.type, glm::value_ptr(uniform.value));
+        this->rshader->set_uniform(uniform.uname, uniform.type, glm::value_ptr(uniform.value.value));
     }
 
     this->rshader->set_uniform("g_Time", TYPE_FLOAT, &engine->time);
diff --git a/src/shader.h b/src/shader.h
index bd4a80c..a878d4f 100644
--- a/src/shader.h
+++ b/src/shader.h
@@ -5,6 +5,7 @@
 
 #include "gl.h"
 #include "texture.h"
+#include "json.h"
 
 using namespace glm;
 
@@ -13,12 +14,22 @@ namespace Mauri
 
 struct Uniform
 {
-    UniformType type;
+    Uniform(std::string name, JsonValue<vec4> value)
+        : name(name), value(value)
+    {
+    }
+
+    Uniform(std::string name, std::string uname, UniformType type, JsonValue<vec4> value)
+        : name(name), uname(uname), type(type), value(value)
+    {
+    }
 
     std::string name;
     std::string uname;
 
-    vec4 value;
+    UniformType type;
+
+    JsonValue<vec4> value;
 };
 
 struct Combo
diff --git a/src/util.h b/src/util.h
index f81b7f7..a1bdb40 100644
--- a/src/util.h
+++ b/src/util.h
@@ -2,6 +2,9 @@
 #define _UTIL_H
 
 #include <stdint.h>
+#include <nlohmann/json.hpp>
+
+using namespace nlohmann;
 
 typedef uint32_t u32;
 typedef int32_t s32;
-- 
cgit v1.2.3-101-g0448