text: """Functions used to generate source files during build time
  
  All such functions are invoked in a subprocess on Windows to prevent build flakiness.
  
  """
  from platform_methods import subprocess_main
  
  
  class RDHeaderStruct:
      def __init__(self):
          self.vertex_lines = []
          self.fragment_lines = []
          self.compute_lines = []
  
          self.vertex_included_files = []
          self.fragment_included_files = []
          self.compute_included_files = []
  
          self.reading = ""
          self.line_offset = 0
          self.vertex_offset = 0
          self.fragment_offset = 0
          self.compute_offset = 0
  
  
  def include_file_in_rd_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
  
          if line.find("#[compute]") != -1:
              header_data.reading = "compute"
              line = fs.readline()
              header_data.line_offset += 1
              header_data.compute_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_rd_header(included_file, header_data, depth + 1) is 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_rd_header(included_file, header_data, depth + 1) is None:
                      print("Error in file '" + filename + "': #include " + includeline + "could not be found!")
              elif not included_file in header_data.compute_included_files and header_data.reading == "compute":
                  header_data.compute_included_files += [included_file]
                  if include_file_in_rd_header(included_file, header_data, depth + 1) is None:
                      print("Error in file '" + filename + "': #include " + includeline + "could not be found!")
  
              line = fs.readline()
  
          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]
          if header_data.reading == "compute":
              header_data.compute_lines += [line]
  
          line = fs.readline()
          header_data.line_offset += 1
  
      fs.close()
  
      return header_data
  
  
  def build_rd_header(filename):
      header_data = RDHeaderStruct()
      include_file_in_rd_header(filename, header_data, 0)
  
      out_file = filename + ".gen.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 :]
      out_file_ifdef = out_file_base.replace(".", "_").upper()
      fd.write("#ifndef " + out_file_ifdef + "_RD\n")
      fd.write("#define " + out_file_ifdef + "_RD\n")
  
      out_file_class = out_file_base.replace(".glsl.gen.h", "").title().replace("_", "").replace(".", "") + "ShaderRD"
      fd.write("\n")
      fd.write('#include "servers/rendering/renderer_rd/shader_rd.h"\n\n')
      fd.write("class " + out_file_class + " : public ShaderRD {\n\n")
      fd.write("public:\n\n")
  
      fd.write("\t" + out_file_class + "() {\n\n")
  
      if len(header_data.compute_lines):
  
          fd.write("\t\tstatic const char _compute_code[] = {\n")
          for x in header_data.compute_lines:
              for c in x:
                  fd.write(str(ord(c)) + ",")
              fd.write(str(ord("\n")) + ",")
          fd.write("\t\t0};\n\n")
  
          fd.write('\t\tsetup(nullptr, nullptr, _compute_code, "' + out_file_class + '");\n')
          fd.write("\t}\n")
  
      else:
  
          fd.write("\t\tstatic const char _vertex_code[] = {\n")
          for x in header_data.vertex_lines:
              for c in x:
                  fd.write(str(ord(c)) + ",")
              fd.write(str(ord("\n")) + ",")
          fd.write("\t\t0};\n\n")
  
          fd.write("\t\tstatic const char _fragment_code[]={\n")
          for x in header_data.fragment_lines:
              for c in x:
                  fd.write(str(ord(c)) + ",")
              fd.write(str(ord("\n")) + ",")
          fd.write("\t\t0};\n\n")
  
          fd.write('\t\tsetup(_vertex_code, _fragment_code, nullptr, "' + out_file_class + '");\n')
          fd.write("\t}\n")
  
      fd.write("};\n\n")
  
      fd.write("#endif\n")
      fd.close()
  
  
  def build_rd_headers(target, source, env):
      for x in source:
          build_rd_header(str(x))
  
  
  class RAWHeaderStruct:
      def __init__(self):
          self.code = ""
  
  
  def include_file_in_raw_header(filename, header_data, depth):
      fs = open(filename, "r")
      line = fs.readline()
  
      while line:
  
          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)
              include_file_in_raw_header(included_file, header_data, depth + 1)
  
              line = fs.readline()
  
          header_data.code += line
          line = fs.readline()
  
      fs.close()
  
  
  def build_raw_header(filename):
      header_data = RAWHeaderStruct()
      include_file_in_raw_header(filename, header_data, 0)
  
      out_file = filename + ".gen.h"
      fd = open(out_file, "w")
  
      fd.write("/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */\n")
  
      out_file_base = out_file.replace(".glsl.gen.h", "_shader_glsl")
      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 + "_RAW_H\n")
      fd.write("#define " + out_file_ifdef + "_RAW_H\n")
      fd.write("\n")
      fd.write("static const char " + out_file_base + "[] = {\n")
      for c in header_data.code:
          fd.write(str(ord(c)) + ",")
      fd.write("\t\t0};\n\n")
      fd.write("#endif\n")
      fd.close()
  
  
  def build_raw_headers(target, source, env):
      for x in source:
          build_raw_header(str(x))
  
  
  if __name__ == "__main__":
      subprocess_main(globals())
  