/*************************************************************************/
/*  shader_compiler_gles2.cpp                                            */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#include "shader_compiler_gles2.h"
#include "print_string.h"

#include "stdio.h"

//#define DEBUG_SHADER_ENABLED

typedef ShaderLanguage SL;

struct CodeGLSL2 {

	String code;
};

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) {

	switch (p_type) {

		case SL::TYPE_VOID: return "void";
		case SL::TYPE_BOOL: return "bool";
		case SL::TYPE_FLOAT: return "float";
		case SL::TYPE_VEC2: return "vec2";
		case SL::TYPE_VEC3: return "vec3";
		case SL::TYPE_VEC4: return "vec4";
		case SL::TYPE_MAT2: return "mat2";
		case SL::TYPE_MAT3: return "mat3";
		case SL::TYPE_MAT4: return "mat4";
		case SL::TYPE_TEXTURE: return "sampler2D";
		case SL::TYPE_CUBEMAP: return "samplerCube";
	}

	return "";
}

static String _mknum(float p_num) {
	return String::num_real(p_num);
}

static String _opstr(SL::Operator p_op) {

	switch (p_op) {
		case SL::OP_ASSIGN: return "=";
		case SL::OP_ADD: return "+";
		case SL::OP_SUB: return "-";
		case SL::OP_MUL: return "*";
		case SL::OP_DIV: return "/";
		case SL::OP_ASSIGN_ADD: return "+=";
		case SL::OP_ASSIGN_SUB: return "-=";
		case SL::OP_ASSIGN_MUL: return "*=";
		case SL::OP_ASSIGN_DIV: return "/=";
		case SL::OP_NEG: return "-";
		case SL::OP_NOT: return "!";
		case SL::OP_CMP_EQ: return "==";
		case SL::OP_CMP_NEQ: return "!=";
		case SL::OP_CMP_LEQ: return "<=";
		case SL::OP_CMP_GEQ: return ">=";
		case SL::OP_CMP_LESS: return "<";
		case SL::OP_CMP_GREATER: return ">";
		case SL::OP_CMP_OR: return "||";
		case SL::OP_CMP_AND: return "&&";
		default: return "";
	}

	return "";
}

//#ifdef DEBUG_SHADER_ENABLED
#if 1
#define ENDL "\n"
#else
#define ENDL ""
#endif

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
			code += "{" ENDL;
			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;
			}

			code += "}" 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 (vnode->name == vname_position && p_assign_left) {
					vertex_code_writes_position = 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_FRAGMENT) {

				if (vnode->name == vname_discard) {
					uses_discard = true;
				}
				if (vnode->name == vname_normalmap) {
					uses_normalmap = 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_shadow) {
					uses_shadow_color = true;
				}
			}
			if (type == ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX) {

				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_world_vec) {
					uses_worldvec = true;
				}
			}

			if (type == ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT) {

				if (vnode->name == vname_texpixel_size) {
					uses_texpixel_size = true;
				}
				if (vnode->name == vname_normal) {
					uses_normal = true;
				}
				if (vnode->name == vname_normalmap || vnode->name == vname_normalmap_depth) {
					uses_normalmap = true;
					uses_normal = true;
				}

				if (vnode->name == vname_screen_uv) {
					uses_screen_uv = true;
				}

				if (vnode->name == vname_var1_interp) {
					flags->use_var1_interp = true;
				}
				if (vnode->name == vname_var2_interp) {
					flags->use_var2_interp = true;
				}
			}

			if (type == ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT) {

				if (vnode->name == vname_light) {
					uses_light = true;
				}

				if (vnode->name == vname_normal) {
					uses_normal = true;
				}

				if (vnode->name == vname_shadow) {
					uses_shadow_color = 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_MAT2: {
					Matrix32 x = cnode->value;
					code = "mat2( vec2(" + _mknum(x[0][0]) + ", " + _mknum(x[0][1]) + "), vec2(" + _mknum(x[1][0]) + ", " + _mknum(x[1][1]) + "))";
				} 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 + ",0.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 + ",0.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) + ",0.0,1.0)).xy";
						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) + ",0.0,1.0)*" + dump_node_code(onode->arguments[1], p_level) + ").xy";
						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, clamp((" + dump_node_code(onode->arguments[1], p_level) + ").xy*texscreen_screen_mult,texscreen_screen_clamp.xy,texscreen_screen_clamp.zw))).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 if (custom_h && callfunc == "cosh_custom") {

						if (!cosh_used) {
							global_code =
									"float cosh_custom(float val)\n"
									"{\n"
									"    float tmp = exp(val);\n"
									"    float cosH = (tmp + 1.0 / tmp) / 2.0;\n"
									"    return cosH;\n"
									"}\n" +
									global_code;
							cosh_used = true;
						}
						code = "cosh_custom(" + dump_node_code(onode->arguments[1], p_level) + "";
					} else if (custom_h && callfunc == "sinh_custom") {

						if (!sinh_used) {
							global_code =
									"float sinh_custom(float val)\n"
									"{\n"
									"    float tmp = exp(val);\n"
									"    float sinH = (tmp - 1.0 / tmp) / 2.0;\n"
									"    return sinH;\n"
									"}\n" +
									global_code;
							sinh_used = true;
						}
						code = "sinh_custom(" + dump_node_code(onode->arguments[1], p_level) + "";
					} else if (custom_h && callfunc == "tanh_custom") {

						if (!tanh_used) {
							global_code =
									"float tanh_custom(float val)\n"
									"{\n"
									"    float tmp = exp(val);\n"
									"    float tanH = (tmp - 1.0 / tmp) / (tmp + 1.0 / tmp);\n"
									"    return tanH;\n"
									"}\n" +
									global_code;
							tanh_used = true;
						}
						code = "tanh_custom(" + dump_node_code(onode->arguments[1], p_level) + "";

					} 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) {

				// Help lazy drivers
				if (!_is_condition_preprocessable(cfnode->statements[0])) {

					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 {

					code += "#if (" + dump_node_code(cfnode->statements[0], p_level) + ")" ENDL;
					code += dump_node_code(cfnode->statements[1], p_level);
					if (cfnode->statements.size() == 3) {

						code += "#else" ENDL;
						code += dump_node_code(cfnode->statements[2], p_level);
					}

					code += "#endif" 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_MAT2) {
				if (mnode->name == "x")
					m = "[0]";
				else if (mnode->name == "y")
					m = "[1]";

			} 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;
}

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) {
			// Check to avoid uniforms with the same name being re-added to avoid overwriting entries
			if (!uniforms->has(E->key())) {
				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;
}

Error ShaderCompilerGLES2::create_glsl_120_code(void *p_str, SL::ProgramNode *p_program) {

	ShaderCompilerGLES2 *compiler = (ShaderCompilerGLES2 *)p_str;
	return compiler->compile_node(p_program);
}

String ShaderCompilerGLES2::replace_string(const StringName &p_string) {

	Map<StringName, StringName>::Element *E = NULL;
	E = replace_table.find(p_string);
	if (E)
		return E->get();

	E = mode_replace_table[type].find(p_string);
	if (E)
		return E->get();

	return "_" + p_string.operator String();
}

bool ShaderCompilerGLES2::_is_condition_preprocessable(ShaderLanguage::Node *p_condition) const {

	// Check if this is a "(!)variable" expression

	SL::Node *maybe_variable;
	if (p_condition->type == SL::Node::TYPE_OPERATOR) {
		SL::OperatorNode *op = (SL::OperatorNode *)p_condition;
		if (op->op != SL::OP_NOT)
			return false;
		maybe_variable = op->arguments[0];
	} else {
		maybe_variable = p_condition;
	}

	if (maybe_variable->type != SL::Node::TYPE_VARIABLE)
		return false;

	SL::VariableNode *variable = (SL::VariableNode *)maybe_variable;
	// Hardcoding since it's currently the only;
	// if more were added, they would be better characterized
	// in the various ShaderLanguage::BuiltinsDef
	if (variable->name != String("AT_LIGHT_PASS"))
		return false;

	return true;
}

Error ShaderCompilerGLES2::compile(const String &p_code, ShaderLanguage::ShaderType p_type, String &r_code_line, String &r_globals_line, Flags &r_flags, Map<StringName, ShaderLanguage::Uniform> *r_uniforms) {

	uses_texscreen = false;
	uses_texpos = false;
	uses_alpha = false;
	uses_discard = false;
	uses_screen_uv = false;
	uses_light = false;
	uses_time = false;
	uses_normalmap = false;
	uses_normal = false;
	uses_texpixel_size = false;
	uses_worldvec = false;
	vertex_code_writes_vertex = false;
	vertex_code_writes_position = false;
	uses_shadow_color = false;
	uniforms = r_uniforms;
	flags = &r_flags;
	r_flags.use_color_interp = false;
	r_flags.use_uv_interp = false;
	r_flags.use_uv2_interp = false;
	r_flags.use_tangent_interp = false;
	r_flags.use_var1_interp = false;
	r_flags.use_var2_interp = false;
	r_flags.uses_normalmap = false;
	r_flags.uses_normal = false;
	sinh_used = false;
	tanh_used = false;
	cosh_used = false;

	String error;
	int errline, errcol;

	type = p_type;
	Error err = SL::compile(p_code, p_type, create_glsl_120_code, this, &error, &errline, &errcol);

	if (err) {
		print_line("***Error precompiling shader: " + error);
		print_line("error " + itos(errline) + ":" + itos(errcol));
		return err;
	}

	r_flags.uses_alpha = uses_alpha;
	r_flags.uses_texscreen = uses_texscreen;
	r_flags.uses_texpos = uses_texpos;
	r_flags.vertex_code_writes_vertex = vertex_code_writes_vertex;
	r_flags.vertex_code_writes_position = vertex_code_writes_position;
	r_flags.uses_discard = uses_discard;
	r_flags.uses_screen_uv = uses_screen_uv;
	r_flags.uses_light = uses_light;
	r_flags.uses_time = uses_time;
	r_flags.uses_normalmap = uses_normalmap;
	r_flags.uses_normal = uses_normal;
	r_flags.uses_texpixel_size = uses_texpixel_size;
	r_flags.uses_worldvec = uses_worldvec;
	r_flags.uses_shadow_color = uses_shadow_color;
	r_code_line = code;
	r_globals_line = global_code;
	return OK;
}

ShaderCompilerGLES2::ShaderCompilerGLES2() {

#ifdef GLEW_ENABLED
	//use custom functions because they are not supported in GLSL120
	custom_h = true;
#else
	custom_h = false;
#endif

	replace_table["bool"] = "bool";
	replace_table["float"] = "float";
	replace_table["vec2"] = "vec2";
	replace_table["vec3"] = "vec3";
	replace_table["vec4"] = "vec4";
	replace_table["mat2"] = "mat2";
	replace_table["mat3"] = "mat3";
	replace_table["mat4"] = "mat4";
	replace_table["texture"] = "sampler2D";
	replace_table["cubemap"] = "samplerCube";

	replace_table["sin"] = "sin";
	replace_table["cos"] = "cos";
	replace_table["tan"] = "tan";
	replace_table["asin"] = "asin";
	replace_table["acos"] = "acos";
	replace_table["atan"] = "atan";
	replace_table["atan2"] = "atan";

	if (custom_h) {
		replace_table["sinh"] = "sinh_custom";
		replace_table["cosh"] = "cosh_custom";
		replace_table["tanh"] = "tanh_custom";
	} else {
		replace_table["sinh"] = "sinh";
		replace_table["cosh"] = "cosh";
		replace_table["tanh"] = "tanh";
	}

	replace_table["pow"] = "pow";
	replace_table["exp"] = "exp";
	replace_table["log"] = "log";
	replace_table["sqrt"] = "sqrt";
	replace_table["abs"] = "abs";
	replace_table["sign"] = "sign";
	replace_table["floor"] = "floor";
	replace_table["trunc"] = "trunc";
#ifdef GLEW_ENABLED
	replace_table["round"] = "roundfix";
#else
	replace_table["round"] = "round";
#endif
	replace_table["ceil"] = "ceil";
	replace_table["fract"] = "fract";
	replace_table["mod"] = "mod";
	replace_table["min"] = "min";
	replace_table["max"] = "max";
	replace_table["clamp"] = "clamp";
	replace_table["mix"] = "mix";
	replace_table["step"] = "step";
	replace_table["smoothstep"] = "smoothstep";
	replace_table["length"] = "length";
	replace_table["distance"] = "distance";
	replace_table["dot"] = "dot";
	replace_table["cross"] = "cross";
	replace_table["normalize"] = "normalize";
	replace_table["reflect"] = "reflect";
	replace_table["refract"] = "refract";
	replace_table["tex"] = "tex";
	replace_table["texa"] = "texa";
	replace_table["tex2"] = "tex2";
	replace_table["texcube"] = "textureCube";
	replace_table["texscreen"] = "texscreen";
	replace_table["texpos"] = "texpos";

	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SRC_VERTEX"] = "vertex_in.xyz";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SRC_NORMAL"] = "normal_in";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SRC_TANGENT"] = "tangent_in";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SRC_BINORMALF"] = "binormalf";

	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["POSITION"] = "gl_Position";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["VERTEX"] = "vertex_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["NORMAL"] = "normal_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["TANGENT"] = "tangent_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["BINORMAL"] = "binormal_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["UV"] = "uv_interp.xy";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["UV2"] = "uv_interp.zw";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["COLOR"] = "color_interp";
	//@TODO convert to glsl stuff
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SPEC_EXP"] = "vertex_specular_exp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["WORLD_MATRIX"] = "world_transform";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["INV_CAMERA_MATRIX"] = "camera_inverse_transform";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["PROJECTION_MATRIX"] = "projection_transform";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["MODELVIEW_MATRIX"] = "modelview";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["POINT_SIZE"] = "gl_PointSize";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["VAR1"] = "var1_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["VAR2"] = "var2_interp";

	//	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SCREEN_POS"]="SCREEN_POS";
	//	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["SCREEN_SIZE"]="SCREEN_SIZE";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["INSTANCE_ID"] = "instance_id";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_VERTEX]["TIME"] = "time";

	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["VERTEX"] = "vertex";
	//mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["POSITION"]="IN_POSITION";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["NORMAL"] = "normal";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["TANGENT"] = "tangent";
	//mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["POSITION"]="gl_Position";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["POSITION"] = "gl_FragCoord";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["BINORMAL"] = "binormal";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["NORMALMAP"] = "normalmap";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["NORMALMAP_DEPTH"] = "normaldepth";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["VAR1"] = "var1_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["VAR2"] = "var2_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["UV"] = "uv";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["UV2"] = "uv2";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["SCREEN_UV"] = "screen_uv";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["VAR1"] = "var1_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["VAR2"] = "var2_interp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["COLOR"] = "color";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["DIFFUSE"] = "diffuse.rgb";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["DIFFUSE_ALPHA"] = "diffuse";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["SPECULAR"] = "specular";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["EMISSION"] = "emission";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["SHADE_PARAM"] = "shade_param";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["SPEC_EXP"] = "specular_exp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["GLOW"] = "glow";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["DISCARD"] = "discard_";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["POINT_COORD"] = "gl_PointCoord";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["INV_CAMERA_MATRIX"] = "camera_inverse_transform";

	//mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["SCREEN_POS"]="SCREEN_POS";
	//mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["SCREEN_TEXEL_SIZE"]="SCREEN_TEXEL_SIZE";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_FRAGMENT]["TIME"] = "time";

	//////////////

	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["NORMAL"] = "normal";
	//mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["POSITION"]="IN_POSITION";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["LIGHT_DIR"] = "light_dir";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["LIGHT_DIFFUSE"] = "light_diffuse";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["LIGHT_SPECULAR"] = "light_specular";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["EYE_VEC"] = "eye_vec";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["DIFFUSE"] = "mdiffuse";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["SPECULAR"] = "specular";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["SPECULAR_EXP"] = "specular_exp";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["SHADE_PARAM"] = "shade_param";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["LIGHT"] = "light";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["POINT_COORD"] = "gl_PointCoord";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["TIME"] = "time";
	mode_replace_table[ShaderLanguage::SHADER_MATERIAL_LIGHT]["SHADOW"] = "shadow_color";

	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["SRC_VERTEX"] = "src_vtx";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["VERTEX"] = "outvec.xy";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["WORLD_VERTEX"] = "outvec.xy";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["UV"] = "uv_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["COLOR"] = "color_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["VAR1"] = "var1_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["VAR2"] = "var2_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["POINT_SIZE"] = "gl_PointSize";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["WORLD_MATRIX"] = "modelview_matrix";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["PROJECTION_MATRIX"] = "projection_matrix";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["EXTRA_MATRIX"] = "extra_matrix";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["TIME"] = "time";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_VERTEX]["AT_LIGHT_PASS"] = "at_light_pass";

	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["POSITION"] = "(gl_FragCoord.xy)";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["NORMAL"] = "normal";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["NORMALMAP"] = "normal_map";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["NORMALMAP_DEPTH"] = "normal_depth";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["UV"] = "uv_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["SRC_COLOR"] = "color_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["COLOR"] = "color";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["TEXTURE"] = "texture";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["TEXTURE_PIXEL_SIZE"] = "texpixel_size";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["VAR1"] = "var1_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["VAR2"] = "var2_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["SCREEN_UV"] = "screen_uv";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["POINT_COORD"] = "gl_PointCoord";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["TIME"] = "time";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_FRAGMENT]["AT_LIGHT_PASS"] = "at_light_pass";

	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["POSITION"] = "(gl_FragCoord.xy)";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["NORMAL"] = "normal";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["UV"] = "uv_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["COLOR"] = "color";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["TEXTURE"] = "texture";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["TEXTURE_PIXEL_SIZE"] = "texpixel_size";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["VAR1"] = "var1_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["VAR2"] = "var2_interp";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["LIGHT_VEC"] = "light_vec";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["LIGHT_HEIGHT"] = "light_height";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["LIGHT_COLOR"] = "light";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["LIGHT_SHADOW"] = "light_shadow_color";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["LIGHT_UV"] = "light_uv";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["LIGHT"] = "light_out";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["SHADOW"] = "shadow_color";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["SCREEN_UV"] = "screen_uv";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["POINT_COORD"] = "gl_PointCoord";
	mode_replace_table[ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT]["TIME"] = "time";

	//mode_replace_table[2]["SCREEN_POS"]="SCREEN_POS";
	//mode_replace_table[2]["SCREEN_TEXEL_SIZE"]="SCREEN_TEXEL_SIZE";

	out_vertex_name = "VERTEX";

	vname_discard = "DISCARD";
	vname_screen_uv = "SCREEN_UV";
	vname_diffuse_alpha = "DIFFUSE_ALPHA";
	vname_color_interp = "COLOR";
	vname_uv_interp = "UV";
	vname_uv2_interp = "UV2";
	vname_tangent_interp = "TANGENT";
	vname_binormal_interp = "BINORMAL";
	vname_var1_interp = "VAR1";
	vname_var2_interp = "VAR2";
	vname_vertex = "VERTEX";
	vname_position = "POSITION";
	vname_light = "LIGHT";
	vname_time = "TIME";
	vname_normalmap = "NORMALMAP";
	vname_normalmap_depth = "NORMALMAP_DEPTH";
	vname_normal = "NORMAL";
	vname_texpixel_size = "TEXTURE_PIXEL_SIZE";
	vname_world_vec = "WORLD_VERTEX";
	vname_shadow = "SHADOW";
}