summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/gles1/rasterizer_gles1.cpp63
-rw-r--r--drivers/gles1/rasterizer_gles1.h28
-rw-r--r--drivers/gles2/rasterizer_gles2.cpp198
-rw-r--r--drivers/gles2/rasterizer_gles2.h25
-rw-r--r--drivers/gles2/shader_compiler_gles2.cpp47
-rw-r--r--drivers/gles2/shader_compiler_gles2.h9
-rw-r--r--drivers/gles2/shader_gles2.cpp24
-rw-r--r--drivers/gles2/shader_gles2.h4
-rw-r--r--drivers/gles2/shaders/copy.glsl75
-rw-r--r--drivers/gles2/shaders/material.glsl60
10 files changed, 355 insertions, 178 deletions
diff --git a/drivers/gles1/rasterizer_gles1.cpp b/drivers/gles1/rasterizer_gles1.cpp
index 9a6c928711..ad0c8e3c7f 100644
--- a/drivers/gles1/rasterizer_gles1.cpp
+++ b/drivers/gles1/rasterizer_gles1.cpp
@@ -891,6 +891,7 @@ RID RasterizerGLES1::shader_create(VS::ShaderMode p_mode) {
shader->has_alpha=false;
shader->fragment_line=0;
shader->vertex_line=0;
+ shader->light_line=0;
RID rid = shader_owner.make_rid(shader);
shader_set_mode(rid,p_mode);
// _shader_make_dirty(shader);
@@ -921,19 +922,22 @@ VS::ShaderMode RasterizerGLES1::shader_get_mode(RID p_shader) const {
-void RasterizerGLES1::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,int p_vertex_ofs,int p_fragment_ofs) {
+void RasterizerGLES1::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs,int p_fragment_ofs,int p_light_ofs) {
+
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
#ifdef DEBUG_ENABLED
- if (shader->vertex_code==p_vertex && shader->fragment_code==p_fragment)
+ if (shader->vertex_code==p_vertex && shader->fragment_code==p_fragment && shader->light_code==p_light)
return;
#endif
shader->fragment_code=p_fragment;
shader->vertex_code=p_vertex;
+ shader->light_code=p_light;
shader->fragment_line=p_fragment_ofs;
shader->vertex_line=p_vertex_ofs;
+ shader->light_line=p_light_ofs;
}
@@ -953,6 +957,13 @@ String RasterizerGLES1::shader_get_fragment_code(RID p_shader) const {
}
+String RasterizerGLES1::shader_get_light_code(RID p_shader) const {
+
+ Shader *shader=shader_owner.get(p_shader);
+ ERR_FAIL_COND_V(!shader,String());
+ return shader->light_code;
+
+}
void RasterizerGLES1::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
@@ -1099,38 +1110,20 @@ bool RasterizerGLES1::material_get_flag(RID p_material,VS::MaterialFlag p_flag)
}
-void RasterizerGLES1::material_set_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled) {
+void RasterizerGLES1::material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode) {
Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- ERR_FAIL_INDEX(p_hint,VS::MATERIAL_HINT_MAX);
- material->hints[p_hint]=p_enabled;
-
+ material->depth_draw_mode=p_mode;
}
-bool RasterizerGLES1::material_get_hint(RID p_material,VS::MaterialHint p_hint) const {
+VS::MaterialDepthDrawMode RasterizerGLES1::material_get_depth_draw_mode(RID p_material) const{
- Material *material = material_owner.get(p_material);
- ERR_FAIL_COND_V(!material,false);
- ERR_FAIL_INDEX_V(p_hint,VS::MATERIAL_HINT_MAX,false);
- return material->hints[p_hint];
-
-}
-
-void RasterizerGLES1::material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model) {
Material *material = material_owner.get(p_material);
- ERR_FAIL_COND(!material);
- material->shade_model=p_model;
-
-};
-
-VS::MaterialShadeModel RasterizerGLES1::material_get_shade_model(RID p_material) const {
-
- Material *material = material_owner.get(p_material);
- ERR_FAIL_COND_V(!material,VS::MATERIAL_SHADE_MODEL_LAMBERT);
- return material->shade_model;
-};
+ ERR_FAIL_COND_V(!material,VS::MATERIAL_DEPTH_DRAW_ALWAYS);
+ return material->depth_draw_mode;
+}
void RasterizerGLES1::material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode) {
@@ -1223,20 +1216,6 @@ RID RasterizerGLES1::fixed_material_get_texture(RID p_material,VS::FixedMaterial
return m->textures[p_parameter];
}
-void RasterizerGLES1::fixed_material_set_detail_blend_mode(RID p_material,VS::MaterialBlendMode p_mode) {
-
- Material *m=material_owner.get( p_material );
- ERR_FAIL_COND(!m);
-
- m->detail_blend_mode = p_mode;
-}
-VS::MaterialBlendMode RasterizerGLES1::fixed_material_get_detail_blend_mode(RID p_material) const {
-
- Material *m=material_owner.get( p_material );
- ERR_FAIL_COND_V(!m, VS::MATERIAL_BLEND_MODE_MIX);
-
- return m->detail_blend_mode;
-}
void RasterizerGLES1::fixed_material_set_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode) {
@@ -3395,7 +3374,7 @@ void RasterizerGLES1::_setup_material(const Geometry *p_geometry,const Material
}
- bool current_depth_write=!p_material->hints[VS::MATERIAL_HINT_NO_DEPTH_DRAW];
+ bool current_depth_write=p_material->depth_draw_mode!=VS::MATERIAL_DEPTH_DRAW_ALWAYS; //broken
bool current_depth_test=!p_material->flags[VS::MATERIAL_FLAG_ONTOP];
@@ -3460,7 +3439,7 @@ void RasterizerGLES1::_setup_light(LightInstance* p_instance, int p_idx) {
glLightfv(glid , GL_DIFFUSE, diffuse_sdark);
- Color amb_color = ld->colors[VS::LIGHT_COLOR_AMBIENT];
+ Color amb_color = Color(0,0,0);
GLfloat amb_stexsize[4]={
amb_color.r,
amb_color.g,
diff --git a/drivers/gles1/rasterizer_gles1.h b/drivers/gles1/rasterizer_gles1.h
index 10b2d7694d..e7937f43c3 100644
--- a/drivers/gles1/rasterizer_gles1.h
+++ b/drivers/gles1/rasterizer_gles1.h
@@ -132,10 +132,12 @@ class RasterizerGLES1 : public Rasterizer {
String vertex_code;
String fragment_code;
+ String light_code;
VS::ShaderMode mode;
Map<StringName,Variant> params;
int fragment_line;
int vertex_line;
+ int light_line;
bool valid;
bool has_alpha;
bool use_world_transform;
@@ -149,15 +151,14 @@ class RasterizerGLES1 : public Rasterizer {
bool fixed_flags[VS::FIXED_MATERIAL_FLAG_MAX];
bool flags[VS::MATERIAL_FLAG_MAX];
- bool hints[VS::MATERIAL_HINT_MAX];
Variant parameters[VisualServer::FIXED_MATERIAL_PARAM_MAX];
RID textures[VisualServer::FIXED_MATERIAL_PARAM_MAX];
- VS::MaterialShadeModel shade_model;
+ VS::MaterialDepthDrawMode depth_draw_mode;
+
Transform uv_transform;
VS::FixedMaterialTexCoordMode texcoord_mode[VisualServer::FIXED_MATERIAL_PARAM_MAX];
- VS::MaterialBlendMode detail_blend_mode;
VS::MaterialBlendMode blend_mode;
float line_width;
@@ -179,8 +180,6 @@ class RasterizerGLES1 : public Rasterizer {
for(int i=0;i<VS::MATERIAL_FLAG_MAX;i++)
flags[i]=false;
flags[VS::MATERIAL_FLAG_VISIBLE]=true;
- for(int i=0;i<VS::MATERIAL_HINT_MAX;i++)
- hints[i]=false;
parameters[VS::FIXED_MATERIAL_PARAM_DIFFUSE] = Color(0.8, 0.8, 0.8);
parameters[VS::FIXED_MATERIAL_PARAM_SPECULAR_EXP] = 12;
@@ -188,7 +187,7 @@ class RasterizerGLES1 : public Rasterizer {
for (int i=0; i<VisualServer::FIXED_MATERIAL_PARAM_MAX; i++) {
texcoord_mode[i] = VS::FIXED_MATERIAL_TEXCOORD_UV;
};
- detail_blend_mode = VS::MATERIAL_BLEND_MODE_MIX;
+ depth_draw_mode=VS::MATERIAL_DEPTH_DRAW_OPAQUE_ONLY;
line_width=1;
has_alpha=false;
blend_mode=VS::MATERIAL_BLEND_MODE_MIX;
@@ -433,7 +432,7 @@ class RasterizerGLES1 : public Rasterizer {
vars[VS::LIGHT_PARAM_ENERGY]=1.0;
vars[VS::LIGHT_PARAM_RADIUS]=1.0;
vars[VS::LIGHT_PARAM_SHADOW_Z_OFFSET]=0.05;
- colors[VS::LIGHT_COLOR_AMBIENT]=Color(0,0,0);
+
colors[VS::LIGHT_COLOR_DIFFUSE]=Color(1,1,1);
colors[VS::LIGHT_COLOR_SPECULAR]=Color(1,1,1);
shadow_enabled=false;
@@ -468,7 +467,7 @@ class RasterizerGLES1 : public Rasterizer {
fx_param[VS::ENV_FX_PARAM_DOF_BLUR_BEGIN]=100.0;
fx_param[VS::ENV_FX_PARAM_DOF_BLUR_RANGE]=10.0;
fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]=0.4;
- fx_param[VS::ENV_FX_PARAM_HDR_SCALAR]=1.0;
+ fx_param[VS::ENV_FX_PARAM_HDR_WHITE]=1.0;
fx_param[VS::ENV_FX_PARAM_HDR_GLOW_TRESHOLD]=0.95;
fx_param[VS::ENV_FX_PARAM_HDR_GLOW_SCALE]=0.2;
fx_param[VS::ENV_FX_PARAM_HDR_MIN_LUMINANCE]=0.4;
@@ -862,9 +861,10 @@ public:
virtual void shader_set_mode(RID p_shader,VS::ShaderMode p_mode);
virtual VS::ShaderMode shader_get_mode(RID p_shader) const;
- virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,int p_vertex_ofs=0,int p_fragment_ofs=0);
+ virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs=0,int p_fragment_ofs=0,int p_light_ofs=0);
virtual String shader_get_fragment_code(RID p_shader) const;
virtual String shader_get_vertex_code(RID p_shader) const;
+ virtual String shader_get_light_code(RID p_shader) const;
virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
@@ -881,11 +881,8 @@ public:
virtual void material_set_flag(RID p_material, VS::MaterialFlag p_flag,bool p_enabled);
virtual bool material_get_flag(RID p_material,VS::MaterialFlag p_flag) const;
- virtual void material_set_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled);
- virtual bool material_get_hint(RID p_material,VS::MaterialHint p_hint) const;
-
- virtual void material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model);
- virtual VS::MaterialShadeModel material_get_shade_model(RID p_material) const;
+ virtual void material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode);
+ virtual VS::MaterialDepthDrawMode material_get_depth_draw_mode(RID p_material) const;
virtual void material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode);
virtual VS::MaterialBlendMode material_get_blend_mode(RID p_material) const;
@@ -906,9 +903,6 @@ public:
virtual void fixed_material_set_texture(RID p_material,VS::FixedMaterialParam p_parameter, RID p_texture);
virtual RID fixed_material_get_texture(RID p_material,VS::FixedMaterialParam p_parameter) const;
- virtual void fixed_material_set_detail_blend_mode(RID p_material,VS::MaterialBlendMode p_mode);
- virtual VS::MaterialBlendMode fixed_material_get_detail_blend_mode(RID p_material) const;
-
virtual void fixed_material_set_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter, VS::FixedMaterialTexCoordMode p_mode);
virtual VS::FixedMaterialTexCoordMode fixed_material_get_texcoord_mode(RID p_material,VS::FixedMaterialParam p_parameter) const;
diff --git a/drivers/gles2/rasterizer_gles2.cpp b/drivers/gles2/rasterizer_gles2.cpp
index d660d02f6c..681a0e7265 100644
--- a/drivers/gles2/rasterizer_gles2.cpp
+++ b/drivers/gles2/rasterizer_gles2.cpp
@@ -1132,20 +1132,22 @@ VS::ShaderMode RasterizerGLES2::shader_get_mode(RID p_shader) const {
}
+void RasterizerGLES2::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs,int p_fragment_ofs,int p_light_ofs) {
-void RasterizerGLES2::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,int p_vertex_ofs,int p_fragment_ofs) {
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
#ifdef DEBUG_ENABLED
- if (shader->vertex_code==p_vertex && shader->fragment_code==p_fragment)
+ if (shader->vertex_code==p_vertex && shader->fragment_code==p_fragment && shader->light_code==p_light)
return;
#endif
shader->fragment_code=p_fragment;
shader->vertex_code=p_vertex;
+ shader->light_code=p_light;
shader->fragment_line=p_fragment_ofs;
shader->vertex_line=p_vertex_ofs;
+ shader->light_line=p_light_ofs;
_shader_make_dirty(shader);
}
@@ -1166,6 +1168,14 @@ String RasterizerGLES2::shader_get_fragment_code(RID p_shader) const {
}
+String RasterizerGLES2::shader_get_light_code(RID p_shader) const {
+
+ Shader *shader=shader_owner.get(p_shader);
+ ERR_FAIL_COND_V(!shader,String());
+ return shader->light_code;
+
+}
+
void RasterizerGLES2::_shader_make_dirty(Shader* p_shader) {
if (p_shader->dirty_list.in_list())
@@ -1334,38 +1344,22 @@ bool RasterizerGLES2::material_get_flag(RID p_material,VS::MaterialFlag p_flag)
}
-void RasterizerGLES2::material_set_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled) {
+void RasterizerGLES2::material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode) {
Material *material = material_owner.get(p_material);
ERR_FAIL_COND(!material);
- ERR_FAIL_INDEX(p_hint,VS::MATERIAL_HINT_MAX);
- material->hints[p_hint]=p_enabled;
+ material->depth_draw_mode=p_mode;
}
-bool RasterizerGLES2::material_get_hint(RID p_material,VS::MaterialHint p_hint) const {
+VS::MaterialDepthDrawMode RasterizerGLES2::material_get_depth_draw_mode(RID p_material) const {
Material *material = material_owner.get(p_material);
- ERR_FAIL_COND_V(!material,false);
- ERR_FAIL_INDEX_V(p_hint,VS::MATERIAL_HINT_MAX,false);
- return material->hints[p_hint];
+ ERR_FAIL_COND_V(!material,VS::MATERIAL_DEPTH_DRAW_ALWAYS);
+ return material->depth_draw_mode;
}
-void RasterizerGLES2::material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model) {
-
- Material *material = material_owner.get(p_material);
- ERR_FAIL_COND(!material);
- material->shade_model=p_model;
-
-};
-
-VS::MaterialShadeModel RasterizerGLES2::material_get_shade_model(RID p_material) const {
-
- Material *material = material_owner.get(p_material);
- ERR_FAIL_COND_V(!material,VS::MATERIAL_SHADE_MODEL_LAMBERT);
- return material->shade_model;
-};
void RasterizerGLES2::material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode) {
@@ -3455,14 +3449,21 @@ RID RasterizerGLES2::viewport_data_create() {
glGenFramebuffers(1, &vd->lum_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, vd->lum_fbo);
+ GLuint format_luminance = use_fp16_fb?_GL_RG_EXT:GL_RGBA;
+ GLuint format_luminance_type = use_fp16_fb?(full_float_fb_supported?GL_FLOAT:_GL_HALF_FLOAT_OES):GL_UNSIGNED_BYTE;
+ GLuint format_luminance_components = use_fp16_fb?_GL_RG_EXT:GL_RGBA;
+
glGenTextures(1, &vd->lum_color);
glBindTexture(GL_TEXTURE_2D, vd->lum_color);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
- GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
+ // GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ glTexImage2D(GL_TEXTURE_2D, 0, format_luminance, 1, 1, 0,
+ format_luminance_components, format_luminance_type, NULL);
+
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, vd->lum_color, 0);
@@ -3934,10 +3935,12 @@ void RasterizerGLES2::_update_shader( Shader* p_shader) const {
String vertex_code;
String vertex_globals;
- ShaderCompilerGLES2::Flags flags;
+ ShaderCompilerGLES2::Flags vertex_flags;
+ ShaderCompilerGLES2::Flags fragment_flags;
+ ShaderCompilerGLES2::Flags light_flags;
if (p_shader->mode==VS::SHADER_MATERIAL) {
- Error err = shader_precompiler.compile(p_shader->vertex_code,ShaderLanguage::SHADER_MATERIAL_VERTEX,vertex_code,vertex_globals,flags,&p_shader->uniforms);
+ Error err = shader_precompiler.compile(p_shader->vertex_code,ShaderLanguage::SHADER_MATERIAL_VERTEX,vertex_code,vertex_globals,vertex_flags,&p_shader->uniforms);
if (err) {
return; //invalid
}
@@ -3950,11 +3953,26 @@ void RasterizerGLES2::_update_shader( Shader* p_shader) const {
String fragment_code;
String fragment_globals;
- Error err = shader_precompiler.compile(p_shader->fragment_code,(p_shader->mode==VS::SHADER_MATERIAL?ShaderLanguage::SHADER_MATERIAL_FRAGMENT:ShaderLanguage::SHADER_POST_PROCESS),fragment_code,fragment_globals,flags,&p_shader->uniforms);
+ Error err = shader_precompiler.compile(p_shader->fragment_code,(p_shader->mode==VS::SHADER_MATERIAL?ShaderLanguage::SHADER_MATERIAL_FRAGMENT:ShaderLanguage::SHADER_POST_PROCESS),fragment_code,fragment_globals,fragment_flags,&p_shader->uniforms);
if (err) {
return; //invalid
}
+
+ String light_code;
+ String light_globals;
+
+ if (p_shader->mode==VS::SHADER_MATERIAL) {
+
+ Error err = shader_precompiler.compile(p_shader->light_code,(ShaderLanguage::SHADER_MATERIAL_LIGHT),light_code,light_globals,light_flags,&p_shader->uniforms);
+ if (err) {
+ return; //invalid
+ }
+ }
+
+ fragment_globals+=light_globals; //both fragment anyway
+
+
//print_line("compiled fragment: "+fragment_code);
// ("compiled fragment globals: "+fragment_globals);
@@ -3975,40 +3993,43 @@ void RasterizerGLES2::_update_shader( Shader* p_shader) const {
if (p_shader->mode==VS::SHADER_MATERIAL) {
//print_line("setting code to id.. "+itos(p_shader->custom_code_id));
Vector<const char*> enablers;
- if (flags.use_color_interp)
+ if (fragment_flags.use_color_interp)
enablers.push_back("#define ENABLE_COLOR_INTERP\n");
- if (flags.use_uv_interp)
+ if (fragment_flags.use_uv_interp)
enablers.push_back("#define ENABLE_UV_INTERP\n");
- if (flags.use_uv2_interp)
+ if (fragment_flags.use_uv2_interp)
enablers.push_back("#define ENABLE_UV2_INTERP\n");
- if (flags.use_tangent_interp)
+ if (fragment_flags.use_tangent_interp)
enablers.push_back("#define ENABLE_TANGENT_INTERP\n");
- if (flags.use_var1_interp)
+ if (fragment_flags.use_var1_interp)
enablers.push_back("#define ENABLE_VAR1_INTERP\n");
- if (flags.use_var2_interp)
+ if (fragment_flags.use_var2_interp)
enablers.push_back("#define ENABLE_VAR2_INTERP\n");
- if (flags.uses_texscreen) {
+ if (fragment_flags.uses_texscreen) {
enablers.push_back("#define ENABLE_TEXSCREEN\n");
}
- if (flags.uses_screen_uv) {
+ if (fragment_flags.uses_screen_uv) {
enablers.push_back("#define ENABLE_SCREEN_UV\n");
}
- if (flags.uses_discard) {
+ if (fragment_flags.uses_discard) {
enablers.push_back("#define ENABLE_DISCARD\n");
}
+ if (light_flags.uses_light) {
+ enablers.push_back("#define USE_LIGHT_SHADER_CODE\n");
+ }
- material_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, fragment_globals,uniform_names,enablers);
+ material_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, light_code, fragment_globals,uniform_names,enablers);
} else {
//postprocess_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, fragment_globals,uniform_names);
}
p_shader->valid=true;
- p_shader->has_alpha=flags.uses_alpha || flags.uses_texscreen;
- p_shader->writes_vertex=flags.vertex_code_writes_vertex;
- p_shader->uses_discard=flags.uses_discard;
- p_shader->has_texscreen=flags.uses_texscreen;
- p_shader->has_screen_uv=flags.uses_screen_uv;
- p_shader->can_zpass=!flags.uses_discard && !flags.vertex_code_writes_vertex;
+ p_shader->has_alpha=fragment_flags.uses_alpha || fragment_flags.uses_texscreen;
+ p_shader->writes_vertex=vertex_flags.vertex_code_writes_vertex;
+ p_shader->uses_discard=fragment_flags.uses_discard;
+ p_shader->has_texscreen=fragment_flags.uses_texscreen;
+ p_shader->has_screen_uv=fragment_flags.uses_screen_uv;
+ p_shader->can_zpass=!fragment_flags.uses_discard && !vertex_flags.vertex_code_writes_vertex;
p_shader->version++;
}
@@ -4073,10 +4094,10 @@ void RasterizerGLES2::_add_geometry( const Geometry* p_geometry, const InstanceD
if (shadow) {
- if (has_blend_alpha || (has_base_alpha && !m->hints[VS::MATERIAL_HINT_OPAQUE_PRE_PASS]))
+ if (has_blend_alpha || (has_base_alpha && m->depth_draw_mode!=VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA))
return; //bye
- if (m->shader_cache && !m->shader_cache->writes_vertex && !m->shader_cache->uses_discard && !m->hints[VS::MATERIAL_HINT_OPAQUE_PRE_PASS]) {
+ if (m->shader_cache && !m->shader_cache->writes_vertex && !m->shader_cache->uses_discard && m->depth_draw_mode!=VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA) {
//shader does not use discard and does not write a vertex position, use generic material
m = shadow_mat_ptr;
if (m->last_pass!=frame) {
@@ -4159,7 +4180,7 @@ void RasterizerGLES2::_add_geometry( const Geometry* p_geometry, const InstanceD
e->light_type=0xFF; // no lights!
e->light=0xFFFF;
- if (!shadow && !has_blend_alpha && has_alpha && m->hints[VS::MATERIAL_HINT_OPAQUE_PRE_PASS]) {
+ if (!shadow && !has_blend_alpha && has_alpha && m->depth_draw_mode==VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA) {
//if nothing exists, add this element as opaque too
RenderList::Element *oe = opaque_render_list.add_element();
@@ -4411,7 +4432,7 @@ bool RasterizerGLES2::_setup_material(const Geometry *p_geometry,const Material
material_shader.set_conditional(MaterialShaderGLES2::USE_SHADOW_PCF_HQ,shadow_filter==SHADOW_FILTER_PCF13);
material_shader.set_conditional(MaterialShaderGLES2::USE_SHADOW_ESM,shadow_filter==SHADOW_FILTER_ESM);
- if (p_opaque_pass && p_material->hints[VS::MATERIAL_HINT_OPAQUE_PRE_PASS] && p_material->shader_cache && p_material->shader_cache->has_alpha) {
+ if (p_opaque_pass && p_material->depth_draw_mode==VS::MATERIAL_DEPTH_DRAW_OPAQUE_PRE_PASS_ALPHA && p_material->shader_cache && p_material->shader_cache->has_alpha) {
material_shader.set_conditional(MaterialShaderGLES2::ENABLE_CLIP_ALPHA,true);
} else {
@@ -4423,7 +4444,8 @@ bool RasterizerGLES2::_setup_material(const Geometry *p_geometry,const Material
if (!shadow) {
bool depth_test=!p_material->flags[VS::MATERIAL_FLAG_ONTOP];
- bool depth_write=!p_material->hints[VS::MATERIAL_HINT_NO_DEPTH_DRAW] && (p_opaque_pass || !p_material->hints[VS::MATERIAL_HINT_NO_DEPTH_DRAW_FOR_ALPHA]);
+ bool depth_write=p_material->depth_draw_mode!=VS::MATERIAL_DEPTH_DRAW_NEVER && (p_opaque_pass || p_material->depth_draw_mode==VS::MATERIAL_DEPTH_DRAW_ALWAYS);
+ //bool depth_write=!p_material->hints[VS::MATERIAL_HINT_NO_DEPTH_DRAW] && (p_opaque_pass || !p_material->hints[VS::MATERIAL_HINT_NO_DEPTH_DRAW_FOR_ALPHA]);
if (current_depth_mask!=depth_write) {
current_depth_mask=depth_write;
@@ -4594,7 +4616,6 @@ void RasterizerGLES2::_setup_light(uint16_t p_light) {
VL_LIGHT_DIR,
VL_LIGHT_ATTENUATION,
VL_LIGHT_SPOT_ATTENUATION,
- VL_LIGHT_AMBIENT,
VL_LIGHT_DIFFUSE,
VL_LIGHT_SPECULAR,
VL_LIGHT_MAX
@@ -4605,7 +4626,6 @@ void RasterizerGLES2::_setup_light(uint16_t p_light) {
MaterialShaderGLES2::LIGHT_DIRECTION,
MaterialShaderGLES2::LIGHT_ATTENUATION,
MaterialShaderGLES2::LIGHT_SPOT_ATTENUATION,
- MaterialShaderGLES2::LIGHT_AMBIENT,
MaterialShaderGLES2::LIGHT_DIFFUSE,
MaterialShaderGLES2::LIGHT_SPECULAR,
};
@@ -4617,12 +4637,10 @@ void RasterizerGLES2::_setup_light(uint16_t p_light) {
LightInstance *li=light_instances[p_light];
Light *l=li->base;
- Color col_ambient=_convert_color(l->colors[VS::LIGHT_COLOR_AMBIENT]);
Color col_diffuse=_convert_color(l->colors[VS::LIGHT_COLOR_DIFFUSE]);
Color col_specular=_convert_color(l->colors[VS::LIGHT_COLOR_SPECULAR]);
for(int j=0;j<3;j++) {
- light_data[VL_LIGHT_AMBIENT][j]=col_ambient[j];
light_data[VL_LIGHT_DIFFUSE][j]=col_diffuse[j];
light_data[VL_LIGHT_SPECULAR][j]=col_specular[j];
}
@@ -5761,6 +5779,17 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
//material_shader.set_uniform(MaterialShaderGLES2::SKELETON_MATRICES,6);
material_shader.set_uniform(MaterialShaderGLES2::SKELTEX_PIXEL_SIZE,skeleton->pixel_size);
}
+ if (!shadow) {
+
+ if (!additive && current_env && current_env->fx_enabled[VS::ENV_FX_AMBIENT_LIGHT]) {
+ Color ambcolor = current_env->fx_param[VS::ENV_FX_PARAM_AMBIENT_LIGHT_COLOR];
+ float ambnrg = current_env->fx_param[VS::ENV_FX_PARAM_AMBIENT_LIGHT_ENERGY];
+ material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_LIGHT,Vector3(ambcolor.r*ambnrg,ambcolor.g*ambnrg,ambcolor.b*ambnrg));
+ } else {
+ material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_LIGHT,Vector3());
+ }
+ }
+
_rinfo.shader_change_count++;
}
@@ -5908,6 +5937,8 @@ void RasterizerGLES2::_process_glow_bloom() {
glBindTexture(GL_TEXTURE_2D, current_vd->lum_color );
glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::HDR_SOURCE),2);
copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_EXPOSURE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]));
+ copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_WHITE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_WHITE]));
+// copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_WHITE,1.0);
copy_shader.set_uniform(CopyShaderGLES2::HDR_GLOW_TRESHOLD,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_GLOW_TRESHOLD]));
copy_shader.set_uniform(CopyShaderGLES2::HDR_GLOW_SCALE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_GLOW_SCALE]));
@@ -5987,7 +6018,7 @@ void RasterizerGLES2::_process_hdr() {
_copy_screen_quad();
copy_shader.set_conditional(CopyShaderGLES2::USE_HDR_COPY,false);
- int passes = current_env->fx_param[VS::ENV_FX_PARAM_GLOW_BLUR_PASSES];
+// int passes = current_env->fx_param[VS::ENV_FX_PARAM_GLOW_BLUR_PASSES];
copy_shader.set_conditional(CopyShaderGLES2::USE_HDR_REDUCE,true);
copy_shader.bind();
@@ -6351,6 +6382,28 @@ void RasterizerGLES2::end_scene() {
glDepthMask(false);
if (current_env && current_env->fx_enabled[VS::ENV_FX_HDR]) {
+
+ int hdr_tm = current_env->fx_param[VS::ENV_FX_PARAM_HDR_TONEMAPPER];
+ switch(hdr_tm) {
+ case VS::ENV_FX_HDR_TONE_MAPPER_LINEAR: {
+
+
+ } break;
+ case VS::ENV_FX_HDR_TONE_MAPPER_LOG: {
+ copy_shader.set_conditional(CopyShaderGLES2::USE_LOG_TONEMAPPER,true);
+
+ } break;
+ case VS::ENV_FX_HDR_TONE_MAPPER_REINHARDT: {
+ copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,true);
+ } break;
+ case VS::ENV_FX_HDR_TONE_MAPPER_REINHARDT_AUTOWHITE: {
+
+ copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,true);
+ copy_shader.set_conditional(CopyShaderGLES2::USE_AUTOWHITE,true);
+ } break;
+ }
+
+
_process_hdr();
}
if (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) {
@@ -6400,6 +6453,7 @@ void RasterizerGLES2::end_scene() {
glBindTexture(GL_TEXTURE_2D, current_vd->lum_color );
glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::HDR_SOURCE),2);
copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_EXPOSURE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]));
+ copy_shader.set_uniform(CopyShaderGLES2::TONEMAP_WHITE,float(current_env->fx_param[VS::ENV_FX_PARAM_HDR_WHITE]));
}
@@ -6430,6 +6484,9 @@ void RasterizerGLES2::end_scene() {
copy_shader.set_conditional(CopyShaderGLES2::USE_FXAA,false);
copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SCREEN,false);
copy_shader.set_conditional(CopyShaderGLES2::USE_GLOW_SOFTLIGHT,false);
+ copy_shader.set_conditional(CopyShaderGLES2::USE_REINHARDT_TONEMAPPER,false);
+ copy_shader.set_conditional(CopyShaderGLES2::USE_AUTOWHITE,false);
+ copy_shader.set_conditional(CopyShaderGLES2::USE_LOG_TONEMAPPER,false);
material_shader.set_conditional(MaterialShaderGLES2::USE_8BIT_HDR,false);
@@ -6444,6 +6501,7 @@ void RasterizerGLES2::end_scene() {
if (GLOBAL_DEF("rasterizer/debug_shadow_maps",false)) {
_debug_shadows();
}
+// _debug_luminances();
}
@@ -6813,7 +6871,7 @@ void RasterizerGLES2::_debug_draw_shadows_type(Vector<ShadowBuffer>& p_shadows,P
void RasterizerGLES2::_debug_luminances() {
- canvas_shader.set_conditional(CanvasShaderGLES2::DEBUG_ENCODED_32,true);
+ canvas_shader.set_conditional(CanvasShaderGLES2::DEBUG_ENCODED_32,!use_fp16_fb);
canvas_begin();
glDisable(GL_BLEND);
canvas_shader.bind();
@@ -6821,10 +6879,17 @@ void RasterizerGLES2::_debug_luminances() {
Size2 debug_size(128,128);
Size2 ofs;
- for (int i=0;i<framebuffer.luminance.size();i++) {
- _debug_draw_shadow(framebuffer.luminance[i].color, Rect2( ofs, debug_size ));
- ofs.x+=debug_size.x;
+ for (int i=0;i<=framebuffer.luminance.size();i++) {
+
+ if (i==framebuffer.luminance.size()) {
+ if (!current_vd)
+ break;
+ _debug_draw_shadow(current_vd->lum_color, Rect2( ofs, debug_size ));
+ } else {
+ _debug_draw_shadow(framebuffer.luminance[i].color, Rect2( ofs, debug_size ));
+ }
+ ofs.x+=debug_size.x/2;
if ( (ofs.x+debug_size.x) > viewport.width ) {
ofs.x=0;
@@ -7936,9 +8001,14 @@ void RasterizerGLES2::_update_framebuffer() {
GLuint format_rgba = GL_RGBA;
GLuint format_rgb = use_fp16_fb?_GL_RGB16F_EXT:GL_RGB;
GLuint format_type = use_fp16_fb?_GL_HALF_FLOAT_OES:GL_UNSIGNED_BYTE;
- GLuint format_luminance = use_fp16_fb?_GL_RED_EXT:GL_RGBA;
+ /*GLuint format_luminance = use_fp16_fb?GL_RGB16F:GL_RGBA;
+ GLuint format_luminance_type = use_fp16_fb?(use_fu_GL_HALF_FLOAT_OES):GL_UNSIGNED_BYTE;
+ GLuint format_luminance_components = use_fp16_fb?GL_RGB:GL_RGBA;*/
+
+ GLuint format_luminance = use_fp16_fb?_GL_RG_EXT:GL_RGBA;
GLuint format_luminance_type = use_fp16_fb?(full_float_fb_supported?GL_FLOAT:_GL_HALF_FLOAT_OES):GL_UNSIGNED_BYTE;
- GLuint format_luminance_components = use_fp16_fb?_GL_RED_EXT:GL_RGBA;
+ GLuint format_luminance_components = use_fp16_fb?_GL_RG_EXT:GL_RGBA;
+
@@ -8082,8 +8152,8 @@ void RasterizerGLES2::_update_framebuffer() {
glGenTextures(1, &lb.color);
glBindTexture(GL_TEXTURE_2D, lb.color);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, format_luminance, lb.size, lb.size, 0,
diff --git a/drivers/gles2/rasterizer_gles2.h b/drivers/gles2/rasterizer_gles2.h
index cf4c8717e9..60a7731fea 100644
--- a/drivers/gles2/rasterizer_gles2.h
+++ b/drivers/gles2/rasterizer_gles2.h
@@ -163,8 +163,10 @@ class RasterizerGLES2 : public Rasterizer {
String vertex_code;
String fragment_code;
+ String light_code;
int vertex_line;
int fragment_line;
+ int light_line;
VS::ShaderMode mode;
uint32_t custom_code_id;
@@ -193,6 +195,7 @@ class RasterizerGLES2 : public Rasterizer {
version=1;
vertex_line=0;
fragment_line=0;
+ light_line=0;
can_zpass=true;
has_texscreen=false;
has_screen_uv=false;
@@ -211,10 +214,9 @@ class RasterizerGLES2 : public Rasterizer {
struct Material {
bool flags[VS::MATERIAL_FLAG_MAX];
- bool hints[VS::MATERIAL_HINT_MAX];
- VS::MaterialShadeModel shade_model;
VS::MaterialBlendMode blend_mode;
+ VS::MaterialDepthDrawMode depth_draw_mode;
float line_width;
bool has_alpha;
@@ -241,12 +243,10 @@ class RasterizerGLES2 : public Rasterizer {
for(int i=0;i<VS::MATERIAL_FLAG_MAX;i++)
flags[i]=false;
flags[VS::MATERIAL_FLAG_VISIBLE]=true;
- for(int i=0;i<VS::MATERIAL_HINT_MAX;i++)
- hints[i]=false;
- hints[VS::MATERIAL_HINT_NO_DEPTH_DRAW_FOR_ALPHA]=true;
line_width=1;
has_alpha=false;
+ depth_draw_mode=VS::MATERIAL_DEPTH_DRAW_OPAQUE_ONLY;
blend_mode=VS::MATERIAL_BLEND_MODE_MIX;
last_pass = 0;
shader_version=0;
@@ -590,7 +590,6 @@ class RasterizerGLES2 : public Rasterizer {
vars[VS::LIGHT_PARAM_SHADOW_Z_SLOPE_SCALE]=1.4;
vars[VS::LIGHT_PARAM_SHADOW_ESM_MULTIPLIER]=60.0;
vars[VS::LIGHT_PARAM_SHADOW_BLUR_PASSES]=1;
- colors[VS::LIGHT_COLOR_AMBIENT]=Color(0,0,0);
colors[VS::LIGHT_COLOR_DIFFUSE]=Color(1,1,1);
colors[VS::LIGHT_COLOR_SPECULAR]=Color(1,1,1);
shadow_enabled=false;
@@ -635,8 +634,9 @@ class RasterizerGLES2 : public Rasterizer {
fx_param[VS::ENV_FX_PARAM_DOF_BLUR_PASSES]=1;
fx_param[VS::ENV_FX_PARAM_DOF_BLUR_BEGIN]=100.0;
fx_param[VS::ENV_FX_PARAM_DOF_BLUR_RANGE]=10.0;
+ fx_param[VS::ENV_FX_PARAM_HDR_TONEMAPPER]=VS::ENV_FX_HDR_TONE_MAPPER_LINEAR;
fx_param[VS::ENV_FX_PARAM_HDR_EXPOSURE]=0.4;
- fx_param[VS::ENV_FX_PARAM_HDR_SCALAR]=1.0;
+ fx_param[VS::ENV_FX_PARAM_HDR_WHITE]=1.0;
fx_param[VS::ENV_FX_PARAM_HDR_GLOW_TRESHOLD]=0.95;
fx_param[VS::ENV_FX_PARAM_HDR_GLOW_SCALE]=0.2;
fx_param[VS::ENV_FX_PARAM_HDR_MIN_LUMINANCE]=0.4;
@@ -1172,9 +1172,11 @@ public:
virtual void shader_set_mode(RID p_shader,VS::ShaderMode p_mode);
virtual VS::ShaderMode shader_get_mode(RID p_shader) const;
- virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,int p_vertex_ofs=0,int p_fragment_ofs=0);
+ virtual void shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,const String& p_light,int p_vertex_ofs=0,int p_fragment_ofs=0,int p_light_ofs=0);
virtual String shader_get_fragment_code(RID p_shader) const;
virtual String shader_get_vertex_code(RID p_shader) const;
+ virtual String shader_get_light_code(RID p_shader) const;
+
virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
@@ -1192,11 +1194,8 @@ public:
virtual void material_set_flag(RID p_material, VS::MaterialFlag p_flag,bool p_enabled);
virtual bool material_get_flag(RID p_material,VS::MaterialFlag p_flag) const;
- virtual void material_set_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled);
- virtual bool material_get_hint(RID p_material,VS::MaterialHint p_hint) const;
-
- virtual void material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model);
- virtual VS::MaterialShadeModel material_get_shade_model(RID p_material) const;
+ virtual void material_set_depth_draw_mode(RID p_material, VS::MaterialDepthDrawMode p_mode);
+ virtual VS::MaterialDepthDrawMode material_get_depth_draw_mode(RID p_material) const;
virtual void material_set_blend_mode(RID p_material,VS::MaterialBlendMode p_mode);
virtual VS::MaterialBlendMode material_get_blend_mode(RID p_material) const;
diff --git a/drivers/gles2/shader_compiler_gles2.cpp b/drivers/gles2/shader_compiler_gles2.cpp
index db63c3aeba..dfab3ea3d1 100644
--- a/drivers/gles2/shader_compiler_gles2.cpp
+++ b/drivers/gles2/shader_compiler_gles2.cpp
@@ -182,6 +182,13 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
}
}
+ if (type==ShaderLanguage::SHADER_MATERIAL_LIGHT) {
+
+ if (vnode->name==vname_light) {
+ uses_light=true;
+ }
+
+ }
code=replace_string(vnode->name);
@@ -410,7 +417,7 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
}
-void ShaderCompilerGLES2::compile_node(SL::ProgramNode *p_program) {
+Error ShaderCompilerGLES2::compile_node(SL::ProgramNode *p_program) {
// feed the local replace table and global code
global_code="";
@@ -423,8 +430,15 @@ void ShaderCompilerGLES2::compile_node(SL::ProgramNode *p_program) {
for(Map<StringName,SL::Uniform>::Element *E=p_program->uniforms.front();E;E=E->next()) {
String uline="uniform "+_typestr(E->get().type)+" _"+E->key().operator String()+";"ENDL;
+
global_code+=uline;
if (uniforms) {
+ //if (uniforms->has(E->key())) {
+ // //repeated uniform, error
+ // ERR_EXPLAIN("Uniform already exists from other shader: "+String(E->key()));
+ // ERR_FAIL_COND_V(uniforms->has(E->key()),ERR_ALREADY_EXISTS);
+//
+// }
SL::Uniform u = E->get();
u.order+=ubase;
uniforms->insert(E->key(),u);
@@ -474,12 +488,14 @@ void ShaderCompilerGLES2::compile_node(SL::ProgramNode *p_program) {
print_line(code);
code=code.replace("\n","");
#endif
+
+ return OK;
}
-void ShaderCompilerGLES2::create_glsl_120_code(void *p_str,SL::ProgramNode *p_program) {
+Error ShaderCompilerGLES2::create_glsl_120_code(void *p_str,SL::ProgramNode *p_program) {
ShaderCompilerGLES2 *compiler=(ShaderCompilerGLES2*)p_str;
- compiler->compile_node(p_program);
+ return compiler->compile_node(p_program);
}
@@ -505,6 +521,7 @@ Error ShaderCompilerGLES2::compile(const String& p_code, ShaderLanguage::ShaderT
uses_alpha=false;
uses_discard=false;
uses_screen_uv=false;
+ uses_light=false;
vertex_code_writes_vertex=false;
uniforms=r_uniforms;
flags=&r_flags;
@@ -533,6 +550,7 @@ Error ShaderCompilerGLES2::compile(const String& p_code, ShaderLanguage::ShaderT
r_flags.vertex_code_writes_vertex=vertex_code_writes_vertex;
r_flags.uses_discard=uses_discard;
r_flags.uses_screen_uv=uses_screen_uv;
+ r_flags.uses_light=uses_light;
r_code_line=code;
r_globals_line=global_code;
return OK;
@@ -577,6 +595,7 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
replace_table["clamp"]= "clamp";
replace_table["mix" ]= "mix";
replace_table["step" ]= "step";
+ replace_table["smoothstep" ]= "smoothstep";
replace_table["length"]= "length";
replace_table["distance"]= "distance";
replace_table["dot" ]= "dot";
@@ -628,6 +647,7 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
mode_replace_table[1]["DIFFUSE_ALPHA"]="diffuse";
mode_replace_table[1]["SPECULAR"]="specular";
mode_replace_table[1]["EMISSION"]="emission";
+ mode_replace_table[1]["SHADE_PARAM"]="shade_param";
mode_replace_table[1]["SPEC_EXP"]="specular_exp";
mode_replace_table[1]["GLOW"]="glow";
mode_replace_table[1]["DISCARD"]="discard_";
@@ -638,6 +658,26 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
//mode_replace_table[1]["SCREEN_TEXEL_SIZE"]="SCREEN_TEXEL_SIZE";
mode_replace_table[1]["TIME"]="time";
+ //////////////
+
+ mode_replace_table[2]["NORMAL"]="normal";
+ //mode_replace_table[2]["POSITION"]="IN_POSITION";
+ mode_replace_table[2]["LIGHT_DIR"]="light_dir";
+ mode_replace_table[2]["LIGHT_DIFFUSE"]="light_diffuse";
+ mode_replace_table[2]["LIGHT_SPECULAR"]="light_specular";
+ mode_replace_table[2]["EYE_VEC"]="eye_vec";
+ mode_replace_table[2]["DIFFUSE"]="mdiffuse";
+ mode_replace_table[2]["SPECULAR"]="specular";
+ mode_replace_table[2]["SPECULAR_EXP"]="specular_exp";
+ mode_replace_table[2]["SHADE_PARAM"]="shade_param";
+ mode_replace_table[2]["LIGHT"]="light";
+ mode_replace_table[2]["POINT_COORD"]="gl_PointCoord";
+ mode_replace_table[2]["TIME"]="time";
+
+ //mode_replace_table[2]["SCREEN_POS"]="SCREEN_POS";
+ //mode_replace_table[2]["SCREEN_TEXEL_SIZE"]="SCREEN_TEXEL_SIZE";
+
+
out_vertex_name="VERTEX";
vname_discard="DISCARD";
@@ -651,5 +691,6 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
vname_var1_interp="VAR1";
vname_var2_interp="VAR2";
vname_vertex="VERTEX";
+ vname_light="LIGHT";
}
diff --git a/drivers/gles2/shader_compiler_gles2.h b/drivers/gles2/shader_compiler_gles2.h
index d683f5b4f3..d63915a2b6 100644
--- a/drivers/gles2/shader_compiler_gles2.h
+++ b/drivers/gles2/shader_compiler_gles2.h
@@ -39,10 +39,11 @@ private:
ShaderLanguage::ProgramNode *program_node;
String dump_node_code(ShaderLanguage::Node *p_node,int p_level,bool p_assign_left=false);
- void compile_node(ShaderLanguage::ProgramNode *p_program);
- static void create_glsl_120_code(void *p_str,ShaderLanguage::ProgramNode *p_program);
+ Error compile_node(ShaderLanguage::ProgramNode *p_program);
+ static Error create_glsl_120_code(void *p_str,ShaderLanguage::ProgramNode *p_program);
+ bool uses_light;
bool uses_texscreen;
bool uses_texpos;
bool uses_alpha;
@@ -62,6 +63,7 @@ private:
StringName vname_var1_interp;
StringName vname_var2_interp;
StringName vname_vertex;
+ StringName vname_light;
Map<StringName,ShaderLanguage::Uniform> *uniforms;
@@ -73,7 +75,7 @@ private:
String replace_string(const StringName& p_string);
- Map<StringName,StringName> mode_replace_table[2];
+ Map<StringName,StringName> mode_replace_table[3];
Map<StringName,StringName> replace_table;
public:
@@ -92,6 +94,7 @@ public:
bool use_tangent_interp;
bool use_var1_interp;
bool use_var2_interp;
+ bool uses_light;
};
Error compile(const String& p_code, ShaderLanguage::ShaderType p_type, String& r_code_line, String& r_globals_line, Flags& r_flags, Map<StringName,ShaderLanguage::Uniform> *r_uniforms=NULL);
diff --git a/drivers/gles2/shader_gles2.cpp b/drivers/gles2/shader_gles2.cpp
index bcd3e6ad4b..dc68ee489a 100644
--- a/drivers/gles2/shader_gles2.cpp
+++ b/drivers/gles2/shader_gles2.cpp
@@ -285,6 +285,7 @@ ShaderGLES2::Version* ShaderGLES2::get_current_version() {
//keep them around during the function
CharString code_string;
+ CharString code_string2;
CharString code_globals;
@@ -437,6 +438,14 @@ ShaderGLES2::Version* ShaderGLES2::get_current_version() {
}
strings.push_back(fragment_code2.get_data());
+
+ if (cc) {
+ code_string2=cc->light.ascii();
+ strings.push_back(code_string2.get_data());
+ }
+
+ strings.push_back(fragment_code3.get_data());
+
#ifdef DEBUG_SHADER
DEBUG_PRINT("\nFragment Code:\n\n"+String(code_string.get_data()));
for(int i=0;i<strings.size();i++) {
@@ -630,6 +639,7 @@ void ShaderGLES2::setup(const char** p_conditional_defines, int p_conditional_co
{
String globals_tag="\nFRAGMENT_SHADER_GLOBALS";
String code_tag="\nFRAGMENT_SHADER_CODE";
+ String light_code_tag="\nLIGHT_SHADER_CODE";
String code = fragment_code;
int cpos = code.find(globals_tag);
if (cpos==-1) {
@@ -645,7 +655,16 @@ void ShaderGLES2::setup(const char** p_conditional_defines, int p_conditional_co
} else {
fragment_code1=code.substr(0,cpos).ascii();
- fragment_code2=code.substr(cpos+code_tag.length(),code.length()).ascii();
+ String code2 = code.substr(cpos+code_tag.length(),code.length());
+
+ cpos = code2.find(light_code_tag);
+ if (cpos==-1) {
+ fragment_code2=code2.ascii();
+ } else {
+
+ fragment_code2=code2.substr(0,cpos).ascii();
+ fragment_code3 = code2.substr(cpos+light_code_tag.length(),code2.length()).ascii();
+ }
}
}
}
@@ -696,7 +715,7 @@ uint32_t ShaderGLES2::create_custom_shader() {
return last_custom_code++;
}
-void ShaderGLES2::set_custom_shader_code(uint32_t p_code_id, const String& p_vertex, const String& p_vertex_globals,const String& p_fragment, const String& p_fragment_globals,const Vector<StringName>& p_uniforms,const Vector<const char*> &p_custom_defines) {
+void ShaderGLES2::set_custom_shader_code(uint32_t p_code_id, const String& p_vertex, const String& p_vertex_globals,const String& p_fragment,const String& p_light, const String& p_fragment_globals,const Vector<StringName>& p_uniforms,const Vector<const char*> &p_custom_defines) {
ERR_FAIL_COND(!custom_code_map.has(p_code_id));
CustomCode *cc=&custom_code_map[p_code_id];
@@ -705,6 +724,7 @@ void ShaderGLES2::set_custom_shader_code(uint32_t p_code_id, const String& p_ver
cc->vertex_globals=p_vertex_globals;
cc->fragment=p_fragment;
cc->fragment_globals=p_fragment_globals;
+ cc->light=p_light;
cc->custom_uniforms=p_uniforms;
cc->custom_defines=p_custom_defines;
cc->version++;
diff --git a/drivers/gles2/shader_gles2.h b/drivers/gles2/shader_gles2.h
index 17d893e349..9cd6142eb0 100644
--- a/drivers/gles2/shader_gles2.h
+++ b/drivers/gles2/shader_gles2.h
@@ -98,6 +98,7 @@ private:
String vertex_globals;
String fragment;
String fragment_globals;
+ String light;
uint32_t version;
Vector<StringName> custom_uniforms;
Vector<const char*> custom_defines;
@@ -157,6 +158,7 @@ private:
CharString fragment_code0;
CharString fragment_code1;
CharString fragment_code2;
+ CharString fragment_code3;
CharString vertex_code0;
CharString vertex_code1;
@@ -292,7 +294,7 @@ public:
void clear_caches();
uint32_t create_custom_shader();
- void set_custom_shader_code(uint32_t p_id,const String& p_vertex, const String& p_vertex_globals,const String& p_fragment, const String& p_fragment_globals,const Vector<StringName>& p_uniforms,const Vector<const char*> &p_custom_defines);
+ void set_custom_shader_code(uint32_t p_id,const String& p_vertex, const String& p_vertex_globals,const String& p_fragment,const String& p_p_light,const String& p_fragment_globals,const Vector<StringName>& p_uniforms,const Vector<const char*> &p_custom_defines);
void set_custom_shader(uint32_t p_id);
void free_custom_shader(uint32_t p_id);
diff --git a/drivers/gles2/shaders/copy.glsl b/drivers/gles2/shaders/copy.glsl
index f96ec1d1bd..d8fb03f3a3 100644
--- a/drivers/gles2/shaders/copy.glsl
+++ b/drivers/gles2/shaders/copy.glsl
@@ -78,7 +78,7 @@ uniform highp float hdr_glow_scale;
uniform sampler2D hdr_source;
uniform highp float tonemap_exposure;
-
+uniform highp float tonemap_white;
#endif
#ifdef USE_BCS
@@ -318,6 +318,7 @@ void main() {
#ifdef USE_HDR
+ highp float white_mult = 1.0;
#ifdef USE_8BIT_HDR
highp vec4 _mult = vec4(1.0 / (256.0 * 256.0 * 256.0),1.0 / (256.0 * 256.0),1.0 / 256.0,1);
@@ -325,11 +326,37 @@ void main() {
color.rgb*=LUM_RANGE;
hdr_lum*=LUM_RANGE; //restore to full range
#else
- highp float hdr_lum = texture2D( hdr_source, vec2(0.0) ).r;
+
+ highp vec2 lv = texture2D( hdr_source, vec2(0.0) ).rg;
+ highp float hdr_lum = lv.r;
+#ifdef USE_AUTOWHITE
+ white_mult=lv.g;
+#endif
+
#endif
+#ifdef USE_REINHARDT_TONEMAPPER
+ float src_lum = dot(color.rgb,vec3(0.3, 0.58, 0.12));
+ float lp = tonemap_exposure/hdr_lum*src_lum;
+ float white = tonemap_white;
+#ifdef USE_AUTOWHITE
+ white_mult = (white_mult + 1.0 * white_mult);
+ white_mult*=white_mult;
+ white*=white_mult;
+#endif
+ lp = ( lp * ( 1.0 + ( lp / ( white) ) ) ) / ( 1.0 + lp );
+ color.rgb*=lp;
+
+#else
+
+#ifdef USE_LOG_TONEMAPPER
+ color.rgb = tonemap_exposure * log(color.rgb+1.0)/log(hdr_lum+1.0);
+#else
highp float tone_scale = tonemap_exposure / hdr_lum; //only linear supported
color.rgb*=tone_scale;
+#endif
+
+#endif
#endif
@@ -393,7 +420,11 @@ void main() {
#ifdef USE_HDR_COPY
//highp float lum = dot(color.rgb,highp vec3(1.0/3.0,1.0/3.0,1.0/3.0));
- highp float lum = max(color.r,max(color.g,color.b));
+ //highp float lum = max(color.r,max(color.g,color.b));
+ highp float lum = dot(color.rgb,vec3(0.3, 0.58, 0.12));
+
+ //lum=log(lum+0.0001); //everyone does it
+
#ifdef USE_8BIT_HDR
highp vec4 comp = fract(lum * vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0));
comp -= comp.xxyz * vec4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);
@@ -422,21 +453,33 @@ void main() {
#else
highp float lum_accum = color.r;
- lum_accum += texture2D( source, uv_interp+vec2(-pixel_size.x,-pixel_size.y) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(0.0,-pixel_size.y) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(pixel_size.x,-pixel_size.y) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(-pixel_size.x,0.0) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(pixel_size.x,0.0) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(-pixel_size.x,pixel_size.y) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(0.0,pixel_size.y) ).r;
- lum_accum += texture2D( source, uv_interp+vec2(pixel_size.x,pixel_size.y) ).r;
+ highp float lum_max = color.g;
+
+#define LUM_REDUCE(m_uv) \
+ {\
+ vec2 val = texture2D( source, uv_interp+m_uv ).rg;\
+ lum_accum+=val.x;\
+ lum_max=max(val.y,lum_max);\
+ }
+
+ LUM_REDUCE( vec2(-pixel_size.x,-pixel_size.y) );
+ LUM_REDUCE( vec2(0.0,-pixel_size.y) );
+ LUM_REDUCE( vec2(pixel_size.x,-pixel_size.y) );
+ LUM_REDUCE( vec2(-pixel_size.x,0.0) );
+ LUM_REDUCE( vec2(pixel_size.x,0.0) );
+ LUM_REDUCE( vec2(-pixel_size.x,pixel_size.y) );
+ LUM_REDUCE( vec2(0.0,pixel_size.y) );
+ LUM_REDUCE( vec2(pixel_size.x,pixel_size.y) );
lum_accum/=9.0;
#endif
#ifdef USE_HDR_STORE
-#ifdef USE_8BIT_HDR
+ //lum_accum=exp(lum_accum);
+
+#ifdef USE_8BIT_HDR
+
highp float vd_lum = dot(texture2D( source_vd_lum, vec2(0.0) ), _multcv );
lum_accum = clamp( vd_lum + (lum_accum-vd_lum)*hdr_time_delta*hdr_exp_adj_speed,min_luminance*(1.0/LUM_RANGE),max_luminance*(1.0/LUM_RANGE));
#else
@@ -451,12 +494,20 @@ void main() {
comp -= comp.xxyz * vec4(0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);
color=comp;
#else
+#ifdef USE_AUTOWHITE
+ color.r=lum_accum;
+ color.g=lum_max;
+#else
color.rgb=vec3(lum_accum);
#endif
#endif
+#endif
+
+
+
#ifdef USE_RGBE
color.rgb = pow(color.rgb,color.a*255.0-(8.0+128.0));
diff --git a/drivers/gles2/shaders/material.glsl b/drivers/gles2/shaders/material.glsl
index 8e7d321fe7..602620a04b 100644
--- a/drivers/gles2/shaders/material.glsl
+++ b/drivers/gles2/shaders/material.glsl
@@ -115,7 +115,6 @@ uniform vec3 light_pos;
uniform vec3 light_direction;
uniform vec3 light_attenuation;
uniform vec3 light_spot_attenuation;
-uniform vec3 light_ambient;
uniform vec3 light_diffuse;
uniform vec3 light_specular;
@@ -132,6 +131,7 @@ varying vec3 specular_interp;
uniform float time;
uniform float instance_id;
+uniform vec3 ambient_light;
#if !defined(USE_DEPTH_SHADOWS) && defined(USE_SHADOW_PASS)
@@ -404,7 +404,7 @@ VERTEX_SHADER_CODE
float NdotL = max(0.0,dot( normal_interp, light_dir ));
vec3 half_vec = normalize(light_dir + eye_vec);
float eye_light = max(dot(normal_interp, half_vec),0.0);
- diffuse_interp.rgb=light_diffuse * NdotL * attenuation;// + light_ambient;
+ diffuse_interp.rgb=light_diffuse * NdotL * attenuation;
diffuse_interp.a=attenuation;
if (NdotL > 0.0) {
specular_interp=light_specular * pow( eye_light, vertex_specular_exp ) * attenuation;
@@ -510,27 +510,15 @@ uniform vec3 light_pos;
uniform vec3 light_direction;
uniform vec3 light_attenuation;
uniform vec3 light_spot_attenuation;
-uniform vec3 light_ambient;
uniform vec3 light_diffuse;
uniform vec3 light_specular;
-
-#ifdef USE_FRAGMENT_LIGHTING
+uniform vec3 ambient_light;
+#ifdef USE_FRAGMENT_LIGHTING
-vec3 process_shade(in vec3 normal, in vec3 light_dir, in vec3 eye_vec, in vec3 diffuse, in vec3 specular, in float specular_exp, in float attenuation) {
- float NdotL = max(0.0,dot( normal, light_dir ));
- vec3 half_vec = normalize(light_dir + eye_vec);
- float eye_light = max(dot(normal, half_vec),0.0);
-
- vec3 ret = light_ambient *diffuse + light_diffuse * diffuse * NdotL * attenuation;
- if (NdotL > 0.0) {
- ret+=light_specular * specular * pow( eye_light, specular_exp ) * attenuation;
- }
- return ret;
-}
# ifdef USE_DEPTH_SHADOWS
# else
@@ -770,9 +758,12 @@ void main() {
bool discard_=false;
#endif
+{
+
FRAGMENT_SHADER_CODE
+}
#if defined(ENABLE_DISCARD)
if (discard_) {
@@ -1009,9 +1000,8 @@ FRAGMENT_SHADER_CODE
#ifdef LIGHT_TYPE_DIRECTIONAL
vec3 light_dir = -light_direction;
- float light_attenuation = light_attenuation.r;
+ float attenuation = light_attenuation.r;
- diffuse.rgb=process_shade(normal,light_dir,eye_vec,diffuse.rgb,specular,specular_exp,shadow_attenuation)*light_attenuation;
#endif
@@ -1023,7 +1013,6 @@ FRAGMENT_SHADER_CODE
light_dir=normalize(light_dir);
float attenuation = pow( max(1.0 - dist/radius, 0.0), light_attenuation.b ) * light_attenuation.r;
- diffuse.rgb=process_shade(normal,light_dir,eye_vec,diffuse.rgb,specular,specular_exp,shadow_attenuation)*attenuation;
#endif
@@ -1040,10 +1029,39 @@ FRAGMENT_SHADER_CODE
float rim = (1.0 - scos) / (1.0 - spot_cutoff);
attenuation *= 1.0 - pow( rim, light_spot_attenuation.g);
- diffuse.rgb=process_shade(normal,light_dir,eye_vec,diffuse.rgb,specular,specular_exp,shadow_attenuation)*attenuation;
+#endif
+
+# if defined(LIGHT_TYPE_DIRECTIONAL) || defined(LIGHT_TYPE_OMNI) || defined (LIGHT_TYPE_SPOT)
+
+ {
+
+ vec3 mdiffuse = diffuse.rgb;
+ vec3 light;
+
+#if defined(USE_LIGHT_SHADER_CODE)
+//light is written by the light shader
+{
+
+LIGHT_SHADER_CODE
+
+}
+#else
+//traditional lambert + blinn
+ float NdotL = max(0.0,dot( normal, light_dir ));
+ vec3 half_vec = normalize(light_dir + eye_vec);
+ float eye_light = max(dot(normal, half_vec),0.0);
+ light = light_diffuse * mdiffuse * NdotL;
+ if (NdotL > 0.0) {
+ light+=specular * light_specular * pow( eye_light, specular_exp );
+ }
#endif
+ diffuse.rgb = ambient_light *diffuse.rgb + light * attenuation * shadow_attenuation;
+
+ }
+
+# endif
# if !defined(LIGHT_TYPE_DIRECTIONAL) && !defined(LIGHT_TYPE_OMNI) && !defined (LIGHT_TYPE_SPOT)
//none
@@ -1062,7 +1080,7 @@ FRAGMENT_SHADER_CODE
#ifdef USE_VERTEX_LIGHTING
- vec3 ambient = light_ambient*diffuse.rgb;
+ vec3 ambient = ambient_light*diffuse.rgb;
# if defined(LIGHT_TYPE_OMNI) || defined (LIGHT_TYPE_SPOT)
ambient*=diffuse_interp.a; //attenuation affects ambient too
# endif
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-03 10:37:15 +0000