mirror of
https://github.com/godotengine/godot
synced 2024-11-05 16:53:09 +00:00
1341 lines
52 KiB
Python
1341 lines
52 KiB
Python
import os
|
|
from compat import iteritems, itervalues, open_utf8, escape_string
|
|
|
|
|
|
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))
|
|
|
|
|
|
|
|
class LegacyGLHeaderStruct:
|
|
|
|
def __init__(self):
|
|
self.vertex_lines = []
|
|
self.fragment_lines = []
|
|
self.uniforms = []
|
|
self.attributes = []
|
|
self.feedbacks = []
|
|
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_", "_")
|
|
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 and line.lower().find("ubo:") != -1):
|
|
# uniform buffer object
|
|
ubostr = line[line.find(":") + 1:].strip()
|
|
ubo = str(int(ubostr))
|
|
uline = line[:line.lower().find("//")]
|
|
uline = uline[uline.find("uniform") + len("uniform"):]
|
|
uline = uline.replace("highp", "")
|
|
uline = uline.replace(";", "")
|
|
uline = uline.replace("{", "").strip()
|
|
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.ubo_names):
|
|
header_data.ubos += [(x, ubo)]
|
|
header_data.ubo_names += [x]
|
|
|
|
elif (line.find("uniform") != -1 and line.find("{") == -1 and line.find(";") != -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("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)]
|
|
|
|
if (line.strip().find("out ") == 0 and line.find("tfb:") != -1):
|
|
uline = line.replace("out ", "")
|
|
uline = uline.replace("highp ", "")
|
|
uline = uline.replace(";", "")
|
|
uline = uline[uline.find(" "):].strip()
|
|
|
|
if (uline.find("//") != -1):
|
|
name, bind = uline.split("//")
|
|
if (bind.find("tfb:") != -1):
|
|
name = name.strip()
|
|
bind = bind.replace("tfb:", "").strip()
|
|
header_data.feedbacks += [(name, bind)]
|
|
|
|
line = line.replace("\r", "")
|
|
line = line.replace("\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, gles2=False):
|
|
|
|
header_data = LegacyGLHeaderStruct()
|
|
include_file_in_legacygl_header(filename, header_data, 0)
|
|
|
|
out_file = filename + ".gen.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:]
|
|
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.gen.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, 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("""_FORCE_INLINE_ void set_uniform(Uniforms p_uniform, const Transform2D& p_transform) { _FU
|
|
|
|
const Transform2D &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("""_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)
|
|
while(2**bits < amt):
|
|
bits += 1
|
|
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")
|
|
|
|
conditionals_found = []
|
|
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")
|
|
conditionals_found.append(x)
|
|
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")
|
|
|
|
feedback_count = 0
|
|
|
|
if (not gles2 and len(header_data.feedbacks)):
|
|
|
|
fd.write("\t\tstatic const Feedback _feedbacks[]={\n")
|
|
for x in header_data.feedbacks:
|
|
name = x[0]
|
|
cond = x[1]
|
|
if (cond in conditionals_found):
|
|
fd.write("\t\t\t{\"" + name + "\"," + str(conditionals_found.index(cond)) + "},\n")
|
|
else:
|
|
fd.write("\t\t\t{\"" + name + "\",-1},\n")
|
|
|
|
feedback_count += 1
|
|
|
|
fd.write("\t\t};\n\n")
|
|
else:
|
|
if gles2:
|
|
pass
|
|
else:
|
|
fd.write("\t\tstatic const Feedback* _feedbacks=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")
|
|
|
|
if (not gles2 and len(header_data.ubos)):
|
|
fd.write("\t\tstatic UBOPair _ubo_pairs[]={\n")
|
|
for x in header_data.ubos:
|
|
fd.write("\t\t\t{\"" + x[0] + "\"," + x[1] + "},\n")
|
|
fd.write("\t\t};\n\n")
|
|
else:
|
|
if gles2:
|
|
pass
|
|
else:
|
|
fd.write("\t\tstatic UBOPair *_ubo_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:
|
|
if gles2:
|
|
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)) + ",_attribute_pairs," + str(len(header_data.attributes)) + ", _texunit_pairs," + str(len(header_data.texunits)) + ",_ubo_pairs," + str(len(header_data.ubos)) + ",_feedbacks," + str(feedback_count) + ",_vertex_code,_fragment_code,_vertex_code_start,_fragment_code_start);\n")
|
|
else:
|
|
if gles2:
|
|
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")
|
|
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) + ",_ubo_pairs," + str(len(header_data.ubos)) + ",_feedbacks," + str(feedback_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_gles3_headers(target, source, env):
|
|
|
|
for x in source:
|
|
build_legacygl_header(str(x), include="drivers/gles3/shader_gles3.h", class_suffix="GLES3", output_attribs=True)
|
|
|
|
|
|
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, gles2=True)
|
|
|
|
def make_authors_header(target, source, env):
|
|
|
|
sections = ["Project Founders", "Lead Developer", "Project Manager", "Developers"]
|
|
sections_id = ["AUTHORS_FOUNDERS", "AUTHORS_LEAD_DEVELOPERS", "AUTHORS_PROJECT_MANAGERS", "AUTHORS_DEVELOPERS"]
|
|
|
|
src = source[0].srcnode().abspath
|
|
dst = target[0].srcnode().abspath
|
|
f = open_utf8(src, "r")
|
|
g = open_utf8(dst, "w")
|
|
|
|
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
|
g.write("#ifndef _EDITOR_AUTHORS_H\n")
|
|
g.write("#define _EDITOR_AUTHORS_H\n")
|
|
|
|
current_section = ""
|
|
reading = False
|
|
|
|
def close_section():
|
|
g.write("\t0\n")
|
|
g.write("};\n")
|
|
|
|
for line in f:
|
|
if reading:
|
|
if line.startswith(" "):
|
|
g.write("\t\"" + escape_string(line.strip()) + "\",\n")
|
|
continue
|
|
if line.startswith("## "):
|
|
if reading:
|
|
close_section()
|
|
reading = False
|
|
for i in range(len(sections)):
|
|
if line.strip().endswith(sections[i]):
|
|
current_section = escape_string(sections_id[i])
|
|
reading = True
|
|
g.write("const char *const " + current_section + "[] = {\n")
|
|
break
|
|
|
|
if reading:
|
|
close_section()
|
|
|
|
g.write("#endif\n")
|
|
|
|
g.close()
|
|
f.close()
|
|
|
|
def make_donors_header(target, source, env):
|
|
|
|
sections = ["Platinum sponsors", "Gold sponsors", "Mini sponsors",
|
|
"Gold donors", "Silver donors", "Bronze donors"]
|
|
sections_id = ["DONORS_SPONSOR_PLAT", "DONORS_SPONSOR_GOLD", "DONORS_SPONSOR_MINI",
|
|
"DONORS_GOLD", "DONORS_SILVER", "DONORS_BRONZE"]
|
|
|
|
src = source[0].srcnode().abspath
|
|
dst = target[0].srcnode().abspath
|
|
f = open_utf8(src, "r")
|
|
g = open_utf8(dst, "w")
|
|
|
|
g.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
|
g.write("#ifndef _EDITOR_DONORS_H\n")
|
|
g.write("#define _EDITOR_DONORS_H\n")
|
|
|
|
current_section = ""
|
|
reading = False
|
|
|
|
def close_section():
|
|
g.write("\t0\n")
|
|
g.write("};\n")
|
|
|
|
for line in f:
|
|
if reading >= 0:
|
|
if line.startswith(" "):
|
|
g.write("\t\"" + escape_string(line.strip()) + "\",\n")
|
|
continue
|
|
if line.startswith("## "):
|
|
if reading:
|
|
close_section()
|
|
reading = False
|
|
for i in range(len(sections)):
|
|
if line.strip().endswith(sections[i]):
|
|
current_section = escape_string(sections_id[i])
|
|
reading = True
|
|
g.write("const char *const " + current_section + "[] = {\n")
|
|
break
|
|
|
|
if reading:
|
|
close_section()
|
|
|
|
g.write("#endif\n")
|
|
|
|
g.close()
|
|
f.close()
|
|
|
|
|
|
def make_license_header(target, source, env):
|
|
src_copyright = source[0].srcnode().abspath
|
|
src_license = source[1].srcnode().abspath
|
|
dst = target[0].srcnode().abspath
|
|
|
|
class LicenseReader:
|
|
def __init__(self, license_file):
|
|
self._license_file = license_file
|
|
self.line_num = 0
|
|
self.current = self.next_line()
|
|
|
|
def next_line(self):
|
|
line = self._license_file.readline()
|
|
self.line_num += 1
|
|
while line.startswith("#"):
|
|
line = self._license_file.readline()
|
|
self.line_num += 1
|
|
self.current = line
|
|
return line
|
|
|
|
def next_tag(self):
|
|
if not ':' in self.current:
|
|
return ('',[])
|
|
tag, line = self.current.split(":", 1)
|
|
lines = [line.strip()]
|
|
while self.next_line() and self.current.startswith(" "):
|
|
lines.append(self.current.strip())
|
|
return (tag, lines)
|
|
|
|
from collections import OrderedDict
|
|
projects = OrderedDict()
|
|
license_list = []
|
|
|
|
with open_utf8(src_copyright, "r") as copyright_file:
|
|
reader = LicenseReader(copyright_file)
|
|
part = {}
|
|
while reader.current:
|
|
tag, content = reader.next_tag()
|
|
if tag in ("Files", "Copyright", "License"):
|
|
part[tag] = content[:]
|
|
elif tag == "Comment":
|
|
# attach part to named project
|
|
projects[content[0]] = projects.get(content[0], []) + [part]
|
|
|
|
if not tag or not reader.current:
|
|
# end of a paragraph start a new part
|
|
if "License" in part and not "Files" in part:
|
|
# no Files tag in this one, so assume standalone license
|
|
license_list.append(part["License"])
|
|
part = {}
|
|
reader.next_line()
|
|
|
|
data_list = []
|
|
for project in itervalues(projects):
|
|
for part in project:
|
|
part["file_index"] = len(data_list)
|
|
data_list += part["Files"]
|
|
part["copyright_index"] = len(data_list)
|
|
data_list += part["Copyright"]
|
|
|
|
with open_utf8(dst, "w") as f:
|
|
|
|
f.write("/* THIS FILE IS GENERATED DO NOT EDIT */\n")
|
|
f.write("#ifndef _EDITOR_LICENSE_H\n")
|
|
f.write("#define _EDITOR_LICENSE_H\n")
|
|
f.write("const char *const GODOT_LICENSE_TEXT =")
|
|
|
|
with open_utf8(src_license, "r") as license_file:
|
|
for line in license_file:
|
|
escaped_string = escape_string(line.strip())
|
|
f.write("\n\t\t\"" + escaped_string + "\\n\"")
|
|
f.write(";\n\n")
|
|
|
|
f.write("struct ComponentCopyrightPart {\n"
|
|
"\tconst char *license;\n"
|
|
"\tconst char *const *files;\n"
|
|
"\tconst char *const *copyright_statements;\n"
|
|
"\tint file_count;\n"
|
|
"\tint copyright_count;\n"
|
|
"};\n\n")
|
|
|
|
f.write("struct ComponentCopyright {\n"
|
|
"\tconst char *name;\n"
|
|
"\tconst ComponentCopyrightPart *parts;\n"
|
|
"\tint part_count;\n"
|
|
"};\n\n")
|
|
|
|
f.write("const char *const COPYRIGHT_INFO_DATA[] = {\n")
|
|
for line in data_list:
|
|
f.write("\t\"" + escape_string(line) + "\",\n")
|
|
f.write("};\n\n")
|
|
|
|
f.write("const ComponentCopyrightPart COPYRIGHT_PROJECT_PARTS[] = {\n")
|
|
part_index = 0
|
|
part_indexes = {}
|
|
for project_name, project in iteritems(projects):
|
|
part_indexes[project_name] = part_index
|
|
for part in project:
|
|
f.write("\t{ \"" + escape_string(part["License"][0]) + "\", "
|
|
+ "©RIGHT_INFO_DATA[" + str(part["file_index"]) + "], "
|
|
+ "©RIGHT_INFO_DATA[" + str(part["copyright_index"]) + "], "
|
|
+ str(len(part["Files"])) + ", "
|
|
+ str(len(part["Copyright"])) + " },\n")
|
|
part_index += 1
|
|
f.write("};\n\n")
|
|
|
|
f.write("const int COPYRIGHT_INFO_COUNT = " + str(len(projects)) + ";\n")
|
|
|
|
f.write("const ComponentCopyright COPYRIGHT_INFO[] = {\n")
|
|
for project_name, project in iteritems(projects):
|
|
f.write("\t{ \"" + escape_string(project_name) + "\", "
|
|
+ "©RIGHT_PROJECT_PARTS[" + str(part_indexes[project_name]) + "], "
|
|
+ str(len(project)) + " },\n")
|
|
f.write("};\n\n")
|
|
|
|
f.write("const int LICENSE_COUNT = " + str(len(license_list)) + ";\n")
|
|
|
|
f.write("const char *const LICENSE_NAMES[] = {\n")
|
|
for l in license_list:
|
|
f.write("\t\"" + escape_string(l[0]) + "\",\n")
|
|
f.write("};\n\n")
|
|
|
|
f.write("const char *const LICENSE_BODIES[] = {\n\n")
|
|
for l in license_list:
|
|
for line in l[1:]:
|
|
if line == ".":
|
|
f.write("\t\"\\n\"\n")
|
|
else:
|
|
f.write("\t\"" + escape_string(line) + "\\n\"\n")
|
|
f.write("\t\"\",\n\n")
|
|
f.write("};\n\n")
|
|
|
|
f.write("#endif\n")
|
|
def add_module_version_string(self,s):
|
|
self.module_version_string += "." + s
|
|
|
|
def update_version(module_version_string=""):
|
|
|
|
build_name = "custom_build"
|
|
if (os.getenv("BUILD_NAME") != None):
|
|
build_name = os.getenv("BUILD_NAME")
|
|
print("Using custom build name: " + build_name)
|
|
|
|
import version
|
|
|
|
f = open("core/version_generated.gen.h", "w")
|
|
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_STATUS \"" + str(version.status) + "\"\n")
|
|
f.write("#define VERSION_BUILD \"" + str(build_name) + "\"\n")
|
|
f.write("#define VERSION_MODULE_CONFIG \"" + str(version.module_config) + module_version_string + "\"\n")
|
|
import datetime
|
|
f.write("#define VERSION_YEAR " + str(datetime.datetime.now().year) + "\n")
|
|
f.close()
|
|
|
|
fhash = open("core/version_hash.gen.h", "w")
|
|
githash = ""
|
|
if os.path.isfile(".git/HEAD"):
|
|
head = open(".git/HEAD", "r").readline().strip()
|
|
if head.startswith("ref: "):
|
|
head = ".git/" + head[5:]
|
|
if os.path.isfile(head):
|
|
githash = open(head, "r").readline().strip()
|
|
else:
|
|
githash = head
|
|
fhash.write("#define VERSION_HASH \"" + githash + "\"")
|
|
fhash.close()
|
|
|
|
|
|
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()
|
|
|
|
fs.close()
|
|
|
|
|
|
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
|
|
if (not os.path.exists(x + "/config.py")):
|
|
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 + """
|
|
}
|
|
"""
|
|
|
|
with open("modules/register_module_types.gen.cpp", "w") as f:
|
|
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()
|
|
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_flat_dir(self, dir):
|
|
if (dir not in self.android_flat_dirs):
|
|
self.android_flat_dirs.append(dir)
|
|
|
|
def android_add_maven_repository(self, url):
|
|
if (url not in self.android_maven_repos):
|
|
self.android_maven_repos.append(url)
|
|
|
|
def android_add_dependency(self, depline):
|
|
if (depline not in self.android_dependencies):
|
|
self.android_dependencies.append(depline)
|
|
|
|
def android_add_java_dir(self, subpath):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
|
|
if (base_path not in self.android_java_dirs):
|
|
self.android_java_dirs.append(base_path)
|
|
|
|
def android_add_res_dir(self, subpath):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
|
|
if (base_path not in self.android_res_dirs):
|
|
self.android_res_dirs.append(base_path)
|
|
|
|
def android_add_asset_dir(self, subpath):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
|
|
if (base_path not in self.android_asset_dirs):
|
|
self.android_asset_dirs.append(base_path)
|
|
|
|
def android_add_aidl_dir(self, subpath):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
|
|
if (base_path not in self.android_aidl_dirs):
|
|
self.android_aidl_dirs.append(base_path)
|
|
|
|
def android_add_jni_dir(self, subpath):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + subpath
|
|
if (base_path not in self.android_jni_dirs):
|
|
self.android_jni_dirs.append(base_path)
|
|
|
|
def android_add_gradle_plugin(self, plugin):
|
|
if (plugin not in self.android_gradle_plugins):
|
|
self.android_gradle_plugins.append(plugin)
|
|
|
|
def android_add_gradle_classpath(self, classpath):
|
|
if (classpath not in self.android_gradle_classpath):
|
|
self.android_gradle_classpath.append(classpath)
|
|
|
|
def android_add_default_config(self, config):
|
|
if (config not in self.android_default_config):
|
|
self.android_default_config.append(config)
|
|
|
|
def android_add_to_manifest(self, file):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + file
|
|
with open(base_path, "r") as f:
|
|
self.android_manifest_chunk += f.read()
|
|
|
|
def android_add_to_permissions(self, file):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + file
|
|
with open(base_path, "r") as f:
|
|
self.android_permission_chunk += f.read()
|
|
|
|
def android_add_to_attributes(self, file):
|
|
base_path = self.Dir(".").abspath + "/modules/" + self.current_module + "/" + file
|
|
with open(base_path, "r") as f:
|
|
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 invocation 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):
|
|
|
|
startupinfo = subprocess.STARTUPINFO()
|
|
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
|
|
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 mySpawn(sh, escape, cmd, args, env):
|
|
|
|
newargs = ' '.join(args[1:])
|
|
cmdline = cmd + " " + newargs
|
|
|
|
rv = 0
|
|
env = {str(key): str(value) for key, value in iteritems(env)}
|
|
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, src_list = None, env_lib = None):
|
|
import string
|
|
env = self
|
|
|
|
num = 0
|
|
cur_base = ""
|
|
max_src = 64
|
|
list = []
|
|
lib_list = []
|
|
|
|
if src_list == None:
|
|
src_list = getattr(env, libname + "_sources")
|
|
|
|
if type(env_lib) == type(None):
|
|
env_lib = env
|
|
|
|
for f in src_list:
|
|
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_lib.add_library(libname + str(num), list)
|
|
lib_list.append(lib)
|
|
list = []
|
|
num = num + 1
|
|
cur_base = base
|
|
list.append(f)
|
|
|
|
lib = env_lib.add_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_lib.add_library(libname + "_collated", lib_list)
|
|
lib_list = [lib]
|
|
|
|
lib_base = []
|
|
env_lib.add_source_files(lib_base, "*.cpp")
|
|
lib = env_lib.add_library(libname, lib_base)
|
|
lib_list.insert(0, lib)
|
|
|
|
env.Prepend(LIBS=lib_list)
|
|
|
|
|
|
def save_active_platforms(apnames, ap):
|
|
|
|
for x in ap:
|
|
names = ['logo']
|
|
if os.path.isfile(x + "/run_icon.png"):
|
|
names.append('run_icon')
|
|
|
|
for name in names:
|
|
pngf = open(x + "/" + name + ".png", "rb")
|
|
b = pngf.read(1)
|
|
str = " /* AUTOGENERATED FILE, DO NOT EDIT */ \n"
|
|
str += " static const unsigned char _" + x[9:] + "_" + name + "[]={"
|
|
while(len(b) == 1):
|
|
str += hex(ord(b))
|
|
b = pngf.read(1)
|
|
if (len(b) == 1):
|
|
str += ","
|
|
|
|
str += "};\n"
|
|
|
|
pngf.close()
|
|
|
|
wf = x + "/" + name + ".gen.h"
|
|
with open(wf, "w") as pngw:
|
|
pngw.write(str)
|
|
|
|
|
|
def no_verbose(sys, env):
|
|
|
|
colors = {}
|
|
|
|
# Colors are disabled in non-TTY environments such as pipes. This means
|
|
# that if output is redirected to a file, it will not contain color codes
|
|
if sys.stdout.isatty():
|
|
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'
|
|
else:
|
|
colors['cyan'] = ''
|
|
colors['purple'] = ''
|
|
colors['blue'] = ''
|
|
colors['green'] = ''
|
|
colors['yellow'] = ''
|
|
colors['red'] = ''
|
|
colors['end'] = ''
|
|
|
|
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 receive 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 proper vc version that will be called
|
|
|
|
# There 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 variable and figure out which one will be called first. Code below 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 = ""
|
|
|
|
# Start with Pre VS 2017 checks which uses VCINSTALLDIR:
|
|
if 'VCINSTALLDIR' in tools_env:
|
|
# print("Checking VCINSTALLDIR")
|
|
|
|
# find() works with -1 so big ifs below 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"
|
|
|
|
# and for VS 2017 and newer we check VCTOOLSINSTALLDIR:
|
|
if 'VCTOOLSINSTALLDIR' in tools_env:
|
|
|
|
# Newer versions have a different path available
|
|
vc_amd64_compiler_detection_index = tools_env["PATH"].upper().find(tools_env['VCTOOLSINSTALLDIR'].upper() + "BIN\\HOSTX64\\X64;")
|
|
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"].upper().find(tools_env['VCTOOLSINSTALLDIR'].upper() + "BIN\\HOSTX64\\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"
|
|
|
|
vc_x86_compiler_detection_index = tools_env["PATH"].upper().find(tools_env['VCTOOLSINSTALLDIR'].upper() + "BIN\\HOSTX86\\X86;")
|
|
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"].upper().find(tools_env['VCTOOLSINSTALLDIR'].upper() + "BIN\\HOSTX86\\X64;")
|
|
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"
|
|
|
|
return vc_chosen_compiler_str
|
|
|
|
def find_visual_c_batch_file(env):
|
|
from SCons.Tool.MSCommon.vc import get_default_version, get_host_target, find_batch_file
|
|
|
|
version = get_default_version(env)
|
|
(host_platform, target_platform,req_target_platform) = get_host_target(env)
|
|
return find_batch_file(env, version, host_platform, target_platform)[0]
|
|
|
|
def generate_cpp_hint_file(filename):
|
|
import os.path
|
|
if os.path.isfile(filename):
|
|
# Don't overwrite an existing hint file since the user may have customized it.
|
|
pass
|
|
else:
|
|
try:
|
|
with open(filename, "w") as fd:
|
|
fd.write("#define GDCLASS(m_class, m_inherits)\n")
|
|
except IOError:
|
|
print("Could not write cpp.hint file.")
|
|
|
|
def generate_vs_project(env, num_jobs):
|
|
batch_file = find_visual_c_batch_file(env)
|
|
if batch_file:
|
|
def build_commandline(commands):
|
|
common_build_prefix = ['cmd /V /C set "plat=$(PlatformTarget)"',
|
|
'(if "$(PlatformTarget)"=="x64" (set "plat=x86_amd64"))',
|
|
'set "tools=yes"',
|
|
'(if "$(Configuration)"=="release" (set "tools=no"))',
|
|
'call "' + batch_file + '" !plat!']
|
|
|
|
result = " ^& ".join(common_build_prefix + [commands])
|
|
return result
|
|
|
|
env.AddToVSProject(env.core_sources)
|
|
env.AddToVSProject(env.main_sources)
|
|
env.AddToVSProject(env.modules_sources)
|
|
env.AddToVSProject(env.scene_sources)
|
|
env.AddToVSProject(env.servers_sources)
|
|
env.AddToVSProject(env.editor_sources)
|
|
|
|
# windows allows us to have spaces in paths, so we need
|
|
# to double quote off the directory. However, the path ends
|
|
# in a backslash, so we need to remove this, lest it escape the
|
|
# last double quote off, confusing MSBuild
|
|
env['MSVSBUILDCOM'] = build_commandline('scons --directory="$(ProjectDir.TrimEnd(\'\\\'))" platform=windows progress=no target=$(Configuration) tools=!tools! -j' + str(num_jobs))
|
|
env['MSVSREBUILDCOM'] = build_commandline('scons --directory="$(ProjectDir.TrimEnd(\'\\\'))" platform=windows progress=no target=$(Configuration) tools=!tools! vsproj=yes -j' + str(num_jobs))
|
|
env['MSVSCLEANCOM'] = build_commandline('scons --directory="$(ProjectDir.TrimEnd(\'\\\'))" --clean platform=windows progress=no target=$(Configuration) tools=!tools! -j' + str(num_jobs))
|
|
|
|
# This version information (Win32, x64, Debug, Release, Release_Debug seems to be
|
|
# required for Visual Studio to understand that it needs to generate an NMAKE
|
|
# project. Do not modify without knowing what you are doing.
|
|
debug_variants = ['debug|Win32'] + ['debug|x64']
|
|
release_variants = ['release|Win32'] + ['release|x64']
|
|
release_debug_variants = ['release_debug|Win32'] + ['release_debug|x64']
|
|
variants = debug_variants + release_variants + release_debug_variants
|
|
debug_targets = ['bin\\godot.windows.tools.32.exe'] + ['bin\\godot.windows.tools.64.exe']
|
|
release_targets = ['bin\\godot.windows.opt.32.exe'] + ['bin\\godot.windows.opt.64.exe']
|
|
release_debug_targets = ['bin\\godot.windows.opt.tools.32.exe'] + ['bin\\godot.windows.opt.tools.64.exe']
|
|
targets = debug_targets + release_targets + release_debug_targets
|
|
msvproj = env.MSVSProject(target=['#godot' + env['MSVSPROJECTSUFFIX']],
|
|
incs=env.vs_incs,
|
|
srcs=env.vs_srcs,
|
|
runfile=targets,
|
|
buildtarget=targets,
|
|
auto_build_solution=1,
|
|
variant=variants)
|
|
else:
|
|
print("Could not locate Visual Studio batch file for setting up the build environment. Not generating VS project.")
|
|
|
|
def precious_program(env, program, sources, **args):
|
|
program = env.ProgramOriginal(program, sources, **args)
|
|
env.Precious(program)
|
|
return program
|
|
|
|
def add_shared_library(env, name, sources, **args):
|
|
library = env.SharedLibrary(name, sources, **args)
|
|
env.NoCache(library)
|
|
return library
|
|
|
|
def add_library(env, name, sources, **args):
|
|
library = env.Library(name, sources, **args)
|
|
env.NoCache(library)
|
|
return library
|
|
|
|
def add_program(env, name, sources, **args):
|
|
program = env.Program(name, sources, **args)
|
|
env.NoCache(program)
|
|
return program
|
|
|
|
def CommandNoCache(env, target, sources, command, **args):
|
|
result = env.Command(target, sources, command, **args)
|
|
env.NoCache(result)
|
|
return result
|