mirror of
https://github.com/godotengine/godot
synced 2024-11-05 16:53:09 +00:00
e21702f764
- Fix buildsystem for WinRT/UWP platform. - Add audio driver and joystick mapping for WinRT. - Enable thread class for WinRT. - Refactor MSVC compiler architecture detection to methods.py, so it can be used by Windows and WinRT.
1521 lines
49 KiB
Python
Executable file
1521 lines
49 KiB
Python
Executable file
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
|
|
|
|
self.split_drivers=True
|
|
|
|
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
|
|
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 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 colored(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
|