static Error recreate_code(void *p_str, SL::ShaderNode *p_program) { String *str = (String *)p_str; *str = dump_node_code(p_program, 0); return OK; }
static String dump_node_code(SL::Node *p_node, int p_level) { String code; switch (p_node->type) { case SL::Node::TYPE_SHADER: { SL::ShaderNode *pnode = (SL::ShaderNode *)p_node; 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 += " " + String(E->key()); if (E->get().default_value.size()) { ucode += " = " + get_constant_text(E->get().type, E->get().default_value); } static const char *hint_name[SL::ShaderNode::Uniform::HINT_MAX] = { "", "color", "range", "albedo", "normal", "black", "white" }; if (E->get().hint) ucode += " : " + String(hint_name[E->get().hint]); code += ucode + "\n"; } for (Map<StringName, SL::ShaderNode::Varying>::Element *E = pnode->varyings.front(); E; E = E->next()) { String vcode = "varying "; vcode += _prestr(E->get().precission); vcode += _typestr(E->get().type); vcode += " " + String(E->key()); code += vcode + "\n"; } for (int i = 0; i < pnode->functions.size(); i++) { SL::FunctionNode *fnode = pnode->functions[i].function; String header; header = _typestr(fnode->return_type) + " " + 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) + " " + fnode->arguments[i].name; } header += ")\n"; code += header; code += dump_node_code(fnode->body, p_level + 1); } //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) + " " + E->key() + ";\n"; } for (int i = 0; i < bnode->statements.size(); i++) { String scode = dump_node_code(bnode->statements[i], p_level); 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; code = 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) + _opstr(onode->op) + dump_node_code(onode->arguments[1], p_level); 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); break; case SL::OP_POST_DECREMENT: case SL::OP_POST_INCREMENT: code = dump_node_code(onode->arguments[0], p_level) + _opstr(onode->op); break; case SL::OP_CALL: case SL::OP_CONSTRUCT: code = dump_node_code(onode->arguments[0], p_level) + "("; for (int i = 1; i < onode->arguments.size(); i++) { if (i > 1) code += ", "; code += dump_node_code(onode->arguments[i], p_level); } code += ")"; break; default: { code = "(" + dump_node_code(onode->arguments[0], p_level) + _opstr(onode->op) + dump_node_code(onode->arguments[1], p_level) + ")"; 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) + ")\n"; code += dump_node_code(cfnode->blocks[0], p_level + 1); if (cfnode->blocks.size() == 2) { code += _mktab(p_level) + "else\n"; code += dump_node_code(cfnode->blocks[1], p_level + 1); } } else if (cfnode->flow_op == SL::FLOW_OP_RETURN) { if (cfnode->blocks.size()) { code = "return " + dump_node_code(cfnode->blocks[0], p_level); } else { code = "return"; } } } break; case SL::Node::TYPE_MEMBER: { SL::MemberNode *mnode = (SL::MemberNode *)p_node; code = dump_node_code(mnode->owner, p_level) + "." + mnode->name; } break; } return code; }
Error ShaderCompilerGLES2::compile_node(SL::ProgramNode *p_program) { // feed the local replace table and global code global_code=""; // uniforms first! int ubase=0; if (uniforms) ubase=uniforms->size(); 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); } } for(int i=0;i<p_program->functions.size();i++) { SL::FunctionNode *fnode=p_program->functions[i].function; StringName funcname=fnode->name; String newfuncname=replace_string(funcname); String header; header=_typestr(fnode->return_type)+" "+newfuncname+"("; for(int i=0;i<fnode->arguments.size();i++) { if (i>0) header+=", "; header+=_typestr(fnode->arguments[i].type)+" "+replace_string(fnode->arguments[i].name); } header+=") {"ENDL; String fcode=header; fcode+=dump_node_code(fnode->body,1); fcode+="}"ENDL; global_code+=fcode; } /* for(Map<StringName,SL::DataType>::Element *E=p_program->preexisting_variables.front();E;E=E->next()) { StringName varname=E->key(); String newvarname=replace_string(varname); global_code+="uniform "+_typestr(E->get())+" "+newvarname+";"ENDL; }*/ code=dump_node_code(p_program,0); #ifdef DEBUG_SHADER_ENABLED print_line("GLOBAL CODE:\n\n"); print_line(global_code); global_code=global_code.replace("\n",""); print_line("CODE:\n\n"); print_line(code); code=code.replace("\n",""); #endif return OK; }
String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_assign_left) { String code; switch(p_node->type) { case SL::Node::TYPE_PROGRAM: { SL::ProgramNode *pnode=(SL::ProgramNode*)p_node; 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 for(Map<StringName,SL::DataType>::Element *E=bnode->variables.front();E;E=E->next()) { code+=_mktab(p_level)+_typestr(E->value())+" "+replace_string(E->key())+";"ENDL; } for(int i=0;i<bnode->statements.size();i++) { code+=_mktab(p_level)+dump_node_code(bnode->statements[i],p_level)+";"ENDL; } } break; case SL::Node::TYPE_VARIABLE: { SL::VariableNode *vnode=(SL::VariableNode*)p_node; if (type==ShaderLanguage::SHADER_MATERIAL_VERTEX) { if (vnode->name==vname_vertex && p_assign_left) { vertex_code_writes_vertex=true; } } if (type==ShaderLanguage::SHADER_MATERIAL_FRAGMENT) { if (vnode->name==vname_discard) { uses_discard=true; } if (vnode->name==vname_screen_uv) { uses_screen_uv=true; } if (vnode->name==vname_diffuse_alpha && p_assign_left) { uses_alpha=true; } if (vnode->name==vname_color_interp) { flags->use_color_interp=true; } if (vnode->name==vname_uv_interp) { flags->use_uv_interp=true; } if (vnode->name==vname_uv2_interp) { flags->use_uv2_interp=true; } if (vnode->name==vname_var1_interp) { flags->use_var1_interp=true; } if (vnode->name==vname_var2_interp) { flags->use_var2_interp=true; } if (vnode->name==vname_tangent_interp || vnode->name==vname_binormal_interp) { flags->use_tangent_interp=true; } } if (type==ShaderLanguage::SHADER_MATERIAL_LIGHT) { if (vnode->name==vname_light) { uses_light=true; } } if (vnode->name==vname_time) { uses_time=true; } code=replace_string(vnode->name); } break; case SL::Node::TYPE_CONSTANT: { SL::ConstantNode *cnode=(SL::ConstantNode*)p_node; switch(cnode->datatype) { case SL::TYPE_BOOL: code=cnode->value.operator bool()?"true":"false"; break; case SL::TYPE_FLOAT: code=_mknum(cnode->value); break; //force zeros, so GLSL doesn't confuse with integer. case SL::TYPE_VEC2: { Vector2 v = cnode->value; code="vec2("+_mknum(v.x)+", "+_mknum(v.y)+")"; } break; case SL::TYPE_VEC3: { Vector3 v = cnode->value; code="vec3("+_mknum(v.x)+", "+_mknum(v.y)+", "+_mknum(v.z)+")"; } break; case SL::TYPE_VEC4: { Plane v = cnode->value; code="vec4("+_mknum(v.normal.x)+", "+_mknum(v.normal.y)+", "+_mknum(v.normal.z)+", "+_mknum(v.d)+")"; } break; case SL::TYPE_MAT3: { Matrix3 x = cnode->value; code="mat3( vec3("+_mknum(x.get_axis(0).x)+", "+_mknum(x.get_axis(0).y)+", "+_mknum(x.get_axis(0).z)+"), vec3("+_mknum(x.get_axis(1).x)+", "+_mknum(x.get_axis(1).y)+", "+_mknum(x.get_axis(1).z)+"), vec3("+_mknum(x.get_axis(2).x)+", "+_mknum(x.get_axis(2).y)+", "+_mknum(x.get_axis(2).z)+"))"; } break; case SL::TYPE_MAT4: { Transform x = cnode->value; code="mat4( vec4("+_mknum(x.basis.get_axis(0).x)+", "+_mknum(x.basis.get_axis(0).y)+", "+_mknum(x.basis.get_axis(0).z)+",0.0), vec4("+_mknum(x.basis.get_axis(1).x)+", "+_mknum(x.basis.get_axis(1).y)+", "+_mknum(x.basis.get_axis(1).z)+",0.0), vec4("+_mknum(x.basis.get_axis(2).x)+", "+_mknum(x.basis.get_axis(2).y)+", "+_mknum(x.basis.get_axis(2).z)+",0.0), vec4("+_mknum(x.origin.x)+", "+_mknum(x.origin.y)+", "+_mknum(x.origin.z)+",1.0))"; } break; default: code="<error: "+Variant::get_type_name(cnode->value.get_type())+" ("+itos(cnode->datatype)+">"; } } break; case SL::Node::TYPE_OPERATOR: { SL::OperatorNode *onode=(SL::OperatorNode*)p_node; switch(onode->op) { case SL::OP_ASSIGN_MUL: { if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC3 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT4) { String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_r=dump_node_code(onode->arguments[1],p_level); code=mul_l+"=(vec4("+mul_l+",1.0)*("+mul_r+")).xyz"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC3) { String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_r=dump_node_code(onode->arguments[1],p_level); code=mul_l+"=(("+mul_l+")*vec4("+mul_r+",1.0)).xyz"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT4) { String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_r=dump_node_code(onode->arguments[1],p_level); code=mul_l+"=(vec4("+mul_l+",1.0,1.0)*("+mul_r+")).xy"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) { String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_r=dump_node_code(onode->arguments[1],p_level); code=mul_l+"=(("+mul_l+")*vec4("+mul_r+",1.0,1.0)).xy"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT3) { String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_r=dump_node_code(onode->arguments[1],p_level); code=mul_l+"=(("+mul_l+")*vec3("+mul_r+",1.0)).xy"; break; } }; case SL::OP_ASSIGN: case SL::OP_ASSIGN_ADD: case SL::OP_ASSIGN_SUB: case SL::OP_ASSIGN_DIV: code="("+dump_node_code(onode->arguments[0],p_level,true)+_opstr(onode->op)+dump_node_code(onode->arguments[1],p_level)+")"; break; case SL::OP_MUL: if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC3) { code="("+dump_node_code(onode->arguments[0],p_level)+"*vec4("+dump_node_code(onode->arguments[1],p_level)+",1.0)).xyz"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC3 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT4) { code="(vec4("+dump_node_code(onode->arguments[0],p_level)+",1.0)*"+dump_node_code(onode->arguments[1],p_level)+").xyz"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) { code="("+dump_node_code(onode->arguments[0],p_level)+"*vec4("+dump_node_code(onode->arguments[1],p_level)+",1.0,1.0)).xyz"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT4) { code="(vec4("+dump_node_code(onode->arguments[0],p_level)+",1.0,1.0)*"+dump_node_code(onode->arguments[1],p_level)+").xyz"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT3 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) { code="("+dump_node_code(onode->arguments[0],p_level)+"*vec3("+dump_node_code(onode->arguments[1],p_level)+",1.0)).xy"; break; } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT3) { code="(vec3("+dump_node_code(onode->arguments[0],p_level)+",1.0)*"+dump_node_code(onode->arguments[1],p_level)+").xy"; break; } case SL::OP_ADD: case SL::OP_SUB: case SL::OP_DIV: case SL::OP_CMP_EQ: case SL::OP_CMP_NEQ: case SL::OP_CMP_LEQ: case SL::OP_CMP_GEQ: case SL::OP_CMP_LESS: case SL::OP_CMP_GREATER: case SL::OP_CMP_OR: case SL::OP_CMP_AND: //handle binary code="("+dump_node_code(onode->arguments[0],p_level)+_opstr(onode->op)+dump_node_code(onode->arguments[1],p_level)+")"; break; case SL::OP_NEG: case SL::OP_NOT: //handle unary code=_opstr(onode->op)+dump_node_code(onode->arguments[0],p_level); break; case SL::OP_CONSTRUCT: case SL::OP_CALL: { String callfunc=dump_node_code(onode->arguments[0],p_level); code=callfunc+"("; /*if (callfunc=="mat4") { //fix constructor for mat4 for(int i=1;i<onode->arguments.size();i++) { if (i>1) code+=", "; //transform code+="vec4( "+dump_node_code(onode->arguments[i],p_level)+(i==4?",1.0)":",0.0)"); } } else*/ if (callfunc=="tex") { code="texture2D( "+dump_node_code(onode->arguments[1],p_level)+","+dump_node_code(onode->arguments[2],p_level)+")"; break; } else if (callfunc=="texcube") { code="(textureCube( "+dump_node_code(onode->arguments[1],p_level)+",("+dump_node_code(onode->arguments[2],p_level)+")).xyz"; break; } else if (callfunc=="texscreen") { //create the call to sample the screen, and clamp it uses_texscreen=true; code="(texture2D( texscreen_tex, min(("+dump_node_code(onode->arguments[1],p_level)+").xy*texscreen_screen_mult,texscreen_screen_mult))).rgb"; //code="(texture2D( screen_texture, ("+dump_node_code(onode->arguments[1],p_level)+").xy).rgb"; break; } else if (callfunc=="texpos") { //create the call to sample the screen, and clamp it uses_texpos=true; code="get_texpos("+dump_node_code(onode->arguments[1],p_level)+""; // code="get_texpos(gl_ProjectionMatrixInverse * texture2D( depth_texture, clamp(("+dump_node_code(onode->arguments[1],p_level)+").xy,vec2(0.0),vec2(1.0))*gl_LightSource[5].specular.zw+gl_LightSource[5].specular.xy)"; //code="(texture2D( screen_texture, ("+dump_node_code(onode->arguments[1],p_level)+").xy).rgb"; break; } else { for(int i=1;i<onode->arguments.size();i++) { if (i>1) code+=", "; //transform code+=dump_node_code(onode->arguments[i],p_level); } } code+=")"; break; } break; default: {} } } break; case SL::Node::TYPE_CONTROL_FLOW: { SL::ControlFlowNode *cfnode=(SL::ControlFlowNode*)p_node; if (cfnode->flow_op==SL::FLOW_OP_IF) { code+="if ("+dump_node_code(cfnode->statements[0],p_level)+") {"ENDL; code+=dump_node_code(cfnode->statements[1],p_level+1); if (cfnode->statements.size()==3) { code+="} else {"ENDL; code+=dump_node_code(cfnode->statements[2],p_level+1); } code+="}"ENDL; } else if (cfnode->flow_op==SL::FLOW_OP_RETURN) { if (cfnode->statements.size()) { code="return "+dump_node_code(cfnode->statements[0],p_level); } else { code="return"; } } } break; case SL::Node::TYPE_MEMBER: { SL::MemberNode *mnode=(SL::MemberNode*)p_node; String m; if (mnode->basetype==SL::TYPE_MAT4) { if (mnode->name=="x") m="[0]"; else if (mnode->name=="y") m="[1]"; else if (mnode->name=="z") m="[2]"; else if (mnode->name=="w") m="[3]"; } else if (mnode->basetype==SL::TYPE_MAT3) { if (mnode->name=="x") m="[0]"; else if (mnode->name=="y") m="[1]"; else if (mnode->name=="z") m="[2]"; } else { m="."+mnode->name; } code=dump_node_code(mnode->owner,p_level)+m; } break; } return code; }