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.cpp301
-rw-r--r--drivers/gles2/rasterizer_gles2.h65
-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.glsl77
-rw-r--r--drivers/gles2/shaders/material.glsl93
10 files changed, 478 insertions, 233 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 307db4b762..dd690435ec 100644
--- a/drivers/gles2/rasterizer_gles2.cpp
+++ b/drivers/gles2/rasterizer_gles2.cpp
@@ -49,6 +49,12 @@
#define _GL_R16F_EXT 0x822D
#define _GL_R32F_EXT 0x822E
+
+#define _GL_RED_EXT 0x1903
+#define _GL_RG_EXT 0x8227
+#define _GL_R8_EXT 0x8229
+#define _GL_RG8_EXT 0x822B
+
#define _DEPTH_COMPONENT24_OES 0x81A6
#ifdef GLEW_ENABLED
@@ -1126,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);
}
@@ -1160,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())
@@ -1328,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) {
@@ -3449,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);
@@ -3928,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
}
@@ -3944,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);
@@ -3969,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++;
}
@@ -4056,7 +4083,6 @@ void RasterizerGLES2::_add_geometry( const Geometry* p_geometry, const InstanceD
}
- LightInstance *lights[RenderList::MAX_LIGHTS];
RenderList *render_list=NULL;
@@ -4067,10 +4093,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) {
@@ -4153,7 +4179,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();
@@ -4170,26 +4196,36 @@ void RasterizerGLES2::_add_geometry( const Geometry* p_geometry, const InstanceD
e->light_type=0x7F; //unshaded is zero
} else {
- //setup lights
- uint16_t light_count=0;
- uint16_t sort_key[4];
- uint8_t light_types[4];
+ bool duplicate=false;
- int dlc = MIN(directional_light_count,RenderList::MAX_LIGHTS);;
- light_count=dlc;
- for(int i=0;i<dlc;i++) {
- sort_key[i]=directional_lights[i]->sort_key;
- light_types[i]=VS::LIGHT_DIRECTIONAL;
+ for(int i=0;i<directional_light_count;i++) {
+ uint16_t sort_key = directional_lights[i]->sort_key;
+ uint8_t light_type = VS::LIGHT_DIRECTIONAL;
if (directional_lights[i]->base->shadow_enabled) {
- light_types[i]|=0x8;
+ light_type|=0x8;
if (directional_lights[i]->base->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS)
- light_types[i]|=0x10;
+ light_type|=0x10;
else if (directional_lights[i]->base->directional_shadow_mode==VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS)
- light_types[i]|=0x30;
+ light_type|=0x30;
+
+ }
+
+ RenderList::Element *ec;
+ if (duplicate) {
+ ec = render_list->add_element();
+ memcpy(ec,e,sizeof(RenderList::Element));
+ } else {
+
+ ec=e;
+ duplicate=true;
}
+ ec->light_type=light_type;
+ ec->light=sort_key;
+ ec->additive_ptr=&e->additive;
+
}
@@ -4200,37 +4236,34 @@ void RasterizerGLES2::_add_geometry( const Geometry* p_geometry, const InstanceD
for(int i=0;i<ilc;i++) {
- if (light_count>=RenderList::MAX_LIGHTS)
- break;
-
LightInstance *li=light_instance_owner.get( liptr[i] );
if (!li || li->last_pass!=scene_pass) //lit by light not in visible scene
continue;
- light_types[light_count]=li->base->type;
- if (li->base->shadow_enabled)
- light_types[light_count]|=0x8;
- sort_key[light_count++]=li->sort_key;
-
-
- }
-
- for(int i=0;i<light_count;i++) {
+ uint8_t light_type=li->base->type|0x40; //penalty to ensure directionals always go first
+ if (li->base->shadow_enabled) {
+ light_type|=0x8;
+ }
+ uint16_t sort_key =li->sort_key;
RenderList::Element *ec;
- if (i>0) {
+ if (duplicate) {
ec = render_list->add_element();
memcpy(ec,e,sizeof(RenderList::Element));
} else {
+ duplicate=true;
ec=e;
}
- ec->light_type=light_types[i];
- ec->light=sort_key[i];
+ ec->light_type=light_type;
+ ec->light=sort_key;
ec->additive_ptr=&e->additive;
+
}
+
+
}
DEBUG_TEST_ERROR("Add Geometry");
@@ -4405,7 +4438,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 {
@@ -4417,7 +4450,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;
@@ -4565,7 +4599,7 @@ bool RasterizerGLES2::_setup_material(const Geometry *p_geometry,const Material
material_shader.set_uniform(MaterialShaderGLES2::FOG_COLOR_END,Vector3(col_end.r,col_end.g,col_end.b));
}
- material_shader.set_uniform(MaterialShaderGLES2::CONST_LIGHT_MULT,p_no_const_light?0.0:1.0);
+
//material_shader.set_uniform(MaterialShaderGLES2::TIME,Math::fmod(last_time,300.0));
//if uses TIME - draw_next_frame=true
@@ -4588,7 +4622,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
@@ -4599,7 +4632,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,
};
@@ -4611,12 +4643,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];
}
@@ -5524,6 +5554,7 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
bool stores_glow = !shadow && (current_env && current_env->fx_enabled[VS::ENV_FX_GLOW]) && !p_alpha_pass;
+
bool prev_blend=false;
glDisable(GL_BLEND);
for (int i=0;i<p_render_list->element_count;i++) {
@@ -5596,6 +5627,7 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
additive=true;
}
+
if (stores_glow)
material_shader.set_conditional(MaterialShaderGLES2::USE_GLOW,!additive);
@@ -5637,7 +5669,7 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
case VS::MATERIAL_BLEND_MODE_ADD: {
glBlendEquation(GL_FUNC_ADD);
- glBlendFunc(GL_SRC_ALPHA,GL_ONE);
+ glBlendFunc(p_alpha_pass?GL_SRC_ALPHA:GL_ONE,GL_ONE);
} break;
case VS::MATERIAL_BLEND_MODE_SUB: {
@@ -5728,7 +5760,8 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
if (i==0 || light!=prev_light || rebind) {
if (e->light!=0xFFFF) {
- _setup_light(e->light&0x3);
+ _setup_light(e->light);
+
}
}
@@ -5739,6 +5772,7 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_OCTREE_LATTICE_DIVIDE, baked_light->octree_lattice_divide);
material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_OCTREE_STEPS, baked_light->octree_steps);
material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_OCTREE_TEX,5);
+ material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_OCTREE_MULTIPLIER,baked_light->texture_multiplier);
material_shader.set_uniform(MaterialShaderGLES2::AMBIENT_OCTREE_PIX_SIZE,baked_light->octree_tex_pixel_size);
@@ -5754,6 +5788,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++;
}
@@ -5788,6 +5833,9 @@ void RasterizerGLES2::_render_list_forward(RenderList *p_render_list,const Trans
material_shader.set_uniform(MaterialShaderGLES2::WORLD_TRANSFORM, e->instance->transform);
}
+ material_shader.set_uniform(MaterialShaderGLES2::NORMAL_MULT, e->mirror?-1.0:1.0);
+ material_shader.set_uniform(MaterialShaderGLES2::CONST_LIGHT_MULT,additive?0.0:1.0);
+
_render(e->geometry, material, skeleton,e->owner,e->instance->transform);
DEBUG_TEST_ERROR("Rendering");
@@ -5901,6 +5949,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]));
@@ -5980,7 +6030,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();
@@ -6048,6 +6098,9 @@ void RasterizerGLES2::_draw_tex_bg() {
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
+ glDisable(GL_BLEND);
+ glColorMask(1,1,1,1);
+
RID texture;
@@ -6083,6 +6136,7 @@ void RasterizerGLES2::_draw_tex_bg() {
copy_shader.set_conditional(CopyShaderGLES2::USE_CUSTOM_ALPHA,true);
+
copy_shader.bind();
if (current_env->bg_mode==VS::ENV_BG_TEXTURE || current_env->bg_mode==VS::ENV_BG_TEXTURE_RGBE) {
@@ -6301,6 +6355,7 @@ void RasterizerGLES2::end_scene() {
_render_list_forward(&opaque_render_list,camera_transform,camera_transform_inverse,camera_projection,false,fragment_lighting);
if (draw_tex_background) {
+
//most 3D vendors recommend drawing a texture bg or skybox here,
//after opaque geometry has been drawn
//so the zbuffer can get rid of most pixels
@@ -6344,6 +6399,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]) {
@@ -6393,6 +6470,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]));
}
@@ -6423,6 +6501,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);
@@ -6437,6 +6518,7 @@ void RasterizerGLES2::end_scene() {
if (GLOBAL_DEF("rasterizer/debug_shadow_maps",false)) {
_debug_shadows();
}
+// _debug_luminances();
}
@@ -6806,7 +6888,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();
@@ -6814,10 +6896,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;
@@ -7873,6 +7962,7 @@ void RasterizerGLES2::_update_framebuffer() {
glDeleteFramebuffers(1,&framebuffer.luminance[i].fbo);
}
+
for(int i=0;i<3;i++) {
glDeleteTextures(1,&framebuffer.blur[i].color);
@@ -7924,12 +8014,20 @@ void RasterizerGLES2::_update_framebuffer() {
#endif
//color
- GLuint format_rgba = use_fp16_fb?_GL_RGBA16F_EXT:GL_RGBA;
+// GLuint format_rgba = use_fp16_fb?_GL_RGBA16F_EXT:GL_RGBA;
+ 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_R32F_EXT:GL_RGBA;
- GLuint format_luminance_type = use_fp16_fb?GL_FLOAT:GL_UNSIGNED_BYTE;
- GLuint format_luminance_components = use_fp16_fb?GL_RED: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_RG_EXT:GL_RGBA;
+
+
+
glGenTextures(1, &framebuffer.color);
glBindTexture(GL_TEXTURE_2D, framebuffer.color);
@@ -8071,8 +8169,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,
@@ -8084,10 +8182,12 @@ void RasterizerGLES2::_update_framebuffer() {
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+ base_size/=3;
+
DEBUG_TEST_ERROR("Shadow Buffer Init");
ERR_CONTINUE( status != GL_FRAMEBUFFER_COMPLETE );
- base_size/=3;
framebuffer.luminance.push_back(lb);
}
@@ -8238,6 +8338,7 @@ void RasterizerGLES2::init() {
// use_attribute_instancing=true;
use_texture_instancing=false;
use_attribute_instancing=true;
+ full_float_fb_supported=true;
#ifdef OSX_ENABLED
use_rgba_shadowmaps=true;
use_fp16_fb=false;
@@ -8290,9 +8391,11 @@ void RasterizerGLES2::init() {
}
if (use_fp16_fb) {
- use_fp16_fb=extensions.has("GL_OES_texture_half_float") && extensions.has("GL_EXT_color_buffer_half_float");
+ use_fp16_fb=extensions.has("GL_OES_texture_half_float") && extensions.has("GL_EXT_color_buffer_half_float") && extensions.has("GL_EXT_texture_rg");
}
+ full_float_fb_supported=extensions.has("GL_EXT_color_buffer_float");
+
//etc_supported=false;
use_hw_skeleton_xform=false;
diff --git a/drivers/gles2/rasterizer_gles2.h b/drivers/gles2/rasterizer_gles2.h
index dce096b29e..83365f2feb 100644
--- a/drivers/gles2/rasterizer_gles2.h
+++ b/drivers/gles2/rasterizer_gles2.h
@@ -79,6 +79,7 @@ class RasterizerGLES2 : public Rasterizer {
bool npo2_textures_available;
bool read_depth_supported;
bool use_framebuffers;
+ bool full_float_fb_supported;
bool use_shadow_mapping;
bool use_fp16_fb;
ShadowFilterTechnique shadow_filter;
@@ -90,6 +91,7 @@ class RasterizerGLES2 : public Rasterizer {
bool use_texture_instancing;
bool use_attribute_instancing;
bool use_rgba_shadowmaps;
+
bool use_half_float;
@@ -161,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;
@@ -191,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;
@@ -209,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;
@@ -239,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;
@@ -588,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;
@@ -633,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;
@@ -779,9 +781,22 @@ class RasterizerGLES2 : public Rasterizer {
bool *additive_ptr;
bool additive;
bool mirror;
- uint16_t light;
- uint8_t light_type;
- uint8_t sort_flags;
+ union {
+#ifdef BIG_ENDIAN_ENABLED
+ struct {
+ uint8_t sort_flags;
+ uint8_t light_type;
+ uint16_t light;
+ };
+#else
+ struct {
+ uint16_t light;
+ uint8_t light_type;
+ uint8_t sort_flags;
+ };
+#endif
+ uint32_t sort_key;
+ };
};
@@ -894,27 +909,22 @@ class RasterizerGLES2 : public Rasterizer {
_FORCE_INLINE_ bool operator()(const Element* A, const Element* B ) const {
- if (A->sort_flags == B->sort_flags) {
- if (A->light_type == B->light_type) {
- if (A->material->shader_cache == B->material->shader_cache) {
- if (A->material == B->material) {
-
- return (A->geometry_cmp < B->geometry_cmp);
- } else {
+ if (A->sort_key == B->sort_key) {
+ if (A->material->shader_cache == B->material->shader_cache) {
+ if (A->material == B->material) {
- return (A->material < B->material);
- }
+ return (A->geometry_cmp < B->geometry_cmp);
} else {
- return (A->material->shader_cache < B->material->shader_cache);
+ return (A->material < B->material);
}
} else {
- return A->light_type < B->light_type;
+ return (A->material->shader_cache < B->material->shader_cache);
}
} else {
- return A->sort_flags < B->sort_flags; //one is null and one is not
+ return A->sort_key < B->sort_key; //one is null and one is not
}
}
};
@@ -1170,9 +1180,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;
@@ -1190,11 +1202,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 6d78c69e50..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,25 +453,37 @@ 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
- highp float vd_lum=texture2D( source_vd_lum, vec2(0.0) );
+ highp float vd_lum=texture2D( source_vd_lum, vec2(0.0) ).r;
lum_accum = clamp( vd_lum + (lum_accum-vd_lum)*hdr_time_delta*hdr_exp_adj_speed,min_luminance,max_luminance);
#endif
@@ -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 3aed9820ed..17365ea264 100644
--- a/drivers/gles2/shaders/material.glsl
+++ b/drivers/gles2/shaders/material.glsl
@@ -31,6 +31,8 @@ attribute vec4 color_attrib; // attrib:3
attribute vec2 uv_attrib; // attrib:4
attribute vec2 uv2_attrib; // attrib:5
+uniform float normal_mult;
+
#ifdef USE_SKELETON
attribute vec4 bone_indices; // attrib:6
attribute vec4 bone_weights; // attrib:7
@@ -115,7 +117,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 +133,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)
@@ -232,8 +234,10 @@ void main() {
#endif
highp vec4 vertex_in = vertex_attrib; // vec4(vertex_attrib.xyz * data_attrib.x,1.0);
vec3 normal_in = normal_attrib;
+ normal_in*=normal_mult;
#if defined(ENABLE_TANGENT_INTERP)
vec3 tangent_in = tangent_attrib.xyz;
+ tangent_in*=normal_mult;
#endif
#ifdef USE_SKELETON
@@ -404,7 +408,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 +514,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;
-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) {
+#ifdef USE_FRAGMENT_LIGHTING
- 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
@@ -548,6 +540,7 @@ uniform highp float ambient_octree_lattice_size;
uniform highp vec2 ambient_octree_pix_size;
uniform highp float ambient_octree_lattice_divide;
uniform highp sampler2D ambient_octree_tex;
+uniform float ambient_octree_multiplier;
uniform int ambient_octree_steps;
#endif
@@ -769,9 +762,12 @@ void main() {
bool discard_=false;
#endif
+{
+
FRAGMENT_SHADER_CODE
+}
#if defined(ENABLE_DISCARD)
if (discard_) {
@@ -824,7 +820,7 @@ FRAGMENT_SHADER_CODE
vec3 col_up=texture2D(ambient_octree_tex,octant_uv).rgb;
octant_uv.y+=ambient_octree_pix_size.y*2.0;
vec3 col_down=texture2D(ambient_octree_tex,octant_uv).rgb;
- ambientmap_color=mix(col_up,col_down,sub.z);
+ ambientmap_color=mix(col_up,col_down,sub.z)*ambient_octree_multiplier;
ambientmap_color*=diffuse.rgb;
@@ -1008,9 +1004,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
@@ -1022,7 +1017,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
@@ -1039,11 +1033,52 @@ 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 = const_light_mult * ambient_light *diffuse.rgb + light * attenuation * shadow_attenuation;
+
+#ifdef USE_FOG
+
+ diffuse.rgb = mix(diffuse.rgb,fog_interp.rgb,fog_interp.a);
+
+# if defined(LIGHT_TYPE_OMNI) || defined (LIGHT_TYPE_SPOT)
+ diffuse.rgb = mix(mix(vec3(0.0),diffuse.rgb,attenuation),diffuse.rgb,const_light_mult);
+# endif
+
#endif
+ }
+
+
+# endif
+
# if !defined(LIGHT_TYPE_DIRECTIONAL) && !defined(LIGHT_TYPE_OMNI) && !defined (LIGHT_TYPE_SPOT)
//none
#ifndef SHADELESS
@@ -1061,9 +1096,10 @@ FRAGMENT_SHADER_CODE
#ifdef USE_VERTEX_LIGHTING
- vec3 ambient = light_ambient*diffuse.rgb;
+ vec3 ambient = const_light_mult*ambient_light*diffuse.rgb;
# if defined(LIGHT_TYPE_OMNI) || defined (LIGHT_TYPE_SPOT)
ambient*=diffuse_interp.a; //attenuation affects ambient too
+
# endif
// diffuse.rgb=(diffuse.rgb * diffuse_interp.rgb + specular * specular_interp)*shadow_attenuation + ambient;
@@ -1071,6 +1107,16 @@ FRAGMENT_SHADER_CODE
diffuse.rgb=(diffuse.rgb * diffuse_interp.rgb + specular * specular_interp)*shadow_attenuation + ambient;
diffuse.rgb+=emission * const_light_mult;
+#ifdef USE_FOG
+
+ diffuse.rgb = mix(diffuse.rgb,fog_interp.rgb,fog_interp.a);
+
+# if defined(LIGHT_TYPE_OMNI) || defined (LIGHT_TYPE_SPOT)
+ diffuse.rgb = mix(mix(vec3(0.0),diffuse.rgb,diffuse_interp.a),diffuse.rgb,const_light_mult);
+# endif
+
+#endif
+
#endif
@@ -1097,10 +1143,7 @@ FRAGMENT_SHADER_CODE
#else
-#ifdef USE_FOG
- diffuse.rgb = mix(diffuse.rgb,fog_interp.rgb,fog_interp.a);
-#endif
#ifdef USE_GLOW
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-27 23:43:25 +0000