"""Functions used to generate source files during build time""" import os.path from methods import generated_wrapper, print_error, to_raw_cstring class GLES3HeaderStruct: def __init__(self): self.vertex_lines = [] self.fragment_lines = [] self.uniforms = [] self.fbos = [] self.texunits = [] self.texunit_names = [] self.ubos = [] self.ubo_names = [] self.feedbacks = [] self.vertex_included_files = [] self.fragment_included_files = [] self.reading = "" self.line_offset = 0 self.vertex_offset = 0 self.fragment_offset = 0 self.variant_defines = [] self.variant_names = [] self.specialization_names = [] self.specialization_values = [] def include_file_in_gles3_header(filename: str, header_data: GLES3HeaderStruct, depth: int): with open(filename, "r", encoding="utf-8") as fs: line = fs.readline() while line: if line.find("=") != -1 and header_data.reading == "": # Mode eqpos = line.find("=") defname = line[:eqpos].strip().upper() define = line[eqpos + 1 :].strip() header_data.variant_names.append(defname) header_data.variant_defines.append(define) line = fs.readline() header_data.line_offset += 1 header_data.vertex_offset = header_data.line_offset continue if line.find("=") != -1 and header_data.reading == "specializations": # Specialization eqpos = line.find("=") specname = line[:eqpos].strip() specvalue = line[eqpos + 1 :] header_data.specialization_names.append(specname) header_data.specialization_values.append(specvalue) line = fs.readline() header_data.line_offset += 1 header_data.vertex_offset = header_data.line_offset continue if line.find("#[modes]") != -1: # Nothing really, just skip line = fs.readline() header_data.line_offset += 1 header_data.vertex_offset = header_data.line_offset continue if line.find("#[specializations]") != -1: header_data.reading = "specializations" line = fs.readline() header_data.line_offset += 1 header_data.vertex_offset = header_data.line_offset continue 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] included_file = os.path.relpath(os.path.dirname(filename) + "/" + includeline) if included_file not in header_data.vertex_included_files and header_data.reading == "vertex": header_data.vertex_included_files += [included_file] if include_file_in_gles3_header(included_file, header_data, depth + 1) is None: print_error(f'In file "{filename}": #include "{includeline}" could not be found!"') elif included_file not in header_data.fragment_included_files and header_data.reading == "fragment": header_data.fragment_included_files += [included_file] if include_file_in_gles3_header(included_file, header_data, depth + 1) is None: print_error(f'In file "{filename}": #include "{includeline}" could not be found!"') line = fs.readline() 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 x not 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 x not 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 x not in header_data.uniforms: header_data.uniforms += [x] if (line.strip().find("out ") == 0 or line.strip().find("flat ") == 0) and line.find("tfb:") != -1: uline = line.replace("flat ", "") uline = uline.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 return header_data def build_gles3_header(filename: str, shader: str) -> None: include_file_in_gles3_header(shader, header_data := GLES3HeaderStruct(), 0) out_file_class = ( os.path.basename(shader).replace(".glsl", "").title().replace("_", "").replace(".", "") + "ShaderGLES3" ) with generated_wrapper(filename) as file: defspec = 0 defvariant = "" file.write(f"""\ #include "drivers/gles3/shader_gles3.h" class {out_file_class} : public ShaderGLES3 {{ public: """) if header_data.uniforms: uniforms = ",\n\t\t".join(uniform.upper() for uniform in header_data.uniforms) file.write(f"""\ enum Uniforms {{ {uniforms}, }}; """) if header_data.variant_names: variant_names = ",\n\t\t".join(name for name in header_data.variant_names) else: variant_names = "DEFAULT" defvariant = " = DEFAULT" file.write(f"""\ enum ShaderVariant {{ {variant_names}, }}; """) if header_data.specialization_names: specialization_names = ",\n\t\t".join( f"{name.upper()} = {1 << index}" for index, name in enumerate(header_data.specialization_names) ) file.write(f"""\ enum Specializations {{ {specialization_names}, }}; """) for index, specialization_value in enumerate(header_data.specialization_values): if specialization_value.strip().upper() in ["TRUE", "1"]: defspec |= 1 << index file.write(f"""\ _FORCE_INLINE_ bool version_bind_shader(RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ return _version_bind_shader(p_version, p_variant, p_specialization); }} """) if header_data.uniforms: file.write(f"""\ _FORCE_INLINE_ int version_get_uniform(Uniforms p_uniform, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ return _version_get_uniform(p_uniform, p_version, p_variant, p_specialization); }} /* clang-format off */ #define TRY_GET_UNIFORM if (version_get_uniform(p_uniform, p_version, p_variant, p_specialization) < 0) return /* clang-format on */ _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, float p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1f(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, double p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1f(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, uint8_t p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1ui(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, int8_t p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1i(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, uint16_t p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1ui(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, int16_t p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1i(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, uint32_t p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1ui(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, int32_t p_value, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform1i(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_value); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Color &p_color, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; GLfloat col[4] = {{ p_color.r, p_color.g, p_color.b, p_color.a }}; glUniform4fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, col); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Vector2 &p_vec2, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; GLfloat vec2[2] = {{ float(p_vec2.x), float(p_vec2.y) }}; glUniform2fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, vec2); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Size2i &p_vec2, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; GLint vec2[2] = {{ GLint(p_vec2.x), GLint(p_vec2.y) }}; glUniform2iv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, vec2); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Vector3 &p_vec3, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; GLfloat vec3[3] = {{ float(p_vec3.x), float(p_vec3.y), float(p_vec3.z) }}; glUniform3fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, vec3); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Vector4 &p_vec4, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; GLfloat vec4[4] = {{ float(p_vec4.x), float(p_vec4.y), float(p_vec4.z), float(p_vec4.w) }}; glUniform4fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, vec4); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, float p_a, float p_b, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform2f(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_a, p_b); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform3f(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_a, p_b, p_c); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, float p_a, float p_b, float p_c, float p_d, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; glUniform4f(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), p_a, p_b, p_c, p_d); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Transform3D &p_transform, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; const Transform3D &tr = p_transform; GLfloat matrix[16] = {{ /* build a 16x16 matrix */ (GLfloat)tr.basis.rows[0][0], (GLfloat)tr.basis.rows[1][0], (GLfloat)tr.basis.rows[2][0], (GLfloat)0, (GLfloat)tr.basis.rows[0][1], (GLfloat)tr.basis.rows[1][1], (GLfloat)tr.basis.rows[2][1], (GLfloat)0, (GLfloat)tr.basis.rows[0][2], (GLfloat)tr.basis.rows[1][2], (GLfloat)tr.basis.rows[2][2], (GLfloat)0, (GLfloat)tr.origin.x, (GLfloat)tr.origin.y, (GLfloat)tr.origin.z, (GLfloat)1 }}; glUniformMatrix4fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, false, matrix); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Transform2D &p_transform, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; const Transform2D &tr = p_transform; GLfloat matrix[16] = {{ /* build a 16x16 matrix */ (GLfloat)tr.columns[0][0], (GLfloat)tr.columns[0][1], (GLfloat)0, (GLfloat)0, (GLfloat)tr.columns[1][0], (GLfloat)tr.columns[1][1], (GLfloat)0, (GLfloat)0, (GLfloat)0, (GLfloat)0, (GLfloat)1, (GLfloat)0, (GLfloat)tr.columns[2][0], (GLfloat)tr.columns[2][1], (GLfloat)0, (GLfloat)1 }}; glUniformMatrix4fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, false, matrix); }} _FORCE_INLINE_ void version_set_uniform(Uniforms p_uniform, const Projection &p_matrix, RID p_version, ShaderVariant p_variant{defvariant}, uint64_t p_specialization = {defspec}) {{ TRY_GET_UNIFORM; GLfloat matrix[16]; for (int i = 0; i < 4; i++) {{ for (int j = 0; j < 4; j++) {{ matrix[i * 4 + j] = p_matrix.columns[i][j]; }} }} glUniformMatrix4fv(version_get_uniform(p_uniform, p_version, p_variant, p_specialization), 1, false, matrix); }} #undef TRY_GET_UNIFORM """) file.write("""\ protected: virtual void _init() override { """) if header_data.uniforms: uniforms = ",\n\t\t\t".join(f'"{uniform}"' for uniform in header_data.uniforms) file.write(f"""\ static const char *_uniform_strings[] = {{ {uniforms} }}; """) else: file.write("""\ static const char **_uniform_strings = nullptr; """) if header_data.variant_defines: variant_count = len(header_data.variant_defines) variant_defines = ",\n\t\t\t".join(f'"{define}"' for define in header_data.variant_defines) file.write(f"""\ static const char *_variant_defines[] = {{ {variant_defines}, }}; """) else: variant_count = 1 file.write("""\ static const char **_variant_defines[] = {" "}; """) if header_data.texunits: texunits = ",\n\t\t\t".join(f'{{ "{name}", {texunit} }}' for name, texunit in header_data.texunits) file.write(f"""\ static TexUnitPair _texunit_pairs[] = {{ {texunits}, }}; """) else: file.write("""\ static TexUnitPair *_texunit_pairs = nullptr; """) if header_data.ubos: ubos = ",\n\t\t\t".join(f'{{ "{name}", {ubo} }}' for name, ubo in header_data.ubos) file.write(f"""\ static UBOPair _ubo_pairs[] = {{ {ubos}, }}; """) else: file.write("""\ static UBOPair *_ubo_pairs = nullptr; """) if header_data.specialization_names: specializations = ",\n\t\t\t".join( f'{{ "{name}", {"true" if header_data.specialization_values[index].strip().upper() in ["TRUE", "1"] else "false"} }}' for index, name in enumerate(header_data.specialization_names) ) file.write(f"""\ static Specialization _spec_pairs[] = {{ {specializations}, }}; """) else: file.write("""\ static Specialization *_spec_pairs = nullptr; """) if header_data.feedbacks: feedbacks = ",\n\t\t\t".join( f'{{ "{name}", {0 if spec not in header_data.specialization_names else (1 << header_data.specialization_names.index(spec))} }}' for name, spec in header_data.feedbacks ) file.write(f"""\ static const Feedback _feedbacks[] = {{ {feedbacks}, }}; """) else: file.write("""\ static const Feedback *_feedbacks = nullptr; """) file.write(f"""\ static const char _vertex_code[] = {{ {to_raw_cstring(header_data.vertex_lines)} }}; static const char _fragment_code[] = {{ {to_raw_cstring(header_data.fragment_lines)} }}; _setup(_vertex_code, _fragment_code, "{out_file_class}", {len(header_data.uniforms)}, _uniform_strings, {len(header_data.ubos)}, _ubo_pairs, {len(header_data.feedbacks)}, _feedbacks, {len(header_data.texunits)}, _texunit_pairs, {len(header_data.specialization_names)}, _spec_pairs, {variant_count}, _variant_defines); }} }}; """) def build_gles3_headers(target, source, env): env.NoCache(target) for src in source: build_gles3_header(f"{src}.gen.h", str(src))