asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2D Shaders are working again using the new syntax, though all is buggy in general

Browse source
This commit is contained in:
Juan Linietsky 2016-10-10 18:31:01 -03:00
parent 850eaf7ed7
commit 1527cf8c0d
26 changed files with 1980 additions and 173 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
core/error_macros.h
View file

@ -49,7 +49,8 @@
enum ErrorHandlerType {
ERR_HANDLER_ERROR,
ERR_HANDLER_WARNING,
ERR_HANDLER_SCRIPT
ERR_HANDLER_SCRIPT,
ERR_HANDLER_SHADER,
};
typedef void (*ErrorHandlerFunc)(void*,const char*,const char*,int p_line,const char *, const char *,ErrorHandlerType p_type);

1
core/os/os.cpp
View file

@ -68,6 +68,7 @@ void OS::print_error(const char* p_function,const char* p_file,int p_line,const
case ERR_ERROR: err_type="**ERROR**"; break;
case ERR_WARNING: err_type="**WARNING**"; break;
case ERR_SCRIPT: err_type="**SCRIPT ERROR**"; break;
case ERR_SHADER: err_type="**SHADER ERROR**"; break;
}
if (p_rationale && *p_rationale)

3
core/os/os.h
View file

@ -120,7 +120,8 @@ public:
enum ErrorType {
ERR_ERROR,
ERR_WARNING,
ERR_SCRIPT
ERR_SCRIPT,
ERR_SHADER
};
virtual void print_error(const char* p_function,const char* p_file,int p_line,const char *p_code,const char*p_rationale,ErrorType p_type=ERR_ERROR);

3
core/pair.h
View file

@ -34,6 +34,9 @@ struct Pair {
F first;
S second;
Pair() {}
Pair( F p_first, S p_second) { first=p_first; second=p_second; }
};
#endif // PAIR_H

145
drivers/gles3/rasterizer_canvas_gles3.cpp
View file

@ -138,6 +138,7 @@ void RasterizerCanvasGLES3::canvas_begin(){
state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_DISTANCE_FIELD,false);
state.canvas_shader.set_custom_shader(0);
state.canvas_shader.bind();
state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,Color(1,1,1,1));
state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,Matrix32());
@ -520,6 +521,8 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
//err..
}
state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
glVertexAttrib4f(1,rect->rect.pos.x,rect->rect.pos.y,rect->rect.size.x,rect->rect.size.y);
glVertexAttrib4f(2,src_rect.pos.x,src_rect.pos.y,src_rect.size.x,src_rect.size.y);
@ -567,6 +570,8 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
#define DSTRECT(m_x,m_y,m_w,m_h) glVertexAttrib4f(1,m_x,m_y,m_w,m_h)
#define SRCRECT(m_x,m_y,m_w,m_h) glVertexAttrib4f(2,(m_x)*texpixel_size.x,(m_y)*texpixel_size.y,(m_w)*texpixel_size.x,(m_h)*texpixel_size.y)
@ -634,8 +639,13 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
ERR_CONTINUE( primitive->points.size()<1);
_bind_canvas_texture(primitive->texture);
RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(primitive->texture);
if (texture ) {
Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
}
if (primitive->colors.size()==1 && primitive->points.size()>1) {
Color c = primitive->colors[0];
@ -652,6 +662,14 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item,Item *curr
Item::CommandPolygon* polygon = static_cast<Item::CommandPolygon*>(c);
_set_texture_rect_mode(false);
RasterizerStorageGLES3::Texture* texture = _bind_canvas_texture(polygon->texture);
if (texture ) {
Size2 texpixel_size( 1.0/texture->width, 1.0/texture->height );
state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE,texpixel_size);
}
_draw_polygon(polygon->count,polygon->indices.ptr(),polygon->points.ptr(),polygon->uvs.ptr(),polygon->colors.ptr(),polygon->texture,polygon->colors.size()==1);
} break;
@ -800,10 +818,14 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
int last_blend_mode=-1;
RID canvas_last_material;
bool prev_distance_field=false;
while(p_item_list) {
Item *ci=p_item_list;
@ -878,53 +900,71 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
RID material = material_owner->material;
if (material!=canvas_last_material || rebind_shader) {
#if 0
Shader *shader = NULL;
if (material && material->shader.is_valid()) {
shader = shader_owner.get(material->shader);
if (shader && !shader->valid) {
shader=NULL;
RasterizerStorageGLES3::Material *material_ptr = storage->material_owner.getornull(material);
RasterizerStorageGLES3::Shader *shader_ptr = NULL;
if (material_ptr) {
shader_ptr = material_ptr->shader;
if (shader_ptr && shader_ptr->mode!=VS::SHADER_CANVAS_ITEM) {
shader_ptr=NULL; //do not use non canvasitem shader
}
}
shader_cache=shader;
if (shader) {
canvas_shader.set_custom_shader(shader->custom_code_id);
_canvas_item_setup_shader_params(material,shader);
} else {
shader_cache=NULL;
canvas_shader.set_custom_shader(0);
canvas_shader.bind();
uses_texpixel_size=false;
if (shader_ptr && shader_ptr!=shader_cache) {
state.canvas_shader.set_custom_shader(shader_ptr->custom_code_id);
state.canvas_shader.bind();
if (material_ptr->ubo_id) {
glBindBufferBase(GL_UNIFORM_BUFFER,2,material_ptr->ubo_id);
}
int tc = material_ptr->textures.size();
RID* textures = material_ptr->textures.ptr();
for(int i=0;i<tc;i++) {
glActiveTexture(GL_TEXTURE1+i);
RasterizerStorageGLES3::Texture *t = storage->texture_owner.getornull( textures[i] );
if (!t) {
//check hints
glBindTexture(GL_TEXTURE_2D,storage->resources.white_tex);
continue;
}
glBindTexture(t->target,t->tex_id);
}
} else if (!shader_ptr) {
state.canvas_shader.set_custom_shader(0);
state.canvas_shader.bind();
}
shader_cache=shader_ptr;
canvas_shader.set_uniform(CanvasShaderGLES3::PROJECTION_MATRIX,canvas_transform);
if (canvas_use_modulate)
reset_modulate=true;
canvas_last_material=material;
rebind_shader=false;
#endif
}
if (material.is_valid() && shader_cache) {
#if 0
_canvas_item_setup_shader_uniforms(material,shader_cache);
#endif
}
bool unshaded = false; //(material && material->shading_mode==VS::CANVAS_ITEM_SHADING_UNSHADED) || ci->blend_mode!=VS::MATERIAL_BLEND_MODE_MIX;
int blend_mode = shader_cache ? shader_cache->canvas_item.blend_mode : RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX;
bool unshaded = shader_cache && (shader_cache->canvas_item.light_mode==RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_UNSHADED || blend_mode!=RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX);
bool reclip=false;
#if 0
if (ci==p_item_list || ci->blend_mode!=canvas_blend_mode) {
switch(ci->blend_mode) {
if (last_blend_mode!=blend_mode) {
case VS::MATERIAL_BLEND_MODE_MIX: {
switch(blend_mode) {
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX: {
glBlendEquation(GL_FUNC_ADD);
if (current_rt && current_rt_transparent) {
if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
else {
@ -932,33 +972,30 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
}
} break;
case VS::MATERIAL_BLEND_MODE_ADD: {
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_ADD: {
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
} break;
case VS::MATERIAL_BLEND_MODE_SUB: {
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_SUB: {
glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
} break;
case VS::MATERIAL_BLEND_MODE_MUL: {
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MUL: {
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_DST_COLOR,GL_ZERO);
} break;
case VS::MATERIAL_BLEND_MODE_PREMULT_ALPHA: {
case RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA: {
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
} break;
}
canvas_blend_mode=ci->blend_mode;
last_blend_mode=blend_mode;
}
#endif
// canvas_shader.set_uniform(CanvasShaderGLES3::CANVAS_MODULATE,unshaded ? Color(1,1,1,1) : p_modulate);
state.canvas_item_modulate = unshaded ? ci->final_modulate : Color(
ci->final_modulate.r * p_modulate.r,
@ -974,10 +1011,10 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,state.extra_matrix);
if (unshaded || (state.canvas_item_modulate.a>0.001 && (!material.is_valid() /*|| material->shading_mode!=VS::CANVAS_ITEM_SHADING_ONLY_LIGHT*/) && !ci->light_masked ))
if (unshaded || (state.canvas_item_modulate.a>0.001 && (!shader_cache || shader_cache->canvas_item.light_mode!=RasterizerStorageGLES3::Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY) && !ci->light_masked ))
_canvas_item_render_commands(ci,current_clip,reclip);
if (/*canvas_blend_mode==VS::MATERIAL_BLEND_MODE_MIX &&*/ p_light && !unshaded) {
if ((blend_mode==RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_MIX || RasterizerStorageGLES3::Shader::CanvasItem::BLEND_MODE_PMALPHA) && p_light && !unshaded) {
Light *light = p_light;
bool light_used=false;
@ -1046,12 +1083,7 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
bool light_rebind = state.canvas_shader.bind();
if (light_rebind) {
#if 0
if (material && shader_cache) {
_canvas_item_setup_shader_params(material,shader_cache);
_canvas_item_setup_shader_uniforms(material,shader_cache);
}
#endif
state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
state.canvas_shader.set_uniform(CanvasShaderGLES3::MODELVIEW_MATRIX,state.final_transform);
state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
@ -1100,15 +1132,12 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF9,false);
state.canvas_shader.set_conditional(CanvasShaderGLES3::SHADOW_FILTER_PCF13,false);
state.canvas_shader.bind();
#if 0
if (material && shader_cache) {
_canvas_item_setup_shader_params(material,shader_cache);
_canvas_item_setup_shader_uniforms(material,shader_cache);
}
#endif
last_blend_mode=-1;
/*
//this is set again, so it should not be needed anyway?
state.canvas_item_modulate = unshaded ? ci->final_modulate : Color(
ci->final_modulate.r * p_modulate.r,
ci->final_modulate.g * p_modulate.g,
@ -1120,7 +1149,6 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
state.canvas_shader.set_uniform(CanvasShaderGLES3::EXTRA_MATRIX,Matrix32());
state.canvas_shader.set_uniform(CanvasShaderGLES3::FINAL_MODULATE,state.canvas_item_modulate);
glBlendEquation(GL_FUNC_ADD);
if (storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
@ -1130,6 +1158,7 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list,int p_z,const
}
//@TODO RESET canvas_blend_mode
*/
}
@ -1380,6 +1409,9 @@ void RasterizerCanvasGLES3::reset_canvas() {
state.vp=canvas_transform;
store_transform(canvas_transform,state.canvas_item_ubo_data.projection_matrix);
for(int i=0;i<4;i++) {
state.canvas_item_ubo_data.time[i]=storage->frame.time[i];
}
glBindBuffer(GL_UNIFORM_BUFFER, state.canvas_item_ubo);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(CanvasItemUBO), &state.canvas_item_ubo_data);
@ -1442,6 +1474,7 @@ void RasterizerCanvasGLES3::initialize() {
glBindBuffer(GL_UNIFORM_BUFFER, 0);
state.canvas_shader.init();
state.canvas_shader.set_base_material_tex_index(1);
state.canvas_shadow_shader.init();
state.canvas_shader.set_conditional(CanvasShaderGLES3::USE_RGBA_SHADOWS,storage->config.use_rgba_2d_shadows);

2
drivers/gles3/rasterizer_canvas_gles3.h
View file

@ -5,12 +5,14 @@
#include "rasterizer_storage_gles3.h"
#include "shaders/canvas_shadow.glsl.h"
class RasterizerCanvasGLES3 : public RasterizerCanvas {
public:
struct CanvasItemUBO {
float projection_matrix[16];
float time[4];
};

10
drivers/gles3/rasterizer_gles3.cpp
View file

@ -115,8 +115,17 @@ void RasterizerGLES3::initialize() {
void RasterizerGLES3::begin_frame(){
double time_total = double(OS::get_singleton()->get_ticks_usec())/1000000.0;
storage->frame.time[0]=time_total;
storage->frame.time[1]=Math::fmod(time_total,3600);
storage->frame.time[2]=Math::fmod(time_total,900);
storage->frame.time[3]=Math::fmod(time_total,60);
storage->update_dirty_shaders();
storage->update_dirty_materials();
}
void RasterizerGLES3::set_current_render_target(RID p_render_target){
if (!p_render_target.is_valid() && storage->frame.current_rt && storage->frame.clear_request) {
@ -257,6 +266,7 @@ RasterizerGLES3::RasterizerGLES3()
storage = memnew( RasterizerStorageGLES3 );
canvas = memnew( RasterizerCanvasGLES3 );
canvas->storage=storage;
storage->canvas=canvas;
}

899
drivers/gles3/rasterizer_storage_gles3.cpp
View file

@ -1,4 +1,5 @@
#include "rasterizer_storage_gles3.h"
#include "rasterizer_canvas_gles3.h"
#include "globals.h"
/* TEXTURE API */
@ -1000,65 +1001,906 @@ void RasterizerStorageGLES3::texture_set_shrink_all_x2_on_set_data(bool p_enable
RID RasterizerStorageGLES3::shader_create(VS::ShaderMode p_mode){
return RID();
Shader *shader = memnew( Shader );
shader->mode=p_mode;
RID rid = shader_owner.make_rid(shader);
shader_set_mode(rid,p_mode);
_shader_make_dirty(shader);
shader->self=rid;
return rid;
}
void RasterizerStorageGLES3::_shader_make_dirty(Shader* p_shader) {
if (p_shader->dirty_list.in_list())
return;
_shader_dirty_list.add(&p_shader->dirty_list);
}
void RasterizerStorageGLES3::shader_set_mode(RID p_shader,VS::ShaderMode p_mode){
ERR_FAIL_INDEX(p_mode,VS::SHADER_MAX);
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
if (shader->custom_code_id && p_mode==shader->mode)
return;
if (shader->custom_code_id) {
shader->shader->free_custom_shader(shader->custom_code_id);
shader->custom_code_id=0;
}
shader->mode=p_mode;
ShaderGLES3* shaders[VS::SHADER_MAX]={
&canvas->state.canvas_shader,
&canvas->state.canvas_shader,
&canvas->state.canvas_shader,
};
shader->shader=shaders[p_mode];
shader->custom_code_id = shader->shader->create_custom_shader();
_shader_make_dirty(shader);
}
VS::ShaderMode RasterizerStorageGLES3::shader_get_mode(RID p_shader) const {
return VS::SHADER_SPATIAL;
const Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND_V(!shader,VS::SHADER_MAX);
return shader->mode;
}
void RasterizerStorageGLES3::shader_set_code(RID p_shader, const String& p_code){
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
shader->code=p_code;
_shader_make_dirty(shader);
}
String RasterizerStorageGLES3::shader_get_code(RID p_shader) const{
return String();
const Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND_V(!shader,String());
return shader->code;
}
void RasterizerStorageGLES3::_update_shader(Shader* p_shader) const {
_shader_dirty_list.remove( &p_shader->dirty_list );
p_shader->valid=false;
p_shader->uniforms.clear();
ShaderCompilerGLES3::GeneratedCode gen_code;
ShaderCompilerGLES3::IdentifierActions *actions=NULL;
switch(p_shader->mode) {
case VS::SHADER_CANVAS_ITEM: {
p_shader->canvas_item.light_mode=Shader::CanvasItem::LIGHT_MODE_NORMAL;
p_shader->canvas_item.blend_mode=Shader::CanvasItem::BLEND_MODE_MIX;
shaders.actions_canvas.render_mode_values["blend_add"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_ADD);
shaders.actions_canvas.render_mode_values["blend_mix"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_MIX);
shaders.actions_canvas.render_mode_values["blend_sub"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_SUB);
shaders.actions_canvas.render_mode_values["blend_mul"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_MUL);
shaders.actions_canvas.render_mode_values["blend_premul_alpha"]=Pair<int*,int>(&p_shader->canvas_item.blend_mode,Shader::CanvasItem::BLEND_MODE_PMALPHA);
shaders.actions_canvas.render_mode_values["unshaded"]=Pair<int*,int>(&p_shader->canvas_item.light_mode,Shader::CanvasItem::LIGHT_MODE_UNSHADED);
shaders.actions_canvas.render_mode_values["light_only"]=Pair<int*,int>(&p_shader->canvas_item.light_mode,Shader::CanvasItem::LIGHT_MODE_LIGHT_ONLY);
actions=&shaders.actions_canvas;
actions->uniforms=&p_shader->uniforms;
} break;
}
Error err = shaders.compiler.compile(p_shader->mode,p_shader->code,actions,p_shader->path,gen_code);
ERR_FAIL_COND(err!=OK);
p_shader->shader->set_custom_shader_code(p_shader->custom_code_id,gen_code.vertex,gen_code.vertex_global,gen_code.fragment,gen_code.light,gen_code.fragment_global,gen_code.uniforms,gen_code.texture_uniforms,gen_code.defines);
p_shader->ubo_size=gen_code.uniform_total_size;
p_shader->ubo_offsets=gen_code.uniform_offsets;
p_shader->texture_count=gen_code.texture_uniforms.size();
//all materials using this shader will have to be invalidated, unfortunately
for (SelfList<Material>* E = p_shader->materials.first();E;E=E->next() ) {
_material_make_dirty(E->self());
}
p_shader->valid=true;
p_shader->version++;
}
void RasterizerStorageGLES3::update_dirty_shaders() {
while( _shader_dirty_list.first() ) {
_update_shader(_shader_dirty_list.first()->self() );
}
}
void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const{
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
if (shader->dirty_list.in_list())
_update_shader(shader); // ok should be not anymore dirty
Map<int,StringName> order;
for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) {
order[E->get().order]=E->key();
}
for(Map<int,StringName>::Element *E=order.front();E;E=E->next()) {
PropertyInfo pi;
ShaderLanguage::ShaderNode::Uniform &u=shader->uniforms[E->get()];
pi.name=E->get();
switch(u.type) {
case ShaderLanguage::TYPE_VOID: pi.type=Variant::NIL; break;
case ShaderLanguage::TYPE_BOOL: pi.type=Variant::BOOL; break;
case ShaderLanguage::TYPE_BVEC2: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y"; break;
case ShaderLanguage::TYPE_BVEC3: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y,z"; break;
case ShaderLanguage::TYPE_BVEC4: pi.type=Variant::INT; pi.hint=PROPERTY_HINT_FLAGS; pi.hint_string="x,y,z,w"; break;
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_INT: {
pi.type=Variant::INT;
if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint=PROPERTY_HINT_RANGE;
pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1]);
}
} break;
case ShaderLanguage::TYPE_IVEC2:
case ShaderLanguage::TYPE_IVEC3:
case ShaderLanguage::TYPE_IVEC4:
case ShaderLanguage::TYPE_UVEC2:
case ShaderLanguage::TYPE_UVEC3:
case ShaderLanguage::TYPE_UVEC4: {
pi.type=Variant::INT_ARRAY;
} break;
case ShaderLanguage::TYPE_FLOAT: {
pi.type=Variant::REAL;
if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint=PROPERTY_HINT_RANGE;
pi.hint_string=rtos(u.hint_range[0])+","+rtos(u.hint_range[1])+","+rtos(u.hint_range[2]);
}
} break;
case ShaderLanguage::TYPE_VEC2: pi.type=Variant::VECTOR2; break;
case ShaderLanguage::TYPE_VEC3: pi.type=Variant::VECTOR3; break;
case ShaderLanguage::TYPE_VEC4: {
if (u.hint==ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
pi.type=Variant::COLOR;
} else {
pi.type=Variant::PLANE;
}
} break;
case ShaderLanguage::TYPE_MAT2: pi.type=Variant::MATRIX32; break;
case ShaderLanguage::TYPE_MAT3: pi.type=Variant::MATRIX3; break;
case ShaderLanguage::TYPE_MAT4: pi.type=Variant::TRANSFORM; break;
case ShaderLanguage::TYPE_SAMPLER2D:
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER2D: {
pi.type=Variant::OBJECT;
pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string="Texture";
} break;
case ShaderLanguage::TYPE_SAMPLERCUBE: {
pi.type=Variant::OBJECT;
pi.hint=PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string="CubeMap";
} break;
};
p_param_list->push_back(pi);
}
}
void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture){
Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND(!shader);
ERR_FAIL_COND(p_texture.is_valid() && !texture_owner.owns(p_texture));
if (p_texture.is_valid())
shader->default_textures[p_name]=p_texture;
else
shader->default_textures.erase(p_name);
_shader_make_dirty(shader);
}
RID RasterizerStorageGLES3::shader_get_default_texture_param(RID p_shader, const StringName& p_name) const{
return RID();
const Shader *shader=shader_owner.get(p_shader);
ERR_FAIL_COND_V(!shader,RID());
const Map<StringName,RID>::Element *E=shader->default_textures.find(p_name);
if (!E)
return RID();
return E->get();
}
/* COMMON MATERIAL API */
void RasterizerStorageGLES3::_material_make_dirty(Material* p_material) const {
if (p_material->dirty_list.in_list())
return;
_material_dirty_list.add(&p_material->dirty_list);
}
RID RasterizerStorageGLES3::material_create(){
return RID();
Material *material = memnew( Material );
return material_owner.make_rid(material);
}
void RasterizerStorageGLES3::material_set_shader(RID p_shader_material, RID p_shader){
void RasterizerStorageGLES3::material_set_shader(RID p_material, RID p_shader){
Material *material = material_owner.get( p_material );
ERR_FAIL_COND(!material);
Shader *shader=shader_owner.getornull(p_shader);
if (material->shader) {
//if shader, remove from previous shader material list
material->shader->materials.remove( &material->list );
}
material->shader=shader;
if (shader) {
shader->materials.add(&material->list);
}
_material_make_dirty(material);
}
RID RasterizerStorageGLES3::material_get_shader(RID p_shader_material) const{
RID RasterizerStorageGLES3::material_get_shader(RID p_material) const{
const Material *material = material_owner.get( p_material );
ERR_FAIL_COND_V(!material,RID());
if (material->shader)
return material->shader->self;
return RID();
}
void RasterizerStorageGLES3::material_set_param(RID p_material, const StringName& p_param, const Variant& p_value){
Material *material = material_owner.get( p_material );
ERR_FAIL_COND(!material);
if (p_value.get_type()==Variant::NIL)
material->params.erase(p_param);
else
material->params[p_param]=p_value;
_material_make_dirty(material);
}
Variant RasterizerStorageGLES3::material_get_param(RID p_material, const StringName& p_param) const{
const Material *material = material_owner.get( p_material );
ERR_FAIL_COND_V(!material,RID());
if (material->params.has(p_param))
return material->params[p_param];
return Variant();
}
_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, const Variant& value, uint8_t *data) {
switch(type) {
case ShaderLanguage::TYPE_BOOL: {
bool v = value;
GLuint *gui = (GLuint*)data;
*gui = v ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC2: {
int v = value;
GLuint *gui = (GLuint*)data;
gui[0]=v&1 ? GL_TRUE : GL_FALSE;
gui[1]=v&2 ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC3: {
int v = value;
GLuint *gui = (GLuint*)data;
gui[0]=v&1 ? GL_TRUE : GL_FALSE;
gui[1]=v&2 ? GL_TRUE : GL_FALSE;
gui[2]=v&4 ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC4: {
int v = value;
GLuint *gui = (GLuint*)data;
gui[0]=v&1 ? GL_TRUE : GL_FALSE;
gui[1]=v&2 ? GL_TRUE : GL_FALSE;
gui[2]=v&4 ? GL_TRUE : GL_FALSE;
gui[3]=v&8 ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_INT: {
int v = value;
GLint *gui = (GLint*)data;
gui[0]=v;
} break;
case ShaderLanguage::TYPE_IVEC2: {
DVector<int> iv = value;
int s = iv.size();
GLint *gui = (GLint*)data;
DVector<int>::Read r = iv.read();
for(int i=0;i<2;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_IVEC3: {
DVector<int> iv = value;
int s = iv.size();
GLint *gui = (GLint*)data;
DVector<int>::Read r = iv.read();
for(int i=0;i<3;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
DVector<int> iv = value;
int s = iv.size();
GLint *gui = (GLint*)data;
DVector<int>::Read r = iv.read();
for(int i=0;i<4;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_UINT: {
int v = value;
GLuint *gui = (GLuint*)data;
gui[0]=v;
} break;
case ShaderLanguage::TYPE_UVEC2: {
DVector<int> iv = value;
int s = iv.size();
GLuint *gui = (GLuint*)data;
DVector<int>::Read r = iv.read();
for(int i=0;i<2;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
DVector<int> iv = value;
int s = iv.size();
GLuint *gui = (GLuint*)data;
DVector<int>::Read r = iv.read();
for(int i=0;i<3;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
DVector<int> iv = value;
int s = iv.size();
GLuint *gui = (GLuint*)data;
DVector<int>::Read r = iv.read();
for(int i=0;i<4;i++) {
if (i<s)
gui[i]=r[i];
else
gui[i]=0;
}
} break;
case ShaderLanguage::TYPE_FLOAT: {
float v = value;
GLfloat *gui = (GLfloat*)data;
gui[0]=v;
} break;
case ShaderLanguage::TYPE_VEC2: {
Vector2 v = value;
GLfloat *gui = (GLfloat*)data;
gui[0]=v.x;
gui[1]=v.y;
} break;
case ShaderLanguage::TYPE_VEC3: {
Vector3 v = value;
GLfloat *gui = (GLfloat*)data;
gui[0]=v.x;
gui[1]=v.y;
gui[2]=v.z;
} break;
case ShaderLanguage::TYPE_VEC4: {
GLfloat *gui = (GLfloat*)data;
if (value.get_type()==Variant::COLOR) {
Color v=value;
gui[0]=v.r;
gui[1]=v.g;
gui[3]=v.b;
gui[4]=v.a;
} else if (value.get_type()==Variant::RECT2) {
Rect2 v=value;
gui[0]=v.pos.x;
gui[1]=v.pos.y;
gui[3]=v.size.x;
gui[4]=v.size.y;
} else if (value.get_type()==Variant::QUAT) {
Quat v=value;
gui[0]=v.x;
gui[1]=v.y;
gui[3]=v.z;
gui[4]=v.w;
} else {
Plane v=value;
gui[0]=v.normal.x;
gui[1]=v.normal.y;
gui[3]=v.normal.x;
gui[4]=v.d;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
Matrix32 v = value;
GLfloat *gui = (GLfloat*)data;
gui[ 0]=v.elements[0][0];
gui[ 1]=v.elements[0][1];
gui[ 2]=v.elements[1][0];
gui[ 3]=v.elements[1][1];
} break;
case ShaderLanguage::TYPE_MAT3: {
Matrix3 v = value;
GLfloat *gui = (GLfloat*)data;
gui[ 0]=v.elements[0][0];
gui[ 1]=v.elements[1][0];
gui[ 2]=v.elements[2][0];
gui[ 3]=0;
gui[ 4]=v.elements[0][1];
gui[ 5]=v.elements[1][1];
gui[ 6]=v.elements[2][1];
gui[ 7]=0;
gui[ 8]=v.elements[0][2];
gui[ 9]=v.elements[1][2];
gui[10]=v.elements[2][2];
gui[11]=0;
} break;
case ShaderLanguage::TYPE_MAT4: {
Transform v = value;
GLfloat *gui = (GLfloat*)data;
gui[ 0]=v.basis.elements[0][0];
gui[ 1]=v.basis.elements[1][0];
gui[ 2]=v.basis.elements[2][0];
gui[ 3]=0;
gui[ 4]=v.basis.elements[0][1];
gui[ 5]=v.basis.elements[1][1];
gui[ 6]=v.basis.elements[2][1];
gui[ 7]=0;
gui[ 8]=v.basis.elements[0][2];
gui[ 9]=v.basis.elements[1][2];
gui[10]=v.basis.elements[2][2];
gui[11]=0;
gui[12]=v.origin.x;
gui[13]=v.origin.y;
gui[14]=v.origin.z;
gui[15]=1;
} break;
default: {}
}
}
_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value>& value, uint8_t *data) {
switch(type) {
case ShaderLanguage::TYPE_BOOL: {
GLuint *gui = (GLuint*)data;
*gui = value[0].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC2: {
GLuint *gui = (GLuint*)data;
gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC3: {
GLuint *gui = (GLuint*)data;
gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_BVEC4: {
GLuint *gui = (GLuint*)data;
gui[0]=value[0].boolean ? GL_TRUE : GL_FALSE;
gui[1]=value[1].boolean ? GL_TRUE : GL_FALSE;
gui[2]=value[2].boolean ? GL_TRUE : GL_FALSE;
gui[3]=value[3].boolean ? GL_TRUE : GL_FALSE;
} break;
case ShaderLanguage::TYPE_INT: {
GLint *gui = (GLint*)data;
gui[0]=value[0].sint;
} break;
case ShaderLanguage::TYPE_IVEC2: {
GLint *gui = (GLint*)data;
for(int i=0;i<2;i++) {
gui[i]=value[i].sint;
}
} break;
case ShaderLanguage::TYPE_IVEC3: {
GLint *gui = (GLint*)data;
for(int i=0;i<3;i++) {
gui[i]=value[i].sint;
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
GLint *gui = (GLint*)data;
for(int i=0;i<4;i++) {
gui[i]=value[i].sint;
}
} break;
case ShaderLanguage::TYPE_UINT: {
GLuint *gui = (GLuint*)data;
gui[0]=value[0].uint;
} break;
case ShaderLanguage::TYPE_UVEC2: {
GLint *gui = (GLint*)data;
for(int i=0;i<2;i++) {
gui[i]=value[i].uint;
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
GLint *gui = (GLint*)data;
for(int i=0;i<3;i++) {
gui[i]=value[i].uint;
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
GLint *gui = (GLint*)data;
for(int i=0;i<4;i++) {
gui[i]=value[i].uint;
}
} break;
case ShaderLanguage::TYPE_FLOAT: {
GLfloat *gui = (GLfloat*)data;
gui[0]=value[0].real;
} break;
case ShaderLanguage::TYPE_VEC2: {
GLfloat *gui = (GLfloat*)data;
for(int i=0;i<2;i++) {
gui[i]=value[i].real;
}
} break;
case ShaderLanguage::TYPE_VEC3: {
GLfloat *gui = (GLfloat*)data;
for(int i=0;i<3;i++) {
gui[i]=value[i].real;
}
} break;
case ShaderLanguage::TYPE_VEC4: {
GLfloat *gui = (GLfloat*)data;
for(int i=0;i<4;i++) {
gui[i]=value[i].real;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
GLfloat *gui = (GLfloat*)data;
for(int i=0;i<2;i++) {
gui[i]=value[i].real;
}
} break;
case ShaderLanguage::TYPE_MAT3: {
GLfloat *gui = (GLfloat*)data;
gui[ 0]=value[0].real;
gui[ 1]=value[1].real;
gui[ 2]=value[2].real;
gui[ 3]=0;
gui[ 4]=value[3].real;
gui[ 5]=value[4].real;
gui[ 6]=value[5].real;
gui[ 7]=0;
gui[ 8]=value[6].real;
gui[ 9]=value[7].real;
gui[10]=value[8].real;
gui[11]=0;
} break;
case ShaderLanguage::TYPE_MAT4: {
GLfloat *gui = (GLfloat*)data;
for(int i=0;i<16;i++) {
gui[i]=value[i].real;
}
} break;
default: {}
}
}
_FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, uint8_t *data) {
switch(type) {
case ShaderLanguage::TYPE_BOOL:
case ShaderLanguage::TYPE_INT:
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_FLOAT: {
zeromem(data,4);
} break;
case ShaderLanguage::TYPE_BVEC2:
case ShaderLanguage::TYPE_IVEC2:
case ShaderLanguage::TYPE_UVEC2:
case ShaderLanguage::TYPE_VEC2: {
zeromem(data,8);
} break;
case ShaderLanguage::TYPE_BVEC3:
case ShaderLanguage::TYPE_IVEC3:
case ShaderLanguage::TYPE_UVEC3:
case ShaderLanguage::TYPE_VEC3:
case ShaderLanguage::TYPE_BVEC4:
case ShaderLanguage::TYPE_IVEC4:
case ShaderLanguage::TYPE_UVEC4:
case ShaderLanguage::TYPE_VEC4:
case ShaderLanguage::TYPE_MAT2:{
zeromem(data,16);
} break;
case ShaderLanguage::TYPE_MAT3:{
zeromem(data,48);
} break;
case ShaderLanguage::TYPE_MAT4:{
zeromem(data,64);
} break;
default: {}
}
}
void RasterizerStorageGLES3::_update_material(Material* material) {
if (material->dirty_list.in_list())
_material_dirty_list.remove( &material->dirty_list );
//clear ubo if it needs to be cleared
if (material->ubo_size) {
if (!material->shader || material->shader->ubo_size!=material->ubo_size) {
//by by ubo
glDeleteBuffers(1,&material->ubo_id);
material->ubo_id=0;
material->ubo_size=0;
}
}
//create ubo if it needs to be created
if (material->ubo_size==0 && material->shader && material->shader->ubo_size) {
glGenBuffers(1, &material->ubo_id);
glBindBuffer(GL_UNIFORM_BUFFER, material->ubo_id);
glBufferData(GL_UNIFORM_BUFFER, material->shader->ubo_size, NULL, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
material->ubo_size=material->shader->ubo_size;
}
//fill up the UBO if it needs to be filled
if (material->shader && material->ubo_size) {
uint8_t* local_ubo = (uint8_t*)alloca(material->ubo_size);
for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
if (E->get().order<0)
continue; // texture, does not go here
//regular uniform
uint8_t *data = &local_ubo[ material->shader->ubo_offsets[E->get().order] ];
Map<StringName,Variant>::Element *V = material->params.find(E->key());
if (V) {
//user provided
_fill_std140_variant_ubo_value(E->get().type,V->get(),data);
} else if (E->get().default_value.size()){
//default value
_fill_std140_ubo_value(E->get().type,E->get().default_value,data);
//value=E->get().default_value;
} else {
//zero because it was not provided
_fill_std140_ubo_empty(E->get().type,data);
}
}
glBindBuffer(GL_UNIFORM_BUFFER,material->ubo_id);
glBufferSubData(GL_UNIFORM_BUFFER, 0, material->ubo_size, local_ubo);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
//set up the texture array, for easy access when it needs to be drawn
if (material->shader && material->shader->texture_count) {
material->textures.resize(material->shader->texture_count);
for(Map<StringName,ShaderLanguage::ShaderNode::Uniform>::Element *E=material->shader->uniforms.front();E;E=E->next()) {
if (E->get().texture_order<0)
continue; // not a texture, does not go here
RID texture;
Map<StringName,Variant>::Element *V = material->params.find(E->key());
if (V) {
texture=V->get();
}
if (!texture.is_valid()) {
Map<StringName,RID>::Element *W = material->shader->default_textures.find(E->key());
if (W) {
texture=W->get();
}
}
material->textures[ E->get().texture_order ]=texture;
}
} else {
material->textures.clear();
}
}
void RasterizerStorageGLES3::update_dirty_materials() {
while( _material_dirty_list.first() ) {
Material *material = _material_dirty_list.first()->self();
_update_material(material);
}
}
/* MESH API */
RID RasterizerStorageGLES3::mesh_create(){
@ -1950,6 +2792,49 @@ bool RasterizerStorageGLES3::free(RID p_rid){
info.texture_mem-=texture->total_data_size;
texture_owner.free(p_rid);
memdelete(texture);
} else if (shader_owner.owns(p_rid)) {
// delete the texture
Shader *shader = shader_owner.get(p_rid);
if (shader->shader)
shader->shader->free_custom_shader(shader->custom_code_id);
if (shader->dirty_list.in_list())
_shader_dirty_list.remove(&shader->dirty_list);
while (shader->materials.first()) {
Material *mat = shader->materials.first()->self();
mat->shader=NULL;
_material_make_dirty(mat);
shader->materials.remove( shader->materials.first() );
}
//material_shader.free_custom_shader(shader->custom_code_id);
shader_owner.free(p_rid);
memdelete(shader);
} else if (material_owner.owns(p_rid)) {
// delete the texture
Material *material = material_owner.get(p_rid);
if (material->shader) {
material->shader->materials.remove( & material->list );
}
if (material->ubo_id) {
glDeleteBuffers(1,&material->ubo_id);
}
material_owner.free(p_rid);
memdelete(material);
} else if (canvas_occluder_owner.owns(p_rid)) {

109
drivers/gles3/rasterizer_storage_gles3.h
View file

@ -2,16 +2,21 @@
#define RASTERIZERSTORAGEGLES3_H
#include "servers/visual/rasterizer.h"
#include "servers/visual/shader_language.h"
#include "shader_gles3.h"
#include "shaders/copy.glsl.h"
#include "shaders/canvas.glsl.h"
#include "self_list.h"
#include "shader_compiler_gles3.h"
class RasterizerCanvasGLES3;
class RasterizerStorageGLES3 : public RasterizerStorage {
public:
RasterizerCanvasGLES3 *canvas;
enum FBOFormat {
FBO_FORMAT_16_BITS,
FBO_FORMAT_32_BITS,
@ -47,9 +52,13 @@ public:
Set<String> extensions;
} config;
struct Shaders {
mutable struct Shaders {
CopyShaderGLES3 copy;
ShaderCompilerGLES3 compiler;
ShaderCompilerGLES3::IdentifierActions actions_canvas;
} shaders;
struct Resources {
@ -169,11 +178,71 @@ public:
/* SHADER API */
struct Material;
struct Shader : public RID_Data {
RID self;
VS::ShaderMode mode;
ShaderGLES3 *shader;
String code;
SelfList<Material>::List materials;
Map<StringName,ShaderLanguage::ShaderNode::Uniform> uniforms;
Vector<uint32_t> ubo_offsets;
uint32_t ubo_size;
uint32_t texture_count;
uint32_t custom_code_id;
uint32_t version;
SelfList<Shader> dirty_list;
Map<StringName,RID> default_textures;
bool valid;
String path;
struct CanvasItem {
enum BlendMode {
BLEND_MODE_MIX,
BLEND_MODE_ADD,
BLEND_MODE_SUB,
BLEND_MODE_MUL,
BLEND_MODE_PMALPHA,
};
int blend_mode;
enum LightMode {
LIGHT_MODE_NORMAL,
LIGHT_MODE_UNSHADED,
LIGHT_MODE_LIGHT_ONLY
};
int light_mode;
} canvas_item;
Shader() : dirty_list(this) {
shader=NULL;
valid=false;
custom_code_id=0;
version=1;
}
};
mutable SelfList<Shader>::List _shader_dirty_list;
void _shader_make_dirty(Shader* p_shader);
mutable RID_Owner<Shader> shader_owner;
virtual RID shader_create(VS::ShaderMode p_mode=VS::SHADER_SPATIAL);
@ -187,17 +256,48 @@ public:
virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture);
virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const;
void _update_shader(Shader* p_shader) const;
void update_dirty_shaders();
/* COMMON MATERIAL API */
struct Material : public RID_Data {
Shader *shader;
GLuint ubo_id;
uint32_t ubo_size;
Map<StringName,Variant> params;
SelfList<Material> list;
SelfList<Material> dirty_list;
Vector<RID> textures;
Material() : list(this), dirty_list(this) {
shader=NULL;
ubo_id=0;
ubo_size=0;
}
};
mutable SelfList<Material>::List _material_dirty_list;
void _material_make_dirty(Material *p_material) const;
mutable RID_Owner<Material> material_owner;
virtual RID material_create();
virtual void material_set_shader(RID p_shader_material, RID p_shader);
virtual RID material_get_shader(RID p_shader_material) const;
virtual void material_set_shader(RID p_material, RID p_shader);
virtual RID material_get_shader(RID p_material) const;
virtual void material_set_param(RID p_material, const StringName& p_param, const Variant& p_value);
virtual Variant material_get_param(RID p_material, const StringName& p_param) const;
void _update_material(Material* material);
void update_dirty_materials();
/* MESH API */
virtual RID mesh_create();
@ -432,6 +532,7 @@ public:
bool clear_request;
Color clear_request_color;
int canvas_draw_commands;
float time[4];
} frame;
void initialize();

528
drivers/gles3/shader_compiler_gles3.cpp Normal file
View file

@ -0,0 +1,528 @@
#include "shader_compiler_gles3.h"
#include "os/os.h"
#define SL ShaderLanguage
static String _mktab(int p_level) {
String tb;
for(int i=0;i<p_level;i++) {
tb+="\t";
}
return tb;
}
static String _typestr(SL::DataType p_type) {
return ShaderLanguage::get_datatype_name(p_type);
}
static int _get_datatype_size(SL::DataType p_type) {
switch(p_type) {
case SL::TYPE_VOID: return 0;
case SL::TYPE_BOOL: return 4;
case SL::TYPE_BVEC2: return 8;
case SL::TYPE_BVEC3: return 16;
case SL::TYPE_BVEC4: return 16;
case SL::TYPE_INT: return 4;
case SL::TYPE_IVEC2: return 8;
case SL::TYPE_IVEC3: return 16;
case SL::TYPE_IVEC4: return 16;
case SL::TYPE_UINT: return 4;
case SL::TYPE_UVEC2: return 8;
case SL::TYPE_UVEC3: return 16;
case SL::TYPE_UVEC4: return 16;
case SL::TYPE_FLOAT: return 4;
case SL::TYPE_VEC2: return 8;
case SL::TYPE_VEC3: return 16;
case SL::TYPE_VEC4: return 16;
case SL::TYPE_MAT2: return 16;
case SL::TYPE_MAT3: return 48;
case SL::TYPE_MAT4: return 64;
case SL::TYPE_SAMPLER2D: return 16;
case SL::TYPE_ISAMPLER2D: return 16;
case SL::TYPE_USAMPLER2D: return 16;
case SL::TYPE_SAMPLERCUBE: return 16;
}
}
static String _prestr(SL::DataPrecision p_pres) {
switch(p_pres) {
case SL::PRECISION_LOWP: return "lowp ";
case SL::PRECISION_MEDIUMP: return "mediump ";
case SL::PRECISION_HIGHP: return "highp ";
case SL::PRECISION_DEFAULT: return "";
}
return "";
}
static String _opstr(SL::Operator p_op) {
return SL::get_operator_text(p_op);
}
static String _mkid(const String& p_id) {
return "m_"+p_id;
}
static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNode::Value>& p_values) {
switch(p_type) {
case SL::TYPE_BOOL: return p_values[0].boolean?"true":"false";
case SL::TYPE_BVEC2: return String()+"bvec2("+(p_values[0].boolean?"true":"false")+(p_values[1].boolean?"true":"false")+")";
case SL::TYPE_BVEC3: return String()+"bvec3("+(p_values[0].boolean?"true":"false")+","+(p_values[1].boolean?"true":"false")+","+(p_values[2].boolean?"true":"false")+")";
case SL::TYPE_BVEC4: return String()+"bvec4("+(p_values[0].boolean?"true":"false")+","+(p_values[1].boolean?"true":"false")+","+(p_values[2].boolean?"true":"false")+","+(p_values[3].boolean?"true":"false")+")";
case SL::TYPE_INT: return rtos(p_values[0].sint);
case SL::TYPE_IVEC2: return String()+"ivec2("+rtos(p_values[0].sint)+","+rtos(p_values[1].sint)+")";
case SL::TYPE_IVEC3: return String()+"ivec3("+rtos(p_values[0].sint)+","+rtos(p_values[1].sint)+","+rtos(p_values[2].sint)+")";
case SL::TYPE_IVEC4: return String()+"ivec4("+rtos(p_values[0].sint)+","+rtos(p_values[1].sint)+","+rtos(p_values[2].sint)+","+rtos(p_values[3].sint)+")";
case SL::TYPE_UINT: return rtos(p_values[0].real);
case SL::TYPE_UVEC2: return String()+"uvec2("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+")";
case SL::TYPE_UVEC3: return String()+"uvec3("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+")";
case SL::TYPE_UVEC4: return String()+"uvec4("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+","+rtos(p_values[3].real)+")";
case SL::TYPE_FLOAT: return rtos(p_values[0].real);
case SL::TYPE_VEC2: return String()+"vec2("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+")";
case SL::TYPE_VEC3: return String()+"vec3("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+")";
case SL::TYPE_VEC4: return String()+"vec4("+rtos(p_values[0].real)+","+rtos(p_values[1].real)+","+rtos(p_values[2].real)+","+rtos(p_values[3].real)+")";
default: ERR_FAIL_V(String());
}
}
void ShaderCompilerGLES3::_dump_function_deps(SL::ShaderNode* p_node, const StringName& p_for_func, const Map<StringName,String>& p_func_code, String& r_to_add, Set<StringName> &added) {
int fidx=-1;
for(int i=0;i<p_node->functions.size();i++) {
if (p_node->functions[i].name==p_for_func) {
fidx=i;
break;
}
}
ERR_FAIL_COND(fidx==-1);
for (Set<StringName>::Element *E=p_node->functions[fidx].uses_function.front();E;E=E->next()) {
if (added.has(E->get())) {
continue; //was added already
}
_dump_function_deps(p_node,E->get(),p_func_code,r_to_add,added);
SL::FunctionNode *fnode=NULL;
for(int i=0;i<p_node->functions.size();i++) {
if (p_node->functions[i].name==E->get()) {
fnode=p_node->functions[i].function;
break;
}
}
ERR_FAIL_COND(!fnode);
r_to_add+="\n";
String header;
header=_typestr(fnode->return_type)+" "+_mkid(fnode->name)+"(";
for(int i=0;i<fnode->arguments.size();i++) {
if (i>0)
header+=", ";
header+=_prestr(fnode->arguments[i].precision)+_typestr(fnode->arguments[i].type)+" "+_mkid(fnode->arguments[i].name);
}
header+=")\n";
r_to_add+=header;
r_to_add+=p_func_code[E->get()];
added.insert(E->get());
}
}
String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, GeneratedCode& r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions) {
String code;
switch(p_node->type) {
case SL::Node::TYPE_SHADER: {
SL::ShaderNode *pnode=(SL::ShaderNode*)p_node;
for(int i=0;i<pnode->render_modes.size();i++) {
if (p_default_actions.render_mode_defines.has(pnode->render_modes[i]) && !used_rmode_defines.has(pnode->render_modes[i])) {
r_gen_code.defines.push_back(p_default_actions.render_mode_defines[pnode->render_modes[i]].utf8());
used_rmode_defines.insert(pnode->render_modes[i]);
}
if (p_actions.render_mode_flags.has(pnode->render_modes[i])) {
*p_actions.render_mode_flags[pnode->render_modes[i]]=true;
}
if (p_actions.render_mode_values.has(pnode->render_modes[i])) {
Pair<int*,int> &p = p_actions.render_mode_values[pnode->render_modes[i]];
*p.first=p.second;
}
}
int max_texture_uniforms=0;
int max_uniforms=0;
for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
if (SL::is_sampler_type(E->get().type))
max_texture_uniforms++;
else
max_uniforms++;
}
r_gen_code.texture_uniforms.resize(max_texture_uniforms);
Vector<int> uniform_sizes;
uniform_sizes.resize(max_uniforms);
for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
String ucode="uniform ";
ucode+=_prestr(E->get().precission);
ucode+=_typestr(E->get().type);
ucode+=" "+_mkid(E->key());
ucode+=";\n";
if (SL::is_sampler_type(E->get().type)) {
r_gen_code.vertex_global+=ucode;
r_gen_code.fragment_global+=ucode;
r_gen_code.texture_uniforms[E->get().texture_order]=_mkid(E->key());
} else {
if (r_gen_code.uniforms.empty()) {
r_gen_code.defines.push_back(String("#define USE_MATERIAL\n").ascii());
}
r_gen_code.uniforms+=ucode;
uniform_sizes[E->get().order]=_get_datatype_size(E->get().type);
}
p_actions.uniforms->insert(E->key(),E->get());
}
// add up
for(int i=0;i<uniform_sizes.size();i++) {
if (i>0)
uniform_sizes[i]=uniform_sizes[i]+uniform_sizes[i-1];
}
//offset
r_gen_code.uniform_offsets.resize(uniform_sizes.size());
for(int i=0;i<uniform_sizes.size();i++) {
if (i>0)
r_gen_code.uniform_offsets[i]=uniform_sizes[i]-1;
else
r_gen_code.uniform_offsets[i]=0;
}
if (uniform_sizes.size()) {
r_gen_code.uniform_total_size=uniform_sizes[ uniform_sizes.size() -1 ];
} else {
r_gen_code.uniform_total_size=0;
}
for(Map<StringName,SL::ShaderNode::Varying>::Element *E=pnode->varyings.front();E;E=E->next()) {
String vcode;
vcode+=_prestr(E->get().precission);
vcode+=_typestr(E->get().type);
vcode+=" "+String(E->key());
vcode+=";\n";
r_gen_code.vertex_global+="out "+vcode;
r_gen_code.fragment_global+="in "+vcode;
}
Map<StringName,String> function_code;
//code for functions
for(int i=0;i<pnode->functions.size();i++) {
SL::FunctionNode *fnode=pnode->functions[i].function;
function_code[fnode->name]=_dump_node_code(fnode->body,p_level+1,r_gen_code,p_actions,p_default_actions);
}
//place functions in actual code
Set<StringName> added_vtx;
Set<StringName> added_fragment; //share for light
for(int i=0;i<pnode->functions.size();i++) {
SL::FunctionNode *fnode=pnode->functions[i].function;
if (fnode->name=="vertex") {
_dump_function_deps(pnode,fnode->name,function_code,r_gen_code.vertex_global,added_vtx);
r_gen_code.vertex=function_code["vertex"];
}
if (fnode->name=="fragment") {
_dump_function_deps(pnode,fnode->name,function_code,r_gen_code.fragment_global,added_fragment);
r_gen_code.fragment=function_code["fragment"];
}
if (fnode->name=="light") {
_dump_function_deps(pnode,fnode->name,function_code,r_gen_code.fragment_global,added_fragment);
r_gen_code.light=function_code["light"];
}
}
//code+=dump_node_code(pnode->body,p_level);
} break;
case SL::Node::TYPE_FUNCTION: {
} break;
case SL::Node::TYPE_BLOCK: {
SL::BlockNode *bnode=(SL::BlockNode*)p_node;
//variables
code+=_mktab(p_level-1)+"{\n";
for(Map<StringName,SL::BlockNode::Variable>::Element *E=bnode->variables.front();E;E=E->next()) {
code+=_mktab(p_level)+_prestr(E->get().precision)+_typestr(E->get().type)+" "+_mkid(E->key())+";\n";
}
for(int i=0;i<bnode->statements.size();i++) {
String scode = _dump_node_code(bnode->statements[i],p_level,r_gen_code,p_actions,p_default_actions);
if (bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW || bnode->statements[i]->type==SL::Node::TYPE_CONTROL_FLOW) {
code+=scode; //use directly
} else {
code+=_mktab(p_level)+scode+";\n";
}
}
code+=_mktab(p_level-1)+"}\n";
} break;
case SL::Node::TYPE_VARIABLE: {
SL::VariableNode *vnode=(SL::VariableNode*)p_node;
if (p_default_actions.usage_defines.has(vnode->name) && !used_name_defines.has(vnode->name)) {
r_gen_code.defines.push_back(p_default_actions.usage_defines[vnode->name].utf8());
used_name_defines.insert(vnode->name);
}
if (p_actions.usage_flag_pointers.has(vnode->name) && !used_name_defines.has(vnode->name)) {
*p_actions.usage_flag_pointers[vnode->name]=true;
used_name_defines.insert(vnode->name);
}
if (p_default_actions.renames.has(vnode->name))
code=p_default_actions.renames[vnode->name];
else
code=_mkid(vnode->name);
} break;
case SL::Node::TYPE_CONSTANT: {
SL::ConstantNode *cnode=(SL::ConstantNode*)p_node;
return get_constant_text(cnode->datatype,cnode->values);
} break;
case SL::Node::TYPE_OPERATOR: {
SL::OperatorNode *onode=(SL::OperatorNode*)p_node;
switch(onode->op) {
case SL::OP_ASSIGN:
case SL::OP_ASSIGN_ADD:
case SL::OP_ASSIGN_SUB:
case SL::OP_ASSIGN_MUL:
case SL::OP_ASSIGN_DIV:
case SL::OP_ASSIGN_SHIFT_LEFT:
case SL::OP_ASSIGN_SHIFT_RIGHT:
case SL::OP_ASSIGN_MOD:
case SL::OP_ASSIGN_BIT_AND:
case SL::OP_ASSIGN_BIT_OR:
case SL::OP_ASSIGN_BIT_XOR:
code=_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op)+_dump_node_code(onode->arguments[1],p_level,r_gen_code,p_actions,p_default_actions);
break;
case SL::OP_BIT_INVERT:
case SL::OP_NEGATE:
case SL::OP_NOT:
case SL::OP_DECREMENT:
case SL::OP_INCREMENT:
code=_opstr(onode->op)+_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions);
break;
case SL::OP_POST_DECREMENT:
case SL::OP_POST_INCREMENT:
code=_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op);
break;
case SL::OP_CALL:
case SL::OP_CONSTRUCT: {
ERR_FAIL_COND_V(onode->arguments[0]->type!=SL::Node::TYPE_VARIABLE,String());
SL::VariableNode *vnode=(SL::VariableNode*)onode->arguments[0];
if (onode->op==SL::OP_CONSTRUCT) {
code+=String(vnode->name);
} else {
if (internal_functions.has(vnode->name)) {
code+=vnode->name;
} else if (p_default_actions.renames.has(vnode->name)) {
code+=p_default_actions.renames[vnode->name];
} else {
code+=_mkid(vnode->name);
}
}
code+="(";
for(int i=1;i<onode->arguments.size();i++) {
if (i>1)
code+=", ";
code+=_dump_node_code(onode->arguments[i],p_level,r_gen_code,p_actions,p_default_actions);
}
code+=")";
} break;
default: {
code="("+_dump_node_code(onode->arguments[0],p_level,r_gen_code,p_actions,p_default_actions)+_opstr(onode->op)+_dump_node_code(onode->arguments[1],p_level,r_gen_code,p_actions,p_default_actions)+")";
break;
}
}
} break;
case SL::Node::TYPE_CONTROL_FLOW: {
SL::ControlFlowNode *cfnode=(SL::ControlFlowNode*)p_node;
if (cfnode->flow_op==SL::FLOW_OP_IF) {
code+=_mktab(p_level)+"if ("+_dump_node_code(cfnode->expressions[0],p_level,r_gen_code,p_actions,p_default_actions)+")\n";
code+=_dump_node_code(cfnode->blocks[0],p_level+1,r_gen_code,p_actions,p_default_actions);
if (cfnode->blocks.size()==2) {
code+=_mktab(p_level)+"else\n";
code+=_dump_node_code(cfnode->blocks[1],p_level+1,r_gen_code,p_actions,p_default_actions);
}
} else if (cfnode->flow_op==SL::FLOW_OP_RETURN) {
if (cfnode->blocks.size()) {
code="return "+_dump_node_code(cfnode->blocks[0],p_level,r_gen_code,p_actions,p_default_actions);
} else {
code="return";
}
}
} break;
case SL::Node::TYPE_MEMBER: {
SL::MemberNode *mnode=(SL::MemberNode*)p_node;
code=_dump_node_code(mnode->owner,p_level,r_gen_code,p_actions,p_default_actions)+"."+mnode->name;
} break;
}
return code;
}
Error ShaderCompilerGLES3::compile(VS::ShaderMode p_mode, const String& p_code, IdentifierActions* p_actions, const String &p_path,GeneratedCode& r_gen_code) {
Error err = parser.compile(p_code,ShaderTypes::get_singleton()->get_functions(p_mode),ShaderTypes::get_singleton()->get_modes(p_mode));
if (err!=OK) {
_err_print_error(NULL,p_path.utf8().get_data(),parser.get_error_line(),parser.get_error_text().utf8().get_data(),ERR_HANDLER_SHADER);
return err;
}
r_gen_code.defines.clear();
r_gen_code.vertex=String();
r_gen_code.vertex_global=String();
r_gen_code.fragment=String();
r_gen_code.fragment_global=String();
r_gen_code.light=String();
used_name_defines.clear();
used_rmode_defines.clear();
_dump_node_code(parser.get_shader(),1,r_gen_code,*p_actions,actions[p_mode]);
return OK;
}
ShaderCompilerGLES3::ShaderCompilerGLES3() {
/** CANVAS ITEM SHADER **/
actions[VS::SHADER_CANVAS_ITEM].renames["SRC_VERTEX"]="vertex";
actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX"]="outvec.xy";
actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX_COLOR"]="vertex_color";
actions[VS::SHADER_CANVAS_ITEM].renames["UV"]="uv_interp";
actions[VS::SHADER_CANVAS_ITEM].renames["POINT_SIZE"]="gl_PointSize";
actions[VS::SHADER_CANVAS_ITEM].renames["WORLD_MATRIX"]="modelview_matrix";
actions[VS::SHADER_CANVAS_ITEM].renames["PROJECTION_MATRIX"]="projection_matrix";
actions[VS::SHADER_CANVAS_ITEM].renames["EXTRA_MATRIX"]=="extra_matrix";
actions[VS::SHADER_CANVAS_ITEM].renames["TIME"]="time";
actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"]="color";
actions[VS::SHADER_CANVAS_ITEM].renames["NORMAL"]="normal";
actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP"]="normal_map";
actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP_DEPTH"]="normal_depth";
actions[VS::SHADER_CANVAS_ITEM].renames["UV"]="uv_interp";
actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"]="color";
actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE"]="color_texture";
actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE_PIXEL_SIZE"]="color_texpixel_size";
actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_UV"]="screen_uv";
actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_TEXTURE"]="screen_texture";
actions[VS::SHADER_CANVAS_ITEM].renames["POINT_COORD"]="gl_PointCoord";
actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_VEC"]="light_vec";
actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_HEIGHT"]="light_height";
actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_COLOR"]="light_color";
actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_UV"]="light_uv";
//actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_SHADOW_COLOR"]="light_shadow_color";
actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT"]="light";
actions[VS::SHADER_CANVAS_ITEM].renames["SHADOW_COLOR"]="shadow_color";
actions[VS::SHADER_CANVAS_ITEM].usage_defines["COLOR"]="#define COLOR_USED\n";
actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_TEXTURE"]="#define SCREEN_TEXTURE_USED\n";
actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_UV"]="#define SCREEN_UV_USED\n";
actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMAL"]="#define NORMAL_USED\n";
actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMALMAP"]="#define NORMALMAP_USED\n";
actions[VS::SHADER_CANVAS_ITEM].usage_defines["SHADOW_COLOR"]="#define SHADOW_COLOR_USED\n";
actions[VS::SHADER_CANVAS_ITEM].render_mode_defines["skip_transform"]="#define SKIP_TRANSFORM_USED\n";
List<String> func_list;
ShaderLanguage::get_builtin_funcs(&func_list);
for (List<String>::Element *E=func_list.front();E;E=E->next()) {
internal_functions.insert(E->get());
}
}

67
drivers/gles3/shader_compiler_gles3.h Normal file
View file

@ -0,0 +1,67 @@
#ifndef SHADERCOMPILERGLES3_H
#define SHADERCOMPILERGLES3_H
#include "servers/visual/shader_language.h"
#include "servers/visual/shader_types.h"
#include "servers/visual_server.h"
#include "pair.h"
class ShaderCompilerGLES3 {
public:
struct IdentifierActions {
Map<StringName,Pair<int*,int> > render_mode_values;
Map<StringName,bool*> render_mode_flags;
Map<StringName,bool*> usage_flag_pointers;
Map<StringName,ShaderLanguage::ShaderNode::Uniform> *uniforms;
};
struct GeneratedCode {
Vector<CharString> defines;
Vector<StringName> texture_uniforms;
Vector<uint32_t> uniform_offsets;
uint32_t uniform_total_size;
String uniforms;
String vertex_global;
String vertex;
String fragment_global;
String fragment;
String light;
};
private:
ShaderLanguage parser;
struct DefaultIdentifierActions {
Map<StringName,String> renames;
Map<StringName,String> render_mode_defines;
Map<StringName,String> usage_defines;
};
void _dump_function_deps(ShaderLanguage::ShaderNode *p_node, const StringName& p_for_func, const Map<StringName, String> &p_func_code, String& r_to_add,Set<StringName> &added);
String _dump_node_code(ShaderLanguage::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions& p_actions, const DefaultIdentifierActions& p_default_actions);
Set<StringName> used_name_defines;
Set<StringName> used_rmode_defines;
Set<StringName> internal_functions;
DefaultIdentifierActions actions[VS::SHADER_MAX];
public:
Error compile(VS::ShaderMode p_mode, const String& p_code, IdentifierActions* p_actions, const String& p_path, GeneratedCode& r_gen_code);
ShaderCompilerGLES3();
};
#endif // SHADERCOMPILERGLES3_H

83
drivers/gles3/shader_gles3.cpp
View file

@ -214,6 +214,8 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
}
v.ok=false;
/* SETUP CONDITIONALS */
@ -245,6 +247,7 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
CharString code_string;
CharString code_string2;
CharString code_globals;
CharString material_string;
//print_line("code version? "+itos(conditional_version.code_version));
@ -258,6 +261,7 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
cc=&custom_code_map[conditional_version.code_version];
v.code_version=cc->version;
define_line_ofs+=2;
}
@ -273,7 +277,7 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
if (cc) {
for(int i=0;i<cc->custom_defines.size();i++) {
strings.push_back(cc->custom_defines[i]);
strings.push_back(cc->custom_defines[i].get_data());
DEBUG_PRINT("CD #"+itos(i)+": "+String(cc->custom_defines[i]));
}
}
@ -305,14 +309,22 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
code_globals=cc->vertex_globals.ascii();
strings.push_back(code_globals.get_data());
}
strings.push_back(vertex_code1.get_data());
if (cc) {
material_string=cc->uniforms.ascii();
strings.push_back(material_string.get_data());
}
strings.push_back(vertex_code2.get_data());
if (cc) {
code_string=cc->vertex.ascii();
strings.push_back(code_string.get_data());
}
strings.push_back(vertex_code2.get_data());
strings.push_back(vertex_code3.get_data());
#ifdef DEBUG_SHADER
DEBUG_PRINT("\nVertex Code:\n\n"+String(code_string.get_data()));
@ -367,7 +379,8 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
ERR_FAIL_V(NULL);
}
/* FRAGMENT SHADER */
strings.resize(strings_base_size);
@ -396,21 +409,29 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
code_globals=cc->fragment_globals.ascii();
strings.push_back(code_globals.get_data());
}
strings.push_back(fragment_code1.get_data());
if (cc) {
material_string=cc->uniforms.ascii();
strings.push_back(material_string.get_data());
}
strings.push_back(fragment_code2.get_data());
if (cc) {
code_string=cc->fragment.ascii();
strings.push_back(code_string.get_data());
}
strings.push_back(fragment_code2.get_data());
strings.push_back(fragment_code3.get_data());
if (cc) {
code_string2=cc->light.ascii();
strings.push_back(code_string2.get_data());
}
strings.push_back(fragment_code3.get_data());
strings.push_back(fragment_code4.get_data());
#ifdef DEBUG_SHADER
DEBUG_PRINT("\nFragment Code:\n\n"+String(code_string.get_data()));
@ -463,7 +484,7 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
ERR_FAIL_V( NULL );
}
glAttachShader(v.id,v.frag_id);
glAttachShader(v.id,v.vert_id);
@ -552,10 +573,11 @@ ShaderGLES3::Version* ShaderGLES3::get_current_version() {
if ( cc ) {
v.custom_uniform_locations.resize(cc->custom_uniforms.size());
for(int i=0;i<cc->custom_uniforms.size();i++) {
v.texture_uniform_locations.resize(cc->texture_uniforms.size());
for(int i=0;i<cc->texture_uniforms.size();i++) {
v.custom_uniform_locations[i]=glGetUniformLocation(v.id,String(cc->custom_uniforms[i]).ascii().get_data());
v.texture_uniform_locations[i]=glGetUniformLocation(v.id,String(cc->texture_uniforms[i]).ascii().get_data());
glUniform1i(v.texture_uniform_locations[i],i+base_material_tex_index);
}
}
@ -597,6 +619,7 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
//split vertex and shader code (thank you, retarded shader compiler programmers from you know what company).
{
String globals_tag="\nVERTEX_SHADER_GLOBALS";
String material_tag="\nMATERIAL_UNIFORMS";
String code_tag="\nVERTEX_SHADER_CODE";
String code = vertex_code;
int cpos = code.find(globals_tag);
@ -606,20 +629,31 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
vertex_code0=code.substr(0,cpos).ascii();
code = code.substr(cpos+globals_tag.length(),code.length());
cpos = code.find(code_tag);
cpos = code.find(material_tag);
if (cpos==-1) {
vertex_code1=code.ascii();
} else {
vertex_code1=code.substr(0,cpos).ascii();
vertex_code2=code.substr(cpos+code_tag.length(),code.length()).ascii();
String code2 = code.substr(cpos+material_tag.length(),code.length());
cpos = code2.find(code_tag);
if (cpos==-1) {
vertex_code2=code2.ascii();
} else {
vertex_code2=code2.substr(0,cpos).ascii();
vertex_code3 = code2.substr(cpos+code_tag.length(),code2.length()).ascii();
}
}
}
}
{
String globals_tag="\nFRAGMENT_SHADER_GLOBALS";
String material_tag="\nMATERIAL_UNIFORMS";
String code_tag="\nFRAGMENT_SHADER_CODE";
String light_code_tag="\nLIGHT_SHADER_CODE";
String code = fragment_code;
@ -630,22 +664,31 @@ void ShaderGLES3::setup(const char** p_conditional_defines, int p_conditional_co
fragment_code0=code.substr(0,cpos).ascii();
code = code.substr(cpos+globals_tag.length(),code.length());
cpos = code.find(code_tag);
cpos = code.find(material_tag);
if (cpos==-1) {
fragment_code1=code.ascii();
} else {
fragment_code1=code.substr(0,cpos).ascii();
String code2 = code.substr(cpos+code_tag.length(),code.length());
String code2 = code.substr(cpos+material_tag.length(),code.length());
cpos = code2.find(light_code_tag);
cpos = code2.find(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();
String code3 = code2.substr(cpos+code_tag.length(),code2.length());
cpos = code3.find(light_code_tag);
if (cpos==-1) {
fragment_code3=code3.ascii();
} else {
fragment_code3=code3.substr(0,cpos).ascii();
fragment_code4 = code3.substr(cpos+light_code_tag.length(),code3.length()).ascii();
}
}
}
}
@ -697,7 +740,7 @@ uint32_t ShaderGLES3::create_custom_shader() {
return last_custom_code++;
}
void ShaderGLES3::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) {
void ShaderGLES3::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 String &p_uniforms, const Vector<StringName> &p_texture_uniforms, const Vector<CharString> &p_custom_defines) {
ERR_FAIL_COND(!custom_code_map.has(p_code_id));
CustomCode *cc=&custom_code_map[p_code_id];
@ -707,7 +750,8 @@ void ShaderGLES3::set_custom_shader_code(uint32_t p_code_id, const String& p_ver
cc->fragment=p_fragment;
cc->fragment_globals=p_fragment_globals;
cc->light=p_light;
cc->custom_uniforms=p_uniforms;
cc->texture_uniforms=p_texture_uniforms;
cc->uniforms=p_uniforms;
cc->custom_defines=p_custom_defines;
cc->version++;
}
@ -734,13 +778,16 @@ void ShaderGLES3::free_custom_shader(uint32_t p_code_id) {
}
void ShaderGLES3::set_base_material_tex_index(int p_idx) {
base_material_tex_index=p_idx;
}
ShaderGLES3::ShaderGLES3() {
version=NULL;
last_custom_code=1;
uniforms_dirty = true;
base_material_tex_index=0;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&max_image_units);
}

27
drivers/gles3/shader_gles3.h
View file

@ -105,9 +105,10 @@ private:
String fragment;
String fragment_globals;
String light;
String uniforms;
uint32_t version;
Vector<StringName> custom_uniforms;
Vector<const char*> custom_defines;
Vector<StringName> texture_uniforms;
Vector<CharString> custom_defines;
};
@ -118,7 +119,7 @@ private:
GLuint vert_id;
GLuint frag_id;
GLint *uniform_location;
Vector<GLint> custom_uniform_locations;
Vector<GLint> texture_uniform_locations;
uint32_t code_version;
bool ok;
Version() { code_version=0; ok=false; uniform_location=NULL; }
@ -166,10 +167,14 @@ private:
CharString fragment_code1;
CharString fragment_code2;
CharString fragment_code3;
CharString fragment_code4;
CharString vertex_code0;
CharString vertex_code1;
CharString vertex_code2;
CharString vertex_code3;
int base_material_tex_index;
Version * get_current_version();
@ -308,7 +313,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_p_light,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 String& p_uniforms,const Vector<StringName>& p_texture_uniforms,const Vector<CharString> &p_custom_defines);
void set_custom_shader(uint32_t p_id);
void free_custom_shader(uint32_t p_id);
@ -332,23 +337,25 @@ public:
uniforms_dirty = true;
};
_FORCE_INLINE_ void set_custom_uniform(int p_idx, const Variant& p_value) {
_FORCE_INLINE_ void set_texture_uniform(int p_idx, const Variant& p_value) {
ERR_FAIL_COND(!version);
ERR_FAIL_INDEX(p_idx,version->custom_uniform_locations.size());
_set_uniform_variant( version->custom_uniform_locations[p_idx], p_value );
ERR_FAIL_INDEX(p_idx,version->texture_uniform_locations.size());
_set_uniform_variant( version->texture_uniform_locations[p_idx], p_value );
}
_FORCE_INLINE_ GLint get_custom_uniform_location(int p_idx) {
_FORCE_INLINE_ GLint get_texture_uniform_location(int p_idx) {
ERR_FAIL_COND_V(!version,-1);
ERR_FAIL_INDEX_V(p_idx,version->custom_uniform_locations.size(),-1);
return version->custom_uniform_locations[p_idx];
ERR_FAIL_INDEX_V(p_idx,version->texture_uniform_locations.size(),-1);
return version->texture_uniform_locations[p_idx];
}
virtual void init()=0;
void finish();
void set_base_material_tex_index(int p_idx);
virtual ~ShaderGLES3();
};

72
drivers/gles3/shaders/canvas.glsl
View file

@ -1,7 +1,7 @@
[vertex]
layout(location=0) in highp vec3 vertex;
layout(location=0) in highp vec2 vertex;
layout(location=3) in vec4 color_attrib;
#ifdef USE_TEXTURE_RECT
@ -20,6 +20,7 @@ layout(location=4) in highp vec2 uv_attrib;
layout(std140) uniform CanvasItemData { //ubo:0
highp mat4 projection_matrix;
highp vec4 time;
};
uniform highp mat4 modelview_matrix;
@ -29,10 +30,6 @@ uniform highp mat4 extra_matrix;
out mediump vec2 uv_interp;
out mediump vec4 color_interp;
#if defined(USE_TIME)
uniform float time;
#endif
#ifdef USE_LIGHTING
layout(std140) uniform LightData { //ubo:1
@ -51,6 +48,7 @@ layout(std140) uniform LightData { //ubo:1
highp float shadow_distance_mult;
};
out vec4 light_uv_interp;
#if defined(NORMAL_USED)
@ -66,20 +64,30 @@ out highp vec2 pos;
VERTEX_SHADER_GLOBALS
#if defined(USE_MATERIAL)
layout(std140) uniform UniformData { //ubo:2
MATERIAL_UNIFORMS
};
#endif
void main() {
color_interp = color_attrib;
vec4 vertex_color = color_attrib;
#ifdef USE_TEXTURE_RECT
uv_interp = src_rect.xy + abs(src_rect.zw) * vertex.xy;
highp vec4 outvec = vec4(dst_rect.xy + dst_rect.zw * mix(vertex.xy,vec2(1.0,1.0)-vertex.xy,lessThan(src_rect.zw,vec2(0.0,0.0))),0.0,1.0);
uv_interp = src_rect.xy + abs(src_rect.zw) * vertex;
highp vec4 outvec = vec4(dst_rect.xy + dst_rect.zw * mix(vertex,vec2(1.0,1.0)-vertex,lessThan(src_rect.zw,vec2(0.0,0.0))),0.0,1.0);
#else
uv_interp = uv_attrib;
highp vec4 outvec = vec4(vertex, 1.0);
highp vec4 outvec = vec4(vertex,0.0,1.0);
#endif
@ -90,16 +98,16 @@ VERTEX_SHADER_CODE
}
#if !defined(USE_WORLD_VEC)
#if !defined(SKIP_TRANSFORM_USED)
outvec = extra_matrix * outvec;
outvec = modelview_matrix * outvec;
#endif
color_interp = vertex_color;
#ifdef USE_PIXEL_SNAP
outvec.xy=floor(outvec.xy+0.5);
outvec.xy=floor(outvec+0.5);
#endif
@ -132,20 +140,24 @@ VERTEX_SHADER_CODE
uniform mediump sampler2D color_texture; // texunit:0
uniform highp vec2 color_texpixel_size;
in mediump vec2 uv_interp;
in mediump vec4 color_interp;
#if defined(ENABLE_TEXSCREEN)
#if defined(SCREEN_TEXTURE_USED)
uniform sampler2D texscreen_tex; // texunit:-3
uniform sampler2D screen_texture; // texunit:-3
#endif
#if defined(USE_TIME)
uniform float time;
#endif
layout(std140) uniform CanvasItemData {
highp mat4 projection_matrix;
highp vec4 time;
};
#ifdef USE_LIGHTING
@ -188,6 +200,17 @@ FRAGMENT_SHADER_GLOBALS
layout(location=0) out mediump vec4 frag_color;
#if defined(USE_MATERIAL)
layout(std140) uniform UniformData {
MATERIAL_UNIFORMS
};
#endif
void main() {
vec4 color = color_interp;
@ -195,6 +218,9 @@ void main() {
vec3 normal = vec3(0.0,0.0,1.0);
#endif
#if !defined(COLOR_USED)
//default behavior, texture by color
#ifdef USE_DISTANCE_FIELD
const float smoothing = 1.0/32.0;
float distance = texture(color_texture, uv_interp).a;
@ -204,6 +230,7 @@ void main() {
#endif
#endif
#if defined(ENABLE_SCREEN_UV)
vec2 screen_uv = gl_FragCoord.xy*screen_uv_mult;
@ -211,14 +238,15 @@ void main() {
{
#if defined(USE_NORMALMAP)
vec3 normal_map=vec3(0.0,0.0,1.0);
float normal_depth=1.0;
#if defined(NORMALMAP_USED)
vec3 normal_map=vec3(0.0,0.0,1.0);
#endif
FRAGMENT_SHADER_CODE
#if defined(USE_NORMALMAP)
#if defined(NORMALMAP_USED)
normal = mix(vec3(0.0,0.0,1.0), normal_map * vec3(2.0,-2.0,1.0) - vec3( 1.0, -1.0, 0.0 ), normal_depth );
#endif
@ -246,7 +274,7 @@ FRAGMENT_SHADER_CODE
vec2 light_uv = light_uv_interp.xy;
vec4 light = texture(light_texture,light_uv) * light_color;
#if defined(USE_OUTPUT_SHADOW_COLOR)
#if defined(SHADOW_COLOR_USED)
vec4 shadow_color=vec4(0.0,0.0,0.0,0.0);
#endif
@ -409,7 +437,7 @@ LIGHT_SHADER_CODE
#endif
#if defined(USE_OUTPUT_SHADOW_COLOR)
#if defined(SHADOW_COLOR_USED)
color=mix(shadow_color,color,shadow_attenuation);
#else
//color*=shadow_attenuation;

4
drivers/unix/os_unix.cpp
View file

@ -88,6 +88,10 @@ void OS_Unix::print_error(const char* p_function,const char* p_file,int p_line,c
print("\E[1;35mSCRIPT ERROR: %s: \E[0m\E[1m%s\n",p_function,err_details);
print("\E[0;35m At: %s:%i.\E[0m\n",p_file,p_line);
break;
case ERR_SHADER:
print("\E[1;36mSHADER ERROR: %s: \E[0m\E[1m%s\n",p_function,err_details);
print("\E[0;36m At: %s:%i.\E[0m\n",p_file,p_line);
break;
}
}

9
platform/windows/os_windows.cpp
View file

@ -1727,6 +1727,10 @@ void OS_Windows::print_error(const char* p_function, const char* p_file, int p_l
print("SCRIPT ERROR: %s: %s\n", p_function, err_details);
print(" At: %s:%i\n", p_file, p_line);
break;
case ERR_SHADER:
print("SHADER ERROR: %s: %s\n", p_function, err_details);
print(" At: %s:%i\n", p_file, p_line);
break;
}
} else {
@ -1742,6 +1746,7 @@ void OS_Windows::print_error(const char* p_function, const char* p_file, int p_l
case ERR_ERROR: basecol = FOREGROUND_RED; break;
case ERR_WARNING: basecol = FOREGROUND_RED | FOREGROUND_GREEN; break;
case ERR_SCRIPT: basecol = FOREGROUND_RED | FOREGROUND_BLUE; break;
case ERR_SHADER: basecol = FOREGROUND_GREEN | FOREGROUND_BLUE; break;
}
basecol |= current_bg;
@ -1753,6 +1758,7 @@ void OS_Windows::print_error(const char* p_function, const char* p_file, int p_l
case ERR_ERROR: print("ERROR: "); break;
case ERR_WARNING: print("WARNING: "); break;
case ERR_SCRIPT: print("SCRIPT ERROR: "); break;
case ERR_SCRIPT: print("SHADER ERROR: "); break;
}
SetConsoleTextAttribute(hCon, current_fg | current_bg | FOREGROUND_INTENSITY);
@ -1763,6 +1769,7 @@ void OS_Windows::print_error(const char* p_function, const char* p_file, int p_l
case ERR_ERROR: print(" At: "); break;
case ERR_WARNING: print(" At: "); break;
case ERR_SCRIPT: print(" At: "); break;
case ERR_SHADER: print(" At: "); break;
}
SetConsoleTextAttribute(hCon, current_fg | current_bg);
@ -1775,6 +1782,7 @@ void OS_Windows::print_error(const char* p_function, const char* p_file, int p_l
case ERR_ERROR: print("ERROR: %s: ", p_function); break;
case ERR_WARNING: print("WARNING: %s: ", p_function); break;
case ERR_SCRIPT: print("SCRIPT ERROR: %s: ", p_function); break;
case ERR_SHADER: print("SCRIPT ERROR: %s: ", p_function); break;
}
SetConsoleTextAttribute(hCon, current_fg | current_bg | FOREGROUND_INTENSITY);
@ -1785,6 +1793,7 @@ void OS_Windows::print_error(const char* p_function, const char* p_file, int p_l
case ERR_ERROR: print(" At: "); break;
case ERR_WARNING: print(" At: "); break;
case ERR_SCRIPT: print(" At: "); break;
case ERR_SHADER: print(" At: "); break;
}
SetConsoleTextAttribute(hCon, current_fg | current_bg);

14
scene/2d/canvas_item.cpp
View file

@ -55,7 +55,7 @@ bool CanvasItemMaterial::_set(const StringName& p_name, const Variant& p_value)
}
}
if (pr) {
VisualServer::get_singleton()->material_set_param(material,pr,p_value);
VisualServer::get_singleton()->material_set_param(_get_material(),pr,p_value);
return true;
}
}
@ -78,7 +78,7 @@ bool CanvasItemMaterial::_get(const StringName& p_name,Variant &r_ret) const {
StringName pr = shader->remap_param(p_name);
if (pr) {
r_ret=VisualServer::get_singleton()->material_get_param(material,pr);
r_ret=VisualServer::get_singleton()->material_get_param(_get_material(),pr);
return true;
}
}
@ -111,7 +111,7 @@ void CanvasItemMaterial::set_shader(const Ref<Shader>& p_shader) {
if (shader.is_valid())
rid=shader->get_rid();
VS::get_singleton()->material_set_shader(material,rid);
VS::get_singleton()->material_set_shader(_get_material(),rid);
_change_notify(); //properties for shader exposed
emit_changed();
}
@ -123,18 +123,14 @@ Ref<Shader> CanvasItemMaterial::get_shader() const{
void CanvasItemMaterial::set_shader_param(const StringName& p_param,const Variant& p_value){
VS::get_singleton()->material_set_param(material,p_param,p_value);
VS::get_singleton()->material_set_param(_get_material(),p_param,p_value);
}
Variant CanvasItemMaterial::get_shader_param(const StringName& p_param) const{
return VS::get_singleton()->material_get_param(material,p_param);
return VS::get_singleton()->material_get_param(_get_material(),p_param);
}
RID CanvasItemMaterial::get_rid() const {
return material;
}
void CanvasItemMaterial::_bind_methods() {

4
scene/2d/canvas_item.h
View file

@ -41,10 +41,9 @@ class Font;
class StyleBox;
class CanvasItemMaterial : public Material{
class CanvasItemMaterial : public Material {
OBJ_TYPE(CanvasItemMaterial,Material);
RID material;
Ref<Shader> shader;
public:
/*enum ShadingMode {
@ -70,7 +69,6 @@ public:
void set_shader_param(const StringName& p_param,const Variant& p_value);
Variant get_shader_param(const StringName& p_param) const;
virtual RID get_rid() const;
CanvasItemMaterial();
~CanvasItemMaterial();
};

37
scene/gui/color_picker.cpp
View file

@ -34,31 +34,12 @@
#include "os/input.h"
#include "os/keyboard.h"
void update_material(Ref<CanvasItemMaterial>mat,const Color& p_color,float h,float s,float v) {
if (!mat.is_valid())
return;
Ref<Shader> sdr = mat->get_shader();
if (!sdr.is_valid())
return;
mat->set_shader_param("R",p_color.r);
mat->set_shader_param("G",p_color.g);
mat->set_shader_param("B",p_color.b);
mat->set_shader_param("H",h);
mat->set_shader_param("S",s);
mat->set_shader_param("V",v);
mat->set_shader_param("A",p_color.a);
}
void ColorPicker::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_THEME_CHANGED: {
uv_material->set_shader(get_shader("uv_editor"));
w_material->set_shader(get_shader("w_editor"));
update_material(uv_material,color,h,s,v);
update_material(w_material,color,h,s,v);
uv_edit->set_texture(get_icon("color_main"));
w_edit->set_texture(get_icon("color_hue"));
sample->set_texture(get_icon("color_sample"));
@ -68,8 +49,6 @@ void ColorPicker::_notification(int p_what) {
case NOTIFICATION_ENTER_TREE: {
btn_pick->set_icon(get_icon("screen_picker", "ColorPicker"));
update_material(uv_material, color,h,s,v);
update_material(w_material, color,h,s,v);
uv_edit->get_child(0)->cast_to<Control>()->update();
w_edit->get_child(0)->cast_to<Control>()->update();
@ -113,8 +92,6 @@ void ColorPicker::set_color(const Color& p_color) {
if (!is_inside_tree())
return;
update_material(uv_material, color,h,s,v);
update_material(w_material, color,h,s,v);
uv_edit->get_child(0)->cast_to<Control>()->update();
w_edit->get_child(0)->cast_to<Control>()->update();
@ -509,7 +486,6 @@ ColorPicker::ColorPicker() :
uv_edit->add_child(c);
c->set_area_as_parent_rect();
c->set_stop_mouse(false);
c->set_material(memnew ( CanvasItemMaterial ));
Vector<Variant> args=Vector<Variant>();
args.push_back(0);
args.push_back(c);
@ -525,7 +501,6 @@ ColorPicker::ColorPicker() :
w_edit->add_child(c);
c->set_area_as_parent_rect();
c->set_stop_mouse(false);
c->set_material(memnew ( CanvasItemMaterial ));
args.clear();
args.push_back(1);
args.push_back(c);
@ -593,18 +568,6 @@ ColorPicker::ColorPicker() :
//_update_color();
updating=false;
uv_material.instance();
Ref<Shader> s_uv = get_shader("uv_editor");
uv_material->set_shader(s_uv);
w_material.instance();
Ref<Shader> s_w = get_shader("w_editor");
w_material->set_shader(s_w);
uv_edit->set_material(uv_material);
w_edit->set_material(w_material);
set_color(Color(1,1,1));

2
scene/gui/color_picker.h
View file

@ -57,8 +57,6 @@ private:
List<Color> presets;
ToolButton *btn_pick;
CheckButton *btn_mode;
Ref<CanvasItemMaterial> uv_material;
Ref<CanvasItemMaterial> w_material;
HSlider *scroll[4];
SpinBox *values[4];
Label *labels[4];

3
scene/resources/material.h
View file

@ -46,6 +46,9 @@ class Material : public Resource {
OBJ_SAVE_TYPE( Material );
RID material;
protected:
_FORCE_INLINE_ RID _get_material() const { return material; }
public:
virtual RID get_rid() const;

53
servers/visual/shader_language.cpp
View file

@ -712,6 +712,8 @@ bool ShaderLanguage::is_token_nonvoid_datatype(TokenType p_type) {
void ShaderLanguage::clear() {
current_function=StringName();
completion_type=COMPLETION_NONE;
completion_block=NULL;
completion_function=StringName();
@ -2096,6 +2098,12 @@ bool ShaderLanguage::is_scalar_type(DataType p_type) {
return p_type==TYPE_BOOL || p_type==TYPE_INT || p_type==TYPE_UINT || p_type==TYPE_FLOAT;
}
bool ShaderLanguage::is_sampler_type(DataType p_type) {
return p_type==TYPE_SAMPLER2D || p_type==TYPE_ISAMPLER2D || p_type==TYPE_USAMPLER2D || p_type==TYPE_SAMPLERCUBE;
}
void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
Set<String> kws;
@ -2122,6 +2130,27 @@ void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
}
}
void ShaderLanguage::get_builtin_funcs(List<String> *r_keywords) {
Set<String> kws;
int idx=0;
while (builtin_func_defs[idx].name) {
kws.insert(builtin_func_defs[idx].name);
idx++;
}
for(Set<String>::Element *E=kws.front();E;E=E->next()) {
r_keywords->push_back(E->get());
}
}
ShaderLanguage::DataType ShaderLanguage::get_scalar_type(DataType p_type) {
static const DataType scalar_types[]={
@ -2342,6 +2371,12 @@ ShaderLanguage::Node* ShaderLanguage::_parse_expression(BlockNode* p_block,const
bool ok =_parse_function_arguments(p_block,p_builtin_types,func,&carg);
for(int i=0;i<shader->functions.size();i++) {
if (shader->functions[i].name==name) {
shader->functions[i].uses_function.insert(name);
}
}
if (carg>=0) {
@ -3140,6 +3175,9 @@ Error ShaderLanguage::_parse_shader(const Map< StringName, Map<StringName,DataTy
Token tk = _get_token();
int texture_uniforms = 0;
int uniforms =0;
while(tk.type!=TK_EOF) {
switch(tk.type) {
@ -3160,12 +3198,12 @@ Error ShaderLanguage::_parse_shader(const Map< StringName, Map<StringName,DataTy
return ERR_PARSE_ERROR;
}
if (shader->render_modes.has(tk.text)) {
if (shader->render_modes.find(tk.text)!=-1) {
_set_error("Duplicate render mode: '"+String(tk.text)+"'");
return ERR_PARSE_ERROR;
}
shader->render_modes.insert(tk.text);
shader->render_modes.push_back(tk.text);
tk = _get_token();
if (tk.type==TK_COMMA) {
@ -3225,6 +3263,13 @@ Error ShaderLanguage::_parse_shader(const Map< StringName, Map<StringName,DataTy
ShaderNode::Uniform uniform;
uniform.order=shader->uniforms.size();
if (is_sampler_type(type)) {
uniform.texture_order=texture_uniforms++;
uniform.order=-1;
} else {
uniform.texture_order=-1;
uniform.order=uniforms++;
}
uniform.type=type;
uniform.precission=precision;
@ -3520,9 +3565,13 @@ Error ShaderLanguage::_parse_shader(const Map< StringName, Map<StringName,DataTy
return ERR_PARSE_ERROR;
}
current_function = name;
Error err = _parse_block(func_node->body,builtin_types);
if (err)
return err;
current_function=StringName();
}
}

8
servers/visual/shader_language.h
View file

@ -370,6 +370,7 @@ public:
struct Function {
StringName name;
FunctionNode*function;
Set<StringName> uses_function;
bool callable;
};
@ -391,6 +392,7 @@ public:
};
int order;
int texture_order;
DataType type;
DataPrecision precission;
Vector<ConstantNode::Value> default_value;
@ -403,7 +405,7 @@ public:
Map<StringName,Varying> varyings;
Map<StringName,Uniform> uniforms;
Set<StringName> render_modes;
Vector<StringName> render_modes;
Vector<Function> functions;
@ -461,8 +463,10 @@ public:
static bool convert_constant(ConstantNode* p_constant, DataType p_to_type,ConstantNode::Value *p_value=NULL);
static DataType get_scalar_type(DataType p_type);
static bool is_scalar_type(DataType p_type);
static bool is_sampler_type(DataType p_type);
static void get_keyword_list(List<String> *r_keywords);
static void get_builtin_funcs(List<String> *r_keywords);
private:
struct KeyWord { TokenType token; const char *text;};
@ -476,6 +480,8 @@ private:
int char_idx;
int tk_line;
StringName current_function;
struct TkPos {
int char_idx;
int tk_line;

62
servers/visual/shader_types.cpp
View file

@ -18,6 +18,7 @@ ShaderTypes::ShaderTypes()
{
singleton=this;
/*************** SPATIAL ***********************/
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["SRC_VERTEX"]=ShaderLanguage::TYPE_VEC3;
shader_modes[VS::SHADER_SPATIAL].functions["vertex"]["SRC_NORMAL"]=ShaderLanguage::TYPE_VEC3;
@ -96,4 +97,65 @@ ShaderTypes::ShaderTypes()
shader_modes[VS::SHADER_SPATIAL].modes.insert("vertex_model_space");
shader_modes[VS::SHADER_SPATIAL].modes.insert("vertex_camera_space");
/************ CANVAS ITEM **************************/
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["SRC_VERTEX"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["VERTEX"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["UV"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["VERTEX_COLOR"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["POINT_SIZE"]=ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["WORLD_MATRIX"]=ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["PROJECTION_MATRIX"]=ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["EXTRA_MATRIX"]=ShaderLanguage::TYPE_MAT4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["vertex"]["TIME"]=ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["SRC_COLOR"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["POSITION"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["NORMAL"]=ShaderLanguage::TYPE_VEC3;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["NORMALMAP"]=ShaderLanguage::TYPE_VEC3;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["NORMALMAP_DEPTH"]=ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["UV"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["COLOR"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["TEXTURE"]=ShaderLanguage::TYPE_SAMPLER2D;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["TEXTURE_PIXEL_SIZE"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["SCREEN_UV"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["POINT_COORD"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["fragment"]["TIME"]=ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["POSITION"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["NORMAL"]=ShaderLanguage::TYPE_VEC3;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["UV"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["COLOR"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["TEXTURE"]=ShaderLanguage::TYPE_SAMPLER2D;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["TEXTURE_PIXEL_SIZE"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["VAR1"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["VAR2"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["SCREEN_UV"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["LIGHT_VEC"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["LIGHT_HEIGHT"]=ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["LIGHT_COLOR"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["LIGHT_UV"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["LIGHT_SHADOW"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["LIGHT"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["SHADOW"]=ShaderLanguage::TYPE_VEC4;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["POINT_COORD"]=ShaderLanguage::TYPE_VEC2;
shader_modes[VS::SHADER_CANVAS_ITEM].functions["light"]["TIME"]=ShaderLanguage::TYPE_FLOAT;
shader_modes[VS::SHADER_SPATIAL].modes.insert("skip_transform");
shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_mix");
shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_add");
shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_sub");
shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_mul");
shader_modes[VS::SHADER_SPATIAL].modes.insert("blend_premul_alpha");
shader_modes[VS::SHADER_SPATIAL].modes.insert("unshaded");
shader_modes[VS::SHADER_SPATIAL].modes.insert("light_only");
}

1
servers/visual_server.h
View file

@ -140,6 +140,7 @@ public:
SHADER_SPATIAL,
SHADER_CANVAS_ITEM,
SHADER_LIGHT,
SHADER_MAX
};

4
tools/editor/editor_log.cpp
View file

@ -67,6 +67,10 @@ void EditorLog::_error_handler(void *p_self, const char*p_func, const char*p_fil
icon = self->get_icon("ScriptError","EditorIcons");
} break;
case ERR_HANDLER_SHADER: {
icon = self->get_icon("Shader","EditorIcons");
} break;
}