maxmustermann/armory
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Simplify shader passes

Browse source
This commit is contained in:
Lubos Lenco 2017-12-13 14:21:42 +01:00
parent 1e3eb5ccfe
commit a1532d5bec
32 changed files with 232 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Shaders/bloom_pass/bloom_pass.frag.glsl
View file

@ -4,7 +4,7 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "compiled.glsl"
uniform sampler2D tex;
uniform vec2 texStep;

4
Shaders/blur_adaptive_pass/blur_adaptive_pass.frag.glsl
View file

@ -5,8 +5,8 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D tex;
uniform sampler2D gbuffer0; // Roughness

4
Shaders/blur_edge_pass/blur_edge_pass.frag.glsl
View file

@ -5,8 +5,8 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D tex;
uniform sampler2D gbuffer0;

2
Shaders/blur_gaus_pass/blur_gaus_pass.frag.glsl
View file

@ -5,7 +5,7 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "compiled.glsl"
uniform sampler2D tex;
uniform vec2 dir;

4
Shaders/blur_shadow_pass/blur_shadow_pass.frag.glsl
View file

@ -1,7 +1,7 @@
#version 450
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D tex;
uniform sampler2D gbuffer0;

8
Shaders/compositor_pass/compositor_pass.frag.glsl
View file

@ -4,11 +4,11 @@
precision highp float;
#endif
#include "../compiled.glsl"
#include "../std/tonemap.glsl"
#include "../std/math.glsl"
#include "compiled.glsl"
#include "std/tonemap.glsl"
#include "std/math.glsl"
#ifdef _CDOF
#include "../std/dof.glsl"
#include "std/dof.glsl"
#endif
uniform sampler2D tex;

4
Shaders/debug_normals/debug_normals.frag.glsl
View file

@ -4,8 +4,8 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D tex;

2
Shaders/debug_velocity/debug_velocity.frag.glsl
View file

@ -4,7 +4,7 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "compiled.glsl"
uniform sampler2D tex;

16
Shaders/deferred_indirect/deferred_indirect.frag.glsl
View file

@ -4,21 +4,21 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "../std/math.glsl"
#include "../std/brdf.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
#include "std/math.glsl"
#include "std/brdf.glsl"
#ifdef _Irr
#include "../std/shirr.glsl"
#include "std/shirr.glsl"
#endif
#ifdef _VoxelGI
#include "../std/conetrace.glsl"
#include "std/conetrace.glsl"
#endif
#ifdef _VoxelAO
#include "../std/conetrace.glsl"
#include "std/conetrace.glsl"
#endif
#ifdef _DFAO
#include "../std/sdf.glsl"
#include "std/sdf.glsl"
#endif
uniform sampler2D gbufferD;

22
Shaders/deferred_light/deferred_light.frag.glsl
View file

@ -4,31 +4,31 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/brdf.glsl"
#include "../std/math.glsl"
#include "compiled.glsl"
#include "std/brdf.glsl"
#include "std/math.glsl"
#ifdef _LampIES
#include "../std/ies.glsl"
#include "std/ies.glsl"
#endif
#ifdef _VoxelGIDirect
#include "../std/conetrace.glsl"
#include "std/conetrace.glsl"
#endif
#ifdef _LTC
#include "../std/ltc.glsl"
#include "std/ltc.glsl"
#endif
#ifndef _NoShadows
#include "../std/shadows.glsl"
#include "std/shadows.glsl"
#endif
#ifdef _DFRS
#include "../std/sdf.glsl"
#include "std/sdf.glsl"
#endif
#ifdef _SSS
#include "../std/sss.glsl"
#include "std/sss.glsl"
#endif
#ifdef _SSRS
#include "../std/ssrs.glsl"
#include "std/ssrs.glsl"
#endif
#include "../std/gbuffer.glsl"
#include "std/gbuffer.glsl"
#ifdef _VoxelGIDirect
//!uniform sampler3D voxels;

16
Shaders/deferred_light_quad/deferred_light_quad.frag.glsl
View file

@ -4,22 +4,22 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/brdf.glsl"
#include "../std/math.glsl"
#include "compiled.glsl"
#include "std/brdf.glsl"
#include "std/math.glsl"
#ifdef _VoxelGIDirect
#include "../std/conetrace.glsl"
#include "std/conetrace.glsl"
#endif
#ifndef _NoShadows
#include "../std/shadows.glsl"
#include "std/shadows.glsl"
#endif
#ifdef _SSS
#include "../std/sss.glsl"
#include "std/sss.glsl"
#endif
#ifdef _SSRS
#include "../std/ssrs.glsl"
#include "std/ssrs.glsl"
#endif
#include "../std/gbuffer.glsl"
#include "std/gbuffer.glsl"
#ifdef _VoxelGIDirect
//!uniform sampler3D voxels;

4
Shaders/dilate_pass/dilate_pass.frag.glsl
View file

@ -1,7 +1,7 @@
#version 450
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D shadowMap;

4
Shaders/motion_blur_pass/motion_blur_pass.frag.glsl
View file

@ -6,8 +6,8 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D gbufferD;
uniform sampler2D gbuffer0;

2
Shaders/motion_blur_veloc_pass/motion_blur_veloc_pass.frag.glsl
View file

@ -6,7 +6,7 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "compiled.glsl"
uniform sampler2D gbuffer0;
uniform sampler2D sveloc;

4
Shaders/ssao_pass/ssao_pass.frag.glsl
View file

@ -17,8 +17,8 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D gbufferD;
uniform sampler2D gbuffer0;

4
Shaders/ssgi_blur_pass/ssgi_blur_pass.frag.glsl
View file

@ -4,8 +4,8 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D tex;
uniform sampler2D gbuffer0;

6
Shaders/ssgi_pass/ssgi_pass.frag.glsl
View file

@ -4,9 +4,9 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/math.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/math.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D gbufferD;
uniform sampler2D gbuffer0; // Normal

6
Shaders/ssr_pass/ssr_pass.frag.glsl
View file

@ -4,9 +4,9 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/math.glsl"
#include "../std/gbuffer.glsl"
#include "compiled.glsl"
#include "std/math.glsl"
#include "std/gbuffer.glsl"
uniform sampler2D tex;
uniform sampler2D gbufferD;

2
Shaders/sss_pass/sss_pass.frag.glsl
View file

@ -39,7 +39,7 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "compiled.glsl"
uniform sampler2D gbufferD;
uniform sampler2D gbuffer1;

2
Shaders/std/ssrs.glsl
View file

@ -1,4 +1,4 @@
#include "../std/gbuffer.glsl"
#include "gbuffer.glsl"
uniform mat4 VP;

2
Shaders/supersample_resolve/supersample_resolve.frag.glsl
View file

@ -4,7 +4,7 @@
precision mediump float;
#endif
#include "../std/filters.glsl"
#include "std/filters.glsl"
uniform sampler2D tex;
uniform vec2 screenSizeInv;

6
Shaders/visibility_pass/visibility_pass.frag.glsl
View file

@ -1,8 +1,8 @@
#version 450
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "../std/math.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
#include "std/math.glsl"
uniform sampler2D shadowMap;
uniform sampler2D dilate;

6
Shaders/volumetric_light/volumetric_light.frag.glsl
View file

@ -5,9 +5,9 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "../std/shadows.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
#include "std/shadows.glsl"
uniform sampler2D gbufferD;
#ifndef _NoShadows

6
Shaders/volumetric_light_quad/volumetric_light_quad.frag.glsl
View file

@ -5,9 +5,9 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
#include "../std/shadows.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
#include "std/shadows.glsl"
uniform sampler2D gbufferD;
#ifndef _NoShadows

8
Shaders/water_pass/water_pass.frag.glsl
View file

@ -8,11 +8,11 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "../std/gbuffer.glsl"
// #include "../std/math.glsl"
#include "compiled.glsl"
#include "std/gbuffer.glsl"
// #include "std/math.glsl"
// #ifndef _NoShadows
// #include "../std/shadows.glsl"
// #include "std/shadows.glsl"
// #endif
uniform sampler2D gbufferD;

4
Shaders/world/world.frag.glsl
View file

@ -4,9 +4,9 @@
precision mediump float;
#endif
#include "../compiled.glsl"
#include "compiled.glsl"
#ifdef _EnvTex
#include "../std/math.glsl"
#include "std/math.glsl"
#endif
#ifdef _EnvCol

184
Sources/armory/renderpath/RenderPathCreator.hx
View file

@ -30,7 +30,7 @@ class RenderPathCreator {
#if (rp_background == "World")
{
path.loadShader("world/world/world");
path.loadShader("shader_datas/world/world");
}
#end
@ -51,11 +51,11 @@ class RenderPathCreator {
#if rp_compositornodes
{
path.loadShader("compositor_pass/compositor_pass/compositor_pass");
path.loadShader("shader_datas/compositor_pass/compositor_pass");
}
#else
{
path.loadShader("copy_pass/copy_pass/copy_pass");
path.loadShader("shader_datas/copy_pass/copy_pass");
}
#end
}
@ -150,7 +150,7 @@ class RenderPathCreator {
path.drawMeshes("mesh");
#if (rp_background == "World")
{
path.drawSkydome("world/world/world");
path.drawSkydome("shader_datas/world/world");
}
#end
@ -178,11 +178,11 @@ class RenderPathCreator {
#if rp_compositornodes
{
path.drawShader("compositor_pass/compositor_pass/compositor_pass");
path.drawShader("shader_datas/compositor_pass/compositor_pass");
}
#else
{
path.drawShader("copy_pass/copy_pass/copy_pass");
path.drawShader("shader_datas/copy_pass/copy_pass");
}
#end
}
@ -205,7 +205,7 @@ class RenderPathCreator {
static function init() {
#if (rp_background == "World")
{
path.loadShader("world/world/world");
path.loadShader("shader_datas/world/world");
}
#end
@ -304,21 +304,21 @@ class RenderPathCreator {
}
#end
path.loadShader("deferred_indirect/deferred_indirect/deferred_indirect");
path.loadShader("deferred_light/deferred_light/deferred_light");
path.loadShader("deferred_light_quad/deferred_light_quad/deferred_light_quad");
path.loadShader("shader_datas/deferred_indirect/deferred_indirect");
path.loadShader("shader_datas/deferred_light/deferred_light");
path.loadShader("shader_datas/deferred_light_quad/deferred_light_quad");
#if ((rp_ssgi == "RTGI") || (rp_ssgi == "RTAO"))
{
path.loadShader("ssgi_pass/ssgi_pass/ssgi_pass");
path.loadShader("ssgi_blur_pass/ssgi_blur_pass/ssgi_blur_pass_x");
path.loadShader("ssgi_blur_pass/ssgi_blur_pass/ssgi_blur_pass_y");
path.loadShader("shader_datas/ssgi_pass/ssgi_pass");
path.loadShader("shader_datas/ssgi_blur_pass/ssgi_blur_pass_x");
path.loadShader("shader_datas/ssgi_blur_pass/ssgi_blur_pass_y");
}
#elseif (rp_ssgi == "SSAO")
{
path.loadShader("ssao_pass/ssao_pass/ssao_pass");
path.loadShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_x");
path.loadShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_y");
path.loadShader("shader_datas/ssao_pass/ssao_pass");
path.loadShader("shader_datas/blur_edge_pass/blur_edge_pass_x");
path.loadShader("shader_datas/blur_edge_pass/blur_edge_pass_y");
}
#end
@ -360,25 +360,25 @@ class RenderPathCreator {
#if rp_compositornodes
{
path.loadShader("compositor_pass/compositor_pass/compositor_pass");
path.loadShader("shader_datas/compositor_pass/compositor_pass");
}
#end
#if ((!rp_compositornodes) || (rp_antialiasing == "TAA") || (rp_rendercapture) || (rp_motionblur == "Camera") || (rp_motionblur == "Object"))
{
path.loadShader("copy_pass/copy_pass/copy_pass");
path.loadShader("shader_datas/copy_pass/copy_pass");
}
#end
#if ((rp_antialiasing == "SMAA") || (rp_antialiasing == "TAA"))
{
path.loadShader("smaa_edge_detect/smaa_edge_detect/smaa_edge_detect");
path.loadShader("smaa_blend_weight/smaa_blend_weight/smaa_blend_weight");
path.loadShader("smaa_neighborhood_blend/smaa_neighborhood_blend/smaa_neighborhood_blend");
path.loadShader("shader_datas/smaa_edge_detect/smaa_edge_detect");
path.loadShader("shader_datas/smaa_blend_weight/smaa_blend_weight");
path.loadShader("shader_datas/smaa_neighborhood_blend/smaa_neighborhood_blend");
#if (rp_antialiasing == "TAA")
{
path.loadShader("taa_pass/taa_pass/taa_pass");
path.loadShader("shader_datas/taa_pass/taa_pass");
}
#end
}
@ -386,22 +386,22 @@ class RenderPathCreator {
#if (rp_supersampling == 4)
{
path.loadShader("supersample_resolve/supersample_resolve/supersample_resolve");
path.loadShader("shader_datas/supersample_resolve/supersample_resolve");
}
#end
#if rp_volumetriclight
{
path.loadShader("volumetric_light_quad/volumetric_light_quad/volumetric_light_quad");
path.loadShader("volumetric_light/volumetric_light/volumetric_light");
path.loadShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_x");
path.loadShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_y_blend_add");
path.loadShader("shader_datas/volumetric_light_quad/volumetric_light_quad");
path.loadShader("shader_datas/volumetric_light/volumetric_light");
path.loadShader("shader_datas/blur_edge_pass/blur_edge_pass_x");
path.loadShader("shader_datas/blur_edge_pass/blur_edge_pass_y_blend_add");
}
#end
#if rp_ocean
{
path.loadShader("water_pass/water_pass/water_pass");
path.loadShader("shader_datas/water_pass/water_pass");
}
#end
@ -427,25 +427,25 @@ class RenderPathCreator {
}
{
path.loadShader("bloom_pass/bloom_pass/bloom_pass");
path.loadShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_x");
path.loadShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_y");
path.loadShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_y_blend");
path.loadShader("shader_datas/bloom_pass/bloom_pass");
path.loadShader("shader_datas/blur_gaus_pass/blur_gaus_pass_x");
path.loadShader("shader_datas/blur_gaus_pass/blur_gaus_pass_y");
path.loadShader("shader_datas/blur_gaus_pass/blur_gaus_pass_y_blend");
}
#end
#if rp_sss
{
path.loadShader("sss_pass/sss_pass/sss_pass_x");
path.loadShader("sss_pass/sss_pass/sss_pass_y");
path.loadShader("shader_datas/sss_pass/sss_pass_x");
path.loadShader("shader_datas/sss_pass/sss_pass_y");
}
#end
#if rp_ssr
{
path.loadShader("ssr_pass/ssr_pass/ssr_pass");
path.loadShader("blur_adaptive_pass/blur_adaptive_pass/blur_adaptive_pass_x");
path.loadShader("blur_adaptive_pass/blur_adaptive_pass/blur_adaptive_pass_y3_blend");
path.loadShader("shader_datas/ssr_pass/ssr_pass");
path.loadShader("shader_datas/blur_adaptive_pass/blur_adaptive_pass_x");
path.loadShader("shader_datas/blur_adaptive_pass/blur_adaptive_pass_y3_blend");
#if rp_ssr_half
{
@ -474,11 +474,11 @@ class RenderPathCreator {
{
#if (rp_motionblur == "Camera")
{
path.loadShader("motion_blur_pass/motion_blur_pass/motion_blur_pass");
path.loadShader("shader_datas/motion_blur_pass/motion_blur_pass");
}
#else
{
path.loadShader("motion_blur_veloc_pass/motion_blur_veloc_pass/motion_blur_veloc_pass");
path.loadShader("shader_datas/motion_blur_veloc_pass/motion_blur_veloc_pass");
}
#end
}
@ -486,11 +486,11 @@ class RenderPathCreator {
#if rp_soft_shadows
{
path.loadShader("dilate_pass/dilate_pass/dilate_pass_x");
path.loadShader("dilate_pass/dilate_pass/dilate_pass_y");
path.loadShader("visibility_pass/visibility_pass/visibility_pass");
path.loadShader("blur_shadow_pass/blur_shadow_pass/blur_shadow_pass_x");
path.loadShader("blur_shadow_pass/blur_shadow_pass/blur_shadow_pass_y");
path.loadShader("shader_datas/dilate_pass/dilate_pass_x");
path.loadShader("shader_datas/dilate_pass/dilate_pass_y");
path.loadShader("shader_datas/visibility_pass/visibility_pass");
path.loadShader("shader_datas/blur_shadow_pass/blur_shadow_pass_x");
path.loadShader("shader_datas/blur_shadow_pass/blur_shadow_pass_y");
{
var t = new RenderTargetRaw();
t.name = "visa";
@ -534,11 +534,11 @@ class RenderPathCreator {
path.setTarget("visa"); // Merge using min blend
path.bindTarget("shadowMap", "shadowMap");
path.drawShader("dilate_pass/dilate_pass/dilate_pass_x");
path.drawShader("shader_datas/dilate_pass/dilate_pass_x");
path.setTarget("visb");
path.bindTarget("visa", "shadowMap");
path.drawShader("dilate_pass/dilate_pass/dilate_pass_y");
path.drawShader("shader_datas/dilate_pass/dilate_pass_y");
path.setTarget("visa", ["dist"]);
//if (i == 0) path.clearTarget(0x00000000);
@ -546,19 +546,19 @@ class RenderPathCreator {
path.bindTarget("shadowMap", "shadowMap");
//path.bindTarget("_main", "gbufferD");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("visibility_pass/visibility_pass/visibility_pass");
path.drawShader("shader_datas/visibility_pass/visibility_pass");
path.setTarget("visb");
path.bindTarget("visa", "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.bindTarget("dist", "dist");
path.drawShader("blur_shadow_pass/blur_shadow_pass/blur_shadow_pass_x");
path.drawShader("shader_datas/blur_shadow_pass/blur_shadow_pass_x");
path.setTarget("visa");
path.bindTarget("visb", "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.bindTarget("dist", "dist");
path.drawShader("blur_shadow_pass/blur_shadow_pass/blur_shadow_pass_y");
path.drawShader("shader_datas/blur_shadow_pass/blur_shadow_pass_y");
#end
}
@ -610,34 +610,34 @@ class RenderPathCreator {
#if ((rp_ssgi == "RTGI"))
path.bindTarget("gbuffer1", "gbuffer1");
#end
path.drawShader("ssgi_pass/ssgi_pass/ssgi_pass");
path.drawShader("shader_datas/ssgi_pass/ssgi_pass");
path.setTarget("bufb");
path.bindTarget("gbuffer0", "gbuffer0");
path.bindTarget("bufa", "tex");
path.drawShader("ssgi_blur_pass/ssgi_blur_pass/ssgi_blur_pass_x");
path.drawShader("shader_datas/ssgi_blur_pass/ssgi_blur_pass_x");
path.setTarget("bufa");
path.bindTarget("gbuffer0", "gbuffer0");
path.bindTarget("bufb", "tex");
path.drawShader("ssgi_blur_pass/ssgi_blur_pass/ssgi_blur_pass_y");
path.drawShader("shader_datas/ssgi_blur_pass/ssgi_blur_pass_y");
}
#elseif (rp_ssgi == "SSAO")
{
path.setTarget("bufa");
path.bindTarget("_main", "gbufferD");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("ssao_pass/ssao_pass/ssao_pass");
path.drawShader("shader_datas/ssao_pass/ssao_pass");
path.setTarget("bufb");
path.bindTarget("bufa", "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_x");
path.drawShader("shader_datas/blur_edge_pass/blur_edge_pass_x");
path.setTarget("bufa");
path.bindTarget("bufb", "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_y");
path.drawShader("shader_datas/blur_edge_pass/blur_edge_pass_y");
}
#end
@ -684,7 +684,7 @@ class RenderPathCreator {
path.bindTarget("voxels", "voxels");
}
#end
path.drawShader("deferred_indirect/deferred_indirect/deferred_indirect");
path.drawShader("shader_datas/deferred_indirect/deferred_indirect");
// Direct
var lamps = iron.Scene.active.lamps;
@ -725,10 +725,10 @@ class RenderPathCreator {
#end
if (path.lampIsSun()) {
path.drawShader("deferred_light_quad/deferred_light_quad/deferred_light_quad");
path.drawShader("shader_datas/deferred_light_quad/deferred_light_quad");
}
else {
path.drawLampVolume("deferred_light/deferred_light/deferred_light");
path.drawLampVolume("shader_datas/deferred_light/deferred_light");
}
#if rp_volumetriclight
@ -737,20 +737,20 @@ class RenderPathCreator {
path.bindTarget("_main", "gbufferD");
path.bindTarget("shadowMap", "shadowMap");
if (path.lampIsSun()) {
path.drawShader("volumetric_light_quad/volumetric_light_quad/volumetric_light_quad");
path.drawShader("shader_datas/volumetric_light_quad/volumetric_light_quad");
}
else {
path.drawLampVolume("volumetric_light/volumetric_light/volumetric_light");
path.drawLampVolume("shader_datas/volumetric_light/volumetric_light");
}
path.setTarget("gbuffer1");
path.bindTarget("buf", "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_x");
path.drawShader("shader_datas/blur_edge_pass/blur_edge_pass_x");
path.setTarget("tex");
path.bindTarget("gbuffer1", "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("blur_edge_pass/blur_edge_pass/blur_edge_pass_y_blend_add");
path.drawShader("shader_datas/blur_edge_pass/blur_edge_pass_y_blend_add");
}
#end
}
@ -758,7 +758,7 @@ class RenderPathCreator {
#if (rp_background == "World")
{
path.drawSkydome("world/world/world");
path.drawSkydome("shader_datas/world/world");
}
#end
@ -766,7 +766,7 @@ class RenderPathCreator {
{
path.setTarget("tex");
path.bindTarget("_main", "gbufferD");
path.drawShader("water_pass/water_pass/water_pass");
path.drawShader("shader_datas/water_pass/water_pass");
}
#end
@ -786,39 +786,39 @@ class RenderPathCreator {
{
path.setTarget("bloomtex");
path.bindTarget("tex", "tex");
path.drawShader("bloom_pass/bloom_pass/bloom_pass");
path.drawShader("shader_datas/bloom_pass/bloom_pass");
path.setTarget("bloomtex2");
path.bindTarget("bloomtex", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_x");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_x");
path.setTarget("bloomtex");
path.bindTarget("bloomtex2", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_y");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_y");
path.setTarget("bloomtex2");
path.bindTarget("bloomtex", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_x");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_x");
path.setTarget("bloomtex");
path.bindTarget("bloomtex2", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_y");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_y");
path.setTarget("bloomtex2");
path.bindTarget("bloomtex", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_x");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_x");
path.setTarget("bloomtex");
path.bindTarget("bloomtex2", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_y");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_y");
path.setTarget("bloomtex2");
path.bindTarget("bloomtex", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_x");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_x");
path.setTarget("tex");
path.bindTarget("bloomtex2", "tex");
path.drawShader("blur_gaus_pass/blur_gaus_pass/blur_gaus_pass_y_blend");
path.drawShader("shader_datas/blur_gaus_pass/blur_gaus_pass_y_blend");
}
#end
@ -828,14 +828,14 @@ class RenderPathCreator {
path.bindTarget("tex", "tex");
path.bindTarget("_main", "gbufferD");
path.bindTarget("gbuffer1", "gbuffer1");
path.drawShader("sss_pass/sss_pass/sss_pass_x");
path.drawShader("shader_datas/sss_pass/sss_pass_x");
path.setTarget("tex");
// TODO: can not bind tex
path.bindTarget("tex", "tex");
path.bindTarget("_main", "gbufferD");
path.bindTarget("gbuffer1", "gbuffer1");
path.drawShader("sss_pass/sss_pass/sss_pass_y");
path.drawShader("shader_datas/sss_pass/sss_pass_y");
}
#end
@ -852,17 +852,17 @@ class RenderPathCreator {
path.bindTarget("tex", "tex");
path.bindTarget("_main", "gbufferD");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("ssr_pass/ssr_pass/ssr_pass");
path.drawShader("shader_datas/ssr_pass/ssr_pass");
path.setTarget(targetb);
path.bindTarget(targeta, "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("blur_adaptive_pass/blur_adaptive_pass/blur_adaptive_pass_x");
path.drawShader("shader_datas/blur_adaptive_pass/blur_adaptive_pass_x");
path.setTarget("tex");
path.bindTarget(targetb, "tex");
path.bindTarget("gbuffer0", "gbuffer0");
path.drawShader("blur_adaptive_pass/blur_adaptive_pass/blur_adaptive_pass_y3_blend");
path.drawShader("shader_datas/blur_adaptive_pass/blur_adaptive_pass_y3_blend");
}
#end
@ -874,17 +874,17 @@ class RenderPathCreator {
#if (rp_motionblur == "Camera")
{
path.bindTarget("_main", "gbufferD");
path.drawShader("motion_blur_pass/motion_blur_pass/motion_blur_pass");
path.drawShader("shader_datas/motion_blur_pass/motion_blur_pass");
}
#else
{
path.bindTarget("gbuffer2", "sveloc");
path.drawShader("motion_blur_veloc_pass/motion_blur_veloc_pass/motion_blur_veloc_pass");
path.drawShader("shader_datas/motion_blur_veloc_pass/motion_blur_veloc_pass");
}
#end
path.setTarget("tex");
path.bindTarget("buf", "tex");
path.drawShader("copy_pass/copy_pass/copy_pass");
path.drawShader("shader_datas/copy_pass/copy_pass");
}
#end
@ -920,11 +920,11 @@ class RenderPathCreator {
#if rp_compositornodes
{
path.drawShader("compositor_pass/compositor_pass/compositor_pass");
path.drawShader("shader_datas/compositor_pass/compositor_pass");
}
#else
{
path.drawShader("copy_pass/copy_pass/copy_pass");
path.drawShader("shader_datas/copy_pass/copy_pass");
}
#end
// End compositor
@ -941,12 +941,12 @@ class RenderPathCreator {
path.setTarget("bufa");
path.clearTarget(0x00000000);
path.bindTarget("buf", "colorTex");
path.drawShader("smaa_edge_detect/smaa_edge_detect/smaa_edge_detect");
path.drawShader("shader_datas/smaa_edge_detect/smaa_edge_detect");
path.setTarget("bufb");
path.clearTarget(0x00000000);
path.bindTarget("bufa", "edgesTex");
path.drawShader("smaa_blend_weight/smaa_blend_weight/smaa_blend_weight");
path.drawShader("shader_datas/smaa_blend_weight/smaa_blend_weight");
#if (rp_antialiasing == "TAA")
path.setTarget("bufa");
@ -955,7 +955,7 @@ class RenderPathCreator {
#end
path.bindTarget("buf", "colorTex");
path.bindTarget("bufb", "blendTex");
path.drawShader("smaa_neighborhood_blend/smaa_neighborhood_blend/smaa_neighborhood_blend");
path.drawShader("shader_datas/smaa_neighborhood_blend/smaa_neighborhood_blend");
#if (rp_antialiasing == "TAA")
{
@ -963,11 +963,11 @@ class RenderPathCreator {
path.bindTarget("bufa", "tex");
path.bindTarget("taa", "tex2");
path.bindTarget("gbuffer2", "sveloc");
path.drawShader("taa_pass/taa_pass/taa_pass");
path.drawShader("shader_datas/taa_pass/taa_pass");
path.setTarget("taa");
path.bindTarget("bufa", "tex");
path.drawShader("copy_pass/copy_pass/copy_pass");
path.drawShader("shader_datas/copy_pass/copy_pass");
}
#end
}
@ -983,13 +983,13 @@ class RenderPathCreator {
#end
path.setTarget(final);
path.bindTarget(framebuffer, "tex");
path.drawShader("supersample_resolve/supersample_resolve/supersample_resolve");
path.drawShader("shader_datas/supersample_resolve/supersample_resolve");
}
#elseif (rp_rendercapture)
{
path.setTarget("capture");
path.bindTarget(framebuffer, "tex");
path.drawShader("copy_pass/copy_pass/copy_pass");
path.drawShader("shader_datas/copy_pass/copy_pass");
}
#end
}
@ -1039,7 +1039,7 @@ class RenderPathCreator {
t.depth_buffer = "main";
path.createRenderTarget(t);
path.loadShader("translucent_resolve/translucent_resolve/translucent_resolve");
path.loadShader("shader_datas/translucent_resolve/translucent_resolve");
}
static function drawTranslucency(target:String) {
@ -1065,7 +1065,7 @@ class RenderPathCreator {
#end
path.bindTarget("accum", "gbuffer0");
path.bindTarget("revealage", "gbuffer1");
path.drawShader("translucent_resolve/translucent_resolve/translucent_resolve");
path.drawShader("shader_datas/translucent_resolve/translucent_resolve");
}
#end

12
blender/arm/assets.py
View file

@ -12,6 +12,7 @@ embedded_data = []
shaders = []
shaders_last = []
shader_datas = []
shader_passes = []
def reset():
global assets
@ -28,6 +29,7 @@ def reset():
shaders_last = shaders
shaders = []
shader_datas = []
shader_passes = []
def add(file):
global assets
@ -59,9 +61,13 @@ def add_shader_data(file):
if file not in shader_datas:
shader_datas.append(file)
def add_shader2(dir_name, data_name):
add_shader_data(arm.utils.build_dir() + '/compiled/Shaders/' + dir_name + '/' + data_name + '.arm')
full_name = arm.utils.build_dir() + '/compiled/Shaders/' + dir_name + '/' + data_name
def add_shader_pass(data_name):
global shader_passes
# Shader data for passes are written into single shader_datas.arm file
add_shader_data(arm.utils.build_dir() + '/compiled/Shaders/shader_datas.arm')
if data_name not in shader_passes:
shader_passes.append(data_name)
full_name = arm.utils.build_dir() + '/compiled/Shaders/' + data_name
add_shader(full_name + '.vert.glsl')
add_shader(full_name + '.frag.glsl')

24
blender/arm/lib/make_datas.py
View file

@ -97,12 +97,6 @@ def write_data(res, defs, json_data, base_name):
tese = f.read().splitlines()
parse_shader(sres, c, con, defs, tese, False)
def find_def(defs, s):
for d in defs:
if d == s:
return True
return False
def parse_shader(sres, c, con, defs, lines, parse_attributes):
skip_till_endif = 0
skip_else = False
@ -120,7 +114,7 @@ def parse_shader(sres, c, con, defs, lines, parse_attributes):
# Preprocessor
if line.startswith('#ifdef') or line.startswith('#ifndef'):
s = line.split(' ')[1]
found = find_def(defs, s)
found = s in defs
if line.startswith('#ifndef'):
found = not found
if found == False:
@ -253,19 +247,5 @@ def parse_shader(sres, c, con, defs, lines, parse_attributes):
break
con['constants'].append(const)
def save_data(path, base_name, res):
r = {}
r['shader_datas'] = [res['shader_datas'][-1]]
arm.utils.write_arm(path + '/' + base_name + '.arm', r)
def make(base_name, json_data, fp, defs):
path = fp + '/compiled/Shaders/' + base_name
if not os.path.exists(path):
os.makedirs(path)
res = {}
res['shader_datas'] = []
def make(res, base_name, json_data, fp, defs):
write_data(res, defs, json_data, base_name)
save_data(path, base_name, res)

5
blender/arm/lib/make_variants.py
View file

@ -13,10 +13,7 @@ def write_variant(path, name, defs, lines):
def make(base_name, json_data, fp, defs):
shaders = []
path = fp + '/compiled/Shaders/' + base_name
if not os.path.exists(path):
os.makedirs(path)
path = fp + '/compiled/Shaders'
# Go through every context shaders and gather ifdefs
for c in json_data['contexts']:

36
blender/arm/make.py
View file

@ -30,7 +30,7 @@ exporter = ArmoryExporter()
scripts_mtime = 0 # Monitor source changes
code_parsed = False
def compile_shader_pass(raw_shaders_path, shader_name, defs):
def compile_shader_pass(res, raw_shaders_path, shader_name, defs):
os.chdir(raw_shaders_path + '/' + shader_name)
# Open json file
@ -41,7 +41,7 @@ def compile_shader_pass(raw_shaders_path, shader_name, defs):
json_data = json.loads(json_file)
fp = arm.utils.get_fp_build()
arm.lib.make_datas.make(base_name, json_data, fp, defs)
arm.lib.make_datas.make(res, base_name, json_data, fp, defs)
arm.lib.make_variants.make(base_name, json_data, fp, defs)
def remove_readonly(func, path, excinfo):
@ -56,7 +56,7 @@ def export_data(fp, sdk_path, is_play=False, is_publish=False, in_viewport=False
print('OS: ' + arm.utils.get_os() + ', Target: ' + state.target + ', GAPI: ' + arm.utils.get_gapi())
# Clean compiled variants if cache is disabled
build_dir = arm.utils.build_dir()
build_dir = arm.utils.get_fp_build()
if wrd.arm_cache_shaders == False:
if os.path.isdir(build_dir + '/debug/html5-resources'):
shutil.rmtree(build_dir + '/debug/html5-resources', onerror=remove_readonly)
@ -145,28 +145,32 @@ def export_data(fp, sdk_path, is_play=False, is_publish=False, in_viewport=False
print('Shader flags: ' + str(defs))
# Write referenced shader passes
for ref in assets.shader_datas:
# Data does not exist yet
if not os.path.isfile(fp + '/' + ref) or state.last_world_defs != wrd.world_defs:
shader_name = ref.split('/')[3] # Extract from 'build/compiled/...'
# Shader pass exists
if not os.path.exists(raw_shaders_path + '/' + shader_name):
if not os.path.isfile(build_dir + '/compiled/Shaders/shader_datas.arm') or state.last_world_defs != wrd.world_defs:
path = build_dir + '/compiled/Shaders'
if not os.path.exists(path):
os.makedirs(path)
res = {}
res['shader_datas'] = []
for ref in assets.shader_passes:
# Ensure shader pass source exists
if not os.path.exists(raw_shaders_path + '/' + ref):
continue
if shader_name.startswith('compositor_pass'):
if ref.startswith('compositor_pass'):
cdefs = arm.utils.def_strings_to_array(wrd.compo_defs)
compile_shader_pass(raw_shaders_path, shader_name, defs + cdefs)
# elif shader_name.startswith('grease_pencil'):
# compile_shader_pass(raw_shaders_path, shader_name, [])
compile_shader_pass(res, raw_shaders_path, ref, defs + cdefs)
# elif ref.startswith('grease_pencil'):
# compile_shader_pass(res, raw_shaders_path, ref, [])
else:
compile_shader_pass(raw_shaders_path, shader_name, defs)
compile_shader_pass(res, raw_shaders_path, ref, defs)
arm.utils.write_arm(path + '/shader_datas.arm', res)
state.last_world_defs = wrd.world_defs
# Reset path
os.chdir(fp)
# Copy std shaders
if not os.path.isdir(arm.utils.build_dir() + '/compiled/Shaders/std'):
shutil.copytree(raw_shaders_path + 'std', arm.utils.build_dir() + '/compiled/Shaders/std')
if not os.path.isdir(build_dir + '/compiled/Shaders/std'):
shutil.copytree(raw_shaders_path + 'std', build_dir + '/compiled/Shaders/std')
# Write compiled.glsl
write_data.write_compiledglsl()

66
blender/arm/make_renderpath.py
View file

@ -28,7 +28,7 @@ def build():
assets.add_khafile_def('rp_background={0}'.format(rpdat.rp_background))
if rpdat.rp_background == 'World':
assets.add_shader2('world', 'world')
assets.add_shader_pass('world')
if '_EnvClouds' in wrd.world_defs:
assets.add(assets_path + 'noise256.png')
assets.add_embedded_data('noise256.png')
@ -69,24 +69,24 @@ def build():
if wrd.arm_lut:
wrd.compo_defs += '_CLUT'
assets.add_embedded_data('luttexture.jpg')
assets.add_shader2('compositor_pass', 'compositor_pass')
assets.add_shader_pass('compositor_pass')
else:
assets.add_shader2('copy_pass', 'copy_pass')
assets.add_shader_pass('copy_pass')
assets.add_khafile_def('rp_antialiasing={0}'.format(rpdat.rp_antialiasing))
if rpdat.rp_antialiasing == 'SMAA' or rpdat.rp_antialiasing == 'TAA':
assets.add_shader2('smaa_edge_detect', 'smaa_edge_detect')
assets.add_shader2('smaa_blend_weight', 'smaa_blend_weight')
assets.add_shader2('smaa_neighborhood_blend', 'smaa_neighborhood_blend')
assets.add_shader_pass('smaa_edge_detect')
assets.add_shader_pass('smaa_blend_weight')
assets.add_shader_pass('smaa_neighborhood_blend')
assets.add(assets_path + 'smaa_area.png')
assets.add(assets_path + 'smaa_search.png')
assets.add_embedded_data('smaa_area.png')
assets.add_embedded_data('smaa_search.png')
wrd.world_defs += '_SMAA'
if rpdat.rp_antialiasing == 'TAA':
assets.add_shader2('taa_pass', 'taa_pass')
assets.add_shader2('copy_pass', 'copy_pass')
assets.add_shader_pass('taa_pass')
assets.add_shader_pass('copy_pass')
if rpdat.rp_antialiasing == 'TAA' or rpdat.rp_motionblur == 'Object':
assets.add_khafile_def('arm_veloc')
@ -96,14 +96,14 @@ def build():
assets.add_khafile_def('rp_supersampling={0}'.format(rpdat.rp_supersampling))
if rpdat.rp_supersampling == '4':
assets.add_shader2('supersample_resolve', 'supersample_resolve')
assets.add_shader_pass('supersample_resolve')
if rpdat.rp_overlays:
assets.add_khafile_def('rp_overlays')
if rpdat.rp_translucency:
assets.add_khafile_def('rp_translucency')
assets.add_shader2('translucent_resolve', 'translucent_resolve')
assets.add_shader_pass('translucent_resolve')
if rpdat.rp_stereo:
assets.add_khafile_def('rp_stereo')
@ -138,64 +138,64 @@ def build():
if rpdat.rp_ssgi != 'Off':
wrd.world_defs += '_SSAO'
if rpdat.rp_ssgi == 'SSAO':
assets.add_shader2('ssao_pass', 'ssao_pass')
assets.add_shader2('blur_edge_pass', 'blur_edge_pass')
assets.add_shader_pass('ssao_pass')
assets.add_shader_pass('blur_edge_pass')
assets.add(assets_path + 'noise8.png')
assets.add_embedded_data('noise8.png')
else:
assets.add_shader2('ssgi_pass', 'ssgi_pass')
assets.add_shader2('ssgi_blur_pass', 'ssgi_blur_pass')
assets.add_shader_pass('ssgi_pass')
assets.add_shader_pass('ssgi_blur_pass')
if rpdat.rp_renderer == 'Deferred':
assets.add_shader2('deferred_indirect', 'deferred_indirect')
assets.add_shader2('deferred_light', 'deferred_light')
assets.add_shader2('deferred_light_quad', 'deferred_light_quad')
assets.add_shader_pass('deferred_indirect')
assets.add_shader_pass('deferred_light')
assets.add_shader_pass('deferred_light_quad')
if rpdat.rp_rendercapture:
assets.add_khafile_def('rp_rendercapture')
assets.add_khafile_def('rp_rendercapture_format={0}'.format(wrd.rp_rendercapture_format))
assets.add_shader2('copy_pass', 'copy_pass')
assets.add_shader_pass('copy_pass')
if rpdat.rp_volumetriclight:
assets.add_khafile_def('rp_volumetriclight')
assets.add_shader2('volumetric_light_quad', 'volumetric_light_quad')
assets.add_shader2('volumetric_light', 'volumetric_light')
assets.add_shader2('blur_edge_pass', 'blur_edge_pass')
assets.add_shader_pass('volumetric_light_quad')
assets.add_shader_pass('volumetric_light')
assets.add_shader_pass('blur_edge_pass')
if rpdat.rp_decals:
assets.add_khafile_def('rp_decals')
if rpdat.rp_ocean:
assets.add_khafile_def('rp_ocean')
assets.add_shader2('water_pass', 'water_pass')
assets.add_shader_pass('water_pass', 'water_pass')
if rpdat.rp_blending_state != 'Off':
assets.add_khafile_def('rp_blending')
if rpdat.rp_bloom:
assets.add_khafile_def('rp_bloom')
assets.add_shader2('bloom_pass', 'bloom_pass')
assets.add_shader2('blur_gaus_pass', 'blur_gaus_pass')
assets.add_shader_pass('bloom_pass')
assets.add_shader_pass('blur_gaus_pass')
if rpdat.rp_sss:
assets.add_khafile_def('rp_sss')
wrd.world_defs += '_SSS'
assets.add_shader2('sss_pass', 'sss_pass')
assets.add_shader_pass('sss_pass')
if rpdat.rp_ssr:
assets.add_khafile_def('rp_ssr')
assets.add_shader2('ssr_pass', 'ssr_pass')
assets.add_shader2('blur_adaptive_pass', 'blur_adaptive_pass')
assets.add_shader_pass('ssr_pass')
assets.add_shader_pass('blur_adaptive_pass')
if rpdat.arm_ssr_half_res:
assets.add_khafile_def('rp_ssr_half')
if rpdat.rp_motionblur != 'Off':
assets.add_khafile_def('rp_motionblur={0}'.format(rpdat.rp_motionblur))
assets.add_shader2('copy_pass', 'copy_pass')
assets.add_shader_pass('copy_pass')
if rpdat.rp_motionblur == 'Camera':
assets.add_shader2('motion_blur_pass', 'motion_blur_pass')
assets.add_shader_pass('motion_blur_pass')
else:
assets.add_shader2('motion_blur_veloc_pass', 'motion_blur_veloc_pass')
assets.add_shader_pass('motion_blur_veloc_pass')
if rpdat.rp_compositornodes and rpdat.rp_autoexposure:
assets.add_khafile_def('rp_autoexposure')
@ -205,9 +205,9 @@ def build():
if rpdat.arm_soft_shadows == 'On':
if rpdat.rp_shadowmap_cascades == '1':
assets.add_shader2('dilate_pass', 'dilate_pass')
assets.add_shader2('visibility_pass', 'visibility_pass')
assets.add_shader2('blur_shadow_pass', 'blur_shadow_pass')
assets.add_shader_pass('dilate_pass')
assets.add_shader_pass('visibility_pass')
assets.add_shader_pass('blur_shadow_pass')
assets.add_khafile_def('rp_soft_shadows')
wrd.world_defs += '_SoftShadows'
if rpdat.arm_soft_shadows_penumbra != 1: