Misc Fixes
========== -NOTIFICATION_WM_QUIT fixed on android (seems tha way this is reported changed in newer sdk) -WIP implementation of APK Expansion APIs for publishing games larger than 50mb in Play Store -Feaures in the new tutorials are all present in the sourcecode -This (hopefully) should get rid of the animation list order getting corrupted -Improved 3D Scene Importer (Skeletons, Animations and other stuff were not being merged). Anything missing? -In code editor, the automatic syntax checker will only use file_exists() to check preload() else it might freeze the editor too much while typing if the preload is a big resource -Fixed bugs in PolygonPathFinder, stil pending to do a node and a demo
This commit is contained in:
Juan Linietsky
@ -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,39 +1110,21 @@ 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];
|
||||
|
||||
ERR_FAIL_COND_V(!material,VS::MATERIAL_DEPTH_DRAW_ALWAYS);
|
||||
return material->depth_draw_mode;
|
||||
}
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
|
||||
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,
|
||||
|
||||
@ -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;
|
||||
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -181,6 +181,13 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
|
||||
flags->use_tangent_interp=true;
|
||||
}
|
||||
|
||||
}
|
||||
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";
|
||||
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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++;
|
||||
|
||||
@ -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);
|
||||
|
||||
|
||||
@ -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
|
||||
@ -450,6 +493,10 @@ void main() {
|
||||
highp vec4 comp = fract(lum_accum * 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);
|
||||
color=comp;
|
||||
#else
|
||||
#ifdef USE_AUTOWHITE
|
||||
color.r=lum_accum;
|
||||
color.g=lum_max;
|
||||
#else
|
||||
color.rgb=vec3(lum_accum);
|
||||
#endif
|
||||
@ -457,6 +504,10 @@ void main() {
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#ifdef USE_RGBE
|
||||
|
||||
color.rgb = pow(color.rgb,color.a*255.0-(8.0+128.0));
|
||||
|
||||
@ -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,28 +510,16 @@ 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;
|
||||
|
||||
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
|
||||
# endif
|
||||
@ -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
|
||||
|
||||
Reference in New Issue
Block a user