godot/methods.py

import os


def add_source_files(self, sources, filetype, lib_env=None, shared=False):
    import glob
    import string
    # if not lib_objects:
    if not lib_env:
        lib_env = self
    if type(filetype) == type(""):

        dir = self.Dir('.').abspath
        list = glob.glob(dir + "/" + filetype)
        for f in list:
            sources.append(self.Object(f))
    else:
        for f in filetype:
            sources.append(self.Object(f))


def build_shader_header(target, source, env):

    for x in source:
        print x

        name = str(x)
        name = name[name.rfind("/") + 1:]
        name = name[name.rfind("\\") + 1:]
        name = name.replace(".", "_")

        fs = open(str(x), "r")
        fd = open(str(x) + ".h", "w")
        fd.write("/* this file has been generated by SCons, do not edit! */\n")
        fd.write("static const char *" + name + "=\n")
        line = fs.readline()
        while(line):
            line = line.replace("\r", "")
            line = line.replace("\n", "")
            line = line.replace("\\", "\\\\")
            line = line.replace("\"", "\\\"")
            fd.write("\"" + line + "\\n\"\n")
            line = fs.readline()

        fd.write(";\n")

    return 0


def build_glsl_header(filename):

    fs = open(filename, "r")
    line = fs.readline()

    vertex_lines = []
    fragment_lines = []
    uniforms = []
    attributes = []
    fbos = []
    conditionals = []
    texunits = []
    texunit_names = []
    ubos = []
    ubo_names = []

    reading = ""
    line_offset = 0
    vertex_offset = 0
    fragment_offset = 0

    while(line):

        if (line.find("[vertex]") != -1):
            reading = "vertex"
            line = fs.readline()
            line_offset += 1
            vertex_offset = line_offset
            continue

        if (line.find("[fragment]") != -1):
            reading = "fragment"
            line = fs.readline()
            line_offset += 1
            fragment_offset = line_offset
            continue

        if (line.find("#ifdef ") != -1):
            ifdefline = line.replace("#ifdef ", "").strip()
            if (not ifdefline in conditionals):
                conditionals += [ifdefline]

        if (line.find("#elif defined(") != -1):
            ifdefline = line.replace("#elif defined(", "").strip()
            ifdefline = ifdefline.replace(")", "").strip()
            if (not ifdefline in conditionals):
                conditionals += [ifdefline]

        import re
        if re.search(r"^\s*uniform", line):

            if (line.lower().find("texunit:") != -1):
                # texture unit
                texunit = str(int(line[line.find(":") + 1:].strip()))
                uline = line[:line.lower().find("//")]
                uline = uline.replace("uniform", "")
                uline = uline.replace(";", "")
                lines = uline.split(",")
                for x in lines:

                    x = x.strip()
                    x = x[x.rfind(" ") + 1:]
                    if (x.find("[") != -1):
                        # unfiorm array
                        x = x[:x.find("[")]

                    if (not x in texunit_names):
                        texunits += [(x, texunit)]
                        texunit_names += [x]

            elif (line.lower().find("ubo:") != -1):
                # ubo
                uboidx = str(int(line[line.find(":") + 1:].strip()))
                uline = line[:line.lower().find("//")]
                uline = uline[uline.find("uniform") + len("uniform"):]
                uline = uline.replace(";", "")
                uline = uline.replace("{", "")
                lines = uline.split(",")
                for x in lines:

                    x = x.strip()
                    x = x[x.rfind(" ") + 1:]
                    if (x.find("[") != -1):
                        # unfiorm array
                        x = x[:x.find("[")]

                    if (not x in ubo_names):
                        ubos += [(x, uboidx)]
                        ubo_names += [x]

            else:
                uline = line.replace("uniform", "")
                uline = uline.replace(";", "")
                lines = uline.split(",")
                for x in lines:

                    x = x.strip()
                    x = x[x.rfind(" ") + 1:]
                    if (x.find("[") != -1):
                        # unfiorm array
                        x = x[:x.find("[")]

                    if (not x in uniforms):
                        uniforms += [x]

        if ((line.strip().find("in ") == 0 or line.strip().find("attribute ") == 0) and line.find("attrib:") != -1):
            uline = line.replace("in ", "")
            uline = uline.replace("attribute ", "")
            uline = uline.replace(";", "")
            uline = uline[uline.find(" "):].strip()

            if (uline.find("//") != -1):
                name, bind = uline.split("//")
                if (bind.find("attrib:") != -1):
                    name = name.strip()
                    bind = bind.replace("attrib:", "").strip()
                    attributes += [(name, bind)]

        if (line.strip().find("out ") == 0):
            uline = line.replace("out", "").strip()
            uline = uline.replace(";", "")
            uline = uline[uline.find(" "):].strip()

            if (uline.find("//") != -1):
                name, bind = uline.split("//")
                if (bind.find("drawbuffer:") != -1):
                    name = name.strip()
                    bind = bind.replace("drawbuffer:", "").strip()
                    fbos += [(name, bind)]

        line = line.replace("\r", "")
        line = line.replace("\n", "")
        line = line.replace("\\", "\\\\")
        line = line.replace("\"", "\\\"")
        # line=line+"\\n\\" no need to anymore

        if (reading == "vertex"):
            vertex_lines += [line]
        if (reading == "fragment"):
            fragment_lines += [line]

        line = fs.readline()
        line_offset += 1

    fs.close()

    out_file = filename + ".h"
    fd = open(out_file, "w")

    fd.write("/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */\n")

    out_file_base = out_file
    out_file_base = out_file_base[out_file_base.rfind("/") + 1:]
    out_file_base = out_file_base[out_file_base.rfind("\\") + 1:]
#	print("out file "+out_file+" base " +out_file_base)
    out_file_ifdef = out_file_base.replace(".", "_").upper()
    fd.write("#ifndef " + out_file_ifdef + "\n")
    fd.write("#define " + out_file_ifdef + "\n")

    out_file_class = out_file_base.replace(".glsl.h", "").title().replace("_", "").replace(".", "") + "ShaderGL"
    fd.write("\n\n")
    fd.write("#include \"drivers/opengl/shader_gl.h\"\n\n\n")
    fd.write("class " + out_file_class + " : public ShaderGL {\n\n")
    fd.write("\t virtual String get_shader_name() const { return \"" + out_file_class + "\"; }\n")
    fd.write("public:\n\n")

    if (len(conditionals)):
        fd.write("\tenum Conditionals {\n")
        for x in conditionals:
            fd.write("\t\t" + x + ",\n")
        fd.write("\t};\n\n")
    if (len(uniforms)):
        fd.write("\tenum Uniforms {\n")
        for x in uniforms:
            fd.write("\t\t" + x.upper() + ",\n")
        fd.write("\t};\n\n")

    fd.write("\t_FORCE_INLINE_ int get_uniform(Uniforms p_uniform) const { return _get_uniform(p_uniform); }\n\n")
    if (len(conditionals)):

        fd.write("\t_FORCE_INLINE_ void set_conditional(Conditionals p_conditional,bool p_enable)  {  _set_conditional(p_conditional,p_enable); }\n\n")
    fd.write("\t#define _FU if (get_uniform(p_uniform)<0) return; ERR_FAIL_COND( get_active()!=this );\n\n ")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, double p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint64_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n");
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int64_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n");
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, unsigned long p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, long p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Color& p_color) { _FU GLfloat col[4]={p_color.r,p_color.g,p_color.b,p_color.a}; glUniform4fv(get_uniform(p_uniform),1,col); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector2& p_vec2) { _FU GLfloat vec2[2]={p_vec2.x,p_vec2.y}; glUniform2fv(get_uniform(p_uniform),1,vec2); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector3& p_vec3) { _FU GLfloat vec3[3]={p_vec3.x,p_vec3.y,p_vec3.z}; glUniform3fv(get_uniform(p_uniform),1,vec3); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b) { _FU glUniform2f(get_uniform(p_uniform),p_a,p_b); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c) { _FU glUniform3f(get_uniform(p_uniform),p_a,p_b,p_c); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, float p_d) { _FU glUniform4f(get_uniform(p_uniform),p_a,p_b,p_c,p_d); }\n\n")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform& p_transform) {  _FU

		const Transform &tr = p_transform;

		GLfloat matrix[16]={ /* build a 16x16 matrix */
			tr.basis.elements[0][0],
			tr.basis.elements[1][0],
			tr.basis.elements[2][0],
			0,
			tr.basis.elements[0][1],
			tr.basis.elements[1][1],
			tr.basis.elements[2][1],
			0,
			tr.basis.elements[0][2],
			tr.basis.elements[1][2],
			tr.basis.elements[2][2],
			0,
			tr.origin.x,
			tr.origin.y,
			tr.origin.z,
			1
		};


	glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);


	}

	""")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Matrix32& p_transform) {  _FU

		const Matrix32 &tr = p_transform;

		GLfloat matrix[16]={ /* build a 16x16 matrix */
			tr.elements[0][0],
			tr.elements[0][1],
			0,
			0,
			tr.elements[1][0],
			tr.elements[1][1],
			0,
			0,
			0,
			0,
			1,
			0,
			tr.elements[2][0],
			tr.elements[2][1],
			0,
			1
		};


	glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);


	}

	""")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const CameraMatrix& p_matrix) {  _FU

		GLfloat matrix[16];

		for (int i=0;i<4;i++) {
			for (int j=0;j<4;j++) {

				matrix[i*4+j]=p_matrix.matrix[i][j];
			}
		}

		glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);
	}; """)

    fd.write("\n\n#undef _FU\n\n\n")

    fd.write("\tvirtual void init() {\n\n")
    if (len(conditionals)):

        fd.write("\t\tstatic const char* _conditional_strings[]={\n")
        if (len(conditionals)):
            for x in conditionals:
                fd.write("\t\t\t\"#define " + x + "\\n\",\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const char **_conditional_strings=NULL;\n")

    if (len(uniforms)):

        fd.write("\t\tstatic const char* _uniform_strings[]={\n")
        if (len(uniforms)):
            for x in uniforms:
                fd.write("\t\t\t\"" + x + "\",\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const char **_uniform_strings=NULL;\n")

    if (len(attributes)):

        fd.write("\t\tstatic AttributePair _attribute_pairs[]={\n")
        for x in attributes:
            fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic AttributePair *_attribute_pairs=NULL;\n")

    if (len(fbos)):
        fd.write("\t\tstatic FBOPair _fbo_pairs[]={\n")
        for x in fbos:
            fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic FBOPair *_fbo_pairs=NULL;\n")

    if (len(ubos)):
        fd.write("\t\tstatic UBOPair _ubo_pairs[]={\n")
        for x in ubos:
            fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic UBOPair *_ubo_pairs=NULL;\n")

    if (len(texunits)):
        fd.write("\t\tstatic TexUnitPair _texunit_pairs[]={\n")
        for x in texunits:
            fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic TexUnitPair *_texunit_pairs=NULL;\n")

    fd.write("\t\tstatic const char* _vertex_code=\"\\\n")
    for x in vertex_lines:
        fd.write("\t\t\t" + x + "\n")
    fd.write("\t\t\";\n\n")

    fd.write("\t\tstatic const int _vertex_code_start=" + str(vertex_offset) + ";\n")

    fd.write("\t\tstatic const char* _fragment_code=\"\\\n")
    for x in fragment_lines:
        fd.write("\t\t\t" + x + "\n")
    fd.write("\t\t\";\n\n")

    fd.write("\t\tstatic const int _fragment_code_start=" + str(fragment_offset) + ";\n")

    fd.write("\t\tsetup(_conditional_strings," + str(len(conditionals)) + ",_uniform_strings," + str(len(uniforms)) + ",_attribute_pairs," + str(len(attributes)) + ",_fbo_pairs," + str(len(fbos)) + ",_ubo_pairs," + str(len(ubos)) + ",_texunit_pairs," + str(len(texunits)) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
    fd.write("\t};\n\n")

    fd.write("};\n\n")
    fd.write("#endif\n\n")
    fd.close()


def build_glsl_headers(target, source, env):

    for x in source:

        build_glsl_header(str(x))

    return 0


def build_hlsl_dx9_header(filename):

    fs = open(filename, "r")
    line = fs.readline()

    vertex_lines = []
    fragment_lines = []
    uniforms = []
    fragment_uniforms = []
    attributes = []
    fbos = []
    conditionals = []

    reading = ""
    line_offset = 0
    vertex_offset = 0
    fragment_offset = 0

    while(line):

        if (line.find("[vertex]") != -1):
            reading = "vertex"
            line = fs.readline()
            line_offset += 1
            vertex_offset = line_offset
            continue

        if (line.find("[fragment]") != -1):
            reading = "fragment"
            line = fs.readline()
            line_offset += 1
            fragment_offset = line_offset
            continue

        if (line.find("#ifdef ") != -1):
            ifdefline = line.replace("#ifdef ", "").strip()
            if (not ifdefline in conditionals):
                conditionals += [ifdefline]

        if (line.find("#elif defined(") != -1):
            ifdefline = line.replace("#elif defined(", "").strip()
            ifdefline = ifdefline.replace(")", "").strip()
            if (not ifdefline in conditionals):
                conditionals += [ifdefline]
        if (line.find("uniform") != -1):
            uline = line.replace("uniform", "")
            uline = uline.replace(";", "")
            lines = uline.split(",")
            for x in lines:

                x = x.strip()
                x = x[x.rfind(" ") + 1:]
                if (x.find("[") != -1):
                    # unfiorm array
                    x = x[:x.find("[")]

                if (not x in uniforms):
                    uniforms += [x]
                    fragment_uniforms += [reading == "fragment"]
        line = line.replace("\r", "")
        line = line.replace("\n", "")
        line = line.replace("\\", "\\\\")
        line = line.replace("\"", "\\\"")
        line = line + "\\n\\"

        if (reading == "vertex"):
            vertex_lines += [line]
        if (reading == "fragment"):
            fragment_lines += [line]

        line = fs.readline()
        line_offset += 1

    fs.close()

    out_file = filename + ".h"
    fd = open(out_file, "w")

    fd.write("/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */\n")

    out_file_base = out_file
    out_file_base = out_file_base[out_file_base.rfind("/") + 1:]
    out_file_base = out_file_base[out_file_base.rfind("\\") + 1:]
#	print("out file "+out_file+" base " +out_file_base)
    out_file_ifdef = out_file_base.replace(".", "_").upper()
    fd.write("#ifndef " + out_file_ifdef + "\n")
    fd.write("#define " + out_file_ifdef + "\n")

    out_file_class = out_file_base.replace(".hlsl.h", "").title().replace("_", "").replace(".", "") + "ShaderDX9"
    fd.write("\n\n")
    fd.write("#include \"drivers/directx9/shader_dx9.h\"\n\n\n")
    fd.write("class " + out_file_class + " : public ShaderDX9 {\n\n")
    fd.write("\t virtual String get_shader_name() const { return \"" + out_file_class + "\"; }\n")
    fd.write("public:\n\n")

    if (len(conditionals)):
        fd.write("\tenum Conditionals {\n")
        for x in conditionals:
            fd.write("\t\t" + x + ",\n")
        fd.write("\t};\n\n")
    if (len(uniforms)):
        fd.write("\tenum Uniforms {\n")
        for x in uniforms:
            fd.write("\t\t" + x.upper() + ",\n")
        fd.write("\t};\n\n")

    if (len(conditionals)):
        fd.write("\t_FORCE_INLINE_ void set_conditional(Conditionals p_conditional,bool p_enable)  {  _set_conditional(p_conditional,p_enable); }\n\n")

    fd.write("\t#define _FU if (!_uniform_valid(p_uniform)) return; ERR_FAIL_COND( get_active()!=this );\n\n ")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, bool p_value) { _FU set_uniformb(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_value) { _FU set_uniformf(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, double p_value) { _FU set_uniformf(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint8_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int8_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint16_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int16_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint32_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int32_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint64_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n");
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int64_t p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n");
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, unsigned long p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, long p_value) { _FU set_uniformi(p_uniform,p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Color& p_color) { _FU float col[4]={p_color.r,p_color.g,p_color.b,p_color.a}; set_uniformfv(p_uniform,col); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector2& p_vec2) { _FU float vec2[4]={p_vec2.x,p_vec2.y,0,0}; set_uniformfv(p_uniform,vec2); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector3& p_vec3) { _FU float vec3[4]={p_vec3.x,p_vec3.y,p_vec3.z,0}; set_uniformfv(p_uniform,vec3); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b) { _FU float vec2[4]={p_a,p_b,0,0}; set_uniformfv(p_uniform,vec2); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c) { _FU float vec3[4]={p_a,p_b,p_c,0}; set_uniformfv(p_uniform,vec3); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, float p_d) { _FU float vec4[4]={p_a,p_b,p_c,p_d}; set_uniformfv(p_uniform,vec4); }\n\n")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform& p_transform) {  _FU

		const Transform &tr = p_transform;

		float matrix[16]={ /* build a 16x16 matrix */
			tr.basis.elements[0][0],
			tr.basis.elements[0][1],
			tr.basis.elements[0][2],
			tr.origin.x,
			tr.basis.elements[1][0],
			tr.basis.elements[1][1],
			tr.basis.elements[1][2],
			tr.origin.y,
			tr.basis.elements[2][0],
			tr.basis.elements[2][1],
			tr.basis.elements[2][2],
			tr.origin.z,
			0,
			0,
			0,
			1
		};

		set_uniformfv(p_uniform,&matrix[0],4);

	}

	""")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const CameraMatrix& p_matrix) {  _FU

		float matrix[16];

		for (int i=0;i<4;i++) {
			for (int j=0;j<4;j++) {

				matrix[i*4+j]=p_matrix.matrix[j][i];
			}
		}

		set_uniformfv(p_uniform,&matrix[0],4);
	}; """)

    fd.write("\n\n#undef _FU\n\n\n")

    fd.write("\tvirtual void init(IDirect3DDevice9 *p_device,ShaderSupport p_version) {\n\n")
    if (len(conditionals)):

        fd.write("\t\tstatic const char* _conditional_strings[]={\n")
        if (len(conditionals)):
            for x in conditionals:
                fd.write("\t\t\t\"" + x + "\",\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const char **_conditional_strings=NULL;\n")

    if (len(uniforms)):

        fd.write("\t\tstatic const char* _uniform_strings[]={\n")
        if (len(uniforms)):
            for x in uniforms:
                fd.write("\t\t\t\"" + x + "\",\n")
        fd.write("\t\t};\n\n")

        fd.write("\t\tstatic const bool _fragment_uniforms[]={\n")

        if (len(uniforms)):
            for x in fragment_uniforms:
                if (x):
                    fd.write("\t\t\ttrue,\n")
                else:
                    fd.write("\t\t\tfalse,\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const char **_uniform_strings=NULL;\n")
        fd.write("\t\tstatic const bool *_fragment_uniforms=NULL;\n")

    fd.write("\t\tstatic const char* _vertex_code=\"\\\n")
    for x in vertex_lines:
        fd.write("\t\t\t" + x + "\n")
    fd.write("\t\t\";\n\n")

    fd.write("\t\tstatic const int _vertex_code_start=" + str(vertex_offset) + ";\n")

    fd.write("\t\tstatic const char* _fragment_code=\"\\\n")
    for x in fragment_lines:
        fd.write("\t\t\t" + x + "\n")
    fd.write("\t\t\";\n\n")

    fd.write("\t\tstatic const int _fragment_code_start=" + str(fragment_offset) + ";\n")

    fd.write("\t\tsetup(p_device,p_version,_conditional_strings," + str(len(conditionals)) + ",_uniform_strings," + str(len(uniforms)) + ",_fragment_uniforms,_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
    fd.write("\t};\n\n")

    fd.write("};\n\n")
    fd.write("#endif\n\n")
    fd.close()


def build_hlsl_dx9_headers(target, source, env):

    for x in source:

        build_hlsl_dx9_header(str(x))

    return 0


class LegacyGLHeaderStruct:

    def __init__(self):
        self.vertex_lines = []
        self.fragment_lines = []
        self.uniforms = []
        self.attributes = []
        self.fbos = []
        self.conditionals = []
        self.enums = {}
        self.texunits = []
        self.texunit_names = []
        self.ubos = []
        self.ubo_names = []

        self.vertex_included_files = []
        self.fragment_included_files = []

        self.reading = ""
        self.line_offset = 0
        self.vertex_offset = 0
        self.fragment_offset = 0


def include_file_in_legacygl_header(filename, header_data, depth):
    fs = open(filename, "r")
    line = fs.readline()

    while(line):

        if (line.find("[vertex]") != -1):
            header_data.reading = "vertex"
            line = fs.readline()
            header_data.line_offset += 1
            header_data.vertex_offset = header_data.line_offset
            continue

        if (line.find("[fragment]") != -1):
            header_data.reading = "fragment"
            line = fs.readline()
            header_data.line_offset += 1
            header_data.fragment_offset = header_data.line_offset
            continue

        while(line.find("#include ") != -1):
            includeline = line.replace("#include ", "").strip()[1:-1]

            import os.path

            included_file = os.path.relpath(os.path.dirname(filename) + "/" + includeline)
            if (not included_file in header_data.vertex_included_files and header_data.reading == "vertex"):
                header_data.vertex_included_files += [included_file]
                if(include_file_in_legacygl_header(included_file, header_data, depth + 1) == None):
                    print "Error in file '" + filename + "': #include " + includeline + "could not be found!"
            elif (not included_file in header_data.fragment_included_files and header_data.reading == "fragment"):
                header_data.fragment_included_files += [included_file]
                if(include_file_in_legacygl_header(included_file, header_data, depth + 1) == None):
                    print "Error in file '" + filename + "': #include " + includeline + "could not be found!"

            line = fs.readline()

        if (line.find("#ifdef ") != -1 or line.find("#elif defined(") != -1):
            if (line.find("#ifdef ") != -1):
                ifdefline = line.replace("#ifdef ", "").strip()
            else:
                ifdefline = line.replace("#elif defined(", "").strip()
                ifdefline = ifdefline.replace(")", "").strip()

            if (line.find("_EN_") != -1):
                enumbase = ifdefline[:ifdefline.find("_EN_")]
                ifdefline = ifdefline.replace("_EN_", "_")
                line = line.replace("_EN_", "_")
#				print(enumbase+":"+ifdefline);
                if (enumbase not in header_data.enums):
                    header_data.enums[enumbase] = []
                if (ifdefline not in header_data.enums[enumbase]):
                    header_data.enums[enumbase].append(ifdefline)

            elif (not ifdefline in header_data.conditionals):
                header_data.conditionals += [ifdefline]

        if (line.find("uniform") != -1 and line.lower().find("texunit:") != -1):
            # texture unit
            texunitstr = line[line.find(":") + 1:].strip()
            if (texunitstr == "auto"):
                texunit = "-1"
            else:
                texunit = str(int(texunitstr))
            uline = line[:line.lower().find("//")]
            uline = uline.replace("uniform", "")
            uline = uline.replace("highp", "")
            uline = uline.replace(";", "")
            lines = uline.split(",")
            for x in lines:

                x = x.strip()
                x = x[x.rfind(" ") + 1:]
                if (x.find("[") != -1):
                    # unfiorm array
                    x = x[:x.find("[")]

                if (not x in header_data.texunit_names):
                    header_data.texunits += [(x, texunit)]
                    header_data.texunit_names += [x]

        elif (line.find("uniform") != -1):
            uline = line.replace("uniform", "")
            uline = uline.replace(";", "")
            lines = uline.split(",")
            for x in lines:

                x = x.strip()
                x = x[x.rfind(" ") + 1:]
                if (x.find("[") != -1):
                    # unfiorm array
                    x = x[:x.find("[")]

                if (not x in header_data.uniforms):
                    header_data.uniforms += [x]

        if ((line.strip().find("in ") == 0 or line.strip().find("attribute ") == 0) and line.find("attrib:") != -1):
            uline = line.replace("in ", "")
            uline = uline.replace("attribute ", "")
            uline = uline.replace("highp ", "")
            uline = uline.replace(";", "")
            uline = uline[uline.find(" "):].strip()

            if (uline.find("//") != -1):
                name, bind = uline.split("//")
                if (bind.find("attrib:") != -1):
                    name = name.strip()
                    bind = bind.replace("attrib:", "").strip()
                    header_data.attributes += [(name, bind)]

        line = line.replace("\r", "")
        line = line.replace("\n", "")
        # line=line.replace("\\","\\\\")
        # line=line.replace("\"","\\\"")
        # line=line+"\\n\\"

        if (header_data.reading == "vertex"):
            header_data.vertex_lines += [line]
        if (header_data.reading == "fragment"):
            header_data.fragment_lines += [line]

        line = fs.readline()
        header_data.line_offset += 1

    fs.close()

    return header_data


def build_legacygl_header(filename, include, class_suffix, output_attribs):

    header_data = LegacyGLHeaderStruct()
    include_file_in_legacygl_header(filename, header_data, 0)

    out_file = filename + ".h"
    fd = open(out_file, "w")

    enum_constants = []

    fd.write("/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */\n")

    out_file_base = out_file
    out_file_base = out_file_base[out_file_base.rfind("/") + 1:]
    out_file_base = out_file_base[out_file_base.rfind("\\") + 1:]
#	print("out file "+out_file+" base " +out_file_base)
    out_file_ifdef = out_file_base.replace(".", "_").upper()
    fd.write("#ifndef " + out_file_ifdef + class_suffix + "_120\n")
    fd.write("#define " + out_file_ifdef + class_suffix + "_120\n")

    out_file_class = out_file_base.replace(".glsl.h", "").title().replace("_", "").replace(".", "") + "Shader" + class_suffix
    fd.write("\n\n")
    fd.write("#include \"" + include + "\"\n\n\n")
    fd.write("class " + out_file_class + " : public Shader" + class_suffix + " {\n\n")
    fd.write("\t virtual String get_shader_name() const { return \"" + out_file_class + "\"; }\n")

    fd.write("public:\n\n")

    if (len(header_data.conditionals)):
        fd.write("\tenum Conditionals {\n")
        for x in header_data.conditionals:
            fd.write("\t\t" + x.upper() + ",\n")
        fd.write("\t};\n\n")

    if (len(header_data.uniforms)):
        fd.write("\tenum Uniforms {\n")
        for x in header_data.uniforms:
            fd.write("\t\t" + x.upper() + ",\n")
        fd.write("\t};\n\n")

    fd.write("\t_FORCE_INLINE_ int get_uniform(Uniforms p_uniform) const { return _get_uniform(p_uniform); }\n\n")
    if (len(header_data.conditionals)):

        fd.write("\t_FORCE_INLINE_ void set_conditional(Conditionals p_conditional,bool p_enable)  {  _set_conditional(p_conditional,p_enable); }\n\n")
    fd.write("\t#define _FU if (get_uniform(p_uniform)<0) return; ERR_FAIL_COND( get_active()!=this );\n\n ")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, double p_value) { _FU glUniform1f(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int8_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int16_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int32_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n")
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, uint64_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n");
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, int64_t p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n");
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, unsigned long p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n");
    #fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, long p_value) { _FU glUniform1i(get_uniform(p_uniform),p_value); }\n\n");
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Color& p_color) { _FU GLfloat col[4]={p_color.r,p_color.g,p_color.b,p_color.a}; glUniform4fv(get_uniform(p_uniform),1,col); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector2& p_vec2) { _FU GLfloat vec2[2]={p_vec2.x,p_vec2.y}; glUniform2fv(get_uniform(p_uniform),1,vec2); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Vector3& p_vec3) { _FU GLfloat vec3[3]={p_vec3.x,p_vec3.y,p_vec3.z}; glUniform3fv(get_uniform(p_uniform),1,vec3); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b) { _FU glUniform2f(get_uniform(p_uniform),p_a,p_b); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c) { _FU glUniform3f(get_uniform(p_uniform),p_a,p_b,p_c); }\n\n")
    fd.write("\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, float p_d) { _FU glUniform4f(get_uniform(p_uniform),p_a,p_b,p_c,p_d); }\n\n")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform& p_transform) {  _FU

		const Transform &tr = p_transform;

		GLfloat matrix[16]={ /* build a 16x16 matrix */
			tr.basis.elements[0][0],
			tr.basis.elements[1][0],
			tr.basis.elements[2][0],
			0,
			tr.basis.elements[0][1],
			tr.basis.elements[1][1],
			tr.basis.elements[2][1],
			0,
			tr.basis.elements[0][2],
			tr.basis.elements[1][2],
			tr.basis.elements[2][2],
			0,
			tr.origin.x,
			tr.origin.y,
			tr.origin.z,
			1
		};


	glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);


	}

	""")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Matrix32& p_transform) {  _FU

		const Matrix32 &tr = p_transform;

		GLfloat matrix[16]={ /* build a 16x16 matrix */
			tr.elements[0][0],
			tr.elements[0][1],
			0,
			0,
			tr.elements[1][0],
			tr.elements[1][1],
			0,
			0,
			0,
			0,
			1,
			0,
			tr.elements[2][0],
			tr.elements[2][1],
			0,
			1
		};


	glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);


	}

	""")

    fd.write("""\t_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const CameraMatrix& p_matrix) {  _FU

		GLfloat matrix[16];

		for (int i=0;i<4;i++) {
			for (int j=0;j<4;j++) {

				matrix[i*4+j]=p_matrix.matrix[i][j];
			}
		}

		glUniformMatrix4fv(get_uniform(p_uniform),1,false,matrix);
	}; """)

    fd.write("\n\n#undef _FU\n\n\n")

    fd.write("\tvirtual void init() {\n\n")

    enum_value_count = 0

    if (len(header_data.enums)):

        fd.write("\t\t//Written using math, given nonstandarity of 64 bits integer constants..\n")
        fd.write("\t\tstatic const Enum _enums[]={\n")

        bitofs = len(header_data.conditionals)
        enum_vals = []

        for xv in header_data.enums:
            x = header_data.enums[xv]
            bits = 1
            amt = len(x)
#			print(x)
            while(2**bits < amt):
                bits += 1
#			print("amount: "+str(amt)+" bits "+str(bits));
            strs = "{"
            for i in range(amt):
                strs += "\"#define " + x[i] + "\\n\","

                v = {}
                v["set_mask"] = "uint64_t(" + str(i) + ")<<" + str(bitofs)
                v["clear_mask"] = "((uint64_t(1)<<40)-1) ^ (((uint64_t(1)<<" + str(bits) + ") - 1)<<" + str(bitofs) + ")"
                enum_vals.append(v)
                enum_constants.append(x[i])

            strs += "NULL}"

            fd.write("\t\t\t{(uint64_t(1<<" + str(bits) + ")-1)<<" + str(bitofs) + "," + str(bitofs) + "," + strs + "},\n")
            bitofs += bits

        fd.write("\t\t};\n\n")

        fd.write("\t\tstatic const EnumValue _enum_values[]={\n")

        enum_value_count = len(enum_vals)
        for x in enum_vals:
            fd.write("\t\t\t{" + x["set_mask"] + "," + x["clear_mask"] + "},\n")

        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const Enum *_enums=NULL;\n")
        fd.write("\t\tstatic const EnumValue *_enum_values=NULL;\n")

    if (len(header_data.conditionals)):

        fd.write("\t\tstatic const char* _conditional_strings[]={\n")
        if (len(header_data.conditionals)):
            for x in header_data.conditionals:
                fd.write("\t\t\t\"#define " + x + "\\n\",\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const char **_conditional_strings=NULL;\n")

    if (len(header_data.uniforms)):

        fd.write("\t\tstatic const char* _uniform_strings[]={\n")
        if (len(header_data.uniforms)):
            for x in header_data.uniforms:
                fd.write("\t\t\t\"" + x + "\",\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic const char **_uniform_strings=NULL;\n")

    if output_attribs:
        if (len(header_data.attributes)):

            fd.write("\t\tstatic AttributePair _attribute_pairs[]={\n")
            for x in header_data.attributes:
                fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
            fd.write("\t\t};\n\n")
        else:
            fd.write("\t\tstatic AttributePair *_attribute_pairs=NULL;\n")

    if (len(header_data.texunits)):
        fd.write("\t\tstatic TexUnitPair _texunit_pairs[]={\n")
        for x in header_data.texunits:
            fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
        fd.write("\t\t};\n\n")
    else:
        fd.write("\t\tstatic TexUnitPair *_texunit_pairs=NULL;\n")

    fd.write("\t\tstatic const char _vertex_code[]={\n")
    for x in header_data.vertex_lines:
        for i in range(len(x)):
            fd.write(str(ord(x[i])) + ",")

        fd.write(str(ord('\n')) + ",")
    fd.write("\t\t0};\n\n")

    fd.write("\t\tstatic const int _vertex_code_start=" + str(header_data.vertex_offset) + ";\n")

    fd.write("\t\tstatic const char _fragment_code[]={\n")
    for x in header_data.fragment_lines:
        for i in range(len(x)):
            fd.write(str(ord(x[i])) + ",")

        fd.write(str(ord('\n')) + ",")
    fd.write("\t\t0};\n\n")

    fd.write("\t\tstatic const int _fragment_code_start=" + str(header_data.fragment_offset) + ";\n")

    if output_attribs:
        fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_attribute_pairs," + str(len(header_data.attributes)) + ", _texunit_pairs," + str(len(header_data.texunits)) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
    else:
        fd.write("\t\tsetup(_conditional_strings," + str(len(header_data.conditionals)) + ",_uniform_strings," + str(len(header_data.uniforms)) + ",_texunit_pairs," + str(len(header_data.texunits)) + ",_enums," + str(len(header_data.enums)) + ",_enum_values," + str(enum_value_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")

    fd.write("\t};\n\n")

    if (len(enum_constants)):

        fd.write("\tenum EnumConditionals {\n")
        for x in enum_constants:
            fd.write("\t\t" + x.upper() + ",\n")
        fd.write("\t};\n\n")
        fd.write("\tvoid set_enum_conditional(EnumConditionals p_cond) { _set_enum_conditional(p_cond); }\n")

    fd.write("};\n\n")
    fd.write("#endif\n\n")
    fd.close()


def build_legacygl_headers(target, source, env):

    for x in source:

        build_legacygl_header(str(x), include="drivers/legacygl/shader_lgl.h", class_suffix="LGL", output_attribs=False)

    return 0


def build_gles2_headers(target, source, env):

    for x in source:
        build_legacygl_header(str(x), include="drivers/gles2/shader_gles2.h", class_suffix="GLES2", output_attribs=True)


def update_version():

    rev = "custom_build"

    if (os.getenv("BUILD_REVISION") != None):
        rev = os.getenv("BUILD_REVISION")
        print("Using custom revision: " + rev)
    import version

    f = open("core/version.h", "wb")
    f.write("#define VERSION_SHORT_NAME " + str(version.short_name) + "\n")
    f.write("#define VERSION_NAME " + str(version.name) + "\n")
    f.write("#define VERSION_MAJOR " + str(version.major) + "\n")
    f.write("#define VERSION_MINOR " + str(version.minor) + "\n")
    if (hasattr(version, 'patch')):
        f.write("#define VERSION_PATCH " + str(version.patch) + "\n")
    f.write("#define VERSION_REVISION " + str(rev) + "\n")
    f.write("#define VERSION_STATUS " + str(version.status) + "\n")
    import datetime
    f.write("#define VERSION_YEAR " + str(datetime.datetime.now().year) + "\n")


def parse_cg_file(fname, uniforms, sizes, conditionals):

    import re
    fs = open(fname, "r")
    line = fs.readline()

    while line:

        if re.match(r"^\s*uniform", line):

            res = re.match(r"uniform ([\d\w]*) ([\d\w]*)")
            type = res.groups(1)
            name = res.groups(2)

            uniforms.append(name)

            if (type.find("texobj") != -1):
                sizes.append(1)
            else:
                t = re.match(r"float(\d)x(\d)", type)
                if t:
                    sizes.append(int(t.groups(1)) * int(t.groups(2)))
                else:
                    t = re.match(r"float(\d)", type)
                    sizes.append(int(t.groups(1)))

            if line.find("[branch]") != -1:
                conditionals.append(name)

        line = fs.readline()


def build_cg_shader(sname):

    vp_uniforms = []
    vp_uniform_sizes = []
    vp_conditionals = []

    parse_cg_file("vp_" + sname + ".cg", vp_uniforms, vp_uniform_sizes, vp_conditionals)

    fp_uniforms = []
    fp_uniform_sizes = []
    fp_conditionals = []

    parse_cg_file("fp_" + sname + ".cg", fp_uniforms, fp_uniform_sizes, fp_conditionals)

    fd = open("shader_" + sname + ".cg.h", "w")

    fd.write('\n#include "shader_cell.h"\n')
    fd.write("\nclass Shader_" + sname + " : public ShaderCell {\n")
    fd.write("\n\tstatic struct VertexUniforms[] = {\n")

    offset = 0
    for i in range(0, len(vp_uniforms)):

        fd.write('\t\t{ "%s", %d, %d },\n' % (vp_uniforms[i], offset, vp_uniform_sizes[i]))
        offset = offset + vp_uniform_sizes[i]
    fd.write("\t};\n\n")

    fd.write("public:\n\n")

    fd.write("\tenum {\n")

    for i in range(0, len(vp_uniforms)):

        fd.write('\t\tVP_%s,\n' % vp_uniforms[i].upper())

    fd.write("\t};\n")


import glob


def detect_modules():

    module_list = []
    includes_cpp = ""
    register_cpp = ""
    unregister_cpp = ""

    files = glob.glob("modules/*")
    files.sort()  # so register_module_types does not change that often, and also plugins are registered in alphabetic order
    for x in files:
        if (not os.path.isdir(x)):
            continue
        x = x.replace("modules/", "")  # rest of world
        x = x.replace("modules\\", "")  # win32
        module_list.append(x)
        try:
            with open("modules/" + x + "/register_types.h"):
                includes_cpp += '#include "modules/' + x + '/register_types.h"\n'
                register_cpp += '#ifdef MODULE_' + x.upper() + '_ENABLED\n'
                register_cpp += '\tregister_' + x + '_types();\n'
                register_cpp += '#endif\n'
                unregister_cpp += '#ifdef MODULE_' + x.upper() + '_ENABLED\n'
                unregister_cpp += '\tunregister_' + x + '_types();\n'
                unregister_cpp += '#endif\n'
        except IOError:
            pass

    modules_cpp = """
// modules.cpp - THIS FILE IS GENERATED, DO NOT EDIT!!!!!!!
#include "register_module_types.h"


""" + includes_cpp + """

void register_module_types() {

""" + register_cpp + """

}

void unregister_module_types() {

""" + unregister_cpp + """

}

"""

    f = open("modules/register_module_types.cpp", "wb")
    f.write(modules_cpp)

    return module_list


def win32_spawn(sh, escape, cmd, args, env):
    import subprocess
    newargs = ' '.join(args[1:])
    cmdline = cmd + " " + newargs
    startupinfo = subprocess.STARTUPINFO()
    #startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
    for e in env:
        if type(env[e]) != type(""):
            env[e] = str(env[e])
    proc = subprocess.Popen(cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE, startupinfo=startupinfo, shell=False, env=env)
    data, err = proc.communicate()
    rv = proc.wait()
    if rv:
        print "====="
        print err
        print "====="
    return rv

"""
def win32_spawn(sh, escape, cmd, args, spawnenv):
	import win32file
	import win32event
	import win32process
	import win32security
	for var in spawnenv:
		spawnenv[var] = spawnenv[var].encode('ascii', 'replace')

	sAttrs = win32security.SECURITY_ATTRIBUTES()
	StartupInfo = win32process.STARTUPINFO()
	newargs = ' '.join(map(escape, args[1:]))
	cmdline = cmd + " " + newargs

	# check for any special operating system commands
	if cmd == 'del':
		for arg in args[1:]:
			win32file.DeleteFile(arg)
		exit_code = 0
	else:
		# otherwise execute the command.
		hProcess, hThread, dwPid, dwTid = win32process.CreateProcess(None, cmdline, None, None, 1, 0, spawnenv, None, StartupInfo)
		win32event.WaitForSingleObject(hProcess, win32event.INFINITE)
		exit_code = win32process.GetExitCodeProcess(hProcess)
		win32file.CloseHandle(hProcess);
		win32file.CloseHandle(hThread);
	return exit_code
"""


def android_add_maven_repository(self, url):
    self.android_maven_repos.append(url)


def android_add_dependency(self, depline):
    self.android_dependencies.append(depline)


def android_add_java_dir(self, subpath):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
    self.android_java_dirs.append(base_path)


def android_add_res_dir(self, subpath):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
    self.android_res_dirs.append(base_path)


def android_add_aidl_dir(self, subpath):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
    self.android_aidl_dirs.append(base_path)


def android_add_jni_dir(self, subpath):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
    self.android_jni_dirs.append(base_path)


def android_add_default_config(self, config):
    self.android_default_config.append(config)


def android_add_to_manifest(self, file):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + file
    f = open(base_path, "rb")
    self.android_manifest_chunk += f.read()


def android_add_to_permissions(self, file):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + file
    f = open(base_path, "rb")
    self.android_permission_chunk += f.read()


def android_add_to_attributes(self, file):
    base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + file
    f = open(base_path, "rb")
    self.android_appattributes_chunk += f.read()


def disable_module(self):
    self.disabled_modules.append(self.current_module)


def use_windows_spawn_fix(self, platform=None):

    if (os.name != "nt"):
        return  # not needed, only for windows

    # On Windows, due to the limited command line length, when creating a static library
    # from a very high number of objects SCons will invoke "ar" once per object file;
    # that makes object files with same names to be overwritten so the last wins and
    # the library looses symbols defined by overwritten objects.
    # By enabling quick append instead of the default mode (replacing), libraries will
    # got built correctly regardless the invokation strategy.
    # Furthermore, since SCons will rebuild the library from scratch when an object file
    # changes, no multiple versions of the same object file will be present.
    self.Replace(ARFLAGS='q')

    import subprocess

    def mySubProcess(cmdline, env):
        prefix = ""
        if(platform == 'javascript'):
            prefix = "python.exe "

        startupinfo = subprocess.STARTUPINFO()
        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
        proc = subprocess.Popen(prefix + cmdline, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE, startupinfo=startupinfo, shell=False, env=env)
        data, err = proc.communicate()
        rv = proc.wait()
        if rv:
            print "====="
            print err
            print "====="
        return rv

    def mySpawn(sh, escape, cmd, args, env):

        newargs = ' '.join(args[1:])
        cmdline = cmd + " " + newargs

        rv = 0
        env = {str(key): str(value) for key, value in env.iteritems()}
        if len(cmdline) > 32000 and cmd.endswith("ar"):
            cmdline = cmd + " " + args[1] + " " + args[2] + " "
            for i in range(3, len(args)):
                rv = mySubProcess(cmdline + args[i], env)
                if rv:
                    break
        else:
            rv = mySubProcess(cmdline, env)

        return rv

    self['SPAWN'] = mySpawn


def split_lib(self, libname):
    import string
    env = self

    num = 0
    cur_base = ""
    max_src = 64
    list = []
    lib_list = []

    for f in getattr(env, libname + "_sources"):
        fname = ""
        if type(f) == type(""):
            fname = env.File(f).path
        else:
            fname = env.File(f)[0].path
        fname = fname.replace("\\", "/")
        base = string.join(fname.split("/")[:2], "/")
        if base != cur_base and len(list) > max_src:
            if num > 0:
                lib = env.Library(libname + str(num), list)
                lib_list.append(lib)
                list = []
            num = num + 1
        cur_base = base
        list.append(f)

    lib = env.Library(libname + str(num), list)
    lib_list.append(lib)

    if len(lib_list) > 0:
        import os, sys
        if os.name == 'posix' and sys.platform == 'msys':
            env.Replace(ARFLAGS=['rcsT'])
            lib = env.Library(libname + "_collated", lib_list)
            lib_list = [lib]

    lib_base = []
    env.add_source_files(lib_base, "*.cpp")
    lib_list.insert(0, env.Library(libname, lib_base))

    env.Prepend(LIBS=lib_list)


def save_active_platforms(apnames, ap):

    for x in ap:
        pth = x + "/logo.png"
#		print("open path: "+pth)
        pngf = open(pth, "rb")
        b = pngf.read(1)
        str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n"
        str += " static const unsigned char _" + x[9:] + "_logo[]={"
        while(len(b) == 1):
            str += hex(ord(b))
            b = pngf.read(1)
            if (len(b) == 1):
                str += ","

        str += "};\n"

        wf = x + "/logo.h"
        logow = open(wf, "wb")
        logow.write(str)


def no_verbose(sys, env):

    # If the output is not a terminal, do nothing
    if not sys.stdout.isatty():
        return

    colors = {}
    colors['cyan'] = '\033[96m'
    colors['purple'] = '\033[95m'
    colors['blue'] = '\033[94m'
    colors['green'] = '\033[92m'
    colors['yellow'] = '\033[93m'
    colors['red'] = '\033[91m'
    colors['end'] = '\033[0m'

    compile_source_message = '%sCompiling %s==> %s$SOURCE%s' % (colors['blue'], colors['purple'], colors['yellow'], colors['end'])
    java_compile_source_message = '%sCompiling %s==> %s$SOURCE%s' % (colors['blue'], colors['purple'], colors['yellow'], colors['end'])
    compile_shared_source_message = '%sCompiling shared %s==> %s$SOURCE%s' % (colors['blue'], colors['purple'], colors['yellow'], colors['end'])
    link_program_message = '%sLinking Program        %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
    link_library_message = '%sLinking Static Library %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
    ranlib_library_message = '%sRanlib Library         %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
    link_shared_library_message = '%sLinking Shared Library %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])
    java_library_message = '%sCreating Java Archive  %s==> %s$TARGET%s' % (colors['red'], colors['purple'], colors['yellow'], colors['end'])

    env.Append(CXXCOMSTR=[compile_source_message])
    env.Append(CCCOMSTR=[compile_source_message])
    env.Append(SHCCCOMSTR=[compile_shared_source_message])
    env.Append(SHCXXCOMSTR=[compile_shared_source_message])
    env.Append(ARCOMSTR=[link_library_message])
    env.Append(RANLIBCOMSTR=[ranlib_library_message])
    env.Append(SHLINKCOMSTR=[link_shared_library_message])
    env.Append(LINKCOMSTR=[link_program_message])
    env.Append(JARCOMSTR=[java_library_message])
    env.Append(JAVACCOMSTR=[java_compile_source_message])


def detect_visual_c_compiler_version(tools_env):
    # tools_env is the variable scons uses to call tools that execute tasks, SCons's env['ENV'] that executes tasks...
    # (see the SCons documentation for more information on what it does)...
    # in order for this function to be well encapsulated i choose to force it to recieve SCons's TOOLS env (env['ENV']
    # and not scons setup environment (env)... so make sure you call the right environment on it or it will fail to detect
    # the propper vc version that will be called

    # These is no flag to give to visual c compilers to set the architecture, ie scons bits argument (32,64,ARM etc)
    # There are many different cl.exe files that are run, and each one compiles & links to a different architecture
    # As far as I know, the only way to figure out what compiler will be run when Scons calls cl.exe via Program()
    # is to check the PATH varaible and figure out which one will be called first. Code bellow does that and returns:
    # the following string values:

    # ""              Compiler not detected
    # "amd64"         Native 64 bit compiler
    # "amd64_x86"     64 bit Cross Compiler for 32 bit
    # "x86"           Native 32 bit compiler
    # "x86_amd64"     32 bit Cross Compiler for 64 bit

    # There are other architectures, but Godot does not support them currently, so this function does not detect arm/amd64_arm
    # and similar architectures/compilers

    # Set chosen compiler to "not detected"
    vc_chosen_compiler_index = -1
    vc_chosen_compiler_str = ""

    # find() works with -1 so big ifs bellow are needed... the simplest solution, in fact
    # First test if amd64 and amd64_x86 compilers are present in the path
    vc_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64;")
    if(vc_amd64_compiler_detection_index > -1):
        vc_chosen_compiler_index = vc_amd64_compiler_detection_index
        vc_chosen_compiler_str = "amd64"

    vc_amd64_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN\\amd64_x86;")
    if(vc_amd64_x86_compiler_detection_index > -1
       and (vc_chosen_compiler_index == -1
            or vc_chosen_compiler_index > vc_amd64_x86_compiler_detection_index)):
        vc_chosen_compiler_index = vc_amd64_x86_compiler_detection_index
        vc_chosen_compiler_str = "amd64_x86"

    # Now check the 32 bit compilers
    vc_x86_compiler_detection_index = tools_env["PATH"].find(tools_env["VCINSTALLDIR"] + "BIN;")
    if(vc_x86_compiler_detection_index > -1
       and (vc_chosen_compiler_index == -1
            or vc_chosen_compiler_index > vc_x86_compiler_detection_index)):
        vc_chosen_compiler_index = vc_x86_compiler_detection_index
        vc_chosen_compiler_str = "x86"

    vc_x86_amd64_compiler_detection_index = tools_env["PATH"].find(tools_env['VCINSTALLDIR'] + "BIN\\x86_amd64;")
    if(vc_x86_amd64_compiler_detection_index > -1
       and (vc_chosen_compiler_index == -1
            or vc_chosen_compiler_index > vc_x86_amd64_compiler_detection_index)):
        vc_chosen_compiler_index = vc_x86_amd64_compiler_detection_index
        vc_chosen_compiler_str = "x86_amd64"

    # debug help
    # print vc_amd64_compiler_detection_index
    # print vc_amd64_x86_compiler_detection_index
    # print vc_x86_compiler_detection_index
    # print vc_x86_amd64_compiler_detection_index
    # print "chosen "+str(vc_chosen_compiler_index)+ " | "+str(vc_chosen_compiler_str)

    return vc_chosen_compiler_str


def precious_program(env, program, sources, **args):
    program = env.ProgramOriginal(program, sources, **args)
    env.Precious(program)
    return program