From 3b0862afe58034f902a90390eb5e9e52110a0fac Mon Sep 17 00:00:00 2001
From: Lubos Lenco <lubos.lenco@gmail.com>
Date: Mon, 11 Jan 2016 13:07:44 +0100
Subject: [PATCH] Include only referenced shaders

---
 Assets/deferred_pass_resource.json            |   15 +-
 ...er_resource.json => forward_resource.json} |  832 ++-
 Assets/pipeline_resource.json                 |    8 +-
 blender/__pycache__/armory.cpython-34.pyc     |  Bin 0 -> 39117 bytes
 blender/__pycache__/project.cpython-34.pyc    |  Bin 11319 -> 11442 bytes
 blender/__pycache__/start.cpython-34.pyc      |  Bin 709 -> 710 bytes
 blender/__pycache__/write_data.cpython-34.pyc |  Bin 2023 -> 2157 bytes
 blender/{scene.py => armory.py}               |   77 +-
 blender/plugin/cyclesgame.py                  |    5 +-
 blender/project.py                            |   11 +-
 blender/start.py                              |    6 +-
 blender/write_data.py                         |   15 +-
 compiled/Assets/attrib_pass_resource.json     | 3156 +++++++++
 compiled/Assets/deferred_pass_resource.json   |   37 +
 compiled/Assets/env_map_resource.json         |   42 +
 compiled/Assets/forward_resource.json         | 6308 +++++++++++++++++
 .../Shaders}/attrib_pass.frag.glsl            |    0
 .../Shaders/attrib_pass.vert.glsl             |    0
 .../Shaders/attrib_pass_Instancing.frag.glsl  |   41 +
 .../Shaders/attrib_pass_Instancing.vert.glsl  |    0
 ...ib_pass_Instancing_NormalMapping.frag.glsl |   42 +
 ...ib_pass_Instancing_NormalMapping.vert.glsl |    0
 ...nstancing_NormalMapping_Skinning.frag.glsl |   43 +
 ...nstancing_NormalMapping_Skinning.vert.glsl |    0
 ...NormalMapping_Skinning_Texturing.frag.glsl |   44 +
 ...NormalMapping_Skinning_Texturing.vert.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.frag.glsl |   45 +
 ...Mapping_Skinning_Texturing_VCols.vert.glsl |    0
 ...ing_NormalMapping_Skinning_VCols.frag.glsl |   44 +
 ...ing_NormalMapping_Skinning_VCols.vert.glsl |    0
 ...stancing_NormalMapping_Texturing.frag.glsl |   43 +
 ...stancing_NormalMapping_Texturing.vert.glsl |    0
 ...ng_NormalMapping_Texturing_VCols.frag.glsl |   44 +
 ...ng_NormalMapping_Texturing_VCols.vert.glsl |    0
 ...s_Instancing_NormalMapping_VCols.frag.glsl |   43 +
 ...s_Instancing_NormalMapping_VCols.vert.glsl |    0
 .../attrib_pass_Instancing_Skinning.frag.glsl |   42 +
 .../attrib_pass_Instancing_Skinning.vert.glsl |    0
 ...ss_Instancing_Skinning_Texturing.frag.glsl |   43 +
 ...ss_Instancing_Skinning_Texturing.vert.glsl |    0
 ...tancing_Skinning_Texturing_VCols.frag.glsl |   44 +
 ...tancing_Skinning_Texturing_VCols.vert.glsl |    0
 ...b_pass_Instancing_Skinning_VCols.frag.glsl |   43 +
 ...b_pass_Instancing_Skinning_VCols.vert.glsl |    0
 ...attrib_pass_Instancing_Texturing.frag.glsl |   42 +
 ...attrib_pass_Instancing_Texturing.vert.glsl |    0
 ..._pass_Instancing_Texturing_VCols.frag.glsl |   43 +
 ..._pass_Instancing_Texturing_VCols.vert.glsl |    0
 .../attrib_pass_Instancing_VCols.frag.glsl    |   42 +
 .../attrib_pass_Instancing_VCols.vert.glsl    |    0
 .../attrib_pass_NormalMapping.frag.glsl       |   41 +
 .../attrib_pass_NormalMapping.vert.glsl       |    0
 ...trib_pass_NormalMapping_Skinning.frag.glsl |   42 +
 ...trib_pass_NormalMapping_Skinning.vert.glsl |    0
 ...NormalMapping_Skinning_Texturing.frag.glsl |   43 +
 ...NormalMapping_Skinning_Texturing.vert.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.frag.glsl |   44 +
 ...Mapping_Skinning_Texturing_VCols.vert.glsl |    0
 ...ass_NormalMapping_Skinning_VCols.frag.glsl |   43 +
 ...ass_NormalMapping_Skinning_VCols.vert.glsl |    0
 ...rib_pass_NormalMapping_Texturing.frag.glsl |   42 +
 ...rib_pass_NormalMapping_Texturing.vert.glsl |    0
 ...ss_NormalMapping_Texturing_VCols.frag.glsl |   43 +
 ...ss_NormalMapping_Texturing_VCols.vert.glsl |    0
 .../attrib_pass_NormalMapping_VCols.frag.glsl |   42 +
 .../attrib_pass_NormalMapping_VCols.vert.glsl |    0
 .../Shaders/attrib_pass_Skinning.frag.glsl    |   41 +
 .../Shaders/attrib_pass_Skinning.vert.glsl    |    0
 .../attrib_pass_Skinning_Texturing.frag.glsl  |   42 +
 .../attrib_pass_Skinning_Texturing.vert.glsl  |    0
 ...ib_pass_Skinning_Texturing_VCols.frag.glsl |   43 +
 ...ib_pass_Skinning_Texturing_VCols.vert.glsl |    0
 .../attrib_pass_Skinning_VCols.frag.glsl      |   42 +
 .../attrib_pass_Skinning_VCols.vert.glsl      |    0
 .../Shaders/attrib_pass_Texturing.frag.glsl   |   41 +
 .../Shaders/attrib_pass_Texturing.vert.glsl   |    0
 .../attrib_pass_Texturing_VCols.frag.glsl     |   42 +
 .../attrib_pass_Texturing_VCols.vert.glsl     |    0
 compiled/Shaders/attrib_pass_VCols.frag.glsl  |   41 +
 .../Shaders/attrib_pass_VCols.vert.glsl       |    0
 .../Shaders/deferred_pass.frag.glsl           |    0
 .../Shaders/deferred_pass.vert.glsl           |    0
 .../Shaders}/env_map.frag.glsl                |    0
 .../Shaders}/env_map.vert.glsl                |    0
 .../Shaders/forward.frag.glsl                 |    0
 .../Shaders/forward.vert.glsl                 |    0
 .../Shaders/forward_AlphaTest.frag.glsl       |    0
 .../Shaders/forward_AlphaTest.vert.glsl       |    0
 .../forward_AlphaTest_Instancing.frag.glsl    |    0
 .../forward_AlphaTest_Instancing.vert.glsl    |    0
 ...phaTest_Instancing_NormalMapping.frag.glsl |    0
 ...phaTest_Instancing_NormalMapping.vert.glsl |    0
 ...nstancing_NormalMapping_Skinning.frag.glsl |    0
 ...nstancing_NormalMapping_Skinning.vert.glsl |    0
 ...NormalMapping_Skinning_Texturing.frag.glsl |    0
 ...NormalMapping_Skinning_Texturing.vert.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.frag.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.vert.glsl |    0
 ...ing_NormalMapping_Skinning_VCols.frag.glsl |    0
 ...ing_NormalMapping_Skinning_VCols.vert.glsl |    0
 ...stancing_NormalMapping_Texturing.frag.glsl |    0
 ...stancing_NormalMapping_Texturing.vert.glsl |    0
 ...ng_NormalMapping_Texturing_VCols.frag.glsl |    0
 ...ng_NormalMapping_Texturing_VCols.vert.glsl |    0
 ...t_Instancing_NormalMapping_VCols.frag.glsl |    0
 ...t_Instancing_NormalMapping_VCols.vert.glsl |    0
 ...rd_AlphaTest_Instancing_Skinning.frag.glsl |    0
 ...rd_AlphaTest_Instancing_Skinning.vert.glsl |    0
 ...st_Instancing_Skinning_Texturing.frag.glsl |    0
 ...st_Instancing_Skinning_Texturing.vert.glsl |    0
 ...tancing_Skinning_Texturing_VCols.frag.glsl |    0
 ...tancing_Skinning_Texturing_VCols.vert.glsl |    0
 ...haTest_Instancing_Skinning_VCols.frag.glsl |    0
 ...haTest_Instancing_Skinning_VCols.vert.glsl |    0
 ...d_AlphaTest_Instancing_Texturing.frag.glsl |    0
 ...d_AlphaTest_Instancing_Texturing.vert.glsl |    0
 ...aTest_Instancing_Texturing_VCols.frag.glsl |    0
 ...aTest_Instancing_Texturing_VCols.vert.glsl |    0
 ...rward_AlphaTest_Instancing_VCols.frag.glsl |    0
 ...rward_AlphaTest_Instancing_VCols.vert.glsl |    0
 .../forward_AlphaTest_NormalMapping.frag.glsl |    0
 .../forward_AlphaTest_NormalMapping.vert.glsl |    0
 ...AlphaTest_NormalMapping_Skinning.frag.glsl |    0
 ...AlphaTest_NormalMapping_Skinning.vert.glsl |    0
 ...NormalMapping_Skinning_Texturing.frag.glsl |    0
 ...NormalMapping_Skinning_Texturing.vert.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.frag.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.vert.glsl |    0
 ...est_NormalMapping_Skinning_VCols.frag.glsl |    0
 ...est_NormalMapping_Skinning_VCols.vert.glsl |    0
 ...lphaTest_NormalMapping_Texturing.frag.glsl |    0
 ...lphaTest_NormalMapping_Texturing.vert.glsl |    0
 ...st_NormalMapping_Texturing_VCols.frag.glsl |    0
 ...st_NormalMapping_Texturing_VCols.vert.glsl |    0
 ...rd_AlphaTest_NormalMapping_VCols.frag.glsl |    0
 ...rd_AlphaTest_NormalMapping_VCols.vert.glsl |    0
 .../forward_AlphaTest_Skinning.frag.glsl      |    0
 .../forward_AlphaTest_Skinning.vert.glsl      |    0
 ...ard_AlphaTest_Skinning_Texturing.frag.glsl |    0
 ...ard_AlphaTest_Skinning_Texturing.vert.glsl |    0
 ...phaTest_Skinning_Texturing_VCols.frag.glsl |    0
 ...phaTest_Skinning_Texturing_VCols.vert.glsl |    0
 ...forward_AlphaTest_Skinning_VCols.frag.glsl |    0
 ...forward_AlphaTest_Skinning_VCols.vert.glsl |    0
 .../forward_AlphaTest_Texturing.frag.glsl     |    0
 .../forward_AlphaTest_Texturing.vert.glsl     |    0
 ...orward_AlphaTest_Texturing_VCols.frag.glsl |    0
 ...orward_AlphaTest_Texturing_VCols.vert.glsl |    0
 .../Shaders/forward_AlphaTest_VCols.frag.glsl |    0
 .../Shaders/forward_AlphaTest_VCols.vert.glsl |    0
 .../Shaders/forward_Instancing.frag.glsl      |    0
 compiled/Shaders/forward_Instancing.vert.glsl |  136 +
 ...forward_Instancing_NormalMapping.frag.glsl |    0
 ...forward_Instancing_NormalMapping.vert.glsl |  137 +
 ...nstancing_NormalMapping_Skinning.frag.glsl |    0
 ...nstancing_NormalMapping_Skinning.vert.glsl |  138 +
 ...NormalMapping_Skinning_Texturing.frag.glsl |    0
 ...NormalMapping_Skinning_Texturing.vert.glsl |  139 +
 ...Mapping_Skinning_Texturing_VCols.frag.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.vert.glsl |  140 +
 ...ing_NormalMapping_Skinning_VCols.frag.glsl |    0
 ...ing_NormalMapping_Skinning_VCols.vert.glsl |  139 +
 ...stancing_NormalMapping_Texturing.frag.glsl |    0
 ...stancing_NormalMapping_Texturing.vert.glsl |  138 +
 ...ng_NormalMapping_Texturing_VCols.frag.glsl |    0
 ...ng_NormalMapping_Texturing_VCols.vert.glsl |  139 +
 ...d_Instancing_NormalMapping_VCols.frag.glsl |    0
 ...d_Instancing_NormalMapping_VCols.vert.glsl |  138 +
 .../forward_Instancing_Skinning.frag.glsl     |    0
 .../forward_Instancing_Skinning.vert.glsl     |  137 +
 ...rd_Instancing_Skinning_Texturing.frag.glsl |    0
 ...rd_Instancing_Skinning_Texturing.vert.glsl |  138 +
 ...tancing_Skinning_Texturing_VCols.frag.glsl |    0
 ...tancing_Skinning_Texturing_VCols.vert.glsl |  139 +
 ...orward_Instancing_Skinning_VCols.frag.glsl |    0
 ...orward_Instancing_Skinning_VCols.vert.glsl |  138 +
 .../forward_Instancing_Texturing.frag.glsl    |    0
 .../forward_Instancing_Texturing.vert.glsl    |  137 +
 ...rward_Instancing_Texturing_VCols.frag.glsl |    0
 ...rward_Instancing_Texturing_VCols.vert.glsl |  138 +
 .../forward_Instancing_VCols.frag.glsl        |    0
 .../forward_Instancing_VCols.vert.glsl        |  137 +
 .../Shaders/forward_NormalMapping.frag.glsl   |    0
 .../Shaders/forward_NormalMapping.vert.glsl   |  136 +
 .../forward_NormalMapping_Skinning.frag.glsl  |    0
 .../forward_NormalMapping_Skinning.vert.glsl  |  137 +
 ...NormalMapping_Skinning_Texturing.frag.glsl |    0
 ...NormalMapping_Skinning_Texturing.vert.glsl |  138 +
 ...Mapping_Skinning_Texturing_VCols.frag.glsl |    0
 ...Mapping_Skinning_Texturing_VCols.vert.glsl |  139 +
 ...ard_NormalMapping_Skinning_VCols.frag.glsl |    0
 ...ard_NormalMapping_Skinning_VCols.vert.glsl |  138 +
 .../forward_NormalMapping_Texturing.frag.glsl |    0
 .../forward_NormalMapping_Texturing.vert.glsl |  137 +
 ...rd_NormalMapping_Texturing_VCols.frag.glsl |    0
 ...rd_NormalMapping_Texturing_VCols.vert.glsl |  138 +
 .../forward_NormalMapping_VCols.frag.glsl     |    0
 .../forward_NormalMapping_VCols.vert.glsl     |  137 +
 .../Shaders/forward_Skinning.frag.glsl        |    0
 compiled/Shaders/forward_Skinning.vert.glsl   |  136 +
 .../forward_Skinning_Texturing.frag.glsl      |    0
 .../forward_Skinning_Texturing.vert.glsl      |  137 +
 ...forward_Skinning_Texturing_VCols.frag.glsl |    0
 ...forward_Skinning_Texturing_VCols.vert.glsl |  138 +
 .../Shaders/forward_Skinning_VCols.frag.glsl  |    0
 .../Shaders/forward_Skinning_VCols.vert.glsl  |  137 +
 .../Shaders/forward_Texturing.frag.glsl       |    0
 compiled/Shaders/forward_Texturing.vert.glsl  |  136 +
 .../Shaders/forward_Texturing_VCols.frag.glsl |    0
 .../Shaders/forward_Texturing_VCols.vert.glsl |  137 +
 .../Shaders/forward_VCols.frag.glsl           |    0
 compiled/Shaders/forward_VCols.vert.glsl      |  136 +
 haxelib.json                                  |    4 +-
 khafile.js                                    |    7 +
 .../attrib_pass}/attrib_pass.frag.glsl        |    9 +-
 .../attrib_pass/attrib_pass.shader.json       |    0
 .../attrib_pass/attrib_pass.vert.glsl         |    0
 raw/compile.py                                |    1 +
 .../deferred_pass/deferred_pass.frag.glsl     |    0
 .../deferred_pass/deferred_pass.shader.json   |    0
 .../deferred_pass/deferred_pass.vert.glsl     |    0
 raw/env_map/env_map.frag.glsl                 |   22 +
 .../env_map/env_map.shader.json               |    0
 raw/env_map/env_map.vert.glsl                 |   71 +
 .../forward/forward.frag.glsl                 |    8 +-
 .../forward/forward.shader.json               |    6 +-
 .../forward/forward.shader_withshadow.json    |    6 +-
 .../forward/forward.vert.glsl                 |    0
 .../forward}/shadow_map.frag.glsl             |    0
 .../forward}/shadow_map.vert.glsl             |    0
 {shader_data => raw}/makeres.py               |    0
 {shader_data => raw}/makevariants.py          |    0
 232 files changed, 15825 insertions(+), 406 deletions(-)
 rename Assets/{blender_resource.json => forward_resource.json} (89%)
 create mode 100644 blender/__pycache__/armory.cpython-34.pyc
 rename blender/{scene.py => armory.py} (97%)
 create mode 100644 compiled/Assets/attrib_pass_resource.json
 create mode 100644 compiled/Assets/deferred_pass_resource.json
 create mode 100644 compiled/Assets/env_map_resource.json
 create mode 100644 compiled/Assets/forward_resource.json
 rename {shader_data/attrib_pass => compiled/Shaders}/attrib_pass.frag.glsl (100%)
 rename {Sources => compiled}/Shaders/attrib_pass.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing.frag.glsl
 rename Sources/Shaders_/blender_Instancing.vert.glsl => compiled/Shaders/attrib_pass_Instancing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Texturing.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_Skinning.frag.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning.vert.glsl => compiled/Shaders/attrib_pass_Instancing_Skinning.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.frag.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning_Texturing.vert.glsl => compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_Texturing.frag.glsl
 rename Sources/Shaders_/blender_Instancing_Texturing.vert.glsl => compiled/Shaders/attrib_pass_Instancing_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Instancing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Instancing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Instancing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_Skinning.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_Skinning.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning_Texturing.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning_VCols.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_Texturing.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_Texturing.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_NormalMapping_VCols.frag.glsl
 rename Sources/Shaders_/blender_NormalMapping_VCols.vert.glsl => compiled/Shaders/attrib_pass_NormalMapping_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Skinning.frag.glsl
 rename Sources/Shaders_/blender_Skinning.vert.glsl => compiled/Shaders/attrib_pass_Skinning.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Skinning_Texturing.frag.glsl
 rename Sources/Shaders_/blender_Skinning_Texturing.vert.glsl => compiled/Shaders/attrib_pass_Skinning_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Skinning_VCols.frag.glsl
 rename Sources/Shaders_/blender_Skinning_VCols.vert.glsl => compiled/Shaders/attrib_pass_Skinning_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Texturing.frag.glsl
 rename Sources/Shaders_/blender_Texturing.vert.glsl => compiled/Shaders/attrib_pass_Texturing.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_Texturing_VCols.frag.glsl
 rename Sources/Shaders_/blender_Texturing_VCols.vert.glsl => compiled/Shaders/attrib_pass_Texturing_VCols.vert.glsl (100%)
 create mode 100644 compiled/Shaders/attrib_pass_VCols.frag.glsl
 rename Sources/Shaders_/blender_VCols.vert.glsl => compiled/Shaders/attrib_pass_VCols.vert.glsl (100%)
 rename {Sources => compiled}/Shaders/deferred_pass.frag.glsl (100%)
 rename {Sources => compiled}/Shaders/deferred_pass.vert.glsl (100%)
 rename {shader_data/env_map => compiled/Shaders}/env_map.frag.glsl (100%)
 rename {shader_data/env_map => compiled/Shaders}/env_map.vert.glsl (100%)
 rename shader_data/forward_pass/blender.frag.glsl => compiled/Shaders/forward.frag.glsl (100%)
 rename Sources/Shaders_/blender.vert.glsl => compiled/Shaders/forward.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest.frag.glsl => compiled/Shaders/forward_AlphaTest.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest.vert.glsl => compiled/Shaders/forward_AlphaTest.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Skinning_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Instancing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Instancing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Instancing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_NormalMapping_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_NormalMapping_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning.frag.glsl => compiled/Shaders/forward_AlphaTest_Skinning.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning.vert.glsl => compiled/Shaders/forward_AlphaTest_Skinning.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_Skinning_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_Skinning_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Skinning_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Skinning_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Skinning_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Skinning_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Skinning_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Texturing.frag.glsl => compiled/Shaders/forward_AlphaTest_Texturing.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Texturing.vert.glsl => compiled/Shaders/forward_AlphaTest_Texturing.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Texturing_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_Texturing_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_Texturing_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_Texturing_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_VCols.frag.glsl => compiled/Shaders/forward_AlphaTest_VCols.frag.glsl (100%)
 rename Sources/Shaders_/blender_AlphaTest_VCols.vert.glsl => compiled/Shaders/forward_AlphaTest_VCols.vert.glsl (100%)
 rename Sources/Shaders_/blender_Instancing.frag.glsl => compiled/Shaders/forward_Instancing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_Skinning.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_Skinning.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_VCols.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Texturing.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_Texturing.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_Texturing_VCols.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_NormalMapping_VCols.frag.glsl => compiled/Shaders/forward_Instancing_NormalMapping_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_NormalMapping_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning.frag.glsl => compiled/Shaders/forward_Instancing_Skinning.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_Skinning.vert.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_Instancing_Skinning_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_Skinning_Texturing.vert.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_Skinning_VCols.frag.glsl => compiled/Shaders/forward_Instancing_Skinning_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_Skinning_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_Texturing.frag.glsl => compiled/Shaders/forward_Instancing_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_Texturing.vert.glsl
 rename Sources/Shaders_/blender_Instancing_Texturing_VCols.frag.glsl => compiled/Shaders/forward_Instancing_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_Instancing_VCols.frag.glsl => compiled/Shaders/forward_Instancing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Instancing_VCols.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping.frag.glsl => compiled/Shaders/forward_NormalMapping.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning.frag.glsl => compiled/Shaders/forward_NormalMapping_Skinning.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_Skinning.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_NormalMapping_Skinning_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_Skinning_Texturing.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_Skinning_VCols.frag.glsl => compiled/Shaders/forward_NormalMapping_Skinning_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_Skinning_VCols.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_Texturing.frag.glsl => compiled/Shaders/forward_NormalMapping_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_Texturing.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_Texturing_VCols.frag.glsl => compiled/Shaders/forward_NormalMapping_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_NormalMapping_VCols.frag.glsl => compiled/Shaders/forward_NormalMapping_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_NormalMapping_VCols.vert.glsl
 rename Sources/Shaders_/blender_Skinning.frag.glsl => compiled/Shaders/forward_Skinning.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Skinning.vert.glsl
 rename Sources/Shaders_/blender_Skinning_Texturing.frag.glsl => compiled/Shaders/forward_Skinning_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Skinning_Texturing.vert.glsl
 rename Sources/Shaders_/blender_Skinning_Texturing_VCols.frag.glsl => compiled/Shaders/forward_Skinning_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Skinning_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_Skinning_VCols.frag.glsl => compiled/Shaders/forward_Skinning_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Skinning_VCols.vert.glsl
 rename Sources/Shaders_/blender_Texturing.frag.glsl => compiled/Shaders/forward_Texturing.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Texturing.vert.glsl
 rename Sources/Shaders_/blender_Texturing_VCols.frag.glsl => compiled/Shaders/forward_Texturing_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_Texturing_VCols.vert.glsl
 rename Sources/Shaders_/blender_VCols.frag.glsl => compiled/Shaders/forward_VCols.frag.glsl (100%)
 create mode 100644 compiled/Shaders/forward_VCols.vert.glsl
 create mode 100644 khafile.js
 rename {Sources/Shaders => raw/attrib_pass}/attrib_pass.frag.glsl (77%)
 rename {shader_data => raw}/attrib_pass/attrib_pass.shader.json (100%)
 rename {shader_data => raw}/attrib_pass/attrib_pass.vert.glsl (100%)
 create mode 100644 raw/compile.py
 rename {shader_data => raw}/deferred_pass/deferred_pass.frag.glsl (100%)
 rename {shader_data => raw}/deferred_pass/deferred_pass.shader.json (100%)
 rename {shader_data => raw}/deferred_pass/deferred_pass.vert.glsl (100%)
 create mode 100644 raw/env_map/env_map.frag.glsl
 rename {shader_data => raw}/env_map/env_map.shader.json (100%)
 create mode 100644 raw/env_map/env_map.vert.glsl
 rename Sources/Shaders_/blender.frag.glsl => raw/forward/forward.frag.glsl (96%)
 rename shader_data/forward_pass/blender.shader.json => raw/forward/forward.shader.json (89%)
 rename shader_data/forward_pass/blender.shader_withshadow.json => raw/forward/forward.shader_withshadow.json (93%)
 rename shader_data/forward_pass/blender.vert.glsl => raw/forward/forward.vert.glsl (100%)
 rename {shader_data/forward_pass => raw/forward}/shadow_map.frag.glsl (100%)
 rename {shader_data/forward_pass => raw/forward}/shadow_map.vert.glsl (100%)
 rename {shader_data => raw}/makeres.py (100%)
 rename {shader_data => raw}/makevariants.py (100%)

diff --git a/Assets/deferred_pass_resource.json b/Assets/deferred_pass_resource.json
index d52a88fc..7113c194 100644
--- a/Assets/deferred_pass_resource.json
+++ b/Assets/deferred_pass_resource.json
@@ -6,20 +6,9 @@
                     "blend_destination": "blend_zero", 
                     "blend_source": "blend_one", 
                     "compare_mode": "always", 
-                    "constants": [
-                         {
-                            "id": "light", 
-                            "link": "_lightPosition", 
-                            "type": "vec3"
-                        }, 
-                        {
-                            "id": "eye", 
-                            "link": "_cameraPosition", 
-                            "type": "vec3"
-                        }
-                    ], 
+                    "constants": [], 
                     "cull_mode": "none", 
-                    "depth_write": true, 
+                    "depth_write": false, 
                     "fragment_shader": "deferred_pass.frag", 
                     "id": "deferred_pass", 
                     "texture_units": [
diff --git a/Assets/blender_resource.json b/Assets/forward_resource.json
similarity index 89%
rename from Assets/blender_resource.json
rename to Assets/forward_resource.json
index ad1ef80b..00b0d82d 100644
--- a/Assets/blender_resource.json
+++ b/Assets/forward_resource.json
@@ -50,7 +50,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -58,17 +61,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender.vert"
+                    "vertex_shader": "forward.vert"
                 }
             ], 
-            "id": "blender", 
+            "id": "forward", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -130,7 +133,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -138,17 +144,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest.vert"
+                    "vertex_shader": "forward_AlphaTest.vert"
                 }
             ], 
-            "id": "blender_AlphaTest", 
+            "id": "forward_AlphaTest", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -210,7 +216,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -218,17 +227,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing.vert"
+                    "vertex_shader": "forward_Instancing.vert"
                 }
             ], 
-            "id": "blender_Instancing", 
+            "id": "forward_Instancing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -290,7 +299,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -298,8 +310,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -308,10 +320,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping.vert"
+                    "vertex_shader": "forward_NormalMapping.vert"
                 }
             ], 
-            "id": "blender_NormalMapping", 
+            "id": "forward_NormalMapping", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -382,7 +394,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -390,17 +405,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Skinning.vert"
+                    "vertex_shader": "forward_Skinning.vert"
                 }
             ], 
-            "id": "blender_Skinning", 
+            "id": "forward_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -470,7 +485,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -478,8 +496,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -488,10 +506,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Texturing.vert"
+                    "vertex_shader": "forward_Texturing.vert"
                 }
             ], 
-            "id": "blender_Texturing", 
+            "id": "forward_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -557,7 +575,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -565,17 +586,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_VCols.vert"
+                    "vertex_shader": "forward_VCols.vert"
                 }
             ], 
-            "id": "blender_VCols", 
+            "id": "forward_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -641,7 +662,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -649,17 +673,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing", 
+            "id": "forward_AlphaTest_Instancing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -721,7 +745,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -729,8 +756,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -739,10 +766,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping", 
+            "id": "forward_AlphaTest_NormalMapping", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -813,7 +840,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -821,17 +851,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Skinning.vert"
+                    "vertex_shader": "forward_AlphaTest_Skinning.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Skinning", 
+            "id": "forward_AlphaTest_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -901,7 +931,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -909,8 +942,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -919,10 +952,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Texturing", 
+            "id": "forward_AlphaTest_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -988,7 +1021,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -996,17 +1032,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_VCols", 
+            "id": "forward_AlphaTest_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1072,7 +1108,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1080,8 +1119,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -1090,10 +1129,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping", 
+            "id": "forward_Instancing_NormalMapping", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1164,7 +1203,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1172,17 +1214,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_Skinning.vert"
+                    "vertex_shader": "forward_Instancing_Skinning.vert"
                 }
             ], 
-            "id": "blender_Instancing_Skinning", 
+            "id": "forward_Instancing_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1252,7 +1294,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1260,8 +1305,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -1270,10 +1315,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_Texturing.vert"
+                    "vertex_shader": "forward_Instancing_Texturing.vert"
                 }
             ], 
-            "id": "blender_Instancing_Texturing", 
+            "id": "forward_Instancing_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1339,7 +1384,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1347,17 +1395,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_VCols.vert"
+                    "vertex_shader": "forward_Instancing_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_VCols", 
+            "id": "forward_Instancing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1428,7 +1476,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1436,8 +1487,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -1446,10 +1497,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_Skinning.vert"
+                    "vertex_shader": "forward_NormalMapping_Skinning.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_Skinning", 
+            "id": "forward_NormalMapping_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1523,7 +1574,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1531,8 +1585,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -1544,10 +1598,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_Texturing.vert"
+                    "vertex_shader": "forward_NormalMapping_Texturing.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_Texturing", 
+            "id": "forward_NormalMapping_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1617,7 +1671,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1625,8 +1682,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -1635,10 +1692,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_VCols.vert"
+                    "vertex_shader": "forward_NormalMapping_VCols.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_VCols", 
+            "id": "forward_NormalMapping_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1713,7 +1770,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1721,8 +1781,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -1731,10 +1791,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_Skinning_Texturing", 
+            "id": "forward_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1813,7 +1873,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1821,17 +1884,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Skinning_VCols.vert"
+                    "vertex_shader": "forward_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_Skinning_VCols", 
+            "id": "forward_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1905,7 +1968,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -1913,8 +1979,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -1923,10 +1989,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Texturing_VCols.vert"
+                    "vertex_shader": "forward_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_Texturing_VCols", 
+            "id": "forward_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -1996,7 +2062,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2004,8 +2073,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -2014,10 +2083,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2088,7 +2157,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2096,17 +2168,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_Skinning.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_Skinning", 
+            "id": "forward_AlphaTest_Instancing_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2176,7 +2248,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2184,8 +2259,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -2194,10 +2269,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_Texturing", 
+            "id": "forward_AlphaTest_Instancing_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2263,7 +2338,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2271,17 +2349,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_VCols", 
+            "id": "forward_AlphaTest_Instancing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2352,7 +2430,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2360,8 +2441,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -2370,10 +2451,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_Skinning.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_Skinning", 
+            "id": "forward_AlphaTest_NormalMapping_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2447,7 +2528,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2455,8 +2539,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -2468,10 +2552,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_Texturing", 
+            "id": "forward_AlphaTest_NormalMapping_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2541,7 +2625,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2549,8 +2636,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -2559,10 +2646,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_VCols", 
+            "id": "forward_AlphaTest_NormalMapping_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2637,7 +2724,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2645,8 +2735,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -2655,10 +2745,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Skinning_Texturing", 
+            "id": "forward_AlphaTest_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2737,7 +2827,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2745,17 +2838,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Skinning_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Skinning_VCols", 
+            "id": "forward_AlphaTest_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2829,7 +2922,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2837,8 +2933,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -2847,10 +2943,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Texturing_VCols", 
+            "id": "forward_AlphaTest_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -2925,7 +3021,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -2933,8 +3032,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -2943,10 +3042,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_Skinning.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_Skinning", 
+            "id": "forward_Instancing_NormalMapping_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3020,7 +3119,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3028,8 +3130,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -3041,10 +3143,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_Texturing.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_Texturing.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_Texturing", 
+            "id": "forward_Instancing_NormalMapping_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3114,7 +3216,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3122,8 +3227,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -3132,10 +3237,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_VCols.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_VCols", 
+            "id": "forward_Instancing_NormalMapping_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3210,7 +3315,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3218,8 +3326,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -3228,10 +3336,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_Instancing_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_Instancing_Skinning_Texturing", 
+            "id": "forward_Instancing_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3310,7 +3418,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3318,17 +3429,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_Skinning_VCols.vert"
+                    "vertex_shader": "forward_Instancing_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_Skinning_VCols", 
+            "id": "forward_Instancing_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3402,7 +3513,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3410,8 +3524,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -3420,10 +3534,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_Texturing_VCols.vert"
+                    "vertex_shader": "forward_Instancing_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_Texturing_VCols", 
+            "id": "forward_Instancing_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3498,7 +3612,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3506,8 +3623,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -3519,10 +3636,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_NormalMapping_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_Skinning_Texturing", 
+            "id": "forward_NormalMapping_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3605,7 +3722,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3613,8 +3733,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -3623,10 +3743,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_Skinning_VCols.vert"
+                    "vertex_shader": "forward_NormalMapping_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_Skinning_VCols", 
+            "id": "forward_NormalMapping_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3704,7 +3824,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3712,8 +3835,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -3725,10 +3848,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_Texturing_VCols.vert"
+                    "vertex_shader": "forward_NormalMapping_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_Texturing_VCols", 
+            "id": "forward_NormalMapping_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3807,7 +3930,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3815,8 +3941,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -3825,10 +3951,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_Skinning_Texturing_VCols", 
+            "id": "forward_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -3911,7 +4037,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -3919,8 +4048,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -3929,10 +4058,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_Skinning", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4006,7 +4135,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4014,8 +4146,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4027,10 +4159,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_Texturing", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4100,7 +4232,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4108,8 +4243,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -4118,10 +4253,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_VCols", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4196,7 +4331,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4204,8 +4342,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4214,10 +4352,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_Skinning_Texturing", 
+            "id": "forward_AlphaTest_Instancing_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4296,7 +4434,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4304,17 +4445,17 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_Skinning_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_Skinning_VCols", 
+            "id": "forward_AlphaTest_Instancing_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4388,7 +4529,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4396,8 +4540,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4406,10 +4550,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_Texturing_VCols", 
+            "id": "forward_AlphaTest_Instancing_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4484,7 +4628,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4492,8 +4639,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4505,10 +4652,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_Skinning_Texturing", 
+            "id": "forward_AlphaTest_NormalMapping_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4591,7 +4738,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4599,8 +4749,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -4609,10 +4759,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_Skinning_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_Skinning_VCols", 
+            "id": "forward_AlphaTest_NormalMapping_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4690,7 +4840,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4698,8 +4851,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4711,10 +4864,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_Texturing_VCols", 
+            "id": "forward_AlphaTest_NormalMapping_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4793,7 +4946,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4801,8 +4957,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4811,10 +4967,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Skinning_Texturing_VCols", 
+            "id": "forward_AlphaTest_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -4897,7 +5053,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -4905,8 +5064,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -4918,10 +5077,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_Skinning_Texturing", 
+            "id": "forward_Instancing_NormalMapping_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5004,7 +5163,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5012,8 +5174,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -5022,10 +5184,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_Skinning_VCols.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_Skinning_VCols", 
+            "id": "forward_Instancing_NormalMapping_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5103,7 +5265,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5111,8 +5276,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5124,10 +5289,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_Texturing_VCols.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_Texturing_VCols", 
+            "id": "forward_Instancing_NormalMapping_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5206,7 +5371,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5214,8 +5382,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5224,10 +5392,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_Instancing_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_Skinning_Texturing_VCols", 
+            "id": "forward_Instancing_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5310,7 +5478,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5318,8 +5489,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_NormalMapping_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5331,10 +5502,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_NormalMapping_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_NormalMapping_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_NormalMapping_Skinning_Texturing_VCols", 
+            "id": "forward_NormalMapping_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5421,7 +5592,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5429,8 +5603,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5442,10 +5616,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5528,7 +5702,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5536,8 +5713,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "shadowMap"
@@ -5546,10 +5723,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5627,7 +5804,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5635,8 +5815,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5648,10 +5828,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5730,7 +5910,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5738,8 +5921,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5748,10 +5931,10 @@
                             "id": "shadowMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_Skinning_Texturing_VCols", 
+            "id": "forward_AlphaTest_Instancing_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5834,7 +6017,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5842,8 +6028,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5855,10 +6041,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols", 
+            "id": "forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -5945,7 +6131,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -5953,8 +6142,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -5966,10 +6155,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_Instancing_NormalMapping_Skinning_Texturing_VCols", 
+            "id": "forward_Instancing_NormalMapping_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
@@ -6056,7 +6245,10 @@
                             "id": "lighting", 
                             "type": "bool"
                         }, 
-                        
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
                         {
                             "id": "roughness", 
                             "type": "float"
@@ -6064,8 +6256,8 @@
                     ], 
                     "cull_mode": "counter_clockwise", 
                     "depth_write": true, 
-                    "fragment_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
-                    "id": "blender", 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
                     "texture_units": [
                         {
                             "id": "stex"
@@ -6077,10 +6269,10 @@
                             "id": "normalMap"
                         }
                     ], 
-                    "vertex_shader": "blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
                 }
             ], 
-            "id": "blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols", 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols", 
             "vertex_structure": [
                 {
                     "name": "pos", 
diff --git a/Assets/pipeline_resource.json b/Assets/pipeline_resource.json
index c2c83c1a..7e785eb7 100644
--- a/Assets/pipeline_resource.json
+++ b/Assets/pipeline_resource.json
@@ -1,7 +1,7 @@
 {
     "pipeline_resources": [
         {
-            "id": "blender_pipeline",
+            "id": "forward_pipeline",
             "render_targets": [],
             "stages": [
                 
@@ -16,7 +16,7 @@
                 },
                 {
                     "command": "draw_geometry",
-                    "params": ["blender"]
+                    "params": ["forward"]
                 }
             ]
         },
@@ -25,8 +25,8 @@
             "render_targets": [
             	{
                     "id": "gbuffer",
-                    "width": 1136,
-                    "height": 640,
+                    "width": 0,
+                    "height": 0,
                     "color_buffers": 3,
                     "depth": true,
                     "format": "RGBA128"
diff --git a/blender/__pycache__/armory.cpython-34.pyc b/blender/__pycache__/armory.cpython-34.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ad9c59d0f7892a79e23b54f7f4054ac69b67e4e
GIT binary patch
literal 39117
zcmeIbd3;>gb?13sZKwhY3juHe7ZIdLNsuM(k}O#pNstmPk)jDwuq&a<AgV}$1Oe2m
zf>cC^#EzU;S)8Tg&g7Fgw&N@vyA!w5N!sI?>DcLPopqA#{>-#rJ2P?n)7_)a#N)|K
z+S86Rp6~D6_i6z_Mb3CW^T!NOb?d&n-*eAB_ndRjz3)rK{@$PYkso>Sqq)F+(RKXg
z@ITGB{)d5cb3Lx&TqST1S5mH$<|pGSS$=Y^LX>?j6O<>Y;3~cR^tnorpMF;va1WQr
zOrk+IAGlJG_*1S#X+AvdN@?>Cx%rGcABSdLDQlq{+<ea6=y9bU7Z6v<JE|^G)vzn|
zy2^+vQQxR56<uYcD^V$F1}x2>r5SRSO|G=TRW`fI7FQW_m94I_%~iI$E0i<rDmz@|
zE?3#<uF#MXR~dJeU9Pg*9!Fi}ZdcjkDtqm5qpRHGD)+j|efGG?RVG~Jeph*uJyQMy
zuJWL(?6XJe+V3g{T;-rWj=5(lhg{{bdoKVv>|Ox^TM0ViDi2xELl(4+pod-M5es_6
zRa5TTc6V)utM<58GOk2B-|Q-nDz>!KRUUJdx0s(cKkh0|n17e6?sk<Y-Sw0Ue>bR(
zyH}hG7N~U4O-($tvhiqmV==rret9vxG1C~oZ{M~0;=)9fS(v#|T^WocPc)Yn!$viX
z`YP4>Y&f^nm|I*}x%)&oH#`1(b>Yg*>ih%aaoS5a$Dd!mv{+Zf>|&IgS#Dfi3||9v
z+-rPY)bmm`tSkTM$+`LJ_><$OZm9GJeI-$TesOlj%HMFc(O7zH|Ni;q>fy@1#qi4h
zDF5=@^||tLIKR@rCKq|CSLn!@i69E@$0_>qo~_O=Rm0a(sy;0zBPWY<<^6y0s~`Ew
zZ-4ShI=fh@mI{{^7pi6R_Ft(k-l#UhoBpwPe(uWEhWGc)0+?{dKNRar)tT$n&_88>
zQoWS9Y3_=-&2X_nh`B4~HtVzVgqXV`H(Rl6*^1@MRxBfdN==~uvAhKO43?XeJVik>
z3T{Th$}Bx<{pImJ&A0v-P8H-}qTw>dhHP@##1zsnQEhh0&-Ah>DnFB1=&>Pz;)_*=
zzZqq&&eX3)eGDK^rxq#%6)w-rR=qb*m*+HcQEoxlG#_PW7v~qls6gu3#l^64pzS?4
zD~!;eel;@3`PPr%KwSKX8F<UNG9k1)<*uack=V{h{Enuk&s-rZe_wto_Bc0@4!05#
zZj-Ye2eio4tMivX=EA#p{OWW2FVsOsFbss<Ke;%&e51P1sPCUzzBE5~qq_fUb$)(v
z|MPQ~!kKWcTHil=b9TO3zXAsAzcgQ^|Ka`_n?C!NZbtcXd2V5@Q7&6YL^NG691I34
z8$Bj^8173_%?c&;r(b<7+pBo!^EKQ+?)9__p(}x#QfOeIfrUa_;!was+LVPJYlQ+k
zLem!d_Eu=dLNgY+&<f33Xx2jCYoUNxFg<yGA{TC?P2m<fV{+DjG!^b3Gzwlaka}mQ
zLUQGDwN@@ai@&Zsf<|WD@5;y;2q|9+KLnc$UxN>Qb`1|A!;-OA0=H^lp~a)^n6y*O
z=Jld7cZdR!f;&gusX%hwsX$h-I~7ROoeCuCP6aYs?^GaBcPfy1eWzSRb>)g@o90vY
zOei8b_u6@eT;LCjIBysmuCB#~%(IY=X^N<8BD!EC*mj5il?`3kpnPX0@+(GrRyt|V
zN}Kkqv}n&tOnX*5?OAElp0@YkM2}{xmbh{`>MfUVELN81<u8`YwdI-lIHpi8*XI`-
z^>R5Jr_JGRIeX-YdUQC#_iz;FX})z)-(rwU6|==b3!NpP^(S<Gny<m3i#8i!doR@2
zuw!Z>6XjmGbgequXiWu?N|kO?VJ{vKUPQsuOi(ecB_I5OBl8T|D?xf{B7Y|8sZ=k|
zEYEirrQ)Xe)_ZV7Uo`N6R#2c*nVW@{X*FG3)6*#b`25U`OO=@?=areSTN(E)-Pc$w
zzjf+`Gy5LbDn4I-5|2+B73wVV<?Gd(_483~4%)fU2nWbIk%}_nIihT3`NmRxA~1Tg
zw#uHk;H#=pAat3Pf$lobOk_gAB)mt?y>br8S#PW+h|n@&MHPck&t0P=h&-(X;vCkD
zlEw#i&8D1IO&GD9II?Sbca4=b0X;0R=YU^vX*koa1T4BRyRfLX5-UMpcLL*E;g{P9
zNIYo#EDY=h4YRmf*wqp9!`s4~ZZyAfxUjcM1D|V5uKXl6R#$!)+wEd?<tL*tyz;}+
zj*H=ypLJ)q7+(2dX7`Bgm4Az?!ZjP`%OhkK&Q&4ziT{m5V5p4|R{HH0YrJqA3j<5~
zed37Ykh?6zxZ^lvr-dXevT7N(kc2~42)r%jBn+}bc3Vio6f5Lz3rSdGh3v7Agh5uw
zUNOj(r>uAM>uFaxYJOPzW3F=C{Pb?pRZf^6HvgonJY#;k`K+s)GXI-g<*lyrocZbR
z^R9B*{0ISOT;&Dx)9bUY@;37$5HN6j&bi8zdoM@@1kSt41&clCDlfXqwE2Mpi}*Xt
zf7n$@uJSGB2O8h%Di_WFkgL4YRm$cEChu~U8S_8lDwkYk*8D)G;wn}1Kk6!%UFC}T
zfsYuztI>dG<2?zkhAW%BZ@jUXF!)|lSQ)9BP*ASVRu`)KJR7vqAE)+(tYl4^2t{WS
zE@*tJIuA*MOB{b;Vg6>QxxBJH&bCO%I1CyIs+I9YBYySpev+JA*?e*_oUM*e&D>a;
zC-UgR9P*09hzE|&zdUoZKJMEyK9fX@&(z0Z{U5v>Lg&Zpmao1t99MOAIjqJ#YV~nR
zVZJBhm6^uOnJykJLo<x<iVK3b(yFSTl>cENg<pkg`-QW;W*PyS@NAN2p4t@27^U9n
zaIR53E>`*5DB6>^U}da(B=)sabv0{4(yU);H>;y*iI?UjUf7GoOBa&%(~ZQdv~jPL
zHufqlF>#j@uhPb$N*jBXmd7M*>{Z&>tF(Nt47FK}4v6*Bl}@llImSAiYj)6bgIu4%
z<g~?oyFjPK(FG6K|H{_&0O%9{e-47-LkUPd3=MpP9pF1TKhuEnt^wg)cLt#{bb&EV
zZkr#&c)I5YlAELn<0$<wYYN13BFeqQd|wRL4sO4-?nR3`H2J-1n=Smo%J%hIl_czH
z(>G<#zL~0DuW^Sb-~YxMcX)DEK+<1<uXqdt*gX(PxRKSgi8g_j)K$0(Tm&;bDfiTB
z&NaWoHQ@Dfik`e!bE`eB`J{rFbQW~Lt>)b=lbMkQ8zunW$}$U6(j}4P5o#cSiT4O4
z*N(aAZy@!4Qqz{SJ5Af<^J3`kpn1&NMM%bN`8ze__y6{Wps=E?EwLmNg?LQ>G<1Sh
zP9u*;*>GmzN;Q0x@TliXwK3CZgcAiXpvIEJ(J-93iB^i3xl2*%r5PzHmKPdPa6Kx_
z&n-ZQ?P)FwuB{#P;TR*O{jhQlP5uy7)pz5#AQy<~??tj13C4qgl)k-$ZMLVoQ!BgH
zN866l{(tmX4^RJ&=n=k!QHjwbd|dt~<VYnJK8X_}M);Hho|bb|&M`Tfmf@tF6LL<<
zS+i>2h75-%f1YG(ks<YWL<VSuQ9Fv%uUIIf6{2VmSIKGCqJ*)qcCKk+-thI*LgUxT
zln~F&>tP{jzM<-(;PP5{crNDT{NhaGH#@3Zmy5AfEo4`hvV5(7Z^Gjjk5N%8bX#I6
z><2oyIq|0PChV4R3o67^6do!WKk56K<&cE=SVP$>xwCnG2IZX}*fjw2OV0T?&+kxV
zUFEu<_YR9rlC;$qF(6X?SzrDVkEiRR<)(TwTAp>y>qhFco^W4uBJW2Ol+f~fMBZcS
z4ACdA5pkp7Mrj|RyxPMp!g=R3caz4}h|{q$%+u{Jx#pYW<)%fq-&m#p@J^MkrO}e^
zUmL{nlQ8Ay-x&fX@?OZdxprD9Z0bEP-=v(sW!5ENHzNE8WT=nhhy)t}X3lMb`05J*
zPHncQu{#jpuCit|&-AA`r>~9Uhwymyh!#EeQTEx2hr)#Y7+ZW9R%vQ~+%+<8YGFP}
zjrNt)4SOUhOFZMmV4#0Zx%v(BqjhchbC#Y`vXpX9Qc917zRxvsUJDGC<dcLwZmN-o
z8Whe%nbRkxo;4OL$~=Gc^w}sqb>U2uJ^R9`Gv}ks)Y%u%yBt4y`oy`TQP0%b6Gxvr
zac-gzWg0gTl0+V(jAWh&P1^j;D~k*DXv6h0?2DWy{+W0?BpPT1J+Cd1Xt4Es+_puc
zp;o|@-x`VfTOle9ay3L<;oIe`nSFiFR2xZ++A69`=j>90!Iq#0J$f<NW4{^vnbd9E
zeMjc?NAUp)^P}iTA-vB<(NyQKEgIU4BT&?}B28H8j7Qvb)LXwgvs5+Zl?PQXdaUv#
zbX?c#(qG-EvMo}uM9-n%THCQAZJSaFiu}*&naL@s0vb?yvTY4T?o8dH%4xFcYX~W3
zzPT^%4GO?l930^ew+fj=35f6oV$uyE-;jc)YC~>1>61w9L^>*Hr^|CgS;Ws9braLs
zGLbsp{85jRoU7hO>hmX|qZ+Az=@QFao8Wr#!OGgzB}v&D64l=72kkaC*Pu`9n`h%b
zO<p`9b{GOk?_z$FDMo*uv`LeOgAH75lQE(;o5E@9yCPDGXsFklAXNqs<y;g?Jf-R9
zAp<+jWL3IE*&XGcKXvBB(Q`KJQSR7@(kbRh7A&vcG%Z4TX>pGIp{O6X8ZuE#1HnXT
zX(M9w1oNO3^gK-EOxPK6thzE+4JkNxd3HH`saon2<2e%=>sji%WYL}vO;dFVb*ZXb
zi&mSC&(GBBbC++nsyeRHdNe58fvii39u5TsrcS@UseG!)77X9i%HB0dw|-e&!=|Os
z(C<BXSgSOdys+Y_nx8<cad?b|P{uKh>~n%X55ON`Wb)!8Hojhc%?b~~TFQ(D<(i2-
zjGV*?sGjEKQ(79QYEQXomKg|WYtU@4&Yzs<@jRYX(ot%5(H0wK=1k*il({@}sSfS(
zs-F`}^|^WWxU*qRY4bqX13rWApe;Qmc@NzN?-rb&V;)b=UA|lm(PD2GyhYSRs*1rV
z>&|E}7WCZ?<Ms2mU@X3&1><o_y(5gb2Ojp_FzyI5P>*Q_8H6nzY=g!E2xr~3oMsEt
z%OK1GlX3O$Ng|BdXh($aH_$h~-?7qkj9}BmQ$K=8naK!JY&&dCJ0y)>``g;FA&48e
zwjDp|QQ#-<hysN+3b5!hwtZJ;7AkD)%vUcrqGJ3IYUK)-i4R|r^RgU?25fE#Bf_Sf
z5GTr5#;ng_Jjt3RYfEcL&r9-zHk?5tSq&HOZ%;x)3Q%G+IK;#ga(F)oa_^c+c&E}@
ztANm>#a@<qXujRJMw^C{7vHKSpn0@2=&-33Y>{JJ81yk?sF|^`*9IC!g*i5^;hn0D
zyXjg#>qV^16dT9<%6Rsz8*T{RsT&9R9=bEjw!u_xv(@&Dc|ySHrC0~2HWEz0qpifc
zSU*Lp;lA54wP2wBw^oov9>8v>%4XWWneKarTR6xlUN>YkeDtdbA<c)iYJjej7w<C^
zW;(FWcosWwXb-gPK!S`r4{DD(KGU`94#Go>6j>`pOdYEGWH3_ymfb7q-52*w<f4I@
zMD<)YPAWHJdhV#lQ~7#SP;hxkB&oOFm<b#8m*?>3W|o#PCZL4;jEr#5Li_bM<CEGN
zVJmg01=Azx8blmLeJr*4F`CrEqLYHNv~eyqz)GNXAQud=1-~`5a`zh4TQ7eL<Xzmb
zm=EC11QW|UCMHVkhV2ARbv`U1(U=KB9H*_tOt_>j9F}ua&bQ;h6dEbcT!*h%OLd1@
z-8map>rAop>Xnedv6}U#R(7uG$=dX-UTh>wi@qMF1dk*woB@wOlIHKG6fPaxucf4b
z13e7K#t_ot2hmZ)Gatk1CA}LU$l)uPuLobR`SSSs#Emd?t3{=`Rdi(tGx&xFw_wPI
z-xuHG!k@Olyj$=g6i%$E_Sj#<&#D--OQa!dO6<L@#J_U42z;X@`U*SS*mqlr&jhy!
zeEkx^5;Yhw_4+pV#W14-UIq&PWokY63ZyOgvSxgf;hRng=&#@QZw$T{Qr~R&{)5yv
z4qp){TU|{#u+vR9064g87_-{%Zn3NEnY6E@eYi0O{ce@5WRRbYNIwNWZ`m{j{>Uig
zfXW?PMV1(H*LVOm2HjYBP(P5}N64ud;_nc%Vci%t&*o4YAO3y%^{ZIFAmtfew~B6%
z>`se&jG;0joLr?q_Q*X{MstD+TjP?TfC?MtolyDQ8mLgCpfciajks&0t?D;+LWLNF
zlo%>&V>YiFvkp|gmU;au)-OnTwyax4H&ou7nHCI?uiyb%Fo4Fb1B11gaR(TT-4O<B
zW7<vcj9CW;F4ql%&g6<&zo2dybmr-X!Q<KK+Gvijra^4-;*eWqNJrhZt)kpPZCg&8
zB~uf*&Rwh`D~cJh*nY&swkR*t$T@hO5_U)Rx@;rsW&(r}A4xaM5oc=VbW!hey;`o{
zSX^ve^`>?2BPtqz1*oEeoX4CHZKYQ@Y)XnNd*jQpSytA=caWo$vxkGWxg0+nihmEs
zzel3cRtd{5mD#`$n^BL_%P$=?`$+i?m2eKrIb!CLX6rPuF`QMi`jcjP^{KSx(FVWg
z?kyWVhoUY@;F_&Qsq1it*AMYM%tj0Tm+(`5u`^fHYmN63Si$@!$!zc{rDiWj{fY6Y
zPf|=Cl`2X#E=Q^AZKj8PlU0M=Y4kGRDt1AdSeGl9f^Z07n157*{KFLKzZl#_$esK{
zsg2)oo{`jmiGxFNoxLz#tuN)ZpZZf9-f+qRSe`dh;%KTL<>zfWvJSAcG}hvX(tMBe
zt;-Ioxm$E@^5RyL(BZAU0$wT<Q%O(NdJqnzHep9sxnKJ_f5x`SWbM-O>~&11f0T$4
zJG*8#ob{NzhG!j;a>z6M9)rH3q4KJ+e!7{zowr+?qs7}vnviPAdNE2lUUt^P60my;
zb7l$#QMgmCdB9jR3)%9t*E1pQsE1Fuvmy*>2~xG4;=t%Be%KWZyWUH=COJ{=q*jlN
zi5uwiKdgvWor=ErebVX!Nn;Cv90p=ZGpIB#eTak(KJbW2hfP2A!Z2YJMr)uFe=SBE
zQA7osG(y3FmQ2`EQtQEISAcB{2etRadB{mYvVv9EG`Wm;wKq!yu2~>uf8y|k1yg+M
zqE(1dwCQ3|Dr@{d3^-6fx0!R)o~eBY*4st-YVYIobM?mT;*F&zhbh-Ko(gW|z#2aN
z!UC!*4ZP@Or@>&78F~D1TH@tSG4Eb%_&NDRDJOaj%R+4+pfxkRGa_Moc%_1j)s0w1
z!^_k)SFLmsDih~_N@e|woS&7m20{C~n)r2L=Y1q|xuKw#Ne2Vcq#?WJQe#M0V@&T2
z=zWSvwEbv-Hl}W~Q|KygR`A!KP*>uNq3!^c0Cyw~BoJ_x;qx*`_=1E8Mp4Yk7{e|Z
zf+tDwJb(sd0Shdb7><nNgoqA$Xe3F&4%5>r@mdeK`H*lEb<QgYC7>o*K|8X7uw=Ev
zB|<IKM6m8Ls?{!mMWlr7w@PBR5@8|l!rq`lQ4~T2{jUCJhJ*v|+F*C$f`sViy~;9q
zaeF*L#5eki$?uz8`ww2pBQ<>bOq7=*S{o6Po5SVV#u;`SCN_kZ0b7*5Qf)*-KKzu-
zN;TA>?Jz{Cxk?lpmrF7}k9|O0_G?jACDx<-?A5vX3R*m~0F8P*HBwT;uxL;s{@EF+
z`TX*x`4Ww2-43hL{=QU2o>z2~kxC%SDnmUfNIG(`)HLd^DrZK~QPyncLTyNdR~6h-
zU%sRUMXCB?G^8|~Kv00!&&#;EdW_ID2paw}neWpS+l>eNdKA7Jg8tkXE1A^3=$bMc
zwf^AW#)@#8Nm;wQvm)gB>msB(C|e`S(1Kui3>(E1GhQb4Yx~P^s0n_ykPs|^8cD<Q
zX0u5#tYgfLVp%>=1@sfvfqn(0WtxlB=G@uZ6OPX`I1v_74May8k#=RI=)?~Wma&Hg
zRiUBaBl2&5SFAz?)(O#ENU|WvAi*?GuiNg2V_O<uI!T4e;3+*rVgTpyWZf4147*YK
zrLNWfidJ_N-<8K;(w)AuKWg!a&DB-`Bi6n*4A+i)?TX=H4c<u$|9+qy5omx~;#Z7z
zi{YYMy<C$~i=xlRAhQ&uIDDtcnc;{ChkBBEHL)@3_d6vht!!Eh_(u@jJW&xg5=*|a
z*@s7&*~O)sM&P5~OVulL3nyi)8Rb!jd0!#U4o6`+qxXQKey$c;+O{Z5{j=Aj94a-@
zf=q+6J6M&?aB!?{^EiBtY#dcm;pY{ZwaD-hf|L1a+mip4ir2i1ig5>gGX~=)rll1U
z^|xxr4(>|$9m;1b%Dd%TvyN=_^Gwtr-XCh|s7`72%D~KJ;69nZgQ@K-9|e?jIT#>p
zir@_gQ^ToYX7~2sNa}&u*B?x<wR2x;Wn#^;dgr=YbG(o0wEEbJ^K1Wa&+(7{-<sq9
z56|c?e)DIvCgiA-daxIjd#d@Z>k=ULKcO;Rgmc{qj!ps19_cn2owUi`qDO!4jn4Mh
zE#>2>H%{E|)W$9%^l<785+Rz^nep|AQ1}@TdSY|<S$@J_mm@uO_#1M}?&~+@`z<-Y
zEvK8BgukP(e=g^D<@}zU-<R_~IU*n7AISMboG9m)d?O!Ger~~}oXSL>U+8~L=~{#&
z{3AX7w{rei&KgSbFBG;uxzK{YmR!6naxqDsJCX~GBL*QJoy0<7uZYUS5R8Y?^1UwU
zSg+m|=@4yfk&cf*NLU5@2Wu>tgsw-})6Q6ADHF$Vm6!uCosaA-c0M8lb>{8ue&qa2
zXDqxxXI@it`VduQ%FXtpsVvcDirX-?m-Kul3*st03c$`sj>mL9azciToQ=WdR17W$
zY&sKgBBk?@BR8Fo+YF^)nYP;!9Jr--1h+VfW8!D*H-m=N9q!f+R}6nI<L5xj1Ix8~
zm%DWrSej{`Oyfa}gwsl|?o4)YcbeQV?rx2{2AjKV(|kH}Yo}D+2(c1#cc+?vooWE%
z*qZo7x4O$I1ypI5rT8rqEqA%GVu*LA$*H^C<CG|l4WBk?(ccook#dUMmf}bg>NdsI
zwxw#n74Vs^eKx7sn=JiAs`;I-U-6StrBetM<E40evWn4QuT${{tYTDqs`vw`+LQWp
zR9vwBjHa6~ldsp~PiZT{SB#g6?a3;J60cKne_B0;QBuYI>Ds4Kd^#%bwTj=LZvIg4
zx)mQtqw4n+<E3JIvWn5QuT$}NTg6*_#owK-9nhzv;y$Z5muYT({fa-9mfU5a#!JQa
zWEI1huT$~YtzxLMdi?ct?PL0MR9v)*za!K9kbB)8@6NDg<txTZ#r9+svy-q+#m$UB
z&D>GN%}i~#J{=YJtK#}EB)B%v{WxgN`mD-eR-FYWYp?3=2zz)HB>laNmKLx0*Uyj}
zJEq?a{A$+&5`fgLAB*AFVvq!&28!XwV)(Tf)Z&l<#qeV>{8|jV0Z;_R@MAIjS_}$o
zPR%KXAB*AFVo*u%aP=R}vdvKpzm!E;Z$HESXOsWg?0>e{PlGKVdW6)(oY~>RPh~kO
zC`P|ua*;X<`wysDU57*~;wU;q;t%$DF@;zd5TZ~^1+@?MEqo#?a<|*Ejkwjj-K|Y7
zd?DBT$<EP6;)9eBw~M`zJ%WRL^`~+Tl<A<(9@W>_WSb2`IgP?@R~yRlnO->W;zV~F
zAX*9QKc3_!0?@1<0jydP;ZMg!tFQEOvs>M(J*x2kT(`Nz#mzMWHdg;qQekIvKa(`~
zGr8JlI-9$9O><B6#Qh+mtGS&KUClk$;~}BuZg$~kdYaF4&fO^iwE-TmQZPun+!l3}
zv!7d5@3H;?<$Hkly}~Z}>i;Nd!o3~vuEw?0sy%$B7rtl(dd=svdBF*#FJ_T`r0%m`
zajw)%L~O+BkLTNwT|MiJ=<Hcn4mQZ!BlOXHJoq2YFO*z!x)X^`z2W}G&FSprg{0sM
z`PzlN_O`;oLi5|cA$US+Vt7K|1<$W19q+8^SCg84HDCMH{Pe=+_EH}HSV8ba$Mw4K
z{Qkln;Mp0`1<%fiE_mM48^iOS-i05qf%S%we~?r`bGX|E0@EIY&OG1n7_?xt&KP{I
z5I5#?h1%x|vOvFfms_21x3;+OJ-yA3bq=<t7{qA`-XD|sv3jjHF8BTp3_g~0@>p-}
zSnu@0yAoubSO;1Eby5P6AZs@!cSZu>uE_8UaWygZ*y&c^<ZcbS@bSL&noeBYbXyw7
z>JRj-)AYYdn*KMvwZG|XI;Vyil&%KUe<Ue^$lIFU8F^dNKiJozB=E>n6C3@8<;ke`
zZ5NK7KXLBNsTa;fy+_}EYN~wn%rnoQU{ePXMB4)Aqk&3w9t)-92A*hu+h@$gwOr+X
zgfJTQ@oPd+XU@!5bvKYQ`-hQMnwjQYy=-SNqIMvcEU?G9pu1wm)|A<fvdtxbrbEKr
zYqA+f+}GcipPCqt`df8ye?v7I@ke}Hsuferd?$&$)zo|CGpVmGA0z9+?~)_wFzTDp
zxv+T0_5BLgR+tHup-F@f>+zq-F|qJZ<ooaCEX#RG&dYKH%_z-XH{s{>_&><`*K+<;
z&gbR)8#xiq!~<Sp>{dOMWL&0R95>tGBE9T*;?AG;Q(v6&IX2QteQ`qn5T~<;4F=+~
zou&GqbDc%|psCLChdMJ_Q9dNj*AWtD^C7g#?g8>cQLU7QXqw?sE2Q7hr1h9|1gvOx
z#6QFxv4@RGd%BDF!8EG7j$unZCFE>X)YT&^v#UoPA#slsf*COgRvPjMR`G>_yB+3u
z->)$}fs^b|2>VLDY}<8+O~uo|Ch9YNX&jQ#1c|aXLrT4E>@W4Un_o%;1w)y&x`KFf
zL#joqMw=VIASJ<*+Nm&QfD{7KA;!Pv*PZ~n#@qabU>8aPZzd?a)j>A1wrZaomBQw4
z($j;~+=FJbFSV7jx5n;)EE{RGatrQQTE>dG><IPlEDoif%NK5YR_qp38N~M#(U)G$
z7t=muV{d<Iomh6xw|AxKtYLah4Ll!S*?mXNY75k}fZG1jxcVOFTNj}c3yl}9o23t{
z(!*|!Gr4F2xH(TjW*PmkQlU@}+~d%rCQ>~yS%i7GYdCLH(ZhnXUI*F{F?!CX`#+@o
z@E35n$ELq(*DxHNpBKhOIe&XX$Eh3JHxe?~Zdv$`@kM=S!$me->xxTGe0*9-{%bki
z>ZtHbgguv`FL^w=#7QV}n`uEui7lXr7Pf%$X4<e8C|?vr00rHqk8~Lr(cc6{X3J(U
zLKFu^f(}X~&#(TVm1eiDD4abcN}wo|9XCy$L2nRm%a9b66VeO-MU1r60=Rr=l02IP
zFU%wR-HZoT0)OV356XkYG<lKrpBA9-7;yDZSuw~?v3c;PT<ues2mhI?ebEFfU#8uq
zRUZl(NRKe;wi^~62~-6-Cx4>rNYF%5B4pT)IMO!_L;&&oGPSLNopsP6p6?j+D0A$E
zGbf__(Q~Jdp1*MJMEEwq91YJcU{bs=TdkCnJ<XF7qv4+u7yi$3Z0UQKd@W>%`n)2u
zY-hlJMRC7~(+a+%EywpMSQu@#M&YOAGp(iYBI;q2U1zDo|5f2#$R(P@sf-<puocb<
z`KQX2uV3eqj|LR<j#&3sq?;1f?Z)FTQo9QhrtQq3)Fyn=YHE{nN9sX-?}U$P#H>23
zKPfI-%F7?%q4_=oIZy{vWb^WpTLn!_muUB1fSyv9`9ah%6@+1QcZQ|mcPBgQc4B4n
z;(o(FKWP!Q*+mB<JvOn)hz<#S7NeI!hjH5RnXY{|qOU%FYIAi6J$8P6tDziG))sdt
zt|$B!9Cp`O>dP~UnYhfq{E*DaXCwO;_&D5RaM$i~_^KQMI_lAgu5+MkG@iXv*XI@%
zsuh_{RqNQw#OGSHkqnG;ECy^#Wp1+_UoUsdya63?+v-~9m^~2y$jo%X9hCwWE`Zb~
z6c9pRxy0N9kZ3xY6eKeU3-U}~9&@%ig4sbud$EcI*p%GkMoAIRY};OzLep2nSfJD@
z2okv3*QGvRB9D|vN;YJOWj}@3&Jt^%R-v&{1zQS~DzpyeoQ<)k60(M6$NFnl2QCRf
z8>)mRVbp*Mg(51N%$zH<!QBvkpGL+8?Q!|OAjf#j-;mE{*}s(UpUAP9r}^o3Hro8D
zv8KPTh<}BXY(un0y<;!pdzI*S<cOgz_4?^=D};6}N&`LsPH|mxgHMuXMOZP8$6>^_
zEuM#)Qd__dKPSi1#q35F+dC|us;s?y3f=Xm-!$LjeCyBR2t9xxXAH21pKx<FE5R09
z8Z3eoM#GtD3@|`WLhW)Jrk>xR2H3VzX4(df9hMv|qejd*F8jS=jwopAMES(t(VGT6
zK-ij<F^Vs$I}ML0drc<Rj|n<5<`L_~DT}qITKwj0M~2x10>X$E1iqaI`bYQGD`o^h
zIFtZ^ka&r-IG;|Sz@Y3E5Zd?&nVNaCAc|q_!jIdL!CwJnc0ph$*v{sF@N_NQ3J~jR
zqcOK|r5=rd9$0J5SEp{)IWgLXqZgL`5v|t!nlQ}yBxTf}_&Ol$i4ztxb<WEEEV*pU
zy_8vE5Z1ytzJKa$SIt2BLxS`Gd9^l-!yXp--yE#mvo6ziTlN-t+DZvUzJ__PF?1fD
zF`*XmXOo9n>tQFbdS1o&f$*PZpjs6jSHPUggTKeNbJ5H|90YUXu@ct<q>NO4?SHq`
z0|k4xwqz7raJ6?Qq^sBHTPyL0g4p5&#Xgwu&y7ujyg^Sg#!bT8z+xDu#NI)kiGiw+
z!M2AnqQ+ose8cVJU>r`nU~jZN1s#J7vpWJ36gW!7SHEi4fElIW!B*xm2S3w50clJN
zxWZ@h;@w6&sSeh~BA}pSGKhzwQm~ZA2ZL$WFcr7aHQy_)C@zIv>$sHhq!jevl!Bg|
zQaXxw8E)vUfgrfW*5qO;2FjQL<xd0gj&}eG+R-*p>|q_C#NqK^p(V%Go!YiqZ7WG_
z+pM<dQm<1Rda-tG_OMQEad^A71*>hl)%HInwe7IlKK**Nu}#>n%^udNEe>zj#$doG
zZ%ccm)xaQpFof*IKn=#-wOyhmj15s}?#jCjHA!%{Mu#Oe9$5_)81A>aUbU@CkQe;w
zgYU@1W4=eX46C4=N2$G5)jjSS_v?AS9qgp+do<J73*utL&EJJ#Bli(+=GaQ(K6h=x
zUAtfBS7=fFSJDc3Q~ao9l?WBT7t9?X3kx&NdLZ8Htp5i~?@Jg^3B~Zc)HF`5G*79e
z*B%6mpLFs0mVK`Nl^8BM9YVYITc26Y>GlTq3TBm@d(n*IL894L(tM`l`H#d0Cot^F
zdtBpyyT#`7peEN3qFHBtU}AMpvDXg8@D0TJz3uHN`Dk<b0ayDjHm7Vm3T~0*4+8Y@
zj2dy+UE5=o8qX2bAU*Isok0L12KW)z{9c2>Lv-vrl9LSF3Fvo!|2$LsV^tBi7^Ni&
ze{KofVAb7gdqo?KcoF_)i9jtH!A@8CQ77_ZS@a0`!vC1|!ids19I<w8^uYOJPM0tm
zZ?WEhb2oDSQCsMUxy<%W?i!adj#}m4ljRai0vDP|IQtI3;HR=&XsPgbCE=b5d^*bw
z?h1c43HS5$PqN(Uu5gCHm+xoRYgsP6R5(5G;dfd2L5>^W6%I{>Q}nS<aBFl<$-s>*
z#sPW~&n_RMY+bL6yT((}YJ&)yxi@n&yEpc$P;x$P5$l6SBXCpz<C;w{r2cBIHD8Dl
zl$cp`Gwtd>XFxla4B)@ZH6OPG#~I&!ZWYos=B`cZvQBOGf6~q|ov^((h&yG0Ghl7)
zlQ}*up>mJsL!)3{TcdE&-wWZ*rh{^n)lKN-uLk?WFSAINauOiwWfN0Ya*C_(k8gR5
zf|t)nS;<@VC^u!7#7Dt_Qf}((vnS4-h=PMr-|-jDym;d6<!3KE|9li2@^Wi%ILZ)C
zf+MB;@po_m!{mu`QSeZy=lIdHQx~2m;^CFvb8}bbD#sQpHy`_I@L2duG$s6Ba3)T+
zg;^6_JtOi7#hbJ#mc$EAeOKoyGTP-xO~@7WbM-l00wnn<YTfqk8JhPgtS784&2z$}
z)a!4d6!(HTKBYY&=W(TJAJnm1g2TU2%-7_k;OV2G7Uu(-V;5{>2oAqhS^bUjzP^hJ
zh_99RA@5X3a<{w>62BfAqyLb6CKVXV{~z@zfcX3C8Jp_mD1Vuo_3iL*Hk7~^r55Yq
z_mC*cRnazbg9Y5}^=f4<tVe^byY6RaX0KK&9TNU8D@SIL!^u(hW!+I}7wSg2#pTA*
zaszwIaAvMiFBNaxESpzm|D5hw(EUo4@>00C#4#wWw!L?7LAc>>T~-_?e{_F^1(XKc
zeoGzoa_D}pQoh8PM}r&-qHHv-WxHb~>WS;n{SI{wF=6~opLrXBE(8t#cY&m(j|l%#
zkN+jk#MTaFgc)d=(9^>>VZgm;rq~{B#O%{eyMGjA{#?b|cK#=oBz{$w%P}o3FGZ=#
zOCDg7uS;1?kHusp$REB{se?wiLBFZ+61LyE2u4XNH_K}Mx;i&C_hT72-2V=b%Z+ex
zfDA%)TuDclr0^Wf6!;ws_MkG|5o{!8JDNFjQHWZ2usKQ5<>O}RU{`u1mfd73KFmcl
z!~AXtcE?&3jK@=>lqN&eF|5goJddQ6c90a*&UYK3#nfop%YAa!`zp2CTSz|;s7@WV
zQYm*ZMmL3xgdzQH;wx#&nDft~Yi+=jK+X_b?6i&dBOsMonOP%|0->5F#b|NFpVIo&
z%B7S!TO@sK&Xv7F0lu+dY6w_XQ$xVdH?P=9(bz)j9mzonmVIN`#X3XuWu*xl|KF%l
zs*n>CtblMJX3u6yB;yfou1$c{5Jwnmoa7dpeYCUU!&Y$;Edy-|r?1A2NO>H$W<%Qy
z{V$!0gq?3*GJr_GI2|iEXf^Cv^F(JA_gfXMUcnJ*$-NLrPeNs$;W%5n5b&Ayfsz=+
z`aEikJqO!WVZXVa`vRh@?sVph;wUFC{u{AZh${dVE(FG^`LZ!eoZKBnTG&XEs!rTe
zyx5~nh*Ypk_*nK4B{0T8O`By0Esz<GsaNGUo5Dw=C4yBO<s>pc{nlzb-W$MwsSBgN
zwVw}apQi^!3-el5^2McnIzUk3aoZ{~%0vvGKB{GHp1g>~E~sMA$jaX5(e&fBn^=2&
zI^d%s{rH#R9AHLmxXLWcWbl5hd}2i|)7oqAdGE;b{JiOcfS&)0Jzsu`O8}r)+iXEY
zs75j8HzTzMw2bIqUJN<CV(WltQ)xi-M=JmtLbfwIG`5cu?U$~$qVRpn(hKGGXJYDR
z&uaRosNYOlo8>Fv;_^~G`~l_GWQ=k?1inBqQSRlcZc{1QnHA2Ya&@M!Iu2p&sW#(~
z4c0iH!3Rxj>LAFbuliBdky^arNvJJ--s{hGolrae51dl3)qk#fV`eFQf@QT-umGJ4
z@=&l0z5s*DDYe8u+o7ImYj_->`@1^NhW(VP=xeZ{IPcT3;>=g|ZV=xZE3DM34*B>}
zuYcpo9CyF0)nLSjilkdT0b#3)0dU!3W-!>69n1`hh_aWp39`B?wKX${|6s;n+oa1;
z`Z)!#fju$)N!hPo)Eqh?u*LS}IBI4KLNB3XnPR?}xdUNU{j+J+&EHAB1-{4m)=%~t
zw;8KE><(vbq{LcqDG6YTVMT2dL+T}{kC9eS1hh3`A!0O11|w|3TOLUa`5AGN89*AF
zZ}o4p5L1PSfQZp$4olaNfpP975BzYS$ZGQgtu`PFPF{R(tiXl7A|Q%FeN-M&O1i|<
z4G+6&_K_KHuWP<l<OIq-dGRR|O3~~>;1T%v_-iy!Ftme=pa)$+CNBoH|ItmKt$oz-
zu>(HT<XiAU(C(j6#P9`EJ2sH{Ac#g4pbce{?r7Q=G*Z2TEC81cB9QV7i#UpcZg34G
zMChGgTOfxRoxGAFr#c9!qC`9xEYm?x9}$;GKkC8_N(Sxn<WqEWlWRU=k6VDigv1-9
z6CITIGL=g~$0)^4yqY27BV@0A!EZZRS<UBL`Hx!u4F)bs88eECgietnbXG9Zx8#qv
zr!+3!&ahqXuGBQ5uv&+~G@wu}NVPv-4<5uYBNAwBab+|lfM&ZBAW1srimTYR5ri^>
z<=)IDsRwYr!h*8R;J4l2hbn{2<V2^n!!^)p;Ag46%hF&a4UETS>WJy7(jdc;1~X>T
z>{1$4kG-8A#N8(C?UoJ%f%O)iyA9#@C<}rhB`9#Oa-lX6Iw8-2+i`wO78#(sll*u(
z^RqIMpTN%icl-P_YMZnoY8SQb5!l$33I8%37rj@ne7LnYDH=~_(FouaO<-ryd#z}J
z+n0W?m41(m+~U$doQX?EJA)SPUMn4>!Q)H6&pM9COX&o5mTsj5D$C!f(JJdcy=m>%
zeMwn(I?DnFD2u?(vhK5%);=svMLZ_hae<Z-uKB2I+}|Ep;4^t~uUoxe1AXg$W?9zQ
zq6vf6uS-WurrNJ(_)OojLPS1}W#f)wW5vL}DQOd$B{0ZPLxHpj@`g4ktp+LNK^tlm
zN(}XzJUovD{vC4f1+X-OIv|5;m&Wb^*L>ji25+$jKajLJD~<dka1~*8y7|AYDdpl9
z+$yz__(9ZSU;(r2!&y;`eXbeaUiLdXfI$}Z_K&hahJKE&qR!f9Z3hGPn>Aq28K9QS
zM6f#$wT1=O{wT|5`i_wEO{6@HXb1FY#T}tn`*4=ev<Tw?*93fE{XT{ijSQWBPzt!1
z-hLn_%5nf3?hoYnOy4@-!n1`Kl@F+f7>UmoG#hQG$IuI|GN!wwAY4WJcCUF388JBQ
zn%h&17}**J4Wn#8fzvh$qYsl8|2hz2QGf>@DL0R;9_b7bz*ZmX3=y<eA9jsH?iLju
zF}PdCjz{I{cvP0lhGMIaBpDy-&KN%?8RN%}jNIt!Yedz@NVjT?ACrvnV@F2j6B+r?
z)Xho8_M<Xh_J`5g0`MuRy)$L}*pc!rNlL2gOc_6Rq(qnXW_RlmjG3Qsw;uJrC*7^L
zxLc1A_LRFt0{NbnF7?(^rd@nmYROSOumtf?bfa6gt)fn&h&YZSEP8ayt)rm*F?S0c
zDpU4YYw>SA$18v9IbQa+_9TdYTrbPHbv&W8c%Wa0Eu@oX9rx6L6=aMHM++hxBubkm
zjui)*>CfbAS^uqq6vb&R>lmiXGptKpW5Q;tWl+%W;b0b!h^g;aPx)9qYd?-*ZRZLq
znbY$ne_DWx(JFSt)RqsqYY$7qi!ztFMX3RC;!7BJzsODMQ6@5zuFMbvdbq5+Gy$Zz
zKH+Yikdl_zYfm^9WEBxBu8Y=mYL<AjGqzyh6{60+?LnKbVOEd2mozNkB#Of@uLu8*
zn3LxrX8teI#MIxHpF({U-^Gni@!Sci2K|fZ`iXA8jjohWE`{;dqT7gF=}W@C<={oT
z&1RO`>`yjZX}(i@Z@cS)Zp3$8@FpthA&i~phPr<szX>3BC86O?`F<Yf2hdU^_goxY
zcL(yB_zLCqF1m<%u-wt@kzAvI(D!7xm7h>IfQGx|?3N?-U3j;Ad*qmYYp;C&SP}1&
z(<4Wkrf^u!h@1&Iwllj)*Aa4GfhnMLm$A2Y#cuZM;>%^ddZ!)bt%a)Ojf$O@9hCYJ
zE_Lhatlfs}wXc^{#UCndZh46-4y#dNDV)23jV4m$R}`+dcS**AV<+k3az2hzO2o_=
zNvrknX~K|oB}B;vzzeoNEZ^Ug^9)X@*dbEZy+nIfk*DN*4JRrj8~5loy>VPQ1}~PE
zU3VXGt!|X_?+po$0?KG8F`_CjUcSt>H>$-;oKH6`aZVkOZab{rSfpdKs%yBVJmoT_
z#bsVlR1ftwkMLeOhe(2odWW^jYZK3*MmE*s5P{(#rTSU<4$F50hYr>mnAnyp3Kqh*
zDKu4I@b^Wi+VJ1ult%n`CKpS4nRG~lsTV6H!KDrH(e=}d;nLL?btWFG8L}5H&D4_@
zcP4jPlzMp=?9x?}olAKokU-6)7P{#=d`fMUm|hy-#>)Adrxz=B)keM4>)|ZBq44jk
zfs*4(t;_el@P1kmA5%p9Dh^*wYH6mFT9^qxq?pv~O!#5*G-gWa#>}D8(2bd9VlQD`
zv^iKx&CQfHCIg*Z;cf*+!Hv>z5@R|1g;mE@{b|8cH+4|@@=G%ij`-SE3OvAVAzV^5
zcc_$l=|K1sO8!ALg@gyfAJO9n^jJu2kPo)Khe~-1z3}3}mhVs$gyE#sM<rBcD&s^a
zyjDpt;4MQED)IAK=*ip3>@vEoGttiur*l}qp@B^m(4-Eb9vDIF&!=~xAC`u-7watP
zY;(j)@2U$0WGAOrlX%T-CXg~=h<{2LC~!#?*I_9y%7vcZZJ8YUUK!%zqF+{71$4_p
zRw}+=2(^W2a}^$pbUh7GMw}zqbXaxkP8{9QNm-VDI2g(8AaoOV^2?rV3|F`2Yz($r
zU1*wv&9uR{HIIf_7Jl>~eGf7Ef7Jf(5A<&rc;W6Qw|X=hx3Un76eyc=$jiMvTT=ZQ
zlq{JMAS7M1G}<dWUYAPGYK_pJNUHq8p1M%f>ylStZe#t3F5p4S%+hJhr(L>?kcwED
zF?}Z*5z~62-;kmaPW)|Br6^CzE$othFt!JsGxG}{UXV`2rx6nY2SJ%$u}uQ6gTWrv
zw9O>bdTa}DZ@d8eWtaAz47JQ*K)$>Xp2rtu?GE!&roOb;;5`hj^}+9a93hE+N!fj1
zUo`07eB35(T4xfY&KF7HiPAy&wBc4NSm|c`o>vWa2%~$!jQTvT+ZzP_lNL_d;OId6
z2JU1N+DOx7|LMZe#w)j(c6MZMjT7^wZQ3dB<BgA#pq#*0ej6}(&`Tjl;(--Hk!5=X
z@Q-lSV_t!D9ecljvR(wq&9X)*2VxsgWz$$=0qTd`ez^MU3ZqFSgKlA?z3$P59!*#)
zTtkoU+-v3kz3G5RKjaoj3G-`yAqlz}lq*QG9r!SC8$PV;UYc8~>cV*x#eU7&&#8fz
zXF|5@;+UxS7#FHYqso1}vW~LzL02?P`inhZek#hIJ#lX8Y^je|Nbo9b<1b1@-t&2N
z@k%(ebaieP6XX_#X~S=BscbhNqcG*d`!aj1+=rC6aJFVkywNodEDc@`m+Ot?8|7J)
z<d~n8@=5E$b3!-2D4PbHo0YY<$R=d9YI~u2!6-YFT+|=G_OxvGy_EW}U84fKWzgfh
zVfj$}PVWRBu_0h=L)(q!QJUOqsdxOYasLjC?}TR5h4O~dnclQeS(IoyFR-|ed%>Wf
z(C^z``{2>qm(jxO48^qQ&omEj9Iqi7Pz>!~c)}z^foy>&>k$s#_p7?hSkm*oV%j?i
z1Y4Je4+KL+>Pz!;jnKfiA$be>8u)ob%CH-LYe5&kF*1Hz$VUV_)X{VrasX}Le*24e
zJe=YTvud>dL;%u!jZi;<N7sC#rIuCqo8l>m)*2v)1S1@wlm;69EP;R2`vrPqQ*2#T
z9c970>viK^g<srrv{<gg330~|cL}iptkBrhI${R^6trE4P<(Ne1_!x8o+8%vc|d#e
zXGnhR=JQ1VygIFIPRAm4*X>JFcj}fHvxN-GWj%hG{x_Gh8eKkUF4XUG7Hjqf)BrtE
zYr*noBv>p2hquW1TsnAAL<U!)QJ_iMbR&j5dbC>(<uN;Ll?IK3G-l(J@<1ScMNm!C
z?o)`YhLVq{ncr^p*vGc1-++s=L1Wop!w!vX3=<yKzgAMe+ZZQB*0fDmB_&bbl^MTQ
zQh&=>oD>R4Tp=Ow>=WScOl{_80R&BbK$%S6*f&7lX7boRqG_SX$BqFPhj<$NqVB#X
z-PziU0iS7FAyq$1gTE7fK8;@_8(I%l4tciXR-x96&am{}lFwU-u#rSvuDwd?@Dlud
znwcB-jqrA1CA*&7m*MmHIF*4uf&F31u=^0gA56tyAO%T>3=AYd{f)&Is|_g`G=@lv
z64B_Xfg{_az}M~t2x>o=T0pbaZowvPQfSjuS@;qA!w+Xv^}}h@_CWhgB#<$uA5b4e
zVu5AOE}>r26XMhpLRrgbx3ZJ=a!1<ExOI9xE6Dk+7hQOQf*$6m4G7l9zY`#4)3wX#
z+FZIepVoxI<{VG~Co>laG{6`N`=dlZkrs8KZolp9_1A2)H0Nc!%GL>+9+MZ*(T+;}
z!rqPFO;H@0Pj9I9i8R)>K8g(w+rB~7ztJ{_sLNZ+eLgLNLK@*KI$QgEn$L9Y6KOuv
z%^%Xf`Q*h{;~gUGIO}i8NLfmaw%frVYCqvQGbN<G-egbRvo^7t5nf5+%u?6(>wMg9
zHl~ue%?9H*-`%1&;pQaHOyh#u<_sU(Jli8xlN8vWvs*yWd+l*e_G{EsyLDNUdQ^J%
zv$cPgk+qtD%a($_$mMLdaj#558xx}8jIIBO+h&IWB88e3l@)tmsJL`74rSVw7h6=1
z5M0}o)$LOm*^_Q^kEBT7c$4(|8Ze03Cezyo3#Qk?GSnBTdAm=FXhGZaSFK|^+d8j=
z7UO-s)Dv@5r6MBoWi%+q^>*K=07rG@Di(D0Qr<Xg_?nZ_smxZ<l_0WL7GI7AU$}7o
z?1l4XPIsL+ck1Z#rQ)%v$&=;DQzuVem^x7^oX3Rj)aj$ooPdW%$K{o4EheorP(H&M
z(3$zu$mn95V2$F(Qg8X_{L<B#^Ht2W`pT!gl0j*5<rirna(wx`T?}pc%61wE@5+{h
zKTH<*gkcPiiAOjPew9x9LrQIC4~w>XLmDOZDL=c&D~y^Liw#_2?Slie%6ZQ4^4BA#
zzKXJ!_3}X7k-0cu8i;`smr&}rd@4itR)?r6z1f>*<F0DKEucBka*GXHQ_or65Y5{_
z@p9Z-={ZG$<-m+!zzx_KjkOuc9<QF^Ag&D7>by)%x{T+Q%QS6|tB~zHwoD_8iL8fb
zltfA{(=CM3$d&qM;ap)4)OoB8b9(c=P7%vK4r8@yqm=Vere=#a_y^f-c-30HG~88!
znaFuwtEJg!G4J(>Ev8{A^(9IV>6ji+i@t_a%D@8GqhMASfdlk|@vmJF&a+(*&hL>Z
zk6E8_G~u*$qJ=j?BQ8~hxh@s!%c1V}wsa+bb+`GWv{3Q7GWPk5K8ciZW$+(E!_?xX
zutb6=%^*g>Z7=#5^o-r<_%u!Z7sVF+8eMRiP4Lg+qjRYZSufQ~E8zcimA3bF|Dy3o
z70{QANME9>6yd*R9fyq?+5-FKc_+Gvp<r)n#KL@d&de(mw=*>)J&TpHjgp3m8BF!3
zuwX+(O}=IU$MvcOYS95^X<WE|o0_n{JG^q&x|)VoH(UIiI9YMA$N5^no1Zdvq0P_z
zoK7dkE7>>5&xwS3ITIJZ7i@9ydu0SJe%LTA?B1uf-TN>C!K6Z@5GIWvBZ7J*35~<T
z0!9WFX$@IKqEL4_#0n9qiDLM5g~D=mD5vel<_Ma2xoVep_QyB`u3?xNjriGFo`GmC
zl;gmD|69g>sj_$@o*pfm+k{kg9qK|*jn5G!a|DG&a=d9Rm%h>C<Jqp0M|D`w_{D^n
z?0}Wv0a)qP6~Vnob}M_<9q%>8v;@2~aL~xxsQ)w`-Hr@Y+oKN0<;6B!8+91AK#Nb4
zm6T)*N6hcHPL110i|wgB)=CDqvNo9wyd|4yCBt}eZL;=?_i9@@DuiRqWj~DXly8Te
z898^!nU}Lu&Js>?$lO%lCJ?UC3B_XI3uba#Ulx$1A$NB4bQ7YW|K4_`wjZN7TMMXA
zj<$JI9{Jfz%|Hu19hk=)LU@pP2&ZUZWkN_Wf~(^ssA*}G7-T2J&|KmOez<nRIW+Eb
z!79Vb6K*DjquUfY=;mNq@C+rM4T)zs@r)#%(ZsVc@oY*wFfEKO_j#!-t`DPmcrbw>
z6m|*!cH1ncb}@)-mYYZ>F7Mx3A{af-oYwxW<71b1!}bAGK%i2vhTUbtPF%$9jw1Hj
zL9yK`g8muG?G0*s{W&h5_iig>&zchVS|~;<UG>~6u*Y@Y*WsV&@WYT%FdOZjkm!Na
zZhssIzL*uzfA~FcAC9mAUq<vkQ*W?G$(arlI(1aX8g~t2fUa%Itb<3;4frQ%i2lC(
z)Op)(i}EK=ojEo2?1{;VgI-r9rH0=CdsRNe+0T;0t`#j6p)Am(s=pYx&#nXZI<4?G
zNfh5QTt=H^w~cDQ$j%((FE7>0+ER(q`2206msP6GBbz-oacs^QLuGXGS5)Ta#U)v`
zm#cQyL)qW)AXE20R{>v8lA$=s!eV*$CTcD?%!S3{<_q7WZu|=+)v5aMKg;<gIWjX3
zzelk@Eayk%{1<XA$a$9>kc6FVIX@=nx0S<oxNLi}z0Kth`bRx6qi0Yn^)Jebe_>|c
zfK?hw9+PX7LsJ~TRb{TB2R+qhb#}Q?eYYsVc@nswm}W!5Z%LSbc!&2xgyVl(f{QHV
z1+L#0VU|xO@bc^H|NGel7)fi(VP(@AQXN-1@s@C}^;6EhI8jfzTv?ngm!rZZUdvKh
zuuH1(&d*$`&PPQZw@?@Z<e5se?3{3@N5y0CvK)^`Kiaq%ei#UrlCkuc$#63gT&f*g
z_=w<Z7<WYVJ}l=EIgiSDOwKcMo|SV-&U13k$k7%kCq{Gu&g_jU>eov6E`?X+K#p8k
zmvd9jx665tobQwKemNhN^K)`OF6Wo!{E3`@CFeiN`I4MA{(Mr8e<LTOb{i&X4>h#K
zz}5j<0!00d9rq|^*kzdXQAM;z-F&v6ewacR`PS!gbQO*Lr*;MW!^IWT#T@@>{<jpz
z>^EE7F+4P!FXo0f4i5~E3>R?o!#}}yqPVNLulP{$>+U0%#%?JN7Vjc&-|z>EvxL1+
z{C=ME#cc6Y#SO(ioAa$TL|WI@!mKS^5f-B@tR5`7@JUjh1cBdp;VlIjNhd1<9;e3d
z+jp(bTSoOtl=+#P@YXQcpur5Z!xNXE0RY$)sOa#gx`81$u#a6`ST0{)UYPx?CV|@H
zg76nfIV*4Sr|{!^>q69qCw|;ClQxlD&t`qgvc}0{t@RbzX`tTBoAeW9mm72Qyc{*;
z_I1Qbl;b*-<6HQh)D?}KI&<=c^6B$sA$d%Jyt#pzvfc<r`J}MlP{Rd8X*R=OdSguo
zwha^P1GV1tdh0elRP(}5$~iB`n)3;K(GYuG>vU%wWaAY~t)#!xZtO@9{;~?nmpP&{
zw@@xm+|At?dLa{%@NQLRlH)QRGjoHh2E_1yo=314Fgh?(-#52d_A!0Lgk?E@AxBqv
z*g>%HqI~a^!>Xot6yq$(d0EaUa7x46oo`0^{=z6TaUUcsxl_vm5X>&wm0I?+*<T%X
zdp>`G8|1eubA0nxX9;=TN~N;=+pA2hH+0Cq(1pYXbPcQl%#+Ra;GBP)E3~*n?n#{@
zsH?+iUgoX;5pxsrto>riTdjX>2f|_J(pxxZ)bXDhxpySL^Xsnr{~geS4FAFZ1x|fL
A<p2Nx

literal 0
HcmV?d00001

diff --git a/blender/__pycache__/project.cpython-34.pyc b/blender/__pycache__/project.cpython-34.pyc
index c3449df620bda8dc62cc0801239a7a34689e3be2..7c64d96e30eac9cd6dd61771f058b450a6c579b5 100644
GIT binary patch
delta 3906
zcmbVPeQaA-6~EWdcI@~gacswR>?BQ-G<|8>s;yeIwshI*tREX`N6H$!wb_gBOZ!s$
zIXlm8lhKl~ZdHLwP+fuet74!HD6o!3P_b^4=rpGBA;C0h;vobQLZT8wObAi!56U^$
zjguH@Ov}sr<-B{&J@=e*&pG$z`uMfa_WnH_Y5uL0j~v>_*q_<5A1~6w_&R^O)O&uO
zF`=<yh?T-DA7)&5neee^7|TbP@H5e*=qM8bCW4A?VS7b06CwIQG&MHe%BExNoW}BP
z$O|(OQM?E{=VAFc6F9p?O-(R?b6S~*v1d5TCz)uQXCkh6?Kl<rNi{XOs5Yh4u0mcr
z6Dh?@t>mSVw~C3h;-y#eI*`}FL`Ly4D|s0vvP^W&6EBZc7Zcrz?qp&$6FrK?!8J_u
zD!QAAJ|_AVjRI?#7*KQ%6YH4J6^+7!OsrRQFB6=N=|i_D^rJd=`5;2{J}8x8Ze(_*
z3>6a!((Ae9^Kah1ar44IJt59B@{TsiqjJ*Q&pQ_`cz?nD?KmI2a@_w)uA9g@=-LNO
zM=V>EPdl)gI0U)|Jw(?5rF;)rc6AoE(D)W<H4V%|KhbqSnLy5RjLD)YU@Nf*P}LC8
zb-;l-b5UXgNz_4K<wnOUVA;nHL3zf6${e(zfa|Nw&6tksJ5q+C054`8bHgKcwNw}L
zksd!mfS95EcBRe>(r`0Dh#*1`MR3FSm&?VvSPPBE2@(XIBoQnb7-q{TI<8ipaa@04
zu23}P*+5oLlTfA(SrU(1wpCF^-qmWE&T4rxu$SK}n}gPt;kvk*sOCfk7^f#@ipJc8
zRWVEZP{i>fFdpQPlkca~^0naScxqus^9J5mcM%%AN|Ne90-yYHXlqa1OCZ1WAPf_a
zqIuUx`NvRp_&)r0gGSLhZkJ5EqWj=}lGsBqOrX4ckf;V%y=3+ya%cD(ex-Dq{9U;7
zo*YSzt`x7k3M0t)6uwRvA<X@?M~i!4MESWda+SBp+mSu#hQ$KAibiQt7`uz|aI~;G
zkJEJykK&&Ov*0ltv*o+d-qcaz9wSNL3b$h|@lNGr!x~MM^2C9$gQL^(zLqs(2Wj>p
zf`<tT1WOYXMY{*%2o}DM2O-SWHwmjBN=n)=3a3+)KWX`vb)2!Y8k?PD6~?AHn+~zu
z(ZlSlm!0vlY3zL-md1v9Qe$vUiA30RlufrVi<5-#vhCPkv9s31Q`lfr=Q!tQG*(e<
z^b@H4iEH>PUu=CK8RJJPZEQNukbjOdP9F*Bk9G47xi;37O)f>oZ7NSrn}v$wda2l8
zTs|Jtcd4vW9b_l^kPn-x@k}@c(>7hdp_&nB$Z})O2}77L0p^qmrd=={c_lVD@5Af@
zETSryj@mGn8!&?tpo3s3q_tY8>ECOV%$!j%o<I=?&mYD-ejev7SP?-)dLlfGPh6w%
zIA6~bT7<XZ)2>A{z}T_^Z3vSG+FJS9g-6?Najbpp#?MlKGjb#`7^VKr&IGA<r$o0r
zo5&5VW+yl`Z#;Q8o;727?<kn41~>t2=ac>omDOcu7Q*tq#76$O%qG9+yG1=mKA+6>
zTDR}qxua*@=w#I@iqWz#4}*!GFV)?YY-%6sqG-CF)1`dGF;1BiCBw3(tRgl%S|=eN
zZm%XON8M(nXM%Rb<qovV-?ty@YzSId$za2w?ZXp0l?x|46rFvZRu5cWcp=rtxha3S
zs(<I_QD@$pE8C`?SZ))o`V_$z2%aW5M}UVLgJ%iO%k}AuUp2;nd??+aQ&PBoFiYiA
zCP@6yn`*t|Yb35x=IcZ~Ex(fP`5%+9i5m7@li!xVPWSRF*a0r@pvK?^9@sy+e{A1K
z4r}}}Y4$AZN)668nX_i0S~347-|E=-$(2>>1}BRXmas9K;L~Kw4+)kOC`wiF_mS~e
zc_uq9FJ_Jn{eaf|ze_7^|B~(5O?y`^3op_#AHLvK6nP(ChuVYcgdVtx5!ff+$^Ljx
zJ>{NkqO91lX%i@$LLYt4<gYqcZJ-pY_40;IS&D&jpW^Z#8SC2dF+6z*=YD|ia!+1T
zo?Og?<X^fTTny(G6#9^zRN;)s$GSgGI2TZN5NmX~5exF|?%VS!l;5PKV;?<uC=TZl
zT)#PMITfdNA)q3M=V>@lGESPp0ta58&&Y~m$6Jnyw#xpk-=#?n;il_LoUCm{g7FM*
z=1CsWHt`KwoWuOWnVuOQsv8c^$$zi;!_-m-sTCpVC1Yx(b`2@lcN*{pfmy%Udvrh0
z`gsr7wW9tWiSeo0oCd3|Bd<s9=o{eI7bg2Y!&{%jfm-+bDN!%WH~a0RDr~jxQ#AMr
zfh`ZL9hiR=Nw-z4oinG5YOzA?4=)~Mg6p;M171TiA1Q!|w<<9~L)g=Z&22bAe>KaV
zahniS(Kc8}D{QB@twDl$`myDQc|cpsJ286lA8X_MRp}kLaF2@lTPOlQM{vDG%Rbq-
z2RD&3zL+tLxAHCyH{}}xC%63!IhdzP$s44k!HOF=c69m7b`CeBxz6P;%VAyjQwxKt
zEbF_6$tAdm;6_9(Bon8MV%2ng#qwzra1}BT-Xv&P<#imJl<(<j{yG*@LS_aBM=1qd
zU$tW4ZL|f<<CvOw;FijwiYJHaLHDlIq;#qZzl02%jIP}*@m#p1)P85Mw|0GdNB(9o
zHLsK`SyG?xHdpP%1szi3L4AzFyNG(9IyGF)nRDRVI8dvz3q%<Rn2$4a8)xu7@4%O6
z@T&wrBB1jf$^>+U0Q_$XQTd?mk=yXo^&K*7v#73)>T*>(BI#HF>L_mDAYN9CN*REf
zI8b8+>PbL70hC6{Y@p-;+I6@=K=B2Nit^!Z^wp|MP6u|?V!InXX3lN|I#m~+<~r5t
U3AcsUg?-s<JP=+ZJBK>{3xVu2-v9sr

delta 3680
zcmb7GYiwLc6`t9**LT<U+Pn7J>-95nuI(fwO+#yf6Y6c9M2!=09k<(r<*w&Cz4q?i
z_1wF$ouqYJhf)w#A0q*ZS`Y=ArWhh&H6c7&9_k<XK`W4ut^|ly{0LP2!5>hHD$bd;
z*Y+Y&WmosRXU=QRoH=vm{^+6W5B7YZgn}P_?Mo+b>?Gtpvgzjm`Vc(U+t2qrwd5wu
zLoO1Mt|iP%m`~CQVSd5_k`9qkRzp}22Y|Yp%!J8I9a(mhbUnzxPLVQ&EW1d$fv^x^
zVQCs63~cHMt0xyJNjDM((ufo_fhCNamZWLZy4$F98v|jKu$Yv^w#u48)=XH7l(lS?
zwSX*6SgVw^Zj}MQjj#lY(yfHG6P85!R2sM)gmp?mg0L>ax+M)7J%sg2I!V|z!nR8q
zl=}$VA?Z%SRKoft4ThAAs{=PN)nh7kXusIz`n%7+=gwVw_O3R$Ybk9Not`WWiDl0=
znpnN!`3?0&L7Th9qVH!DNhB+vx^MX>4U-k-E&d6VAgFHMiF5@(%X`0JmKOLP<RgGi
zH_~Mgi~hc)TY;2eY1y34_+AttfZ71k6#zy>xUMmX8Wm7mobb5K4fD(iUMT9^UgQm+
z;CSuDqHa0f$pX(Y?nah!uUX2kYdyd{=*NrTM``U5(_R<y0J3Wkf(Qyi2*6S9DHL)Q
zwJ`D{2#p8{aWSx8Z9%fN0&PG!jfQF1GL$u2L$^A_dx23pECy<fy$37m(oouj8Q11B
z#hkX7F>F0Q3Mv-HOlS?|BZ79s#b0X9)7a|6!JV|XvXJW7o6xn2;1MgecXU<O!ZCWa
zhReAzXKO2YK}j4s1Vg7r%Nb|Pyl&d6mwyHo?m>|Ha*;=IShZ3QMm-@;Dc|r(pZmlu
zrTy*^)I7FTy|PlC0>S<8SQwi^edWKq(Zy48nMUX;4U2eqBwjUH;6P5xXPGuUD@x(1
z&WFHUr92I<s<8OOz{`t&hkHg(q4YFrdS#_-?4RSAu?nW+Wu<)40zY!eRWthSLgwiB
z@i9YW>$=Cs(ARN<69`#^4FgHxR`N-JN8qts01B1kDInz!_tXau=EyoJ{#f_&$%P4G
z6EZ`|Of5;B9wm>u$pz?f&;nf~&fH|yP56pb39WTLgQ5oWkp1P3Sypd`mf5^aDV<v(
zb1UNA`uidukx9Fr%ruZ?C?upJ;?oTsG%ijzBomDr8FBoD?2JBTTaE`$5}y=bZ&15r
zG0FBY1kt7yeW6(3cE+00O+D?-m2~l+hW=p>ln&2pc8Tkj+zp3nJPrn%l2b16vi+!*
z*HfCU6)^+-!icm-8fhcl>kiQf{A2E*o6m_CBXMf2UW?qsp7mN&e^~a;3vds#lV+9_
z?>40dJIEsx8z*#q$_TW+t}za8!YKk~`kZg4-C3{}c&+$cbQjHtC!${#b+J@ZO*r9f
z$;h#>0@EMhI)uJ)D0Fc)HkiaUJFfYBI%H{Q^-Nwf%xNR1^Eq_hD1H$uMX_d_p!Ac$
zygAh3QE{~S^X(gTA(yU59q0y_<mbd&%_$}5Qm8@?yXsy1(rUD&mr^E%;@duT4t%CP
zse-AiO`BuFSuY?witrf162jvMPar%gF2&n?vN!p~PvfmBZk^-fdcJU0=g-1G^_R>1
zc~qAh`vOvriI3u4{}b|5PS?z}kbfr*wD!<f;CvnyueP2XszuL%`;Lqq89#h)3Qo@@
z^zPc!H>wig*BA7ulC9qqceU+0w)G@AHQ8LoU?$WB|18FH1!2R1q~yuE41&MGW8n#s
zt;5AHLr~+wmlz*>6__6%iuC?Z@x{dMPi_r^zXtXn6TtUD<pc4Zwg<&X`|C@UT07^*
z${5<co68t#Z)@M2;JlvAa=2x6?s(u<Gq*J0s=eAsOPjp0FjpUn$CE>&x4)Vdu>BW2
zo71@h>HOw;DqjKN|JhZU%Aojd$L_msfAXu~+egLwi8gVp^ZjxzU&Q$uZYz8INw9Hz
z`hsEER{3Ja3!Z-)*@3(^t22XJ{AC=5ww!qQ+K{=GM<D)PG}@G09G(ZL7w>e%>G{=v
zbQNi>+;9w%za*x6{xscy<i;04W#aPL`XNXi?>vY597=q>*{D8_bERF}ET7`<p&Feo
z+f+rc3bLfQ(%VN@SKsNKp!F{Squk?ON9vl`zuk<=lZ*>4H;5l2l@~X*_t6{TuiIP3
za6ZRlLZ{<D0Wuw$;<{$*EQ2iQSSY3@KZ9?#VHO=ffIN;>;oJa?JH%+;064b#p1xZq
z?JZ#PU!kohXPC3qNqhq&6LhV}2(70{%HI(CcFf-SbC5uFNhiNVCsngu2VQ!!WsLIc
z;tx9<dQDtaRUbAX&c&bA;X@cYe;U9EF@0Jq<?PH^4K66hn=8!g9A?1)`L7YGW_c5M
z8F8vVPTz#mZxUbW?;pc`b-X3p$XQMu*Uvz0={%D!uoCotS?a@EJxQOkMLh$8Sq$0(
z1T5FZpOJ2313l$Wq_@Svf#xOYWFwM_y%Q{%>k}5yjZ3=WzlWFFEqlM?wiYe^Ent)n
z%0;BU002c+T-;TJ4`Yizh0L!a`~bm3NFd0-N94`155|u7gl6hF`B5f6RLa-eB~-=J
z?*xv+=YVDxIKPZMY=H1F0)XdNo)C^j%CR&!?ls44<Cs;BxsZ`>%6WOEcu6^d1Lcek
u!#as|K+Fxc^tqIXvP1DE5{&_+v+kf0OVq%>E)i71N>u4qyzo~P?|%V89t6w)

diff --git a/blender/__pycache__/start.cpython-34.pyc b/blender/__pycache__/start.cpython-34.pyc
index fff5775c5e979780c4166e460f7d7f1e13bb38c3..9c5a7f823a9dadad16fd13ae7b614d7480073716 100644
GIT binary patch
delta 31
ncmX@gdW@Cx9S<+p_V&qP%Qtc|GqSTK7Ukv_Rc;ny+{_37tegs6

delta 30
mcmX@cdX$y(9S<+pmQ$%=OEz*cGqSN3C#UA6ZWd<T%m@IYLkZsi

diff --git a/blender/__pycache__/write_data.cpython-34.pyc b/blender/__pycache__/write_data.cpython-34.pyc
index 9cd800b21074fe871e931e1cf48c2b207f995228..2fcb45a039ea9d2b6701b3756a43bf91e99ea262 100644
GIT binary patch
delta 469
zcmY*VyG{a85S@D$1+Oe32Jz8orE4Nss@Q31V=z8q3|V(CxC9oQyS@m-L<&nKoA?J7
z#?sov%7)Hzf51w=!4Zj%o6MOxXU@zd_igAsE<U2Vc)s<wF2ilHJI~<zX_N*jRw>jK
zfd^nSusO6iTq86YG+6s)dh=`%8USni3(({wL5WOZXmCi`5lFQdu>az~w|KMy+r5T>
zFW0sWu(3msGX~pFIbMJ9lg#uVnC`!_wC}RHi~4d6t0if9Y16iIho&u2&CaYl2WX-r
zRmM8E%2E~0ip*HmO3f)tJJYje>alzQ&0@M(R^=HZD~O*+^nQ6<p!AN>o$B4l8ht^i
zT9a<jcZ!ZD1I=IJi771@R^7{alm&^>wWJDIA<&5414jKEFOA0OzknrJKTk#?TxUr(
z&N24b;dh}uK`o5_fKF8)x)<^l({U$=s|W#bnitj>j!<ocu%A-Es|sUObj3egy8Cp$
I6P{$rPxZKSH~;_u

delta 308
zcmaDW@SLCP9S<+p0?vxC&1@67BGnn7fDuS@1F<s@7uy4g5(b78Murq7hGr&)eyzzh
z%*q1Ij0}w7DGUsO5kMkXlYKHPV=!x?Fi`8{D8|Ie{}`1fuV7S=Dk#d&N=+`&OH4`e
z$xJFrEUMH{&nZn+*R-B|f>BQcE|!s4k(yMRlapEkl;YwlN-ZfZ%2R;qw&t4L$E3``
zc#AP@B|{O{<cmyMd>lY$F)#`-vN4Hr7x8QkWM0Y=%?T7L;(`+(FWllPFUl-Qjn7TY
v%o7Lli^2Msfcm(SC5i-rBAP5kY#@b9`Nc&%Kn7S4$rP}8+>--2q#1<(Sdv4-

diff --git a/blender/scene.py b/blender/armory.py
similarity index 97%
rename from blender/scene.py
rename to blender/armory.py
index e7bd94fa..d7c25dd4 100644
--- a/blender/scene.py
+++ b/blender/armory.py
@@ -1,5 +1,5 @@
 # =============================================================
-#  Lue Scene Exporter
+#  Armory Scene Exporter
 #  http://lue3d.org/
 #  by Lubos Lenco
 #
@@ -9,23 +9,20 @@
 # 
 #  Export plugin for Blender
 #  by Eric Lengyel
-#
 #  Version 1.1.2.2
-# 
 #  Copyright 2015, Terathon Software LLC
 # 
 #  This software is licensed under the Creative Commons
 #  Attribution-ShareAlike 3.0 Unported License:
-# 
 #  http://creativecommons.org/licenses/by-sa/3.0/deed.en_US
 #
 # =============================================================
 
 
 bl_info = {
-	"name": "Lue format (.json)",
-	"description": "Lue Exporter",
-	"author": "Eric Lengyel, adapted by Lubos Lenco",
+	"name": "Armory format (.json)",
+	"description": "Armory Exporter",
+	"author": "Eric Lengyel, Armory by Lubos Lenco",
 	"version": (1, 0, 0, 0),
 	"location": "File > Import-Export",
 	"wiki_url": "http://lue3d.org/",
@@ -111,15 +108,17 @@ class Object:
 		return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
 
 
-class LueExporter(bpy.types.Operator, ExportHelper):
-	"""Export to Lue format"""
-	bl_idname = "export_scene.lue"
-	bl_label = "Export Lue"
+class ArmoryExporter(bpy.types.Operator, ExportHelper):
+	"""Export to Armory format"""
+	bl_idname = "export_scene.armory"
+	bl_label = "Export Armory"
 	filename_ext = ".json"
 
 	option_export_selection = bpy.props.BoolProperty(name = "Export Selection Only", description = "Export only selected objects", default = False)
 	option_sample_animation = bpy.props.BoolProperty(name = "Force Sampled Animation", description = "Always export animation as per-frame samples", default = False)
-	option_no_cycles = bpy.props.BoolProperty(name = "Export Pure Lue", description = "Export pure lue data", default = False)
+	option_no_cycles = bpy.props.BoolProperty(name = "Export Pure Armory", description = "Export pure armory data", default = False)
+
+	shader_references = None
 
 	def WriteColor(self, color):
 		return [color[0], color[1], color[2]]
@@ -341,9 +340,9 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 	@staticmethod
 	def AnimationPresent(fcurve, kind):
 		if (kind != kAnimationBezier):
-			return (LueExporter.AnimationKeysDifferent(fcurve))
+			return (ArmoryExporter.AnimationKeysDifferent(fcurve))
 
-		return ((LueExporter.AnimationKeysDifferent(fcurve)) or (LueExporter.AnimationTangentsNonzero(fcurve)))
+		return ((ArmoryExporter.AnimationKeysDifferent(fcurve)) or (ArmoryExporter.AnimationTangentsNonzero(fcurve)))
 
 
 	@staticmethod
@@ -534,7 +533,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		for i in range(len(exportVertexArray)):
 			ev = exportVertexArray[i]
 			bucket = ev.hash & (bucketCount - 1)
-			index = LueExporter.FindExportVertex(hashTable[bucket], exportVertexArray, ev)
+			index = ArmoryExporter.FindExportVertex(hashTable[bucket], exportVertexArray, ev)
 			if (index < 0):
 				indexTable.append(len(unifiedVertexArray))
 				unifiedVertexArray.append(ev)
@@ -596,7 +595,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		for i in range(self.beginFrame, self.endFrame):
 			scene.frame_set(i)
 			m2 = node.matrix_local
-			if (LueExporter.MatricesDifferent(m1, m2)):
+			if (ArmoryExporter.MatricesDifferent(m1, m2)):
 				animationFlag = True
 				break
 
@@ -642,7 +641,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		for i in range(self.beginFrame, self.endFrame):
 			scene.frame_set(i)
 			m2 = poseBone.matrix
-			if (LueExporter.MatricesDifferent(m1, m2)):
+			if (ArmoryExporter.MatricesDifferent(m1, m2)):
 				animationFlag = True
 				break
 
@@ -718,49 +717,49 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 			action = node.animation_data.action
 			if (action):
 				for fcurve in action.fcurves:
-					kind = LueExporter.ClassifyAnimationCurve(fcurve)
+					kind = ArmoryExporter.ClassifyAnimationCurve(fcurve)
 					if (kind != kAnimationSampled):
 						if (fcurve.data_path == "location"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not posAnimCurve[i])):
 									posAnimCurve[i] = fcurve
 									posAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										posAnimated[i] = True
 						elif (fcurve.data_path == "delta_location"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not deltaPosAnimCurve[i])):
 									deltaPosAnimCurve[i] = fcurve
 									deltaPosAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										deltaPosAnimated[i] = True
 						elif (fcurve.data_path == "rotation_euler"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not rotAnimCurve[i])):
 									rotAnimCurve[i] = fcurve
 									rotAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										rotAnimated[i] = True
 						elif (fcurve.data_path == "delta_rotation_euler"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not deltaRotAnimCurve[i])):
 									deltaRotAnimCurve[i] = fcurve
 									deltaRotAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										deltaRotAnimated[i] = True
 						elif (fcurve.data_path == "scale"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not sclAnimCurve[i])):
 									sclAnimCurve[i] = fcurve
 									sclAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										sclAnimated[i] = True
 						elif (fcurve.data_path == "delta_scale"):
 							for i in range(3):
 								if ((fcurve.array_index == i) and (not deltaSclAnimCurve[i])):
 									deltaSclAnimCurve[i] = fcurve
 									deltaSclAnimKind[i] = kind
-									if (LueExporter.AnimationPresent(fcurve, kind)):
+									if (ArmoryExporter.AnimationPresent(fcurve, kind)):
 										deltaSclAnimated[i] = True
 						elif ((fcurve.data_path == "rotation_axis_angle") or (fcurve.data_path == "rotation_quaternion") or (fcurve.data_path == "delta_rotation_quaternion")):
 							sampledAnimation = True
@@ -1107,7 +1106,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 
 	def ProcessNode(self, node):
 		if ((self.exportAllFlag) or (node.select)):
-			type = LueExporter.GetNodeType(node)
+			type = ArmoryExporter.GetNodeType(node)
 			self.nodeArray[node] = {"nodeType" : type, "structName" : node.name}
 
 			if (node.parent_type == "BONE"):
@@ -1233,7 +1232,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 				for i in range(len(node.particle_systems)):
 					self.ExportParticleSystemRef(node.particle_systems[i], i, o)
 
-				#shapeKeys = LueExporter.GetShapeKeys(object)
+				#shapeKeys = ArmoryExporter.GetShapeKeys(object)
 				#if (shapeKeys):
 				#	self.ExportMorphWeights(node, shapeKeys, scene, o)
 				# TODO
@@ -1491,7 +1490,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		showOnlyShapeKey = node.show_only_shape_key
 		currentMorphValue = []
 
-		shapeKeys = LueExporter.GetShapeKeys(mesh)
+		shapeKeys = ArmoryExporter.GetShapeKeys(mesh)
 		if (shapeKeys):
 			node.active_shape_key_index = 0
 			node.show_only_shape_key = True
@@ -1552,11 +1551,11 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		# Triangulate mesh and remap vertices to eliminate duplicates.
 
 		materialTable = []
-		exportVertexArray = LueExporter.DeindexMesh(exportMesh, materialTable)
+		exportVertexArray = ArmoryExporter.DeindexMesh(exportMesh, materialTable)
 		triangleCount = len(materialTable)
 
 		indexTable = []
-		unifiedVertexArray = LueExporter.UnifyVertices(exportVertexArray, indexTable)
+		unifiedVertexArray = ArmoryExporter.UnifyVertices(exportVertexArray, indexTable)
 		vertexCount = len(unifiedVertexArray)
 
 		# Write the position array.
@@ -1935,7 +1934,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 		o.near_plane = object.clip_start
 		o.far_plane = object.clip_end
 		o.frustum_culling = False
-		o.pipeline = "pipeline_resource/blender_pipeline"
+		o.pipeline = "pipeline_resource/forward_pipeline"
 		
 		if 'Background' in bpy.data.worlds[0].node_tree.nodes: # TODO: parse node tree
 			col = bpy.data.worlds[0].node_tree.nodes['Background'].inputs[0].default_value
@@ -1985,7 +1984,7 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 			o.contexts = []
 			
 			c = Object()
-			c.id = "blender"
+			c.id = "forward"
 			c.bind_constants = []
 			const1 = Object()
 			const1.id = "diffuseColor"
@@ -2086,9 +2085,12 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 				# Merge duplicates and sort
 				defs = sorted(list(set(defs)))
 				# Select correct shader variant
-				o.shader = "blender_resource/blender"
+				o.shader = "forward_resource/forward"
+				ext = ''
 				for d in defs:
-					o.shader += d
+					ext += d
+				o.shader += ext
+				ArmoryExporter.shader_references.append('forward' + ext)
 			else:
 				o.shader = material.custom_shader_name
 
@@ -2174,6 +2176,9 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 	def execute(self, context):
 		self.output = Object()
 
+		# Store used shaders in this scene
+		ArmoryExporter.shader_references = []
+
 		scene = context.scene
 
 		originalFrame = scene.frame_current
@@ -2233,15 +2238,15 @@ class LueExporter(bpy.types.Operator, ExportHelper):
 
 
 def menu_func(self, context):
-	self.layout.operator(LueExporter.bl_idname, text = "Lue (.json)")
+	self.layout.operator(ArmoryExporter.bl_idname, text = "Armory (.json)")
 
 def register():
-	bpy.utils.register_class(LueExporter)
+	bpy.utils.register_class(ArmoryExporter)
 	bpy.types.INFO_MT_file_export.append(menu_func)
 
 def unregister():
 	bpy.types.INFO_MT_file_export.remove(menu_func)
-	bpy.utils.unregister_class(LueExporter)
+	bpy.utils.unregister_class(ArmoryExporter)
 
 if __name__ == "__main__":
 	register()
diff --git a/blender/plugin/cyclesgame.py b/blender/plugin/cyclesgame.py
index fe1965c7..4598c733 100644
--- a/blender/plugin/cyclesgame.py
+++ b/blender/plugin/cyclesgame.py
@@ -1,12 +1,11 @@
 # Cycles Game Engine
 # https://github.com/luboslenco/cyclesgame
-# cyclesgame.py 15.12.0
 bl_info = {
     "name": "Cycles Game",
     "category": "Game Engine",
     "description": "3D Game Engine built for Cycles",
     "author": "Lubos Lenco",
-    "version": (15, 12, 0, 0),
+    "version": (16, 1, 0, 0),
     "wiki_url": "http://cyclesgame.org/"
 }
 
@@ -87,7 +86,7 @@ def start_plugin():
 
     output = subprocess.check_output([haxelib_path + " path cyclesgame"], shell=True)
     output = str(output).split("\\n")[0].split("'")[1]
-    scripts_path = output + "blender/"
+    scripts_path = output[:-8] + "blender/" # Remove 'Sources/' from haxelib path
     
     sys.path.append(scripts_path)
     import start
diff --git a/blender/project.py b/blender/project.py
index 353e9ee0..467117bc 100755
--- a/blender/project.py
+++ b/blender/project.py
@@ -9,10 +9,11 @@ import subprocess
 import atexit
 import webbrowser
 import write_data
+from armory import ArmoryExporter
 
 def defaultSettings():
     wrd = bpy.data.worlds[0]
-    wrd['CGVersion'] = "15.12.0"
+    wrd['CGVersion'] = "16.1.0"
     wrd['CGProjectTarget'] = 0
     wrd['CGProjectName'] = "cycles_game"
     wrd['CGProjectPackage'] = "game"
@@ -125,9 +126,11 @@ def exportGameData():
             o.location.z = 0
 
     # Export scene data
+    shader_references = []
     for scene in bpy.data.scenes:
         if scene.name[0] != '.': # Skip hidden scenes
-            bpy.ops.export_scene.lue({"scene":scene}, filepath='Assets/' + scene.name + '.json')
+            bpy.ops.export_scene.armory({"scene":scene}, filepath='Assets/' + scene.name + '.json')
+            shader_references += ArmoryExporter.shader_references
 
     # Move armatures back
     for a in armatures:
@@ -136,7 +139,7 @@ def exportGameData():
         a.armature.location.z = a.z
     
     # Write khafile.js
-    write_data.write_khafilejs()
+    write_data.write_khafilejs(shader_references)
 
     # Write Main.hx
     write_data.write_main()
@@ -194,7 +197,7 @@ def buildProject(self, build_type=0):
 
     output = subprocess.check_output([haxelib_path + " path cyclesgame"], shell=True)
     output = str(output).split("\\n")[0].split("'")[1]
-    scripts_path = output + "blender/"
+    scripts_path = output[:-8] + "blender/"
 
     blender_path = bpy.app.binary_path
     blend_path = bpy.data.filepath
diff --git a/blender/start.py b/blender/start.py
index 949380a1..354ae649 100755
--- a/blender/start.py
+++ b/blender/start.py
@@ -1,6 +1,6 @@
 import project
 import nodes
-import scene
+import armory
 import traits_animation
 import traits
 import props
@@ -8,7 +8,7 @@ import props
 def register():
     project.register()
     nodes.register()
-    scene.register()
+    armory.register()
     traits_animation.register()
     traits.register()
     props.register()
@@ -16,7 +16,7 @@ def register():
 def unregister():
     project.unregister()
     nodes.unregister()
-    scene.unregister()
+    armory.unregister()
     traits_animation.unregister()
     traits.unregister()
     props.unregister()
diff --git a/blender/write_data.py b/blender/write_data.py
index d887d6dc..8325e29a 100644
--- a/blender/write_data.py
+++ b/blender/write_data.py
@@ -2,7 +2,7 @@ import bpy
 import os
 
 # Write khafile.js
-def write_khafilejs():
+def write_khafilejs(shader_references):
 	with open('khafile.js', 'w') as f:
 			f.write(
 """// Auto-generated
@@ -10,15 +10,18 @@ var project = new Project('""" + bpy.data.worlds[0]['CGProjectName'] + """');
 
 project.addSources('Sources');
 project.addShaders('Sources/Shaders/**');
-project.addAssets('Libraries/cyclesgame/Assets/**');
 project.addAssets('Assets/**');
-project.addLibrary('lue');
-project.addLibrary('cyclesgame');
-project.addLibrary('haxebullet');
 
-return project;
+project.addLibrary('cyclesgame');
+project.addAssets('Libraries/cyclesgame/Assets/**');
 """)
 
+			for ref in shader_references:
+				f.write("project.addShaders('Libraries/cyclesgame/compiled/Shaders/" + ref + ".frag.glsl');\n")
+				f.write("project.addShaders('Libraries/cyclesgame/compiled/Shaders/" + ref + ".vert.glsl');\n")
+
+			f.write("\nreturn project;")
+
 # Write Main.hx
 def write_main():
 	#if not os.path.isfile('Sources/Main.hx'):
diff --git a/compiled/Assets/attrib_pass_resource.json b/compiled/Assets/attrib_pass_resource.json
new file mode 100644
index 00000000..dd482ce2
--- /dev/null
+++ b/compiled/Assets/attrib_pass_resource.json
@@ -0,0 +1,3156 @@
+{
+    "shader_resources": [
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass.vert"
+                }
+            ], 
+            "id": "attrib_pass", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Skinning.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Skinning.vert"
+                }
+            ], 
+            "id": "attrib_pass_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_Skinning.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_Skinning.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_Skinning.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_Skinning.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Skinning_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Skinning_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_Skinning.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_Skinning.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_Skinning_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_Skinning_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_Skinning_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Skinning_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_Skinning_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_Skinning_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_NormalMapping_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_NormalMapping_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "attrib_pass", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/compiled/Assets/deferred_pass_resource.json b/compiled/Assets/deferred_pass_resource.json
new file mode 100644
index 00000000..7113c194
--- /dev/null
+++ b/compiled/Assets/deferred_pass_resource.json
@@ -0,0 +1,37 @@
+{
+    "shader_resources": [
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "always", 
+                    "constants": [], 
+                    "cull_mode": "none", 
+                    "depth_write": false, 
+                    "fragment_shader": "deferred_pass.frag", 
+                    "id": "deferred_pass", 
+                    "texture_units": [
+                        {
+                            "id": "gbuffer0"
+                        }, 
+                        {
+                            "id": "gbuffer1"
+                        }, 
+                        {
+                            "id": "gbuffer2"
+                        }
+                    ], 
+                    "vertex_shader": "deferred_pass.vert"
+                }
+            ], 
+            "id": "deferred_pass", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 2
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/compiled/Assets/env_map_resource.json b/compiled/Assets/env_map_resource.json
new file mode 100644
index 00000000..7dd901c7
--- /dev/null
+++ b/compiled/Assets/env_map_resource.json
@@ -0,0 +1,42 @@
+{
+    "shader_resources": [
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "always", 
+                    "constants": [
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }
+                    ], 
+                    "cull_mode": "none", 
+                    "depth_write": false, 
+                    "fragment_shader": "env_map.frag", 
+                    "id": "env_map", 
+                    "texture_units": [
+                        {
+                            "id": "envmap"
+                        }
+                    ], 
+                    "vertex_shader": "env_map.vert"
+                }
+            ], 
+            "id": "env_map", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 2
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/compiled/Assets/forward_resource.json b/compiled/Assets/forward_resource.json
new file mode 100644
index 00000000..00b0d82d
--- /dev/null
+++ b/compiled/Assets/forward_resource.json
@@ -0,0 +1,6308 @@
+{
+    "shader_resources": [
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward.vert"
+                }
+            ], 
+            "id": "forward", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing.vert"
+                }
+            ], 
+            "id": "forward_Instancing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Skinning.vert"
+                }
+            ], 
+            "id": "forward_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Texturing.vert"
+                }
+            ], 
+            "id": "forward_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_VCols.vert"
+                }
+            ], 
+            "id": "forward_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Skinning.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_Skinning.vert"
+                }
+            ], 
+            "id": "forward_Instancing_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_Texturing.vert"
+                }
+            ], 
+            "id": "forward_Instancing_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_Skinning.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_Texturing.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_VCols.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_Texturing.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_Instancing_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_NormalMapping_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_NormalMapping_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_Instancing_NormalMapping_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }, 
+        {
+            "contexts": [
+                {
+                    "blend_destination": "blend_zero", 
+                    "blend_source": "blend_one", 
+                    "compare_mode": "less", 
+                    "constants": [
+                        {
+                            "id": "M", 
+                            "link": "_modelMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "NM", 
+                            "link": "_normalMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "V", 
+                            "link": "_viewMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "P", 
+                            "link": "_projectionMatrix", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "lightMVP", 
+                            "link": "_lightMVP", 
+                            "type": "mat4"
+                        }, 
+                        {
+                            "id": "diffuseColor", 
+                            "type": "vec4"
+                        }, 
+                        {
+                            "id": "light", 
+                            "link": "_lightPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "eye", 
+                            "link": "_cameraPosition", 
+                            "type": "vec3"
+                        }, 
+                        {
+                            "id": "skinBones", 
+                            "link": "_skinBones", 
+                            "type": "floats"
+                        }, 
+                        {
+                            "id": "lighting", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "receiveShadow", 
+                            "type": "bool"
+                        }, 
+                        {
+                            "id": "roughness", 
+                            "type": "float"
+                        }
+                    ], 
+                    "cull_mode": "counter_clockwise", 
+                    "depth_write": true, 
+                    "fragment_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag", 
+                    "id": "forward", 
+                    "texture_units": [
+                        {
+                            "id": "stex"
+                        }, 
+                        {
+                            "id": "shadowMap"
+                        }, 
+                        {
+                            "id": "normalMap"
+                        }
+                    ], 
+                    "vertex_shader": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert"
+                }
+            ], 
+            "id": "forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols", 
+            "vertex_structure": [
+                {
+                    "name": "pos", 
+                    "size": 3
+                }, 
+                {
+                    "name": "nor", 
+                    "size": 3
+                }, 
+                {
+                    "name": "tex", 
+                    "size": 2
+                }, 
+                {
+                    "name": "col", 
+                    "size": 4
+                }, 
+                {
+                    "name": "tan", 
+                    "size": 3
+                }, 
+                {
+                    "name": "bone", 
+                    "size": 4
+                }, 
+                {
+                    "name": "weight", 
+                    "size": 4
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/shader_data/attrib_pass/attrib_pass.frag.glsl b/compiled/Shaders/attrib_pass.frag.glsl
similarity index 100%
rename from shader_data/attrib_pass/attrib_pass.frag.glsl
rename to compiled/Shaders/attrib_pass.frag.glsl
diff --git a/Sources/Shaders/attrib_pass.vert.glsl b/compiled/Shaders/attrib_pass.vert.glsl
similarity index 100%
rename from Sources/Shaders/attrib_pass.vert.glsl
rename to compiled/Shaders/attrib_pass.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing.frag.glsl b/compiled/Shaders/attrib_pass_Instancing.frag.glsl
new file mode 100644
index 00000000..17c3aa5f
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing.frag.glsl
@@ -0,0 +1,41 @@
+#define _Instancing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing.vert.glsl b/compiled/Shaders/attrib_pass_Instancing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping.frag.glsl
new file mode 100644
index 00000000..7896f23d
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping.frag.glsl
@@ -0,0 +1,42 @@
+#define _Instancing
+#define _NormalMapping
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.frag.glsl
new file mode 100644
index 00000000..083f5290
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.frag.glsl
@@ -0,0 +1,43 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
new file mode 100644
index 00000000..cb0e1980
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
@@ -0,0 +1,44 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..45097b2b
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
@@ -0,0 +1,45 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.frag.glsl
new file mode 100644
index 00000000..4123e7f2
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.frag.glsl
@@ -0,0 +1,44 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_Skinning_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.frag.glsl
new file mode 100644
index 00000000..89ce03a4
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.frag.glsl
@@ -0,0 +1,43 @@
+#define _Instancing
+#define _NormalMapping
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..50744822
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.frag.glsl
@@ -0,0 +1,44 @@
+#define _Instancing
+#define _NormalMapping
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.frag.glsl
new file mode 100644
index 00000000..7cb025d1
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.frag.glsl
@@ -0,0 +1,43 @@
+#define _Instancing
+#define _NormalMapping
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_NormalMapping_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_Skinning.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning.frag.glsl
new file mode 100644
index 00000000..d54439ae
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_Skinning.frag.glsl
@@ -0,0 +1,42 @@
+#define _Instancing
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_Skinning.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.frag.glsl
new file mode 100644
index 00000000..6a99a224
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.frag.glsl
@@ -0,0 +1,43 @@
+#define _Instancing
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..fa021664
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.frag.glsl
@@ -0,0 +1,44 @@
+#define _Instancing
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_Skinning_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.frag.glsl
new file mode 100644
index 00000000..a4333528
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.frag.glsl
@@ -0,0 +1,43 @@
+#define _Instancing
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_Skinning_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_Texturing.frag.glsl
new file mode 100644
index 00000000..0a14567d
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_Texturing.frag.glsl
@@ -0,0 +1,42 @@
+#define _Instancing
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..d6397e0c
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.frag.glsl
@@ -0,0 +1,43 @@
+#define _Instancing
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Instancing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Instancing_VCols.frag.glsl
new file mode 100644
index 00000000..5e2d5b63
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Instancing_VCols.frag.glsl
@@ -0,0 +1,42 @@
+#define _Instancing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Instancing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Instancing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping.frag.glsl
new file mode 100644
index 00000000..1bbf32db
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping.frag.glsl
@@ -0,0 +1,41 @@
+#define _NormalMapping
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_Skinning.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning.frag.glsl
new file mode 100644
index 00000000..00026555
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_Skinning.frag.glsl
@@ -0,0 +1,42 @@
+#define _NormalMapping
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_Skinning.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.frag.glsl
new file mode 100644
index 00000000..9cb04ee5
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.frag.glsl
@@ -0,0 +1,43 @@
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..9058f238
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.frag.glsl
@@ -0,0 +1,44 @@
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_Skinning_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.frag.glsl
new file mode 100644
index 00000000..e1be4b1a
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.frag.glsl
@@ -0,0 +1,43 @@
+#define _NormalMapping
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning_VCols.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_Skinning_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Texturing.frag.glsl
new file mode 100644
index 00000000..5574fc86
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_Texturing.frag.glsl
@@ -0,0 +1,42 @@
+#define _NormalMapping
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..5817d82a
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.frag.glsl
@@ -0,0 +1,43 @@
+#define _NormalMapping
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_NormalMapping_VCols.frag.glsl b/compiled/Shaders/attrib_pass_NormalMapping_VCols.frag.glsl
new file mode 100644
index 00000000..d40f0da1
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_NormalMapping_VCols.frag.glsl
@@ -0,0 +1,42 @@
+#define _NormalMapping
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_VCols.vert.glsl b/compiled/Shaders/attrib_pass_NormalMapping_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_NormalMapping_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Skinning.frag.glsl b/compiled/Shaders/attrib_pass_Skinning.frag.glsl
new file mode 100644
index 00000000..b4ea84cb
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Skinning.frag.glsl
@@ -0,0 +1,41 @@
+#define _Skinning
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning.vert.glsl b/compiled/Shaders/attrib_pass_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning.vert.glsl
rename to compiled/Shaders/attrib_pass_Skinning.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Skinning_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_Skinning_Texturing.frag.glsl
new file mode 100644
index 00000000..6364fdb4
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Skinning_Texturing.frag.glsl
@@ -0,0 +1,42 @@
+#define _Skinning
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_Skinning_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..c2919b6b
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.frag.glsl
@@ -0,0 +1,43 @@
+#define _Skinning
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Skinning_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Skinning_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Skinning_VCols.frag.glsl
new file mode 100644
index 00000000..01597a95
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Skinning_VCols.frag.glsl
@@ -0,0 +1,42 @@
+#define _Skinning
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Skinning_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Texturing.frag.glsl b/compiled/Shaders/attrib_pass_Texturing.frag.glsl
new file mode 100644
index 00000000..41370c92
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Texturing.frag.glsl
@@ -0,0 +1,41 @@
+#define _Texturing
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Texturing.vert.glsl b/compiled/Shaders/attrib_pass_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Texturing.vert.glsl
rename to compiled/Shaders/attrib_pass_Texturing.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_Texturing_VCols.frag.glsl b/compiled/Shaders/attrib_pass_Texturing_VCols.frag.glsl
new file mode 100644
index 00000000..3c87278b
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_Texturing_VCols.frag.glsl
@@ -0,0 +1,42 @@
+#define _Texturing
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_Texturing_VCols.vert.glsl b/compiled/Shaders/attrib_pass_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Texturing_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_Texturing_VCols.vert.glsl
diff --git a/compiled/Shaders/attrib_pass_VCols.frag.glsl b/compiled/Shaders/attrib_pass_VCols.frag.glsl
new file mode 100644
index 00000000..420fa53e
--- /dev/null
+++ b/compiled/Shaders/attrib_pass_VCols.frag.glsl
@@ -0,0 +1,41 @@
+#define _VCols
+#extension GL_EXT_draw_buffers : require
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+
+#ifdef _Texturing
+uniform sampler2D stex;
+#endif
+uniform sampler2D shadowMap;
+#ifdef _NormalMapping
+uniform sampler2D normalMap;
+#endif
+uniform bool lighting;
+uniform bool receiveShadow;
+uniform float roughness;
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+void kore() {
+
+	gl_FragData[0] = vec4(position.xyz, 0);
+	gl_FragData[1] = vec4(normal.xyz, 0);
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
+}
diff --git a/Sources/Shaders_/blender_VCols.vert.glsl b/compiled/Shaders/attrib_pass_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_VCols.vert.glsl
rename to compiled/Shaders/attrib_pass_VCols.vert.glsl
diff --git a/Sources/Shaders/deferred_pass.frag.glsl b/compiled/Shaders/deferred_pass.frag.glsl
similarity index 100%
rename from Sources/Shaders/deferred_pass.frag.glsl
rename to compiled/Shaders/deferred_pass.frag.glsl
diff --git a/Sources/Shaders/deferred_pass.vert.glsl b/compiled/Shaders/deferred_pass.vert.glsl
similarity index 100%
rename from Sources/Shaders/deferred_pass.vert.glsl
rename to compiled/Shaders/deferred_pass.vert.glsl
diff --git a/shader_data/env_map/env_map.frag.glsl b/compiled/Shaders/env_map.frag.glsl
similarity index 100%
rename from shader_data/env_map/env_map.frag.glsl
rename to compiled/Shaders/env_map.frag.glsl
diff --git a/shader_data/env_map/env_map.vert.glsl b/compiled/Shaders/env_map.vert.glsl
similarity index 100%
rename from shader_data/env_map/env_map.vert.glsl
rename to compiled/Shaders/env_map.vert.glsl
diff --git a/shader_data/forward_pass/blender.frag.glsl b/compiled/Shaders/forward.frag.glsl
similarity index 100%
rename from shader_data/forward_pass/blender.frag.glsl
rename to compiled/Shaders/forward.frag.glsl
diff --git a/Sources/Shaders_/blender.vert.glsl b/compiled/Shaders/forward.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender.vert.glsl
rename to compiled/Shaders/forward.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest.frag.glsl b/compiled/Shaders/forward_AlphaTest.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest.frag.glsl
rename to compiled/Shaders/forward_AlphaTest.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest.vert.glsl b/compiled/Shaders/forward_AlphaTest.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest.vert.glsl
rename to compiled/Shaders/forward_AlphaTest.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Skinning_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_NormalMapping_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_NormalMapping_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Skinning_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Skinning_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Instancing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Instancing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Instancing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Instancing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Skinning_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Skinning_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_NormalMapping_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_NormalMapping_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_NormalMapping_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_NormalMapping_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning.frag.glsl b/compiled/Shaders/forward_AlphaTest_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning.vert.glsl b/compiled/Shaders/forward_AlphaTest_Skinning.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Skinning_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Skinning_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Skinning_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Skinning_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Skinning_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Texturing.frag.glsl b/compiled/Shaders/forward_AlphaTest_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Texturing.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Texturing.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Texturing.vert.glsl b/compiled/Shaders/forward_AlphaTest_Texturing.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Texturing.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Texturing.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_Texturing_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_Texturing_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_Texturing_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_Texturing_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_VCols.frag.glsl b/compiled/Shaders/forward_AlphaTest_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_VCols.frag.glsl
rename to compiled/Shaders/forward_AlphaTest_VCols.frag.glsl
diff --git a/Sources/Shaders_/blender_AlphaTest_VCols.vert.glsl b/compiled/Shaders/forward_AlphaTest_VCols.vert.glsl
similarity index 100%
rename from Sources/Shaders_/blender_AlphaTest_VCols.vert.glsl
rename to compiled/Shaders/forward_AlphaTest_VCols.vert.glsl
diff --git a/Sources/Shaders_/blender_Instancing.frag.glsl b/compiled/Shaders/forward_Instancing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing.frag.glsl
rename to compiled/Shaders/forward_Instancing.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing.vert.glsl b/compiled/Shaders/forward_Instancing.vert.glsl
new file mode 100644
index 00000000..a47f0f78
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing.vert.glsl
@@ -0,0 +1,136 @@
+#define _Instancing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping.vert.glsl
new file mode 100644
index 00000000..0cecb06b
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping.vert.glsl
@@ -0,0 +1,137 @@
+#define _Instancing
+#define _NormalMapping
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_Skinning.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_Skinning.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning.vert.glsl
new file mode 100644
index 00000000..64ed870a
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning.vert.glsl
@@ -0,0 +1,138 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
new file mode 100644
index 00000000..6a264419
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing.vert.glsl
@@ -0,0 +1,139 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..2683eb9e
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_Texturing_VCols.vert.glsl
@@ -0,0 +1,140 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.vert.glsl
new file mode 100644
index 00000000..8ca6183a
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_Skinning_VCols.vert.glsl
@@ -0,0 +1,139 @@
+#define _Instancing
+#define _NormalMapping
+#define _Skinning
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Texturing.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Texturing.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_Texturing.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Texturing.vert.glsl
new file mode 100644
index 00000000..635b5be2
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_Texturing.vert.glsl
@@ -0,0 +1,138 @@
+#define _Instancing
+#define _NormalMapping
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..fcba6552
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_Texturing_VCols.vert.glsl
@@ -0,0 +1,139 @@
+#define _Instancing
+#define _NormalMapping
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_NormalMapping_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_NormalMapping_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_NormalMapping_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_NormalMapping_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_NormalMapping_VCols.vert.glsl
new file mode 100644
index 00000000..a5b70818
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_NormalMapping_VCols.vert.glsl
@@ -0,0 +1,138 @@
+#define _Instancing
+#define _NormalMapping
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning.frag.glsl b/compiled/Shaders/forward_Instancing_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning.frag.glsl
rename to compiled/Shaders/forward_Instancing_Skinning.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_Skinning.vert.glsl b/compiled/Shaders/forward_Instancing_Skinning.vert.glsl
new file mode 100644
index 00000000..c5f018b2
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_Skinning.vert.glsl
@@ -0,0 +1,137 @@
+#define _Instancing
+#define _Skinning
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_Instancing_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_Instancing_Skinning_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_Instancing_Skinning_Texturing.vert.glsl
new file mode 100644
index 00000000..4fcbd8de
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_Skinning_Texturing.vert.glsl
@@ -0,0 +1,138 @@
+#define _Instancing
+#define _Skinning
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..3e7fd8fe
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_Skinning_Texturing_VCols.vert.glsl
@@ -0,0 +1,139 @@
+#define _Instancing
+#define _Skinning
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_Skinning_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_Skinning_VCols.vert.glsl
new file mode 100644
index 00000000..cf66a69c
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_Skinning_VCols.vert.glsl
@@ -0,0 +1,138 @@
+#define _Instancing
+#define _Skinning
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Texturing.frag.glsl b/compiled/Shaders/forward_Instancing_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Texturing.frag.glsl
rename to compiled/Shaders/forward_Instancing_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_Texturing.vert.glsl b/compiled/Shaders/forward_Instancing_Texturing.vert.glsl
new file mode 100644
index 00000000..e4d7fd5e
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_Texturing.vert.glsl
@@ -0,0 +1,137 @@
+#define _Instancing
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..feb42c66
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_Texturing_VCols.vert.glsl
@@ -0,0 +1,138 @@
+#define _Instancing
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Instancing_VCols.frag.glsl b/compiled/Shaders/forward_Instancing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Instancing_VCols.frag.glsl
rename to compiled/Shaders/forward_Instancing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Instancing_VCols.vert.glsl b/compiled/Shaders/forward_Instancing_VCols.vert.glsl
new file mode 100644
index 00000000..cce64e8f
--- /dev/null
+++ b/compiled/Shaders/forward_Instancing_VCols.vert.glsl
@@ -0,0 +1,137 @@
+#define _Instancing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping.frag.glsl b/compiled/Shaders/forward_NormalMapping.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping.frag.glsl
rename to compiled/Shaders/forward_NormalMapping.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping.vert.glsl b/compiled/Shaders/forward_NormalMapping.vert.glsl
new file mode 100644
index 00000000..3e717599
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping.vert.glsl
@@ -0,0 +1,136 @@
+#define _NormalMapping
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning.frag.glsl b/compiled/Shaders/forward_NormalMapping_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_Skinning.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_Skinning.vert.glsl b/compiled/Shaders/forward_NormalMapping_Skinning.vert.glsl
new file mode 100644
index 00000000..58623c28
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_Skinning.vert.glsl
@@ -0,0 +1,137 @@
+#define _NormalMapping
+#define _Skinning
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_NormalMapping_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_Skinning_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_NormalMapping_Skinning_Texturing.vert.glsl
new file mode 100644
index 00000000..0643ef89
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_Skinning_Texturing.vert.glsl
@@ -0,0 +1,138 @@
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..25833bd4
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_Skinning_Texturing_VCols.vert.glsl
@@ -0,0 +1,139 @@
+#define _NormalMapping
+#define _Skinning
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_NormalMapping_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_Skinning_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_NormalMapping_Skinning_VCols.vert.glsl
new file mode 100644
index 00000000..3a767b29
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_Skinning_VCols.vert.glsl
@@ -0,0 +1,138 @@
+#define _NormalMapping
+#define _Skinning
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Texturing.frag.glsl b/compiled/Shaders/forward_NormalMapping_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Texturing.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_Texturing.vert.glsl b/compiled/Shaders/forward_NormalMapping_Texturing.vert.glsl
new file mode 100644
index 00000000..a7c5e7eb
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_Texturing.vert.glsl
@@ -0,0 +1,137 @@
+#define _NormalMapping
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_NormalMapping_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_NormalMapping_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..14dda2b3
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_Texturing_VCols.vert.glsl
@@ -0,0 +1,138 @@
+#define _NormalMapping
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_NormalMapping_VCols.frag.glsl b/compiled/Shaders/forward_NormalMapping_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_NormalMapping_VCols.frag.glsl
rename to compiled/Shaders/forward_NormalMapping_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_NormalMapping_VCols.vert.glsl b/compiled/Shaders/forward_NormalMapping_VCols.vert.glsl
new file mode 100644
index 00000000..9b816492
--- /dev/null
+++ b/compiled/Shaders/forward_NormalMapping_VCols.vert.glsl
@@ -0,0 +1,137 @@
+#define _NormalMapping
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning.frag.glsl b/compiled/Shaders/forward_Skinning.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning.frag.glsl
rename to compiled/Shaders/forward_Skinning.frag.glsl
diff --git a/compiled/Shaders/forward_Skinning.vert.glsl b/compiled/Shaders/forward_Skinning.vert.glsl
new file mode 100644
index 00000000..8d0e36f7
--- /dev/null
+++ b/compiled/Shaders/forward_Skinning.vert.glsl
@@ -0,0 +1,136 @@
+#define _Skinning
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning_Texturing.frag.glsl b/compiled/Shaders/forward_Skinning_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning_Texturing.frag.glsl
rename to compiled/Shaders/forward_Skinning_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_Skinning_Texturing.vert.glsl b/compiled/Shaders/forward_Skinning_Texturing.vert.glsl
new file mode 100644
index 00000000..4fb5f024
--- /dev/null
+++ b/compiled/Shaders/forward_Skinning_Texturing.vert.glsl
@@ -0,0 +1,137 @@
+#define _Skinning
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_Skinning_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_Skinning_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Skinning_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_Skinning_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..a470fa9b
--- /dev/null
+++ b/compiled/Shaders/forward_Skinning_Texturing_VCols.vert.glsl
@@ -0,0 +1,138 @@
+#define _Skinning
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Skinning_VCols.frag.glsl b/compiled/Shaders/forward_Skinning_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Skinning_VCols.frag.glsl
rename to compiled/Shaders/forward_Skinning_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Skinning_VCols.vert.glsl b/compiled/Shaders/forward_Skinning_VCols.vert.glsl
new file mode 100644
index 00000000..d6bf08ba
--- /dev/null
+++ b/compiled/Shaders/forward_Skinning_VCols.vert.glsl
@@ -0,0 +1,137 @@
+#define _Skinning
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Texturing.frag.glsl b/compiled/Shaders/forward_Texturing.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Texturing.frag.glsl
rename to compiled/Shaders/forward_Texturing.frag.glsl
diff --git a/compiled/Shaders/forward_Texturing.vert.glsl b/compiled/Shaders/forward_Texturing.vert.glsl
new file mode 100644
index 00000000..6077f21b
--- /dev/null
+++ b/compiled/Shaders/forward_Texturing.vert.glsl
@@ -0,0 +1,136 @@
+#define _Texturing
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_Texturing_VCols.frag.glsl b/compiled/Shaders/forward_Texturing_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_Texturing_VCols.frag.glsl
rename to compiled/Shaders/forward_Texturing_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_Texturing_VCols.vert.glsl b/compiled/Shaders/forward_Texturing_VCols.vert.glsl
new file mode 100644
index 00000000..15ed538c
--- /dev/null
+++ b/compiled/Shaders/forward_Texturing_VCols.vert.glsl
@@ -0,0 +1,137 @@
+#define _Texturing
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/Sources/Shaders_/blender_VCols.frag.glsl b/compiled/Shaders/forward_VCols.frag.glsl
similarity index 100%
rename from Sources/Shaders_/blender_VCols.frag.glsl
rename to compiled/Shaders/forward_VCols.frag.glsl
diff --git a/compiled/Shaders/forward_VCols.vert.glsl b/compiled/Shaders/forward_VCols.vert.glsl
new file mode 100644
index 00000000..da4ed61d
--- /dev/null
+++ b/compiled/Shaders/forward_VCols.vert.glsl
@@ -0,0 +1,136 @@
+#define _VCols
+#ifdef GL_ES
+precision highp float;
+#endif
+
+#ifdef _NormalMapping
+#define _Texturing
+#endif
+
+attribute vec3 pos;
+attribute vec3 nor;
+#ifdef _Texturing
+attribute vec2 tex;
+#endif
+#ifdef _VCols
+attribute vec4 col;
+#endif
+#ifdef _NormalMapping
+attribute vec3 tan;
+#endif
+#ifdef _Skinning
+attribute vec4 bone;
+attribute vec4 weight;
+#endif
+#ifdef _Instancing
+attribute vec3 off;
+#endif
+
+uniform mat4 M;
+uniform mat4 NM;
+uniform mat4 V;
+uniform mat4 P;
+uniform mat4 lightMVP;
+uniform vec4 diffuseColor;
+uniform vec3 light;
+uniform vec3 eye;
+#ifdef _Skinning
+uniform float skinBones[50 * 12];
+#endif
+
+varying vec3 position;
+#ifdef _Texturing
+varying vec2 texCoord;
+#endif
+varying vec3 normal;
+varying vec4 lPos;
+varying vec4 matColor;
+varying vec3 lightDir;
+varying vec3 eyeDir;
+
+#ifdef _NormalMapping
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+#endif
+
+#ifdef _Skinning
+mat4 getBoneMat(const int boneIndex) {
+	vec4 v0 = vec4(skinBones[boneIndex * 12 + 0],
+				   skinBones[boneIndex * 12 + 1],
+				   skinBones[boneIndex * 12 + 2],
+				   skinBones[boneIndex * 12 + 3]);
+	vec4 v1 = vec4(skinBones[boneIndex * 12 + 4],
+				   skinBones[boneIndex * 12 + 5],
+				   skinBones[boneIndex * 12 + 6],
+				   skinBones[boneIndex * 12 + 7]);
+	vec4 v2 = vec4(skinBones[boneIndex * 12 + 8],
+				   skinBones[boneIndex * 12 + 9],
+				   skinBones[boneIndex * 12 + 10],
+				   skinBones[boneIndex * 12 + 11]);
+	return mat4(v0.x, v0.y, v0.z, v0.w, 
+				v1.x, v1.y, v1.z, v1.w,
+				v2.x, v2.y, v2.z, v2.w,
+				0, 0, 0, 1);
+}
+
+mat4 getSkinningMat() {
+	return weight.x * getBoneMat(int(bone.x)) +
+		   weight.y * getBoneMat(int(bone.y)) +
+		   weight.z * getBoneMat(int(bone.z)) +
+		   weight.w * getBoneMat(int(bone.w));
+}
+
+mat3 getSkinningMatVec(const mat4 skinningMat) {
+	return mat3(skinningMat[0].xyz, skinningMat[1].xyz, skinningMat[2].xyz);
+}
+#endif
+
+void kore() {
+
+#ifdef _Instancing
+	vec4 sPos = (vec4(pos + off, 1.0));
+#else
+	vec4 sPos = (vec4(pos, 1.0));
+#endif
+#ifdef _Skinning
+	mat4 skinningMat = getSkinningMat();
+	mat3 skinningMatVec = getSkinningMatVec(skinningMat);
+	sPos = sPos * skinningMat;
+#endif
+	vec4 mPos = M * sPos;
+	lPos = lightMVP * sPos;
+
+	gl_Position = P * V * mPos;
+	position = mPos.xyz / mPos.w;
+
+#ifdef _Texturing
+	texCoord = tex;
+#endif
+
+#ifdef _Skinning
+	normal = normalize(mat3(NM) * (nor * skinningMatVec));
+#else
+	normal = normalize(mat3(NM) * nor);
+#endif
+
+	matColor = diffuseColor;
+
+#ifdef _VCols
+	matColor *= col;
+#endif
+
+#ifdef _NormalMapping
+	vec3 vtan = (tan);
+	vec3 vbitan = cross(normal, vtan) * 1.0;//tangent.w;
+   
+	mat3 TBN = transpose(mat3(vtan, vbitan, normal));
+	lightDir = normalize(TBN * lightDir); 
+	eyeDir = normalize(TBN * eyeDir); 
+#else
+	lightDir = normalize(light - position);
+	eyeDir = normalize(eye - position);
+#endif
+}
diff --git a/haxelib.json b/haxelib.json
index ee82e457..d5f4c25b 100644
--- a/haxelib.json
+++ b/haxelib.json
@@ -4,8 +4,8 @@
   "license": "LGPL",
   "tags": ["kha", "3d"],
   "description": "Blender game engine",
-  "version": "15.11.0",
-  "classPath": "",
+  "version": "16.1.0",
+  "classPath": "Sources",
   "releasenote": "Initial release.",
   "contributors": ["Lubos"],
   "dependencies": {
diff --git a/khafile.js b/khafile.js
new file mode 100644
index 00000000..e75d0a60
--- /dev/null
+++ b/khafile.js
@@ -0,0 +1,7 @@
+var project = new Project('cycles_library');
+
+//project.addSources('Sources');
+//project.addShaders('Sources/Shaders/**');
+//project.addAssets('Assets/**');
+
+return project;
diff --git a/Sources/Shaders/attrib_pass.frag.glsl b/raw/attrib_pass/attrib_pass.frag.glsl
similarity index 77%
rename from Sources/Shaders/attrib_pass.frag.glsl
rename to raw/attrib_pass/attrib_pass.frag.glsl
index b973a105..ae3f3b7a 100644
--- a/Sources/Shaders/attrib_pass.frag.glsl
+++ b/raw/attrib_pass/attrib_pass.frag.glsl
@@ -1,4 +1,4 @@
-//#extension GL_EXT_draw_buffers : require
+#extension GL_EXT_draw_buffers : require
 
 #ifdef GL_ES
 precision mediump float;
@@ -34,8 +34,7 @@ void kore() {
 
 	gl_FragData[0] = vec4(position.xyz, 0);
 	gl_FragData[1] = vec4(normal.xyz, 0);
-	gl_FragData[2] = vec4(normal.xyz, 0);
-	//#ifdef _Texturing
-	//gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
-	//#endif
+	#ifdef _Texturing
+	gl_FragData[2] = vec4(texture2D(stex, texCoord).rgb, 0);
+	#endif
 }
diff --git a/shader_data/attrib_pass/attrib_pass.shader.json b/raw/attrib_pass/attrib_pass.shader.json
similarity index 100%
rename from shader_data/attrib_pass/attrib_pass.shader.json
rename to raw/attrib_pass/attrib_pass.shader.json
diff --git a/shader_data/attrib_pass/attrib_pass.vert.glsl b/raw/attrib_pass/attrib_pass.vert.glsl
similarity index 100%
rename from shader_data/attrib_pass/attrib_pass.vert.glsl
rename to raw/attrib_pass/attrib_pass.vert.glsl
diff --git a/raw/compile.py b/raw/compile.py
new file mode 100644
index 00000000..013e4b7e
--- /dev/null
+++ b/raw/compile.py
@@ -0,0 +1 @@
+#!/usr/bin/python
diff --git a/shader_data/deferred_pass/deferred_pass.frag.glsl b/raw/deferred_pass/deferred_pass.frag.glsl
similarity index 100%
rename from shader_data/deferred_pass/deferred_pass.frag.glsl
rename to raw/deferred_pass/deferred_pass.frag.glsl
diff --git a/shader_data/deferred_pass/deferred_pass.shader.json b/raw/deferred_pass/deferred_pass.shader.json
similarity index 100%
rename from shader_data/deferred_pass/deferred_pass.shader.json
rename to raw/deferred_pass/deferred_pass.shader.json
diff --git a/shader_data/deferred_pass/deferred_pass.vert.glsl b/raw/deferred_pass/deferred_pass.vert.glsl
similarity index 100%
rename from shader_data/deferred_pass/deferred_pass.vert.glsl
rename to raw/deferred_pass/deferred_pass.vert.glsl
diff --git a/raw/env_map/env_map.frag.glsl b/raw/env_map/env_map.frag.glsl
new file mode 100644
index 00000000..e1e01f33
--- /dev/null
+++ b/raw/env_map/env_map.frag.glsl
@@ -0,0 +1,22 @@
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#define PI 3.1415926
+#define TwoPI (2.0 * PI)
+
+uniform sampler2D envmap;
+
+varying vec3 wcNormal;
+
+vec2 envMapEquirect(vec3 wcNormal, float flipEnvMap) {
+  float phi = acos(wcNormal.z);
+  float theta = atan(flipEnvMap * wcNormal.x, wcNormal.y) + PI;
+  return vec2(theta / TwoPI, phi / PI);
+}
+
+void kore() {
+
+  vec3 N = normalize(wcNormal);
+    gl_FragColor = texture2D(envmap, envMapEquirect(N, -1.0));
+}
diff --git a/shader_data/env_map/env_map.shader.json b/raw/env_map/env_map.shader.json
similarity index 100%
rename from shader_data/env_map/env_map.shader.json
rename to raw/env_map/env_map.shader.json
diff --git a/raw/env_map/env_map.vert.glsl b/raw/env_map/env_map.vert.glsl
new file mode 100644
index 00000000..787ff2fb
--- /dev/null
+++ b/raw/env_map/env_map.vert.glsl
@@ -0,0 +1,71 @@
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform mat4 V;
+uniform mat4 P;
+
+attribute vec2 pos;
+
+varying vec3 wcNormal;
+
+mat4 inverse(mat4 m) {
+  float
+      a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],
+      a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],
+      a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],
+      a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],
+
+      b00 = a00 * a11 - a01 * a10,
+      b01 = a00 * a12 - a02 * a10,
+      b02 = a00 * a13 - a03 * a10,
+      b03 = a01 * a12 - a02 * a11,
+      b04 = a01 * a13 - a03 * a11,
+      b05 = a02 * a13 - a03 * a12,
+      b06 = a20 * a31 - a21 * a30,
+      b07 = a20 * a32 - a22 * a30,
+      b08 = a20 * a33 - a23 * a30,
+      b09 = a21 * a32 - a22 * a31,
+      b10 = a21 * a33 - a23 * a31,
+      b11 = a22 * a33 - a23 * a32,
+
+      det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+
+  return mat4(
+      a11 * b11 - a12 * b10 + a13 * b09,
+      a02 * b10 - a01 * b11 - a03 * b09,
+      a31 * b05 - a32 * b04 + a33 * b03,
+      a22 * b04 - a21 * b05 - a23 * b03,
+      a12 * b08 - a10 * b11 - a13 * b07,
+      a00 * b11 - a02 * b08 + a03 * b07,
+      a32 * b02 - a30 * b05 - a33 * b01,
+      a20 * b05 - a22 * b02 + a23 * b01,
+      a10 * b10 - a11 * b08 + a13 * b06,
+      a01 * b08 - a00 * b10 - a03 * b06,
+      a30 * b04 - a31 * b02 + a33 * b00,
+      a21 * b02 - a20 * b04 - a23 * b00,
+      a11 * b07 - a10 * b09 - a12 * b06,
+      a00 * b09 - a01 * b07 + a02 * b06,
+      a31 * b01 - a30 * b03 - a32 * b00,
+      a20 * b03 - a21 * b01 + a22 * b00) / det;
+}
+
+mat3 transpose(mat3 m) {
+  return mat3(m[0][0], m[1][0], m[2][0],
+              m[0][1], m[1][1], m[2][1],
+              m[0][2], m[1][2], m[2][2]);
+}
+
+void kore() {
+
+	mat4 invP = inverse(P);
+	mat3 invMV = transpose(mat3(V));
+
+	vec4 p = vec4(pos.xy, 0.0, 1.0);
+
+	vec3 unprojected = (invP * p).xyz;
+
+	wcNormal = invMV * unprojected;
+
+	gl_Position = vec4(pos.xy, 0.0, 1.0);
+}
diff --git a/Sources/Shaders_/blender.frag.glsl b/raw/forward/forward.frag.glsl
similarity index 96%
rename from Sources/Shaders_/blender.frag.glsl
rename to raw/forward/forward.frag.glsl
index 410cc5bc..2d294f88 100644
--- a/Sources/Shaders_/blender.frag.glsl
+++ b/raw/forward/forward.frag.glsl
@@ -98,10 +98,10 @@ float LightingFuncGGX_OPT3(vec3 N, vec3 V, vec3 L, float roughness, float F0) {
 void kore() {
 
 	float visibility = 1.0;
-	//if (receiveShadow && lPos.w > 0.0) {
-	//	visibility = shadowSimple(lPos);
-	//	visibility = (visibility * 0.8) + 0.2;
-	//}
+	if (receiveShadow && lPos.w > 0.0) {
+		visibility = shadowSimple(lPos);
+		visibility = (visibility * 0.8) + 0.2;
+	}
 
 	vec4 outColor;
 	vec3 t = pow(matColor.rgb, vec3(2.2));
diff --git a/shader_data/forward_pass/blender.shader.json b/raw/forward/forward.shader.json
similarity index 89%
rename from shader_data/forward_pass/blender.shader.json
rename to raw/forward/forward.shader.json
index 8cf68bfd..12abce94 100755
--- a/shader_data/forward_pass/blender.shader.json
+++ b/raw/forward/forward.shader.json
@@ -1,7 +1,7 @@
 {
 	"contexts": [
 		{
-			"id": "blender",
+			"id": "forward",
 			"params": [
 				{
 					"id": "depth_write",
@@ -59,8 +59,8 @@
 					"ifdef": "_Skinning"
 				}
 			],
-			"vertex_shader": "blender.vert.glsl",
-			"fragment_shader": "blender.frag.glsl"
+			"vertex_shader": "forward.vert.glsl",
+			"fragment_shader": "forward.frag.glsl"
 		}
 	]
 }
diff --git a/shader_data/forward_pass/blender.shader_withshadow.json b/raw/forward/forward.shader_withshadow.json
similarity index 93%
rename from shader_data/forward_pass/blender.shader_withshadow.json
rename to raw/forward/forward.shader_withshadow.json
index 0da59a4c..251fb27b 100755
--- a/shader_data/forward_pass/blender.shader_withshadow.json
+++ b/raw/forward/forward.shader_withshadow.json
@@ -1,7 +1,7 @@
 {
 	"contexts": [
 		{
-			"id": "blender",
+			"id": "forward",
 			"params": [
 				{
 					"id": "depth_write",
@@ -59,8 +59,8 @@
 					"ifdef": "_Skinning"
 				}
 			],
-			"vertex_shader": "blender.vert.glsl",
-			"fragment_shader": "blender.frag.glsl"
+			"vertex_shader": "forward.vert.glsl",
+			"fragment_shader": "forward.frag.glsl"
 		},
 		{
 			"id": "shadow_map",
diff --git a/shader_data/forward_pass/blender.vert.glsl b/raw/forward/forward.vert.glsl
similarity index 100%
rename from shader_data/forward_pass/blender.vert.glsl
rename to raw/forward/forward.vert.glsl
diff --git a/shader_data/forward_pass/shadow_map.frag.glsl b/raw/forward/shadow_map.frag.glsl
similarity index 100%
rename from shader_data/forward_pass/shadow_map.frag.glsl
rename to raw/forward/shadow_map.frag.glsl
diff --git a/shader_data/forward_pass/shadow_map.vert.glsl b/raw/forward/shadow_map.vert.glsl
similarity index 100%
rename from shader_data/forward_pass/shadow_map.vert.glsl
rename to raw/forward/shadow_map.vert.glsl
diff --git a/shader_data/makeres.py b/raw/makeres.py
similarity index 100%
rename from shader_data/makeres.py
rename to raw/makeres.py
diff --git a/shader_data/makevariants.py b/raw/makevariants.py
similarity index 100%
rename from shader_data/makevariants.py
rename to raw/makevariants.py