godotengine/godot-angle-static
1
0
Fork 0
mirror of https://github.com/godotengine/godot-angle-static.git synced 2026-01-03 14:09:33 +03:00
Code Issues Packages Projects Releases Wiki Activity

Use auto_script in run_code_generation.

Browse Source 
Cleans up the generator scripts to prepare for listing outputs in the
generated hashes file. Also reorganizes the scripts somewhat to make
them a bit more maintainable.

Bug: angleproject:3227
Change-Id: If40946c2004941d3f6cd51d5521c7db8cc0b52df
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1512052
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
This commit is contained in:
Jamie Madill
2019-03-11 10:18:57 -04:00
committed by Commit Bot
parent f563fdc91e
commit 0f34f3f2f7
32 changed files with 1693 additions and 1242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

458
scripts/generate_entry_points.py
View File

@@ -6,26 +6,12 @@
#
# generate_entry_points.py:
# Generates the OpenGL bindings and entry point layers for ANGLE.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
import sys, os, pprint, json
from datetime import date
import registry_xml
# Handle inputs/outputs for run_code_generation.py's auto_script
if len(sys.argv) == 2 and sys.argv[1] == 'inputs':
inputs = [
'egl.xml',
'egl_angle_ext.xml',
'entry_point_packed_gl_enums.json',
'gl.xml',
'gl_angle_ext.xml',
'registry_xml.py',
]
print(",".join(inputs))
sys.exit(0)
# List of GLES1 extensions for which we don't need to add Context.h decls.
gles1_no_context_decl_extensions = [
"GL_OES_framebuffer_object",
@@ -640,158 +626,6 @@ def get_exports(commands, fmt = None):
else:
return [" %s" % cmd for cmd in sorted(commands)]
gles1decls = {}
gles1decls['core'] = []
gles1decls['exts'] = {}
libgles_ep_defs = []
libgles_ep_exports = []
xml = registry_xml.RegistryXML('gl.xml', 'gl_angle_ext.xml')
# First run through the main GLES entry points. Since ES2+ is the primary use
# case, we go through those first and then add ES1-only APIs at the end.
for major_version, minor_version in [[2, 0], [3, 0], [3, 1], [1, 0]]:
annotation = "{}_{}".format(major_version, minor_version)
name_prefix = "GL_ES_VERSION_"
is_gles1 = major_version == 1
if is_gles1:
name_prefix = "GL_VERSION_ES_CM_"
comment = annotation.replace("_", ".")
feature_name = "{}{}".format(name_prefix, annotation)
xml.AddCommands(feature_name, annotation)
gles_commands = xml.commands[annotation]
all_commands = xml.all_commands
decls, defs, libgles_defs, validation_protos = get_entry_points(
all_commands, gles_commands, False)
# Write the version as a comment before the first EP.
libgles_defs.insert(0, "\n// OpenGL ES %s" % comment)
libgles_ep_exports.append("\n ; OpenGL ES %s" % comment)
libgles_ep_defs += libgles_defs
libgles_ep_exports += get_exports(gles_commands)
major_if_not_one = major_version if major_version != 1 else ""
minor_if_not_zero = minor_version if minor_version != 0 else ""
header_includes = template_header_includes.format(
major=major_if_not_one, minor=minor_if_not_zero)
# We include the platform.h header since it undefines the conflicting MemoryBarrier macro.
if major_version == 3 and minor_version == 1:
header_includes += "\n#include \"common/platform.h\"\n"
source_includes = template_sources_includes.format(
annotation.lower(), major_version, minor_if_not_zero)
write_file(annotation, comment, template_entry_point_header,
"\n".join(decls), "h", header_includes, "gl.xml")
write_file(annotation, comment, template_entry_point_source,
"\n".join(defs), "cpp", source_includes, "gl.xml")
if is_gles1:
gles1decls['core'] = get_gles1_decls(all_commands, gles_commands)
validation_annotation = "%s%s" % (major_version, minor_if_not_zero)
write_validation_header(validation_annotation, comment, validation_protos)
# After we finish with the main entry points, we process the extensions.
extension_defs = []
extension_decls = []
# Accumulated validation prototypes.
ext_validation_protos = []
for gles1ext in registry_xml.gles1_extensions:
gles1decls['exts'][gles1ext] = []
xml.AddExtensionCommands(registry_xml.supported_extensions, ['gles2', 'gles1'])
for extension_name, ext_cmd_names in sorted(xml.ext_data.iteritems()):
# Detect and filter duplicate extensions.
decls, defs, libgles_defs, validation_protos = get_entry_points(
xml.all_commands, ext_cmd_names, False)
# Avoid writing out entry points defined by a prior extension.
for dupe in xml.ext_dupes[extension_name]:
msg = "// {} is already defined.\n".format(dupe[2:])
defs.append(msg)
# Write the extension name as a comment before the first EP.
comment = "\n// {}".format(extension_name)
defs.insert(0, comment)
decls.insert(0, comment)
libgles_defs.insert(0, comment)
libgles_ep_exports.append("\n ; %s" % extension_name)
extension_defs += defs
extension_decls += decls
ext_validation_protos += [comment] + validation_protos
libgles_ep_defs += libgles_defs
libgles_ep_exports += get_exports(ext_cmd_names)
if extension_name in registry_xml.gles1_extensions:
if extension_name not in gles1_no_context_decl_extensions:
gles1decls['exts'][extension_name] = get_gles1_decls(all_commands, ext_cmd_names)
# Special handling for EGL_ANGLE_explicit_context extension
if registry_xml.support_EGL_ANGLE_explicit_context:
comment = "\n// EGL_ANGLE_explicit_context"
extension_defs.append(comment)
extension_decls.append(comment)
libgles_ep_defs.append(comment)
cmds = xml.all_cmd_names.get_all_commands()
# Get the explicit context entry points
decls, defs, libgles_defs, validation_protos = get_entry_points(
xml.all_commands, cmds, True)
# Append the explicit context entry points
extension_decls += decls
extension_defs += defs
libgles_ep_defs += libgles_defs
libgles_ep_exports.append("\n ; EGL_ANGLE_explicit_context")
libgles_ep_exports += get_exports(cmds, lambda x: "%sContextANGLE" % x)
# Generate .inc files for extension function pointers and declarations
for major, minor in [[2, 0], [3, 0], [3, 1], [1, 0]]:
annotation = "{}_{}".format(major, minor)
major_if_not_one = major if major != 1 else ""
minor_if_not_zero = minor if minor != 0 else ""
version = "{}{}".format(major_if_not_one, minor_if_not_zero)
glext_ptrs, glext_protos = get_glext_decls(all_commands,
xml.all_cmd_names.get_commands(annotation), version, True)
glext_ext_ptrs = []
glext_ext_protos = []
# Append extensions for 1.0 and 2.0
if(annotation == "1_0"):
glext_ext_ptrs, glext_ext_protos = get_glext_decls(all_commands,
xml.all_cmd_names.get_commands("glext"), version, True)
elif(annotation == "2_0"):
glext_ext_ptrs, glext_ext_protos = get_glext_decls(all_commands,
xml.all_cmd_names.get_commands("gl2ext"), version, True)
glext_ptrs += glext_ext_ptrs
glext_protos += glext_ext_protos
write_glext_explicit_context_inc(version, "\n".join(glext_ptrs), "\n".join(glext_protos))
# Get EGL exports
def get_egl_exports():
@@ -828,62 +662,260 @@ def get_egl_exports():
return exports
header_includes = template_header_includes.format(
major="", minor="")
header_includes += """
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
"""
def main():
source_includes = template_sources_includes.format("ext", "EXT", "")
source_includes += """
#include "libANGLE/validationES1.h"
#include "libANGLE/validationES2.h"
#include "libANGLE/validationES3.h"
#include "libANGLE/validationES31.h"
"""
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [
'egl.xml',
'egl_angle_ext.xml',
'entry_point_packed_gl_enums.json',
'gl.xml',
'gl_angle_ext.xml',
'registry_xml.py',
]
outputs = [
'../src/libANGLE/Context_gles_1_0_autogen.h',
'../src/libANGLE/validationES1_autogen.h',
'../src/libANGLE/validationES2_autogen.h',
'../src/libANGLE/validationES31_autogen.h',
'../src/libANGLE/validationES3_autogen.h',
'../src/libANGLE/validationESEXT_autogen.h',
'../src/libGLESv2/entry_points_enum_autogen.h',
'../src/libGLESv2/entry_points_gles_1_0_autogen.cpp',
'../src/libGLESv2/entry_points_gles_1_0_autogen.h',
'../src/libGLESv2/entry_points_gles_2_0_autogen.cpp',
'../src/libGLESv2/entry_points_gles_2_0_autogen.h',
'../src/libGLESv2/entry_points_gles_3_0_autogen.cpp',
'../src/libGLESv2/entry_points_gles_3_0_autogen.h',
'../src/libGLESv2/entry_points_gles_3_1_autogen.cpp',
'../src/libGLESv2/entry_points_gles_3_1_autogen.h',
'../src/libGLESv2/entry_points_gles_ext_autogen.cpp',
'../src/libGLESv2/entry_points_gles_ext_autogen.h',
'../src/libGLESv2/libGLESv2_autogen.cpp',
'../src/libGLESv2/libGLESv2_autogen.def',
]
write_file("ext", "extension", template_entry_point_header,
"\n".join([item for item in extension_decls]), "h", header_includes,
"gl.xml and gl_angle_ext.xml")
write_file("ext", "extension", template_entry_point_source,
"\n".join([item for item in extension_defs]), "cpp", source_includes,
"gl.xml and gl_angle_ext.xml")
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
write_validation_header("EXT", "extension", ext_validation_protos)
gles1decls = {}
write_context_api_decls("1_0", context_gles_header, gles1decls)
gles1decls['core'] = []
gles1decls['exts'] = {}
sorted_cmd_names = ["Invalid"] + [cmd[2:] for cmd in sorted(xml.all_cmd_names.get_all_commands())]
libgles_ep_defs = []
libgles_ep_exports = []
entry_points_enum = template_entry_points_enum_header.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = "gl.xml and gl_angle_ext.xml",
year = date.today().year,
entry_points_list = ",\n".join([" " + cmd for cmd in sorted_cmd_names]))
xml = registry_xml.RegistryXML('gl.xml', 'gl_angle_ext.xml')
entry_points_enum_header_path = path_to("libGLESv2", "entry_points_enum_autogen.h")
with open(entry_points_enum_header_path, "w") as out:
out.write(entry_points_enum)
out.close()
# First run through the main GLES entry points. Since ES2+ is the primary use
# case, we go through those first and then add ES1-only APIs at the end.
for major_version, minor_version in [[2, 0], [3, 0], [3, 1], [1, 0]]:
annotation = "{}_{}".format(major_version, minor_version)
name_prefix = "GL_ES_VERSION_"
source_includes = """
#include "angle_gl.h"
is_gles1 = major_version == 1
if is_gles1:
name_prefix = "GL_VERSION_ES_CM_"
#include "libGLESv2/entry_points_gles_1_0_autogen.h"
#include "libGLESv2/entry_points_gles_2_0_autogen.h"
#include "libGLESv2/entry_points_gles_3_0_autogen.h"
#include "libGLESv2/entry_points_gles_3_1_autogen.h"
#include "libGLESv2/entry_points_gles_ext_autogen.h"
comment = annotation.replace("_", ".")
feature_name = "{}{}".format(name_prefix, annotation)
#include "common/event_tracer.h"
"""
xml.AddCommands(feature_name, annotation)
write_export_files("\n".join([item for item in libgles_ep_defs]), source_includes)
gles_commands = xml.commands[annotation]
all_commands = xml.all_commands
libgles_ep_exports += get_egl_exports()
decls, defs, libgles_defs, validation_protos = get_entry_points(
all_commands, gles_commands, False)
everything = "Khronos and ANGLE XML files"
write_windows_def_file(everything, "libGLESv2", libgles_ep_exports)
# Write the version as a comment before the first EP.
libgles_defs.insert(0, "\n// OpenGL ES %s" % comment)
libgles_ep_exports.append("\n ; OpenGL ES %s" % comment)
libgles_ep_defs += libgles_defs
libgles_ep_exports += get_exports(gles_commands)
major_if_not_one = major_version if major_version != 1 else ""
minor_if_not_zero = minor_version if minor_version != 0 else ""
header_includes = template_header_includes.format(
major=major_if_not_one, minor=minor_if_not_zero)
# We include the platform.h header since it undefines the conflicting MemoryBarrier macro.
if major_version == 3 and minor_version == 1:
header_includes += "\n#include \"common/platform.h\"\n"
source_includes = template_sources_includes.format(
annotation.lower(), major_version, minor_if_not_zero)
write_file(annotation, comment, template_entry_point_header,
"\n".join(decls), "h", header_includes, "gl.xml")
write_file(annotation, comment, template_entry_point_source,
"\n".join(defs), "cpp", source_includes, "gl.xml")
if is_gles1:
gles1decls['core'] = get_gles1_decls(all_commands, gles_commands)
validation_annotation = "%s%s" % (major_version, minor_if_not_zero)
write_validation_header(validation_annotation, comment, validation_protos)
# After we finish with the main entry points, we process the extensions.
extension_defs = []
extension_decls = []
# Accumulated validation prototypes.
ext_validation_protos = []
for gles1ext in registry_xml.gles1_extensions:
gles1decls['exts'][gles1ext] = []
xml.AddExtensionCommands(registry_xml.supported_extensions, ['gles2', 'gles1'])
for extension_name, ext_cmd_names in sorted(xml.ext_data.iteritems()):
# Detect and filter duplicate extensions.
decls, defs, libgles_defs, validation_protos = get_entry_points(
xml.all_commands, ext_cmd_names, False)
# Avoid writing out entry points defined by a prior extension.
for dupe in xml.ext_dupes[extension_name]:
msg = "// {} is already defined.\n".format(dupe[2:])
defs.append(msg)
# Write the extension name as a comment before the first EP.
comment = "\n// {}".format(extension_name)
defs.insert(0, comment)
decls.insert(0, comment)
libgles_defs.insert(0, comment)
libgles_ep_exports.append("\n ; %s" % extension_name)
extension_defs += defs
extension_decls += decls
ext_validation_protos += [comment] + validation_protos
libgles_ep_defs += libgles_defs
libgles_ep_exports += get_exports(ext_cmd_names)
if extension_name in registry_xml.gles1_extensions:
if extension_name not in gles1_no_context_decl_extensions:
gles1decls['exts'][extension_name] = get_gles1_decls(all_commands, ext_cmd_names)
# Special handling for EGL_ANGLE_explicit_context extension
if registry_xml.support_EGL_ANGLE_explicit_context:
comment = "\n// EGL_ANGLE_explicit_context"
extension_defs.append(comment)
extension_decls.append(comment)
libgles_ep_defs.append(comment)
cmds = xml.all_cmd_names.get_all_commands()
# Get the explicit context entry points
decls, defs, libgles_defs, validation_protos = get_entry_points(
xml.all_commands, cmds, True)
# Append the explicit context entry points
extension_decls += decls
extension_defs += defs
libgles_ep_defs += libgles_defs
libgles_ep_exports.append("\n ; EGL_ANGLE_explicit_context")
libgles_ep_exports += get_exports(cmds, lambda x: "%sContextANGLE" % x)
# Generate .inc files for extension function pointers and declarations
for major, minor in [[2, 0], [3, 0], [3, 1], [1, 0]]:
annotation = "{}_{}".format(major, minor)
major_if_not_one = major if major != 1 else ""
minor_if_not_zero = minor if minor != 0 else ""
version = "{}{}".format(major_if_not_one, minor_if_not_zero)
glext_ptrs, glext_protos = get_glext_decls(all_commands,
xml.all_cmd_names.get_commands(annotation), version, True)
glext_ext_ptrs = []
glext_ext_protos = []
# Append extensions for 1.0 and 2.0
if(annotation == "1_0"):
glext_ext_ptrs, glext_ext_protos = get_glext_decls(all_commands,
xml.all_cmd_names.get_commands("glext"), version, True)
elif(annotation == "2_0"):
glext_ext_ptrs, glext_ext_protos = get_glext_decls(all_commands,
xml.all_cmd_names.get_commands("gl2ext"), version, True)
glext_ptrs += glext_ext_ptrs
glext_protos += glext_ext_protos
write_glext_explicit_context_inc(version, "\n".join(glext_ptrs), "\n".join(glext_protos))
header_includes = template_header_includes.format(
major="", minor="")
header_includes += """
#include <GLES/glext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
"""
source_includes = template_sources_includes.format("ext", "EXT", "")
source_includes += """
#include "libANGLE/validationES1.h"
#include "libANGLE/validationES2.h"
#include "libANGLE/validationES3.h"
#include "libANGLE/validationES31.h"
"""
write_file("ext", "extension", template_entry_point_header,
"\n".join([item for item in extension_decls]), "h", header_includes,
"gl.xml and gl_angle_ext.xml")
write_file("ext", "extension", template_entry_point_source,
"\n".join([item for item in extension_defs]), "cpp", source_includes,
"gl.xml and gl_angle_ext.xml")
write_validation_header("EXT", "extension", ext_validation_protos)
write_context_api_decls("1_0", context_gles_header, gles1decls)
sorted_cmd_names = ["Invalid"] + [cmd[2:] for cmd in sorted(xml.all_cmd_names.get_all_commands())]
entry_points_enum = template_entry_points_enum_header.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = "gl.xml and gl_angle_ext.xml",
year = date.today().year,
entry_points_list = ",\n".join([" " + cmd for cmd in sorted_cmd_names]))
entry_points_enum_header_path = path_to("libGLESv2", "entry_points_enum_autogen.h")
with open(entry_points_enum_header_path, "w") as out:
out.write(entry_points_enum)
out.close()
source_includes = """
#include "angle_gl.h"
#include "libGLESv2/entry_points_gles_1_0_autogen.h"
#include "libGLESv2/entry_points_gles_2_0_autogen.h"
#include "libGLESv2/entry_points_gles_3_0_autogen.h"
#include "libGLESv2/entry_points_gles_3_1_autogen.h"
#include "libGLESv2/entry_points_gles_ext_autogen.h"
#include "common/event_tracer.h"
"""
write_export_files("\n".join([item for item in libgles_ep_defs]), source_includes)
libgles_ep_exports += get_egl_exports()
everything = "Khronos and ANGLE XML files"
write_windows_def_file(everything, "libGLESv2", libgles_ep_exports)
if __name__ == '__main__':
sys.exit(main())

44
scripts/generate_loader.py
View File

@@ -6,24 +6,12 @@
#
# generate_loader.py:
# Generates dynamic loaders for various binding interfaces.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
import sys, os, pprint, json
from datetime import date
import registry_xml
# Handle inputs/outputs for run_code_generation.py's auto_script
if len(sys.argv) == 2 and sys.argv[1] == 'inputs':
inputs = [
'egl.xml',
'egl_angle_ext.xml',
'registry_xml.py',
'wgl.xml',
]
print(",".join(inputs))
sys.exit(0)
def write_header(data_source_name, all_cmds, api, preamble, path, lib, ns = "", prefix = None, export = ""):
file_name = "%s_loader_autogen.h" % api
header_path = registry_xml.path_to(path, file_name)
@@ -175,10 +163,40 @@ def gen_wgl_loader():
write_source(source, all_cmds, "wgl", path, "_")
def main():
# Handle inputs/outputs for run_code_generation.py's auto_script
if len(sys.argv) > 1:
inputs = [
'egl.xml',
'egl_angle_ext.xml',
'registry_xml.py',
'wgl.xml',
]
outputs = [
'../src/libEGL/egl_loader_autogen.cpp',
'../src/libEGL/egl_loader_autogen.h',
'../util/egl_loader_autogen.cpp',
'../util/egl_loader_autogen.h',
'../util/gles_loader_autogen.cpp',
'../util/gles_loader_autogen.h',
'../util/windows/wgl_loader_autogen.cpp',
'../util/windows/wgl_loader_autogen.h',
]
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
gen_libegl_loader()
gen_gl_loader()
gen_egl_loader()
gen_wgl_loader()
return 0
libegl_preamble = """#include <EGL/egl.h>

160
scripts/run_code_generation.py
View File

@@ -28,138 +28,65 @@ def clean_path_slashes(path):
# Takes a script input file name which is relative to the code generation script's directory and
# changes it to be relative to the angle root directory
def rebase_script_input_path(script_path, input_file_path):
return os.path.relpath(os.path.join(os.path.dirname(script_path), input_file_path), root_dir);
def rebase_script_path(script_path, input_file_path):
return os.path.relpath(os.path.join(os.path.dirname(script_path), input_file_path), root_dir)
def grab_from_script(script, param):
res = subprocess.check_output(['python', script, param]).strip()
return [clean_path_slashes(rebase_script_input_path(script, name)) for name in res.split(',')]
if res == '':
return []
return [clean_path_slashes(rebase_script_path(script, name)) for name in res.split(',')]
def auto_script(script):
# Set the CWD to the script directory.
os.chdir(get_child_script_dirname(script))
base_script = os.path.basename(script)
return {
'script': script,
'inputs': grab_from_script(base_script, 'inputs'),
'outputs': grab_from_script(base_script, 'outputs')
}
hash_fname = "run_code_generation_hashes.json"
# TODO(jmadill): Convert everyting to auto-script.
generators = {
'ANGLE format': {
'inputs': [
'src/libANGLE/renderer/angle_format.py',
'src/libANGLE/renderer/angle_format_data.json',
'src/libANGLE/renderer/angle_format_map.json',
],
'script': 'src/libANGLE/renderer/gen_angle_format_table.py',
},
'ANGLE load functions table': {
'inputs': [
'src/libANGLE/renderer/load_functions_data.json',
],
'script': 'src/libANGLE/renderer/gen_load_functions_table.py',
},
'D3D11 blit shader selection': {
'inputs': [],
'script': 'src/libANGLE/renderer/d3d/d3d11/gen_blit11helper.py',
},
'D3D11 format': {
'inputs': [
'src/libANGLE/renderer/angle_format.py',
'src/libANGLE/renderer/d3d/d3d11/texture_format_data.json',
'src/libANGLE/renderer/d3d/d3d11/texture_format_map.json',
],
'script': 'src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py',
},
'DXGI format': {
'inputs': [
'src/libANGLE/renderer/angle_format.py',
'src/libANGLE/renderer/angle_format_map.json',
'src/libANGLE/renderer/d3d/d3d11/dxgi_format_data.json',
'src/libANGLE/renderer/gen_angle_format_table.py',
],
'script': 'src/libANGLE/renderer/d3d/d3d11/gen_dxgi_format_table.py',
},
'DXGI format support': {
'inputs': [
'src/libANGLE/renderer/d3d/d3d11/dxgi_support_data.json',
],
'script': 'src/libANGLE/renderer/d3d/d3d11/gen_dxgi_support_tables.py',
},
'ANGLE format':
'src/libANGLE/renderer/gen_angle_format_table.py',
'ANGLE load functions table':
'src/libANGLE/renderer/gen_load_functions_table.py',
'D3D11 blit shader selection':
'src/libANGLE/renderer/d3d/d3d11/gen_blit11helper.py',
'D3D11 format':
'src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py',
'DXGI format':
'src/libANGLE/renderer/d3d/d3d11/gen_dxgi_format_table.py',
'DXGI format support':
'src/libANGLE/renderer/d3d/d3d11/gen_dxgi_support_tables.py',
'GL copy conversion table':
'src/libANGLE/gen_copy_conversion_table.py',
'GL/EGL/WGL loader':
auto_script('scripts/generate_loader.py'),
'scripts/generate_loader.py',
'GL/EGL entry points':
auto_script('scripts/generate_entry_points.py'),
'GL copy conversion table': {
'inputs': [
'src/libANGLE/es3_copy_conversion_formats.json',
],
'script': 'src/libANGLE/gen_copy_conversion_table.py',
},
'GL format map': {
'inputs': [
'src/libANGLE/es3_format_type_combinations.json',
'src/libANGLE/format_map_data.json',
],
'script': 'src/libANGLE/gen_format_map.py',
},
'uniform type': {
'inputs': [],
'script': 'src/common/gen_uniform_type_table.py',
},
'OpenGL dispatch table': {
'inputs': [
'scripts/gl.xml',
],
'script': 'src/libANGLE/renderer/gl/generate_gl_dispatch_table.py',
},
'packed enum': {
'inputs': [
'src/common/packed_gl_enums.json',
'src/common/packed_egl_enums.json',
],
'script': 'src/common/gen_packed_gl_enums.py',
},
'proc table': {
'inputs': [
'src/libGLESv2/proc_table_data.json',
],
'script': 'src/libGLESv2/gen_proc_table.py',
},
'Vulkan format': {
'inputs': [
'src/libANGLE/renderer/angle_format.py',
'src/libANGLE/renderer/angle_format_map.json',
'src/libANGLE/renderer/vulkan/vk_format_map.json',
],
'script': 'src/libANGLE/renderer/vulkan/gen_vk_format_table.py',
},
'Vulkan mandatory format support table': {
'inputs': [
'src/libANGLE/renderer/angle_format.py',
'third_party/vulkan-headers/src/registry/vk.xml',
'src/libANGLE/renderer/vulkan/vk_mandatory_format_support_data.json',
],
'script': 'src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py',
},
'scripts/generate_entry_points.py',
'GL format map':
'src/libANGLE/gen_format_map.py',
'uniform type':
'src/common/gen_uniform_type_table.py',
'OpenGL dispatch table':
'src/libANGLE/renderer/gl/generate_gl_dispatch_table.py',
'packed enum':
'src/common/gen_packed_gl_enums.py',
'proc table':
'src/libGLESv2/gen_proc_table.py',
'Vulkan format':
'src/libANGLE/renderer/vulkan/gen_vk_format_table.py',
'Vulkan mandatory format support table':
'src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py',
'Vulkan internal shader programs':
auto_script('src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py'),
'Emulated HLSL functions': {
'inputs': [
'src/compiler/translator/emulated_builtin_function_data_hlsl.json'
],
'script': 'src/compiler/translator/gen_emulated_builtin_function_tables.py'
},
'ESSL static builtins': {
'inputs': [
'src/compiler/translator/builtin_function_declarations.txt',
'src/compiler/translator/builtin_variables.json',
],
'script': 'src/compiler/translator/gen_builtin_symbols.py',
},
'src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py',
'Emulated HLSL functions':
'src/compiler/translator/gen_emulated_builtin_function_tables.py',
'ESSL static builtins':
'src/compiler/translator/gen_builtin_symbols.py',
}
@@ -198,11 +125,12 @@ def main():
if len(sys.argv) > 1 and sys.argv[1] == '--verify-no-dirty':
verify_only = True
for name, info in sorted(generators.iteritems()):
for name, script in sorted(generators.iteritems()):
info = auto_script(script)
# Reset the CWD to the root ANGLE directory.
os.chdir(root_dir)
script = info['script']
if any_input_dirty(name, info['inputs'] + [script], new_hashes, old_hashes):
any_dirty = True

44
scripts/run_code_generation_hashes.json
View File

@@ -6,17 +6,17 @@
"ANGLE format:src/libANGLE/renderer/angle_format_map.json":
"be9f9bdbdf785dda05920146e8c55dbb",
"ANGLE format:src/libANGLE/renderer/gen_angle_format_table.py":
"00d5b2293e79d71e8d4212d1190a6426",
"3d9f679b65f39ccf19bd7bdf5498f837",
"ANGLE load functions table:src/libANGLE/renderer/gen_load_functions_table.py":
"8afc7eecce2a3ba9f0b4beacb1aa7fe2",
"475de30b8552795ca928096543cec7f2",
"ANGLE load functions table:src/libANGLE/renderer/load_functions_data.json":
"4253e14cd3217f42b6fec75ee400655a",
"D3D11 blit shader selection:src/libANGLE/renderer/d3d/d3d11/gen_blit11helper.py":
"fa59a0edd32890a018a7247e0484426c",
"38bff72bc17ac25c6b42c98d40c76e20",
"D3D11 format:src/libANGLE/renderer/angle_format.py":
"b18ca0fe4835114a4a2f54977b19e798",
"D3D11 format:src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py":
"15fb2a9b3f81e39a22090bce2f071185",
"d3260e0390ad2cd8b07420b7426fad43",
"D3D11 format:src/libANGLE/renderer/d3d/d3d11/texture_format_data.json":
"d7483ece817e819588f4ca157716dc7b",
"D3D11 format:src/libANGLE/renderer/d3d/d3d11/texture_format_map.json":
@@ -24,7 +24,7 @@
"DXGI format support:src/libANGLE/renderer/d3d/d3d11/dxgi_support_data.json":
"09195053f8829fc81efe08229b54a8b5",
"DXGI format support:src/libANGLE/renderer/d3d/d3d11/gen_dxgi_support_tables.py":
"30158f76e168e014a1bee3925cd5910a",
"389a6358534ebad5e232a44944b6123b",
"DXGI format:src/libANGLE/renderer/angle_format.py":
"b18ca0fe4835114a4a2f54977b19e798",
"DXGI format:src/libANGLE/renderer/angle_format_map.json":
@@ -32,29 +32,27 @@
"DXGI format:src/libANGLE/renderer/d3d/d3d11/dxgi_format_data.json":
"24f525b05dc665fbbc8c6d68fb863719",
"DXGI format:src/libANGLE/renderer/d3d/d3d11/gen_dxgi_format_table.py":
"8ea01df6cb7f160772d3c85dd5164890",
"DXGI format:src/libANGLE/renderer/gen_angle_format_table.py":
"00d5b2293e79d71e8d4212d1190a6426",
"bed2688ca828fc9fd1904408d33ba007",
"ESSL static builtins:src/compiler/translator/builtin_function_declarations.txt":
"e5e567406476306ea06984d885be028d",
"ESSL static builtins:src/compiler/translator/builtin_variables.json":
"d07ec4348b35d0db1eeab3c99a5e91f9",
"ESSL static builtins:src/compiler/translator/gen_builtin_symbols.py":
"932aafd053b3a64affdc7ad31d0a3c42",
"f056dba2fdeac5a5dbad9d8f7b17f55f",
"Emulated HLSL functions:src/compiler/translator/emulated_builtin_function_data_hlsl.json":
"002ad46d144c51fe98d73478aa554ba7",
"Emulated HLSL functions:src/compiler/translator/gen_emulated_builtin_function_tables.py":
"6a00c1ba22c35a9b700a154efda6f861",
"c24de0c9ce5f201985c852d2b4b12b98",
"GL copy conversion table:src/libANGLE/es3_copy_conversion_formats.json":
"54608f6f7d9aa7c59a8458ccf3ab9935",
"GL copy conversion table:src/libANGLE/gen_copy_conversion_table.py":
"ac1afe23d9578bd1d2ef74f4a7aa927a",
"92428cef9d97d33ee7063cfa387ccf56",
"GL format map:src/libANGLE/es3_format_type_combinations.json":
"a232823cd6430f14e28793ccabb968ee",
"GL format map:src/libANGLE/format_map_data.json":
"779798d4879e5f73a5a108e3e3fd3095",
"GL format map:src/libANGLE/gen_format_map.py":
"a383ee79a7bf929d145165f3e76c1079",
"0fd8c00e8b5afb28a5f8b40d9628b9a4",
"GL/EGL entry points:scripts/egl.xml":
"842e24514c4cfe09fba703c17a0fd292",
"GL/EGL entry points:scripts/egl_angle_ext.xml":
@@ -62,7 +60,7 @@
"GL/EGL entry points:scripts/entry_point_packed_gl_enums.json":
"afe2284956be2360463d0d036ad9cdde",
"GL/EGL entry points:scripts/generate_entry_points.py":
"a959669b31f086510fb60c5b55de56d1",
"7bd73a78c638334a114ed027d49cb6df",
"GL/EGL entry points:scripts/gl.xml":
"b470cb06b06cbbe7adb2c8129ec85708",
"GL/EGL entry points:scripts/gl_angle_ext.xml":
@@ -74,25 +72,29 @@
"GL/EGL/WGL loader:scripts/egl_angle_ext.xml":
"745534010f31fbe8e1a1fcddce15ed2d",
"GL/EGL/WGL loader:scripts/generate_loader.py":
"2d9be1d0f4f54905f3372411522133d1",
"475030714c1644b6dfb1f6f08572039d",
"GL/EGL/WGL loader:scripts/registry_xml.py":
"be6628bdeb99e50868cf4af51ea63f54",
"GL/EGL/WGL loader:scripts/wgl.xml":
"aa96419c582af2f6673430e2847693f4",
"OpenGL dispatch table:scripts/gl.xml":
"b470cb06b06cbbe7adb2c8129ec85708",
"OpenGL dispatch table:src/libANGLE/renderer/angle_format.py":
"b18ca0fe4835114a4a2f54977b19e798",
"OpenGL dispatch table:src/libANGLE/renderer/gl/generate_gl_dispatch_table.py":
"f527232452ecf930cfb1276883581342",
"8365d4130b9814eaa396915ae85734eb",
"OpenGL dispatch table:src/libANGLE/renderer/gl/gl_bindings_data.json":
"71079f089335ce1f67835d67a6d49d1a",
"Vulkan format:src/libANGLE/renderer/angle_format.py":
"b18ca0fe4835114a4a2f54977b19e798",
"Vulkan format:src/libANGLE/renderer/angle_format_map.json":
"be9f9bdbdf785dda05920146e8c55dbb",
"Vulkan format:src/libANGLE/renderer/vulkan/gen_vk_format_table.py":
"61a7752424595e24edff0c1f1784e18e",
"9937d3c942f0a5fe08f1ca080d40d47e",
"Vulkan format:src/libANGLE/renderer/vulkan/vk_format_map.json":
"992749b88763adb66003fe5d801b5ded",
"Vulkan internal shader programs:src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py":
"1c64f7187357d7561c984ec57d251e74",
"97e148951cbbf009ab963ca5a90ddf1a",
"Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/BufferUtils.comp":
"0c8c050841543da0d7faca2559212aa8",
"Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ConvertVertex.comp":
@@ -106,21 +108,21 @@
"Vulkan mandatory format support table:src/libANGLE/renderer/angle_format.py":
"b18ca0fe4835114a4a2f54977b19e798",
"Vulkan mandatory format support table:src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py":
"d647fcb39acb9a18e08e3e604b19cfee",
"417772416d3082400ce05acc2f209c9f",
"Vulkan mandatory format support table:src/libANGLE/renderer/vulkan/vk_mandatory_format_support_data.json":
"fa2bd54c1bb0ab2cf1d386061a4bc5c5",
"Vulkan mandatory format support table:third_party/vulkan-headers/src/registry/vk.xml":
"f5c8c9b8e521644ded34d44b1016c25e",
"packed enum:src/common/gen_packed_gl_enums.py":
"a9b1c38b4e4d8a1038e743be323f1a51",
"0cd1a1cb6d5fde8cbac2994db24eb901",
"packed enum:src/common/packed_egl_enums.json":
"5f591d220ee53b6e54a27d1523a3ab79",
"packed enum:src/common/packed_gl_enums.json":
"6e2e2845f96754509b8add1f77e203b3",
"proc table:src/libGLESv2/gen_proc_table.py":
"ee265eada3dd238646010dd03874d242",
"20ebe54894d613de42b0b15ca34078d9",
"proc table:src/libGLESv2/proc_table_data.json":
"6deb74c7709ecb664b917a2f1e598399",
"uniform type:src/common/gen_uniform_type_table.py":
"e185802e66950dfc5fc7a8fc19751206"
"fa40444d496ac07cd9dc0cd239e4a499"
}

32
src/common/gen_packed_gl_enums.py
View File

@@ -3,7 +3,8 @@
# found in the LICENSE file.
#
# gen_packed_gl_enums.py:
# Code generation for the packed enums.
# Code generation for the packed enums.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
import datetime, json, os, sys
from collections import namedtuple
@@ -204,7 +205,29 @@ def write_cpp(enums, path_prefix, file_name, data_source_name, namespace, api_en
with (open(path_prefix + file_name, 'wt')) as f:
f.write(cpp)
if __name__ == '__main__':
def main():
# auto_script parameters.
if len(sys.argv) > 1:
inputs = []
outputs = []
for generator in Generators:
inputs += [generator['json']]
outputs += [
generator['output'] + '_autogen.cpp',
generator['output'] + '_autogen.h',
]
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
path_prefix = os.path.dirname(os.path.realpath(__file__)) + os.path.sep
for generator in Generators:
@@ -215,3 +238,8 @@ if __name__ == '__main__':
enums = load_enums(path_prefix + json_file)
write_header(enums, path_prefix, output_file + '_autogen.h', json_file, namespace, enum_type)
write_cpp(enums, path_prefix, output_file + '_autogen.cpp', json_file, namespace, enum_type)
return 0
if __name__ == '__main__':
sys.exit(main())

45
src/common/gen_uniform_type_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_uniform_type_table.py:
# Code generation for OpenGL uniform type info tables.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
@@ -265,15 +266,37 @@ def gen_type_info(uniform_type):
def gen_type_index_case(index, uniform_type):
return "case " + uniform_type + ": return " + str(index) + ";"
uniform_type_info_data = ",\n".join([gen_type_info(uniform_type) for uniform_type in all_uniform_types])
uniform_type_index_cases = "\n".join([gen_type_index_case(index, uniform_type) for index, uniform_type in enumerate(all_uniform_types)])
with open('uniform_type_info_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
total_count = len(all_uniform_types),
uniform_type_info_data = uniform_type_info_data,
uniform_type_index_cases = uniform_type_index_cases)
out_file.write(output_cpp)
out_file.close()
def main():
# auto_script parameters.
if len(sys.argv) > 1:
inputs = []
outputs = ['uniform_type_info_autogen.cpp']
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
uniform_type_info_data = ",\n".join([gen_type_info(uniform_type) for uniform_type in all_uniform_types])
uniform_type_index_cases = "\n".join([gen_type_index_case(index, uniform_type) for index, uniform_type in enumerate(all_uniform_types)])
with open('uniform_type_info_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
total_count = len(all_uniform_types),
uniform_type_info_data = uniform_type_info_data,
uniform_type_index_cases = uniform_type_index_cases)
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

2
src/common/uniform_type_info_autogen.cpp
View File

@@ -1,7 +1,7 @@
// GENERATED FILE - DO NOT EDIT.
// Generated by gen_uniform_type_table.py.
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

2
src/compiler/translator/builtin_symbols_hash_autogen.txt
View File

@@ -1 +1 @@
c0555364e16391744b56e1f5d9c614c0
0df8efe673974da147a740d6e084e0b5

2
src/compiler/translator/emulated_builtin_functions_hlsl_autogen.cpp
View File

@@ -2,7 +2,7 @@
// Generated by gen_emulated_builtin_function_tables.py using data from
// emulated_builtin_function_data_hlsl.json.
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

455
src/compiler/translator/gen_builtin_symbols.py
View File

@@ -15,34 +15,6 @@ import re
import os
import sys
def set_working_dir():
script_dir = os.path.dirname(os.path.abspath(__file__))
os.chdir(script_dir)
set_working_dir()
variables_json_filename = 'builtin_variables.json'
functions_txt_filename = 'builtin_function_declarations.txt'
hash_filename = 'builtin_symbols_hash_autogen.txt'
all_inputs = [os.path.abspath(__file__), variables_json_filename, functions_txt_filename]
# This script takes a while to run since it searches for hash collisions of mangled names. To avoid
# running it unnecessarily, we first check if we've already ran it with the same inputs.
m = hashlib.md5()
for input_path in all_inputs:
with open(input_path, 'rU') as input_file:
m.update(input_file.read())
input_hash = m.hexdigest()
if os.path.exists(hash_filename):
with open(hash_filename) as hash_file:
if input_hash == hash_file.read():
print "Canceling ESSL static builtins code generator - generated hash matches inputs."
sys.exit(0)
parser = argparse.ArgumentParser()
parser.add_argument('--dump-intermediate-json', help='Dump parsed function data as a JSON file builtin_functions.json', action="store_true")
args = parser.parse_args()
template_immutablestringtest_cpp = """// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {function_data_source_name}.
//
@@ -328,6 +300,12 @@ basic_types_enumeration = [
'UImageCube'
]
id_counter = 0
def set_working_dir():
script_dir = os.path.dirname(os.path.abspath(__file__))
os.chdir(script_dir)
def get_basic_mangled_name(basic):
index = basic_types_enumeration.index(basic)
if index < 26:
@@ -381,7 +359,7 @@ class GroupedList:
def get_max_name_length(self):
return self.max_name_length
def get_switch_code(self):
def get_switch_code(self, script_generated_hash_tests):
code = []
for level in levels:
if len(self.objs[level]) == 0:
@@ -398,7 +376,7 @@ class GroupedList:
switch = {}
for name, obj in objs.iteritems():
name_hash = mangledNameHash(name)
name_hash = mangledNameHash(name, script_generated_hash_tests)
if name_hash not in switch:
switch[name_hash] = []
switch[name_hash].append(obj['hash_matched_code'])
@@ -575,7 +553,7 @@ class TType:
raise Exception('Unrecognized type: ' + str(glsl_header_type))
def get_parsed_functions():
def get_parsed_functions(functions_txt_filename):
def parse_function_parameters(parameters):
if parameters == '':
@@ -643,67 +621,6 @@ def get_parsed_functions():
return parsed_functions
parsed_functions = get_parsed_functions()
if args.dump_intermediate_json:
with open('builtin_functions.json', 'w') as outfile:
def serialize_obj(obj):
if isinstance(obj, TType):
return obj.data
else:
raise "Cannot serialize to JSON: " + str(obj)
json.dump(parsed_functions, outfile, indent=4, separators=(',', ': '), default=serialize_obj)
with open(variables_json_filename) as f:
parsed_variables = json.load(f, object_pairs_hook=OrderedDict)
# Declarations of symbol unique ids
builtin_id_declarations = []
# Definitions of symbol unique ids needed for those ids used outside of constexpr expressions.
builtin_id_definitions = []
# Declarations of name string variables
name_declarations = set()
# Declarations of builtin TVariables
variable_declarations = []
# Declarations of parameter arrays for builtin TFunctions. Map from C++ variable name to the full
# declaration.
parameter_declarations = {}
# Declarations of builtin TFunctions
function_declarations = []
# Functions for querying the pointer to a specific TVariable.
get_variable_declarations = []
get_variable_definitions = []
# Code for defining TVariables stored as members of TSymbolTable.
declare_member_variables = []
init_member_variables = []
# Code for querying builtins.
get_builtin_if_statements = GroupedList()
# Declarations of UnmangledBuiltIn objects
unmangled_builtin_declarations = set()
# Code for querying builtin function unmangled names.
unmangled_function_if_statements = GroupedList()
# Code for testing that script-generated hashes match with runtime computed hashes.
script_generated_hash_tests = OrderedDict()
# Functions for testing whether a builtin belongs in group.
is_in_group_definitions = []
# Counts of variables with a certain name string:
variable_name_count = {}
id_counter = 0
fnvPrime = 16777619
def hash32(str):
fnvOffsetBasis = 0x811c9dc5
@@ -713,7 +630,7 @@ def hash32(str):
hash = (hash * fnvPrime) & 0xffffffff
return hash
def mangledNameHash(str, save_test = True):
def mangledNameHash(str, script_generated_hash_tests, save_test = True):
hash = hash32(str)
index = 0
max_six_bit_value = (1 << 6) - 1
@@ -776,27 +693,14 @@ def get_function_human_readable_name(function_name, parameters):
name += '_' + param.get_human_readable_name()
return name
ttype_mangled_name_variants = []
for basic_type in basic_types_enumeration:
primary_sizes = [1]
secondary_sizes = [1]
if basic_type in ['Float', 'Int', 'UInt', 'Bool']:
primary_sizes = [1, 2, 3, 4]
if basic_type == 'Float':
secondary_sizes = [1, 2, 3, 4]
for primary_size in primary_sizes:
for secondary_size in secondary_sizes:
type = TType({'basic': basic_type, 'primarySize': primary_size, 'secondarySize': secondary_size})
ttype_mangled_name_variants.append(type.get_mangled_name())
def gen_parameters_variant_ids(str_len):
def gen_parameters_variant_ids(str_len, ttype_mangled_name_variants):
# Note that this doesn't generate variants with array parameters or struct / interface block parameters. They are assumed to have been filtered out separately.
if str_len % 2 != 0:
raise Exception('Expecting parameters mangled name length to be divisible by two')
num_variants = pow(len(ttype_mangled_name_variants), str_len / 2)
return xrange(num_variants)
def get_parameters_mangled_name_variant(variant_id, paren_location, total_length):
def get_parameters_mangled_name_variant(variant_id, paren_location, total_length, ttype_mangled_name_variants):
str_len = total_length - paren_location - 1
if str_len % 2 != 0:
raise Exception('Expecting parameters mangled name length to be divisible by two')
@@ -813,8 +717,8 @@ def get_parameters_mangled_name_variant(variant_id, paren_location, total_length
# Calculate the mangled name hash of a common prefix string that's been pre-hashed with hash32()
# plus a variant of the parameters. This is faster than constructing the whole string and then
# calculating the hash for that.
num_type_variants = len(ttype_mangled_name_variants)
def get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, total_length):
def get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, total_length,
num_type_variants, ttype_mangled_name_variants):
hash = prefix_hash32
parameter_count = (total_length - paren_location) >> 1
parameter_variant_id_base = variant_id
@@ -828,16 +732,13 @@ def get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, tot
parameter_variant_id_base = parameter_variant_id_base / num_type_variants
return ((hash >> 13) ^ (hash & 0x1fff)) | (total_length << 19) | (paren_location << 25)
# Sanity check for get_mangled_name_variant_hash:
if get_mangled_name_variant_hash(hash32("atan("), 3, 4, len("atan(0123")) != mangledNameHash("atan(" + get_parameters_mangled_name_variant(3, 4, len("atan(0123"))):
raise Exception("get_mangled_name_variant_hash sanity check failed")
def mangled_name_hash_can_collide_with_different_parameters(function_variant_props):
def mangled_name_hash_can_collide_with_different_parameters(function_variant_props, num_type_variants,
ttype_mangled_name_variants, script_generated_hash_tests):
# We exhaustively search through all possible lists of parameters and see if any other mangled
# name has the same hash.
mangled_name = function_variant_props['mangled_name']
mangled_name_len = len(mangled_name)
hash = mangledNameHash(mangled_name)
hash = mangledNameHash(mangled_name, script_generated_hash_tests)
mangled_name_prefix = function_variant_props['name'] + '('
paren_location = len(mangled_name_prefix) - 1
prefix_hash32 = hash32(mangled_name_prefix)
@@ -846,8 +747,12 @@ def mangled_name_hash_can_collide_with_different_parameters(function_variant_pro
if (parameters_mangled_name_len > 6):
# This increases the complexity of searching for hash collisions considerably, so rather than doing it we just conservatively assume that a hash collision may be possible.
return True
for variant_id in gen_parameters_variant_ids(parameters_mangled_name_len):
if get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, mangled_name_len) == hash and get_parameters_mangled_name_variant(variant_id, paren_location, mangled_name_len) != parameters_mangled_name:
for variant_id in gen_parameters_variant_ids(parameters_mangled_name_len, ttype_mangled_name_variants):
variant_hash = get_mangled_name_variant_hash(prefix_hash32, variant_id, paren_location, mangled_name_len,
num_type_variants, ttype_mangled_name_variants)
manged_name_variant = get_parameters_mangled_name_variant(variant_id, paren_location, mangled_name_len,
ttype_mangled_name_variants)
if variant_hash == hash and manged_name_variant != parameters_mangled_name:
return True
return False
@@ -880,7 +785,7 @@ def get_variable_name_to_store_parameters(parameters):
unique_name += param.get_mangled_name()
return unique_name
def define_constexpr_variable(template_args):
def define_constexpr_variable(template_args, variable_declarations):
template_variable_declaration = 'constexpr const TVariable kVar_{name_with_suffix}(BuiltInId::{name_with_suffix}, BuiltInName::{name}, SymbolType::BuiltIn, TExtension::{extension}, {type});'
variable_declarations.append(template_variable_declaration.format(**template_args))
@@ -928,11 +833,12 @@ def gen_function_variants(function_name, function_props):
function_variants.append(variant_props)
return function_variants
defined_function_variants = set()
defined_parameter_names = set()
def process_single_function_group(condition, group_name, group):
def process_single_function_group(condition, group_name, group, num_type_variants, parameter_declarations, ttype_mangled_name_variants,
name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations, defined_function_variants,
builtin_id_declarations, builtin_id_definitions, defined_parameter_names, variable_declarations, function_declarations,
script_generated_hash_tests, get_builtin_if_statements):
global id_counter
if 'functions' not in group:
return
@@ -1006,7 +912,7 @@ def process_single_function_group(condition, group_name, group):
param_template_args['id'] = id_counter
template_builtin_id_declaration = ' static constexpr const TSymbolUniqueId {name_with_suffix} = TSymbolUniqueId({id});'
builtin_id_declarations.append(template_builtin_id_declaration.format(**param_template_args))
define_constexpr_variable(param_template_args)
define_constexpr_variable(param_template_args, variable_declarations)
defined_parameter_names.add(unique_param_name)
parameters_list.append('&BuiltInVariable::kVar_{name_with_suffix}'.format(**param_template_args));
@@ -1026,7 +932,8 @@ def process_single_function_group(condition, group_name, group):
# name and hash, then we can only check the mangled name length and the function name
# instead of checking the whole mangled name.
template_mangled_if = ''
if mangled_name_hash_can_collide_with_different_parameters(template_args):
if mangled_name_hash_can_collide_with_different_parameters(template_args, num_type_variants,
ttype_mangled_name_variants, script_generated_hash_tests):
template_mangled_name_declaration = 'constexpr const ImmutableString {unique_name}("{mangled_name}");'
name_declarations.add(template_mangled_name_declaration.format(**template_args))
template_mangled_if = """if (name == BuiltInName::{unique_name})
@@ -1044,7 +951,11 @@ def process_single_function_group(condition, group_name, group):
id_counter += 1
def process_function_group(group_name, group):
def process_function_group(group_name, group, num_type_variants, parameter_declarations, ttype_mangled_name_variants,
name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations,
defined_function_variants, builtin_id_declarations, builtin_id_definitions, defined_parameter_names,
variable_declarations, function_declarations, script_generated_hash_tests, get_builtin_if_statements,
is_in_group_definitions):
global id_counter
first_id = id_counter
@@ -1052,11 +963,18 @@ def process_function_group(group_name, group):
if 'condition' in group:
condition = group['condition']
process_single_function_group(condition, group_name, group)
process_single_function_group(condition, group_name, group, num_type_variants, parameter_declarations,
ttype_mangled_name_variants, name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations,
defined_function_variants, builtin_id_declarations, builtin_id_definitions, defined_parameter_names,
variable_declarations, function_declarations, script_generated_hash_tests, get_builtin_if_statements)
if 'subgroups' in group:
for subgroup_name, subgroup in group['subgroups'].iteritems():
process_function_group(group_name + subgroup_name, subgroup)
process_function_group(group_name + subgroup_name, subgroup, num_type_variants, parameter_declarations,
ttype_mangled_name_variants, name_declarations, unmangled_function_if_statements,
unmangled_builtin_declarations, defined_function_variants, builtin_id_declarations,
builtin_id_definitions, defined_parameter_names, variable_declarations, function_declarations,
script_generated_hash_tests, get_builtin_if_statements, is_in_group_definitions)
if 'queryFunction' in group:
template_args = {
@@ -1071,12 +989,8 @@ def process_function_group(group_name, group):
}}"""
is_in_group_definitions.append(template_is_in_group_definition.format(**template_args))
for group_name, group in parsed_functions.iteritems():
process_function_group(group_name, group)
def prune_parameters_arrays():
def prune_parameters_arrays(parameter_declarations, function_declarations):
# We can share parameters arrays between functions in case one array is a subarray of another.
global parameter_declarations
parameter_variable_name_replacements = {}
used_param_variable_names = set()
for param_variable_name, param_declaration in sorted(parameter_declarations.iteritems(), key=lambda item: -len(item[0])):
@@ -1088,14 +1002,16 @@ def prune_parameters_arrays():
break
if not replaced:
used_param_variable_names.add(param_variable_name)
parameter_declarations = [value for key, value in parameter_declarations.iteritems() if key in used_param_variable_names]
for i in xrange(len(function_declarations)):
for replaced, replacement in parameter_variable_name_replacements.iteritems():
function_declarations[i] = function_declarations[i].replace('BuiltInParameters::' + replaced + ',', 'BuiltInParameters::' + replacement + ',')
prune_parameters_arrays()
def process_single_variable_group(condition, group_name, group):
return [value for key, value in parameter_declarations.iteritems() if key in used_param_variable_names]
def process_single_variable_group(condition, group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations,
init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations,
get_variable_definitions, variable_name_count):
global id_counter
if 'variables' not in group:
return
@@ -1184,7 +1100,7 @@ def process_single_variable_group(condition, group_name, group):
else:
# Handle variables that can be stored as constexpr TVariable like
# gl_Position, gl_FragColor etc.
define_constexpr_variable(template_args)
define_constexpr_variable(template_args, variable_declarations)
is_member = False
template_get_variable_declaration = 'const TVariable *{name_with_suffix}();'
@@ -1232,7 +1148,7 @@ def process_single_variable_group(condition, group_name, group):
id_counter += 1
def count_variable_names(group):
def count_variable_names(group, variable_name_count):
if 'variables' in group:
for name in group['variables'].iterkeys():
if name not in variable_name_count:
@@ -1241,9 +1157,12 @@ def count_variable_names(group):
variable_name_count[name] += 1
if 'subgroups' in group:
for subgroup_name, subgroup in group['subgroups'].iteritems():
count_variable_names(subgroup)
count_variable_names(subgroup, variable_name_count)
def process_variable_group(parent_condition, group_name, group):
def process_variable_group(parent_condition, group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations,
init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations,
get_variable_definitions, variable_name_count):
global id_counter
condition = 'NO_CONDITION'
if 'condition' in group:
condition = group['condition']
@@ -1254,69 +1173,231 @@ def process_variable_group(parent_condition, group_name, group):
else:
condition = '({cond1}) && ({cond2})'.format(cond1 = parent_condition, cond2 = condition)
process_single_variable_group(condition, group_name, group)
process_single_variable_group(condition, group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations,
init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations,
get_variable_definitions, variable_name_count)
if 'subgroups' in group:
for subgroup_name, subgroup in group['subgroups'].iteritems():
process_variable_group(condition, subgroup_name, subgroup)
process_variable_group(condition, subgroup_name, subgroup, builtin_id_declarations, builtin_id_definitions, name_declarations,
init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations,
get_variable_definitions, variable_name_count)
for group_name, group in parsed_variables.iteritems():
count_variable_names(group)
for group_name, group in parsed_variables.iteritems():
process_variable_group('NO_CONDITION', group_name, group)
def main():
output_strings = {
'script_name': os.path.basename(__file__),
'copyright_year': date.today().year,
set_working_dir()
'builtin_id_declarations': '\n'.join(builtin_id_declarations),
'builtin_id_definitions': '\n'.join(builtin_id_definitions),
'last_builtin_id': id_counter - 1,
'name_declarations': '\n'.join(sorted(list(name_declarations))),
parser = argparse.ArgumentParser()
parser.add_argument('--dump-intermediate-json', help='Dump parsed function data as a JSON file builtin_functions.json', action="store_true")
parser.add_argument('auto_script_command', nargs='?', default='')
args = parser.parse_args()
'function_data_source_name': functions_txt_filename,
'function_declarations': '\n'.join(function_declarations),
'parameter_declarations': '\n'.join(sorted(parameter_declarations)),
test_filename = '../../tests/compiler_tests/ImmutableString_test_autogen.cpp'
variables_json_filename = 'builtin_variables.json'
functions_txt_filename = 'builtin_function_declarations.txt'
hash_filename = 'builtin_symbols_hash_autogen.txt'
'is_in_group_definitions': '\n'.join(is_in_group_definitions),
# auto_script parameters.
if args.auto_script_command != '':
inputs = [
functions_txt_filename,
variables_json_filename,
]
outputs = [
'ParseContext_autogen.h',
'SymbolTable_autogen.cpp',
'SymbolTable_autogen.h',
'tree_util/BuiltIn_autogen.h',
test_filename,
hash_filename,
]
'variable_data_source_name': variables_json_filename,
'variable_declarations': '\n'.join(sorted(variable_declarations)),
'get_variable_declarations': '\n'.join(sorted(get_variable_declarations)),
'get_variable_definitions': '\n'.join(sorted(get_variable_definitions)),
'unmangled_builtin_declarations': '\n'.join(sorted(unmangled_builtin_declarations)),
if args.auto_script_command == 'inputs':
print ','.join(inputs)
elif args.auto_script_command == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
'declare_member_variables': '\n'.join(declare_member_variables),
'init_member_variables': '\n'.join(init_member_variables),
'get_unmangled_builtin': unmangled_function_if_statements.get_switch_code(),
'get_builtin': get_builtin_if_statements.get_switch_code(),
'max_unmangled_name_length': unmangled_function_if_statements.get_max_name_length(),
'max_mangled_name_length': get_builtin_if_statements.get_max_name_length(),
all_inputs = [os.path.abspath(__file__), variables_json_filename, functions_txt_filename]
# This script takes a while to run since it searches for hash collisions of mangled names. To avoid
# running it unnecessarily, we first check if we've already ran it with the same inputs.
m = hashlib.md5()
for input_path in all_inputs:
with open(input_path, 'rU') as input_file:
m.update(input_file.read())
input_hash = m.hexdigest()
if os.path.exists(hash_filename):
with open(hash_filename) as hash_file:
if input_hash == hash_file.read():
print "Canceling ESSL static builtins code generator - generated hash matches inputs."
sys.exit(0)
'script_generated_hash_tests': '\n'.join(script_generated_hash_tests.iterkeys())
}
# Declarations of symbol unique ids
builtin_id_declarations = []
with open('../../tests/compiler_tests/ImmutableString_test_autogen.cpp', 'wt') as outfile_cpp:
output_cpp = template_immutablestringtest_cpp.format(**output_strings)
outfile_cpp.write(output_cpp)
# Definitions of symbol unique ids needed for those ids used outside of constexpr expressions.
builtin_id_definitions = []
with open('tree_util/BuiltIn_autogen.h', 'wt') as outfile_header:
output_header = template_builtin_header.format(**output_strings)
outfile_header.write(output_header)
# Declarations of name string variables
name_declarations = set()
with open('SymbolTable_autogen.cpp', 'wt') as outfile_cpp:
output_cpp = template_symboltable_cpp.format(**output_strings)
outfile_cpp.write(output_cpp)
# Declarations of builtin TVariables
variable_declarations = []
with open('ParseContext_autogen.h', 'wt') as outfile_header:
output_header = template_parsecontext_header.format(**output_strings)
outfile_header.write(output_header)
# Declarations of builtin TFunctions
function_declarations = []
with open('SymbolTable_autogen.h', 'wt') as outfile_h:
output_h = template_symboltable_h.format(**output_strings)
outfile_h.write(output_h)
# Functions for querying the pointer to a specific TVariable.
get_variable_declarations = []
get_variable_definitions = []
with open(hash_filename, 'wt') as hash_file:
hash_file.write(input_hash)
# Code for defining TVariables stored as members of TSymbolTable.
declare_member_variables = []
init_member_variables = []
# Code for querying builtins.
get_builtin_if_statements = GroupedList()
# Declarations of UnmangledBuiltIn objects
unmangled_builtin_declarations = set()
# Code for querying builtin function unmangled names.
unmangled_function_if_statements = GroupedList()
# Code for testing that script-generated hashes match with runtime computed hashes.
script_generated_hash_tests = OrderedDict()
# Functions for testing whether a builtin belongs in group.
is_in_group_definitions = []
# Counts of variables with a certain name string:
variable_name_count = {}
# Declarations of parameter arrays for builtin TFunctions. Map from C++ variable name to the full
# declaration.
parameter_declarations = {}
ttype_mangled_name_variants = []
defined_function_variants = set()
defined_parameter_names = set()
parsed_functions = get_parsed_functions(functions_txt_filename)
if args.dump_intermediate_json:
with open('builtin_functions.json', 'w') as outfile:
def serialize_obj(obj):
if isinstance(obj, TType):
return obj.data
else:
raise "Cannot serialize to JSON: " + str(obj)
json.dump(parsed_functions, outfile, indent=4, separators=(',', ': '), default=serialize_obj)
with open(variables_json_filename) as f:
parsed_variables = json.load(f, object_pairs_hook=OrderedDict)
for basic_type in basic_types_enumeration:
primary_sizes = [1]
secondary_sizes = [1]
if basic_type in ['Float', 'Int', 'UInt', 'Bool']:
primary_sizes = [1, 2, 3, 4]
if basic_type == 'Float':
secondary_sizes = [1, 2, 3, 4]
for primary_size in primary_sizes:
for secondary_size in secondary_sizes:
type = TType({'basic': basic_type, 'primarySize': primary_size, 'secondarySize': secondary_size})
ttype_mangled_name_variants.append(type.get_mangled_name())
num_type_variants = len(ttype_mangled_name_variants)
# Sanity check for get_mangled_name_variant_hash:
variant_hash = get_mangled_name_variant_hash(hash32("atan("), 3, 4, len("atan(0123"), num_type_variants,
ttype_mangled_name_variants)
mangled_name_hash = mangledNameHash("atan(" + get_parameters_mangled_name_variant(3, 4, len("atan(0123"),
ttype_mangled_name_variants), script_generated_hash_tests)
if variant_hash != mangled_name_hash:
raise Exception("get_mangled_name_variant_hash sanity check failed")
for group_name, group in parsed_functions.iteritems():
process_function_group(group_name, group, num_type_variants, parameter_declarations, ttype_mangled_name_variants,
name_declarations, unmangled_function_if_statements, unmangled_builtin_declarations,
defined_function_variants, builtin_id_declarations, builtin_id_definitions, defined_parameter_names,
variable_declarations, function_declarations, script_generated_hash_tests, get_builtin_if_statements,
is_in_group_definitions)
parameter_declarations = prune_parameters_arrays(parameter_declarations, function_declarations)
for group_name, group in parsed_variables.iteritems():
count_variable_names(group, variable_name_count)
for group_name, group in parsed_variables.iteritems():
process_variable_group('NO_CONDITION', group_name, group, builtin_id_declarations, builtin_id_definitions, name_declarations,
init_member_variables, get_variable_declarations, get_builtin_if_statements, declare_member_variables, variable_declarations,
get_variable_definitions, variable_name_count)
output_strings = {
'script_name': os.path.basename(__file__),
'copyright_year': date.today().year,
'builtin_id_declarations': '\n'.join(builtin_id_declarations),
'builtin_id_definitions': '\n'.join(builtin_id_definitions),
'last_builtin_id': id_counter - 1,
'name_declarations': '\n'.join(sorted(list(name_declarations))),
'function_data_source_name': functions_txt_filename,
'function_declarations': '\n'.join(function_declarations),
'parameter_declarations': '\n'.join(sorted(parameter_declarations)),
'is_in_group_definitions': '\n'.join(is_in_group_definitions),
'variable_data_source_name': variables_json_filename,
'variable_declarations': '\n'.join(sorted(variable_declarations)),
'get_variable_declarations': '\n'.join(sorted(get_variable_declarations)),
'get_variable_definitions': '\n'.join(sorted(get_variable_definitions)),
'unmangled_builtin_declarations': '\n'.join(sorted(unmangled_builtin_declarations)),
'declare_member_variables': '\n'.join(declare_member_variables),
'init_member_variables': '\n'.join(init_member_variables),
'get_unmangled_builtin': unmangled_function_if_statements.get_switch_code(script_generated_hash_tests),
'get_builtin': get_builtin_if_statements.get_switch_code(script_generated_hash_tests),
'max_unmangled_name_length': unmangled_function_if_statements.get_max_name_length(),
'max_mangled_name_length': get_builtin_if_statements.get_max_name_length(),
'script_generated_hash_tests': '\n'.join(script_generated_hash_tests.iterkeys())
}
with open(test_filename, 'wt') as outfile_cpp:
output_cpp = template_immutablestringtest_cpp.format(**output_strings)
outfile_cpp.write(output_cpp)
with open('tree_util/BuiltIn_autogen.h', 'wt') as outfile_header:
output_header = template_builtin_header.format(**output_strings)
outfile_header.write(output_header)
with open('SymbolTable_autogen.cpp', 'wt') as outfile_cpp:
output_cpp = template_symboltable_cpp.format(**output_strings)
outfile_cpp.write(output_cpp)
with open('ParseContext_autogen.h', 'wt') as outfile_header:
output_header = template_parsecontext_header.format(**output_strings)
outfile_header.write(output_header)
with open('SymbolTable_autogen.h', 'wt') as outfile_h:
output_h = template_symboltable_h.format(**output_strings)
outfile_h.write(output_h)
with open(hash_filename, 'wt') as hash_file:
hash_file.write(input_hash)
return 0
if __name__ == '__main__':
sys.exit(main())

54
src/compiler/translator/gen_emulated_builtin_function_tables.py
View File

@@ -5,6 +5,7 @@
#
# gen_emulated_builtin_function_tables.py:
# Generator for the builtin function maps.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
import json
@@ -88,10 +89,6 @@ def enum_type(arg):
return 'UI' + arg_type[2:] + suffix
return arg_type.capitalize() + suffix
input_script = "emulated_builtin_function_data_hlsl.json"
hlsl_json = load_json(input_script)
emulated_functions = []
def gen_emulated_function(data):
func = ""
@@ -109,17 +106,44 @@ def gen_emulated_function(data):
func += "},\n"
return [ func ]
for item in hlsl_json:
emulated_functions += gen_emulated_function(item)
hlsl_fname = "emulated_builtin_functions_hlsl_autogen.cpp"
def main():
hlsl_gen = template_emulated_builtin_functions_hlsl.format(
script_name = sys.argv[0],
data_source_name = input_script,
copyright_year = date.today().year,
emulated_functions = "".join(emulated_functions))
input_script = "emulated_builtin_function_data_hlsl.json"
hlsl_fname = "emulated_builtin_functions_hlsl_autogen.cpp"
with open(hlsl_fname, 'wt') as f:
f.write(hlsl_gen)
f.close()
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [input_script]
outputs = [hlsl_fname]
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
hlsl_json = load_json(input_script)
emulated_functions = []
for item in hlsl_json:
emulated_functions += gen_emulated_function(item)
hlsl_gen = template_emulated_builtin_functions_hlsl.format(
script_name = sys.argv[0],
data_source_name = input_script,
copyright_year = date.today().year,
emulated_functions = "".join(emulated_functions))
with open(hlsl_fname, 'wt') as f:
f.write(hlsl_gen)
f.close()
return 0
if __name__ == '__main__':
sys.exit(main())

2
src/libANGLE/es3_copy_conversion_table_autogen.cpp
View File

@@ -1,7 +1,7 @@
// GENERATED FILE - DO NOT EDIT.
// Generated by gen_copy_conversion_table.py using data from es3_copy_conversion_formats.json.
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

2
src/libANGLE/format_map_autogen.cpp
View File

@@ -2,7 +2,7 @@
// Generated by gen_format_map.py using data from format_map_data.json.
// ES3 format info from es3_format_type_combinations.json.
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

62
src/libANGLE/gen_copy_conversion_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_copy_conversion_table.py:
# Code generation for ES3 valid copy conversions table format map.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
import sys
@@ -64,28 +65,51 @@ def parse_texture_format_case(texture_format, framebuffer_formats):
return template_format_case.format(
texture_format = texture_format, framebuffer_format_cases = framebuffer_format_cases)
data_source_name = 'es3_copy_conversion_formats.json'
json_data = angle_format.load_json(data_source_name)
def main():
format_map = {}
data_source_name = 'es3_copy_conversion_formats.json'
out_file_name = 'es3_copy_conversion_table_autogen.cpp'
for description, data in json_data.iteritems():
for texture_format, framebuffer_format in data:
if texture_format not in format_map:
format_map[texture_format] = []
format_map[texture_format] += [ framebuffer_format ]
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [data_source_name]
outputs = [out_file_name]
texture_format_cases = ""
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
for texture_format, framebuffer_formats in sorted(format_map.iteritems()):
texture_format_cases += parse_texture_format_case(texture_format, framebuffer_formats)
json_data = angle_format.load_json(data_source_name)
with open('es3_copy_conversion_table_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = data_source_name,
copyright_year = date.today().year,
texture_format_cases = texture_format_cases)
out_file.write(output_cpp)
out_file.close()
format_map = {}
for description, data in json_data.iteritems():
for texture_format, framebuffer_format in data:
if texture_format not in format_map:
format_map[texture_format] = []
format_map[texture_format] += [ framebuffer_format ]
texture_format_cases = ""
for texture_format, framebuffer_formats in sorted(format_map.iteritems()):
texture_format_cases += parse_texture_format_case(texture_format, framebuffer_formats)
with open(out_file_name, 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = data_source_name,
copyright_year = date.today().year,
texture_format_cases = texture_format_cases)
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

121
src/libANGLE/gen_format_map.py
View File

@@ -6,6 +6,7 @@
# gen_format_map.py:
# Code generation for GL format map. The format map matches between
# {format,type} and internal format.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
import sys
@@ -110,10 +111,12 @@ template_es3_combo_type_case = """ case {type}:
}}
"""
def parse_type_case(type, result):
return template_simple_case.format(
key = type, result = result)
def parse_format_case(format, type_map):
type_cases = ""
for type, internal_format in sorted(type_map.iteritems()):
@@ -121,66 +124,88 @@ def parse_format_case(format, type_map):
return template_format_case.format(
format = format, type_cases = type_cases)
input_script = 'format_map_data.json'
format_map = angle_format.load_json(input_script)
def main():
format_cases = ""
# auto_script parameters.
if len(sys.argv) > 1:
inputs = ['es3_format_type_combinations.json', 'format_map_data.json']
outputs = ['format_map_autogen.cpp']
for format, type_map in sorted(format_map.iteritems()):
format_cases += parse_format_case(format, type_map)
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
combo_data_file = 'es3_format_type_combinations.json'
es3_combo_data = angle_format.load_json(combo_data_file)
combo_data = [combo for sublist in es3_combo_data.values() for combo in sublist]
input_script = 'format_map_data.json'
types = set()
formats = set()
combos = {}
format_map = angle_format.load_json(input_script)
for internal_format, format, type in combo_data:
types.update([type])
formats.update([format])
if format not in combos:
combos[format] = {}
if type not in combos[format]:
combos[format][type] = [internal_format]
else:
combos[format][type] += [internal_format]
format_cases = ""
es3_format_cases = ""
for format, type_map in sorted(format_map.iteritems()):
format_cases += parse_format_case(format, type_map)
for format in sorted(formats):
es3_format_cases += " case " + format + ":\n"
combo_data_file = 'es3_format_type_combinations.json'
es3_combo_data = angle_format.load_json(combo_data_file)
combo_data = [combo for sublist in es3_combo_data.values() for combo in sublist]
es3_type_cases = ""
types = set()
formats = set()
combos = {}
for type in sorted(types):
es3_type_cases += " case " + type + ":\n"
for internal_format, format, type in combo_data:
types.update([type])
formats.update([format])
if format not in combos:
combos[format] = {}
if type not in combos[format]:
combos[format][type] = [internal_format]
else:
combos[format][type] += [internal_format]
es3_combo_cases = ""
es3_format_cases = ""
for format, type_combos in combos.iteritems():
this_type_cases = ""
for type, combos in type_combos.iteritems():
internal_format_cases = ""
for internal_format in combos:
internal_format_cases += " case " + internal_format + ":\n"
for format in sorted(formats):
es3_format_cases += " case " + format + ":\n"
this_type_cases += template_es3_combo_type_case.format(
type = type, internal_format_cases = internal_format_cases)
es3_type_cases = ""
es3_combo_cases += template_format_case.format(
format = format, type_cases = this_type_cases)
for type in sorted(types):
es3_type_cases += " case " + type + ":\n"
with open('format_map_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = input_script,
es3_data_source_name = combo_data_file,
copyright_year = date.today().year,
format_cases = format_cases,
es3_format_cases = es3_format_cases,
es3_type_cases = es3_type_cases,
es3_combo_cases = es3_combo_cases)
out_file.write(output_cpp)
es3_combo_cases = ""
for format, type_combos in combos.iteritems():
this_type_cases = ""
for type, combos in type_combos.iteritems():
internal_format_cases = ""
for internal_format in combos:
internal_format_cases += " case " + internal_format + ":\n"
this_type_cases += template_es3_combo_type_case.format(
type = type, internal_format_cases = internal_format_cases)
es3_combo_cases += template_format_case.format(
format = format, type_cases = this_type_cases)
with open('format_map_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = input_script,
es3_data_source_name = combo_data_file,
copyright_year = date.today().year,
format_cases = format_cases,
es3_format_cases = es3_format_cases,
es3_type_cases = es3_type_cases,
es3_combo_cases = es3_combo_cases)
out_file.write(output_cpp)
return 0
if __name__ == '__main__':
sys.exit(main())

0
src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.cpp → src/libANGLE/renderer/d3d/d3d11/dxgi_support_table_autogen.cpp
View File

55
src/libANGLE/renderer/d3d/d3d11/gen_blit11helper.py
View File

@@ -6,6 +6,7 @@
#
# gen_blit11helper.py:
# Generates the code for retrieving the various blit shaders for D3D11
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
import sys, os, pprint
from datetime import date
@@ -335,22 +336,42 @@ def write_gni_file(shader_filename_list):
out.close()
map_blitshader_cases = []
shader_includes = []
blitshadertype_cases = []
blitshadertype_enums = []
blitshaderop_enums = []
shader_filenames = []
def main():
map_blitshader_cases = get_map_blitshader_cases()
shader_includes = get_shader_includes()
blitshadertype_cases = get_blitshader_cases()
blitshaderop_enums = get_blitshaderop_enums()
blitshadertype_enums = get_blitshadertype_enums()
shader_filenames = get_shader_filenames()
# auto_script parameters.
if len(sys.argv) > 1:
inputs = []
outputs = ['Blit11Helper_autogen.inc', 'd3d11_blit_shaders_autogen.gni']
write_inc_file("\n".join([d for d in blitshadertype_cases]), "\n".join(
[c for c in map_blitshader_cases]), "\n".join([i for i in shader_includes]),
"\n".join([e for e in blitshaderop_enums]), "\n".join(
[e for e in blitshadertype_enums]))
write_gni_file("\n".join([s for s in shader_filenames]))
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
map_blitshader_cases = []
shader_includes = []
blitshadertype_cases = []
blitshadertype_enums = []
blitshaderop_enums = []
shader_filenames = []
map_blitshader_cases = get_map_blitshader_cases()
shader_includes = get_shader_includes()
blitshadertype_cases = get_blitshader_cases()
blitshaderop_enums = get_blitshaderop_enums()
blitshadertype_enums = get_blitshadertype_enums()
shader_filenames = get_shader_filenames()
write_inc_file("\n".join([d for d in blitshadertype_cases]), "\n".join(
[c for c in map_blitshader_cases]), "\n".join([i for i in shader_includes]),
"\n".join([e for e in blitshaderop_enums]), "\n".join(
[e for e in blitshadertype_enums]))
write_gni_file("\n".join([s for s in shader_filenames]))
return 0
if __name__ == '__main__':
sys.exit(main())

103
src/libANGLE/renderer/d3d/d3d11/gen_dxgi_format_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_dxgi_format_table.py:
# Code generation for DXGI format map.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
import sys
@@ -82,52 +83,78 @@ def format_case(dxgi_format, result):
def undefined_case(dxgi_format):
return template_undefined_case.format(dxgi_format = dxgi_format)
component_cases = ""
format_cases = ""
input_data = 'dxgi_format_data.json'
def main():
dxgi_map = angle_format.load_json(input_data)
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [
'../../angle_format.py',
'../../angle_format_map.json',
'dxgi_format_data.json',
]
outputs = ['dxgi_format_map_autogen.cpp']
types = {
'SNORM': 'GL_SIGNED_NORMALIZED',
'UNORM': 'GL_UNSIGNED_NORMALIZED',
'SINT': 'GL_INT',
'UINT': 'GL_UNSIGNED_INT',
'FLOAT': 'GL_FLOAT',
'SHAREDEXP': 'GL_FLOAT'
}
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
all_angle = angle_format.get_all_angle_formats()
component_cases = ""
format_cases = ""
for dxgi_format, angle_format in sorted(dxgi_map.iteritems()):
input_data = 'dxgi_format_data.json'
found = [ctype in dxgi_format for ctype in types.keys()]
count = reduce((lambda a, b: int(a) + int(b)), found)
dxgi_map = angle_format.load_json(input_data)
component_type = 'GL_NONE'
types = {
'SNORM': 'GL_SIGNED_NORMALIZED',
'UNORM': 'GL_UNSIGNED_NORMALIZED',
'SINT': 'GL_INT',
'UINT': 'GL_UNSIGNED_INT',
'FLOAT': 'GL_FLOAT',
'SHAREDEXP': 'GL_FLOAT'
}
if count == 1:
gltype = next(gltype for ctype, gltype in types.iteritems() if ctype in dxgi_format)
component_cases += format_case(dxgi_format, gltype)
else:
component_cases += undefined_case(dxgi_format)
all_angle = angle_format.get_all_angle_formats()
if angle_format == "":
angle_format = dxgi_format
for dxgi_format, a_format in sorted(dxgi_map.iteritems()):
if angle_format in all_angle:
angle_format = "Format::Get(FormatID::" + angle_format + ")"
format_cases += format_case(dxgi_format, angle_format)
else:
format_cases += undefined_case(dxgi_format)
found = [ctype in dxgi_format for ctype in types.keys()]
count = reduce((lambda a, b: int(a) + int(b)), found)
with open('dxgi_format_map_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = input_data,
copyright_year = date.today().year,
component_type_cases = component_cases,
format_cases = format_cases)
out_file.write(output_cpp)
out_file.close()
component_type = 'GL_NONE'
if count == 1:
gltype = next(gltype for ctype, gltype in types.iteritems() if ctype in dxgi_format)
component_cases += format_case(dxgi_format, gltype)
else:
component_cases += undefined_case(dxgi_format)
if a_format == "":
a_format = dxgi_format
if a_format in all_angle:
a_format = "Format::Get(FormatID::" + a_format + ")"
format_cases += format_case(dxgi_format, a_format)
else:
format_cases += undefined_case(dxgi_format)
with open('dxgi_format_map_autogen.cpp', 'wt') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = input_data,
copyright_year = date.today().year,
component_type_cases = component_cases,
format_cases = format_cases)
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

58
src/libANGLE/renderer/d3d/d3d11/gen_dxgi_support_tables.py
View File

@@ -6,8 +6,9 @@
# gen_dxgi_support_tables.py:
# Code generation for the DXGI support tables. Determines which formats
# are natively support in D3D10+.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
#
# TODO: The "never supported" formats should not be combined with the
# NOTE: The "never supported" formats should not be combined with the
# "supported" and "optional" ones. At the moment, this does not cause
# any issues as ANGLE does not internally check for "never supported".
#
@@ -167,8 +168,6 @@ const DXGISupport &GetDXGISupport(DXGI_FORMAT dxgiFormat, D3D_FEATURE_LEVEL feat
}} // namespace rx
"""
table_init = ""
def do_format(format_data):
table_data = {'9_3': '', '10_0': '', '10_1': '', '11_0': '', '11_1': ''}
@@ -290,24 +289,45 @@ def join_table_data(table_data_1, table_data_2):
'11_0': table_data_1['11_0'] + table_data_2['11_0'],
'11_1': table_data_1['11_1'] + table_data_2['11_1']}
with open('dxgi_support_data.json') as dxgi_file:
file_data = dxgi_file.read()
dxgi_file.close()
json_data = json.loads(file_data)
table_data = {'9_3': '', '10_0': '', '10_1': '', '11_0': '', '11_1': ''}
def main():
for format_data in json_data:
table_data = join_table_data(table_data, do_format(format_data))
# auto_script parameters.
if len(sys.argv) > 1:
inputs = ['dxgi_support_data.json']
outputs = ['dxgi_support_table_autogen.cpp']
out_data = template.format(prefix=macro_prefix,
table_data_9_3=table_data['9_3'],
table_data_10_0=table_data['10_0'],
table_data_10_1=table_data['10_1'],
table_data_11_0=table_data['11_0'],
table_data_11_1=table_data['11_1'])
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
with open('dxgi_support_table.cpp', 'wt') as out_file:
out_file.write(out_data)
out_file.close()
with open('dxgi_support_data.json') as dxgi_file:
file_data = dxgi_file.read()
dxgi_file.close()
json_data = json.loads(file_data)
table_data = {'9_3': '', '10_0': '', '10_1': '', '11_0': '', '11_1': ''}
for format_data in json_data:
table_data = join_table_data(table_data, do_format(format_data))
out_data = template.format(prefix=macro_prefix,
table_data_9_3=table_data['9_3'],
table_data_10_0=table_data['10_0'],
table_data_10_1=table_data['10_1'],
table_data_11_0=table_data['11_0'],
table_data_11_1=table_data['11_1'])
with open('dxgi_support_table_autogen.cpp', 'wt') as out_file:
out_file.write(out_data)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

47
src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_texture_format_table.py:
# Code generation for texture format map
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
#
from datetime import date
@@ -266,16 +267,38 @@ def parse_json_into_switch_angle_format_string(json_map, json_data):
return table_data
json_map = angle_format.load_with_override(os.path.abspath('texture_format_map.json'))
data_source_name = 'texture_format_data.json'
json_data = angle_format.load_json(data_source_name)
angle_format_cases = parse_json_into_switch_angle_format_string(json_map, json_data)
output_cpp = template_texture_format_table_autogen_cpp.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
angle_format_info_cases = angle_format_cases,
data_source_name = data_source_name)
with open('texture_format_table_autogen.cpp', 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
def main():
# auto_script parameters.
if len(sys.argv) > 1:
inputs = ['../../angle_format.py', 'texture_format_data.json', 'texture_format_map.json']
outputs = ['texture_format_table_autogen.cpp']
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
json_map = angle_format.load_with_override(os.path.abspath('texture_format_map.json'))
data_source_name = 'texture_format_data.json'
json_data = angle_format.load_json(data_source_name)
angle_format_cases = parse_json_into_switch_angle_format_string(json_map, json_data)
output_cpp = template_texture_format_table_autogen_cpp.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
angle_format_info_cases = angle_format_cases,
data_source_name = data_source_name)
with open('texture_format_table_autogen.cpp', 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

2
src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp
View File

@@ -1,7 +1,7 @@
// GENERATED FILE - DO NOT EDIT.
// Generated by gen_texture_format_table.py using data from texture_format_data.json
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

92
src/libANGLE/renderer/gen_angle_format_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_angle_format_table.py:
# Code generation for ANGLE format map.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
#
import angle_format
@@ -90,11 +91,13 @@ const Format *GetFormatInfoTable()
}} // namespace angle
"""
def is_depth_stencil(angle_format):
if not 'channels' in angle_format or not angle_format['channels']:
return False
return 'd' in angle_format['channels'] or 's' in angle_format['channels']
def get_component_suffix(angle_format):
if angle_format['componentType'] == 'float':
return 'F'
@@ -102,6 +105,7 @@ def get_component_suffix(angle_format):
return 'S'
return ""
def get_channel_struct(angle_format):
if 'bits' not in angle_format or angle_format['bits'] is None:
return None
@@ -136,12 +140,14 @@ def get_channel_struct(angle_format):
return struct_name
def get_mip_generation_function(angle_format):
channel_struct = get_channel_struct(angle_format)
if is_depth_stencil(angle_format) or channel_struct == None or "BLOCK" in angle_format["id"]:
return 'nullptr'
return 'GenerateMip<' + channel_struct + '>'
def get_color_read_write_component_type(angle_format):
component_type_map = {
'uint': 'GLuint',
@@ -152,6 +158,7 @@ def get_color_read_write_component_type(angle_format):
}
return component_type_map[angle_format['componentType']]
def get_color_read_function(angle_format):
channel_struct = get_channel_struct(angle_format)
if channel_struct == None:
@@ -163,6 +170,7 @@ def get_color_read_function(angle_format):
read_component_type = get_color_read_write_component_type(angle_format)
return 'ReadColor<' + channel_struct + ', '+ read_component_type + '>'
def get_color_write_function(angle_format):
channel_struct = get_channel_struct(angle_format)
if channel_struct == None:
@@ -194,6 +202,7 @@ def get_named_component_type(component_type):
else:
raise ValueError("Unknown component type for " + component_type)
def get_component_alignment_mask(channels, bits):
if channels == None or bits == None:
return "std::numeric_limits<GLuint>::max()"
@@ -216,6 +225,7 @@ def get_component_alignment_mask(channels, bits):
# Can happen for 4-bit RGBA.
return "std::numeric_limits<GLuint>::max()"
def json_to_table_data(format_id, json, angle_to_gl):
table_data = ""
@@ -280,6 +290,7 @@ def json_to_table_data(format_id, json, angle_to_gl):
return format_entry_template.format(**parsed)
def parse_angle_format_table(all_angle, json_data, angle_to_gl):
table_data = ''
for format_id in sorted(all_angle):
@@ -289,6 +300,7 @@ def parse_angle_format_table(all_angle, json_data, angle_to_gl):
return table_data
def gen_enum_string(all_angle):
enum_data = ' NONE'
for format_id in sorted(all_angle):
@@ -301,6 +313,7 @@ case_template = """ case {gl_format}:
return FormatID::{angle_format};
"""
def gen_map_switch_string(gl_to_angle):
switch_data = '';
for gl_format in sorted(gl_to_angle.keys()):
@@ -312,33 +325,56 @@ def gen_map_switch_string(gl_to_angle):
switch_data += " return FormatID::NONE;"
return switch_data;
gl_to_angle = angle_format.load_forward_table('angle_format_map.json')
angle_to_gl = angle_format.load_inverse_table('angle_format_map.json')
data_source_name = 'angle_format_data.json'
json_data = angle_format.load_json(data_source_name)
all_angle = angle_to_gl.keys()
angle_format_cases = parse_angle_format_table(
all_angle, json_data, angle_to_gl)
switch_data = gen_map_switch_string(gl_to_angle)
output_cpp = template_autogen_inl.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
angle_format_info_cases = angle_format_cases,
angle_format_switch = switch_data,
data_source_name = data_source_name)
with open('Format_table_autogen.cpp', 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
def main():
enum_data = gen_enum_string(all_angle)
num_angle_formats = len(all_angle)
output_h = template_autogen_h.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
angle_format_enum = enum_data,
data_source_name = data_source_name,
num_angle_formats = num_angle_formats)
with open('FormatID_autogen.h', 'wt') as out_file:
out_file.write(output_h)
out_file.close()
# auto_script parameters.
if len(sys.argv) > 1:
inputs = ['angle_format.py', 'angle_format_data.json', 'angle_format_map.json']
outputs = ['Format_table_autogen.cpp', 'FormatID_autogen.h']
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
gl_to_angle = angle_format.load_forward_table('angle_format_map.json')
angle_to_gl = angle_format.load_inverse_table('angle_format_map.json')
data_source_name = 'angle_format_data.json'
json_data = angle_format.load_json(data_source_name)
all_angle = angle_to_gl.keys()
angle_format_cases = parse_angle_format_table(
all_angle, json_data, angle_to_gl)
switch_data = gen_map_switch_string(gl_to_angle)
output_cpp = template_autogen_inl.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
angle_format_info_cases = angle_format_cases,
angle_format_switch = switch_data,
data_source_name = data_source_name)
with open('Format_table_autogen.cpp', 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
enum_data = gen_enum_string(all_angle)
num_angle_formats = len(all_angle)
output_h = template_autogen_h.format(
script_name = sys.argv[0],
copyright_year = date.today().year,
angle_format_enum = enum_data,
data_source_name = data_source_name,
num_angle_formats = num_angle_formats)
with open('FormatID_autogen.h', 'wt') as out_file:
out_file.write(output_h)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

41
src/libANGLE/renderer/gen_load_functions_table.py
View File

@@ -7,6 +7,7 @@
# Code generation for the load function tables used for texture formats. These mappings are
# not renderer specific. The mappings are done from the GL internal format, to the ANGLE
# format ID, and then for the specific data type.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
#
import json, sys
@@ -184,15 +185,35 @@ def parse_json(json_data):
return table_data, load_functions_data
json_data = angle_format.load_json('load_functions_data.json')
def main():
switch_data, load_functions_data = parse_json(json_data)
output = template.format(internal_format = internal_format_param,
angle_format = angle_format_param,
switch_data = switch_data,
load_functions_data = load_functions_data,
copyright_year = date.today().year)
# auto_script parameters.
if len(sys.argv) > 1:
inputs = ['load_functions_data.json']
outputs = ['load_functions_table_autogen.cpp']
with open('load_functions_table_autogen.cpp', 'wt') as out_file:
out_file.write(output)
out_file.close()
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
json_data = angle_format.load_json('load_functions_data.json')
switch_data, load_functions_data = parse_json(json_data)
output = template.format(internal_format = internal_format_param,
angle_format = angle_format_param,
switch_data = switch_data,
load_functions_data = load_functions_data,
copyright_year = date.today().year)
with open('load_functions_table_autogen.cpp', 'wt') as out_file:
out_file.write(output)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

483
src/libANGLE/renderer/gl/generate_gl_dispatch_table.py
View File

@@ -5,6 +5,7 @@
#
# generate_gl_dispatch_table.py:
# Generation script for OpenGL bindings with ANGLE.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
import sys
import os
@@ -23,130 +24,6 @@ def safe_append(the_dict, key, element):
the_dict[key] = []
the_dict[key].append(element)
gl_xml_path = os.path.join('..', '..', '..', '..', 'scripts', 'gl.xml')
dispatch_header_path = 'DispatchTableGL_autogen.h'
dispatch_source_path = 'DispatchTableGL_autogen.cpp'
null_functions_header_path = 'null_functions.h'
null_functions_source_path = 'null_functions.cpp'
# Load the JSON and XML data.
data_source_name = 'gl_bindings_data.json'
json_data = angle_format.load_json(data_source_name)
xml_root = etree.parse(gl_xml_path).getroot()
api_feature_info = {}
core_removed_eps = []
for core_removed_ep in xml_root.findall('feature/remove'):
assert(core_removed_ep.attrib['profile'] == 'core')
for command in core_removed_ep.findall('./command'):
core_removed_eps.append(command.attrib['name'])
for feature in xml_root.findall('feature'):
api = feature.attrib['api']
name = feature.attrib['name']
number = feature.attrib['number']
# OpenGL ES 3.x versions are listed as api 'gles2'
if api != 'gl' and api != 'gles2':
continue
for command in feature.findall('./require/command'):
command_name = command.attrib['name']
safe_append(api_feature_info, command_name, (api, name, number))
gl_extension_commands = {}
gles2_extension_commands = {}
both_extension_commands = {}
for extension in xml_root.findall('extensions/extension'):
extension_name = extension.attrib['name']
support = extension.attrib['supported'].split('|')
for command in extension.findall('./require/command'):
command_name = command.attrib['name']
if 'gl' in support and 'gles2' in support:
# Special case for KHR extensions, since in GLES they are suffixed.
if '_KHR_' in extension_name:
safe_append(gl_extension_commands, command_name, extension_name)
safe_append(gles2_extension_commands, command_name, extension_name)
else:
safe_append(both_extension_commands, command_name, extension_name)
elif 'gl' in support:
safe_append(gl_extension_commands, command_name, extension_name)
elif 'gles2' in support:
safe_append(gles2_extension_commands, command_name, extension_name)
gl_requirements = {}
gles2_requirements = {}
gl_extension_requirements = {}
gles2_extension_requirements = {}
both_extension_requirements = {}
# Used later in the NULL bindings.
all_entry_points = []
for comment, entry_points in json_data.iteritems():
for entry_point_no_prefix in entry_points:
entry_point = "gl" + entry_point_no_prefix
all_entry_points.append(entry_point)
gl_required = None
gles2_required = None
if entry_point in api_feature_info:
for api, name, number in api_feature_info[entry_point]:
major, minor = number.split(".")
reqs = (major, minor)
if api == 'gl':
if not gl_required:
gl_required = reqs
elif entry_point in core_removed_eps:
print('Upgrade ' + entry_point + ' to ' + str(reqs) + ' instead of ' + str(gl_required))
gl_required = reqs
else:
print('Keep ' + entry_point + ' at ' + str(gl_required) + ' instead of ' + str(reqs))
elif api == 'gles2':
if not gles2_required:
gles2_required = reqs
else:
print("Duplicate for " + entry_point + ": " + str(reqs) + " and " + str(gles2_required))
else:
raise Exception('Bad api type: ' + api)
if gl_required:
safe_append(gl_requirements, gl_required, entry_point)
if gles2_required:
safe_append(gles2_requirements, gles2_required, entry_point)
# Special case for finding extensions that overlap with core functions.
extension = False
for ep in [entry_point, entry_point + "EXT", entry_point + "ARB", entry_point + "OES"]:
if ep in both_extension_commands:
extension = True
for extension in both_extension_commands[ep]:
safe_append(both_extension_requirements, extension, (entry_point, ep))
else:
if ep in gl_extension_commands:
extension = True
for extension in gl_extension_commands[ep]:
safe_append(gl_extension_requirements, extension, (entry_point, ep))
if ep in gles2_extension_commands:
extension = True
for extension in gles2_extension_commands[ep]:
full_ep = ep
if '_KHR_' in extension:
full_ep += 'KHR'
safe_append(gles2_extension_requirements, extension, (entry_point, full_ep))
if not (gl_required or gles2_required or extension):
raise Exception('Entry point ' + entry_point + ' not found in the xml.')
# Template for the header declaration of the dispatch table.
dispatch_table_header_template = """// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name} and gl.xml.
@@ -206,23 +83,6 @@ def first_lower(str):
def format_ep_decl(entry_point):
return " PFNGL" + entry_point.upper() + "PROC " + first_lower(entry_point) + " = nullptr;"
table_data = []
for comment, entry_points in sorted(json_data.iteritems()):
formatted = [" // " + comment]
formatted += [format_ep_decl(entry_point) for entry_point in sorted(entry_points)]
table_data.append("\n".join(formatted))
dispatch_table_header = dispatch_table_header_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = dispatch_header_path,
table_data = "\n\n".join(table_data))
with open(dispatch_header_path, "w") as out:
out.write(dispatch_table_header)
# Template for the initialization file of the dispatch table.
dispatch_table_source_template = """// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name} and gl.xml.
@@ -309,26 +169,6 @@ def format_extension_requirements_lines(extension, entry_points, api):
lines += [' }']
return '\n'.join(lines)
gl_data = []
for gl_required, entry_points in sorted(gl_requirements.iteritems()):
gl_data.append(format_requirements_lines(gl_required, entry_points))
gl_extensions_data = []
for extension, entry_points in sorted(gl_extension_requirements.iteritems()):
gl_extensions_data.append(format_extension_requirements_lines(extension, entry_points, "gl"))
gles2_data = []
for gles2_required, entry_points in sorted(gles2_requirements.iteritems()):
gles2_data.append(format_requirements_lines(gles2_required, entry_points))
gles2_extensions_data = []
for extension, entry_points in sorted(gles2_extension_requirements.iteritems()):
gles2_extensions_data.append(format_extension_requirements_lines(extension, entry_points, "gles2"))
both_extensions_data = []
for extension, entry_points in sorted(both_extension_requirements.iteritems()):
both_extensions_data.append(format_extension_requirements_lines(extension, entry_points, "gles2|gl"))
def assign_null_line(line):
m = re.match(r' ASSIGN\("gl.*", (.+)\);', line)
if m:
@@ -343,56 +183,9 @@ def assign_null(entry):
def nullify(data):
return [assign_null(entry) for entry in data]
dispatch_table_source = dispatch_table_source_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = dispatch_source_path,
gl_data = "\n\n".join(gl_data),
gl_extensions_data = "\n\n".join(gl_extensions_data),
gles2_data = "\n\n".join(gles2_data),
gles2_extensions_data = "\n\n".join(gles2_extensions_data),
both_extensions_data = "\n\n".join(both_extensions_data),
gl_null_data = "\n\n".join(nullify(gl_data)),
gl_null_extensions_data = "\n\n".join(nullify(gl_extensions_data)),
gles2_null_data = "\n\n".join(nullify(gles2_data)),
gles2_null_extensions_data = "\n\n".join(nullify(gles2_extensions_data)),
both_null_extensions_data = "\n\n".join(nullify(both_extensions_data)))
with open(dispatch_source_path, "w") as out:
out.write(dispatch_table_source)
# Generate the NULL/stub entry points.
# Process the whole set of commands
def format_param(param):
return "".join(param.itertext())
command_defs = {}
command_decls = {}
for command in xml_root.findall('commands/command'):
proto = command.find('proto')
command_name = proto.find('name').text
entry = ''.join(proto.itertext())
return_type = entry[:-len(command_name)]
entry = return_type + ' INTERNAL_GL_APIENTRY ' + entry[len(return_type):] + 'NULL('
param_text = [format_param(param) for param in command.findall('param')]
entry += ', '.join(param_text) + ')'
command_decls[command_name] = entry + ';'
entry += '\n{\n'
if return_type != 'void ':
entry += ' return static_cast<' + return_type + '>(0);\n'
entry += '}'
command_defs[command_name] = entry
null_decls = [command_decls[entry_point] for entry_point in sorted(all_entry_points)]
null_stubs = [command_defs[entry_point] for entry_point in sorted(all_entry_points)]
null_functions_header_template = """// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name} and gl.xml.
//
@@ -416,16 +209,6 @@ namespace rx
#endif // LIBGLESV2_RENDERER_GL_NULL_GL_FUNCTIONS_AUTOGEN_H_
"""
null_functions_header = null_functions_header_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = null_functions_header_path,
table_data = "\n".join(null_decls))
with open(null_functions_header_path, "w") as out:
out.write(null_functions_header)
null_functions_source_template = """// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name} and gl.xml.
//
@@ -444,12 +227,260 @@ namespace rx
}} // namespace rx
"""
null_functions_source = null_functions_source_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = null_functions_source_path,
table_data = "\n\n".join(null_stubs))
def main():
with open(null_functions_source_path, "w") as out:
out.write(null_functions_source)
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [
'../../../../scripts/gl.xml',
'../angle_format.py',
'gl_bindings_data.json',
]
outputs = [
'DispatchTableGL_autogen.cpp',
'DispatchTableGL_autogen.h',
'null_functions.cpp',
'null_functions.h',
]
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
gl_xml_path = os.path.join('..', '..', '..', '..', 'scripts', 'gl.xml')
dispatch_header_path = 'DispatchTableGL_autogen.h'
dispatch_source_path = 'DispatchTableGL_autogen.cpp'
null_functions_header_path = 'null_functions.h'
null_functions_source_path = 'null_functions.cpp'
# Load the JSON and XML data.
data_source_name = 'gl_bindings_data.json'
json_data = angle_format.load_json(data_source_name)
xml_root = etree.parse(gl_xml_path).getroot()
api_feature_info = {}
core_removed_eps = []
for core_removed_ep in xml_root.findall('feature/remove'):
assert(core_removed_ep.attrib['profile'] == 'core')
for command in core_removed_ep.findall('./command'):
core_removed_eps.append(command.attrib['name'])
for feature in xml_root.findall('feature'):
api = feature.attrib['api']
name = feature.attrib['name']
number = feature.attrib['number']
# OpenGL ES 3.x versions are listed as api 'gles2'
if api != 'gl' and api != 'gles2':
continue
for command in feature.findall('./require/command'):
command_name = command.attrib['name']
safe_append(api_feature_info, command_name, (api, name, number))
gl_extension_commands = {}
gles2_extension_commands = {}
both_extension_commands = {}
for extension in xml_root.findall('extensions/extension'):
extension_name = extension.attrib['name']
support = extension.attrib['supported'].split('|')
for command in extension.findall('./require/command'):
command_name = command.attrib['name']
if 'gl' in support and 'gles2' in support:
# Special case for KHR extensions, since in GLES they are suffixed.
if '_KHR_' in extension_name:
safe_append(gl_extension_commands, command_name, extension_name)
safe_append(gles2_extension_commands, command_name, extension_name)
else:
safe_append(both_extension_commands, command_name, extension_name)
elif 'gl' in support:
safe_append(gl_extension_commands, command_name, extension_name)
elif 'gles2' in support:
safe_append(gles2_extension_commands, command_name, extension_name)
gl_requirements = {}
gles2_requirements = {}
gl_extension_requirements = {}
gles2_extension_requirements = {}
both_extension_requirements = {}
# Used later in the NULL bindings.
all_entry_points = []
for comment, entry_points in json_data.iteritems():
for entry_point_no_prefix in entry_points:
entry_point = "gl" + entry_point_no_prefix
all_entry_points.append(entry_point)
gl_required = None
gles2_required = None
if entry_point in api_feature_info:
for api, name, number in api_feature_info[entry_point]:
major, minor = number.split(".")
reqs = (major, minor)
if api == 'gl':
if not gl_required:
gl_required = reqs
elif entry_point in core_removed_eps:
print('Upgrade ' + entry_point + ' to ' + str(reqs) + ' instead of ' + str(gl_required))
gl_required = reqs
else:
print('Keep ' + entry_point + ' at ' + str(gl_required) + ' instead of ' + str(reqs))
elif api == 'gles2':
if not gles2_required:
gles2_required = reqs
else:
print("Duplicate for " + entry_point + ": " + str(reqs) + " and " + str(gles2_required))
else:
raise Exception('Bad api type: ' + api)
if gl_required:
safe_append(gl_requirements, gl_required, entry_point)
if gles2_required:
safe_append(gles2_requirements, gles2_required, entry_point)
# Special case for finding extensions that overlap with core functions.
extension = False
for ep in [entry_point, entry_point + "EXT", entry_point + "ARB", entry_point + "OES"]:
if ep in both_extension_commands:
extension = True
for extension in both_extension_commands[ep]:
safe_append(both_extension_requirements, extension, (entry_point, ep))
else:
if ep in gl_extension_commands:
extension = True
for extension in gl_extension_commands[ep]:
safe_append(gl_extension_requirements, extension, (entry_point, ep))
if ep in gles2_extension_commands:
extension = True
for extension in gles2_extension_commands[ep]:
full_ep = ep
if '_KHR_' in extension:
full_ep += 'KHR'
safe_append(gles2_extension_requirements, extension, (entry_point, full_ep))
if not (gl_required or gles2_required or extension):
raise Exception('Entry point ' + entry_point + ' not found in the xml.')
table_data = []
for comment, entry_points in sorted(json_data.iteritems()):
formatted = [" // " + comment]
formatted += [format_ep_decl(entry_point) for entry_point in sorted(entry_points)]
table_data.append("\n".join(formatted))
dispatch_table_header = dispatch_table_header_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = dispatch_header_path,
table_data = "\n\n".join(table_data))
with open(dispatch_header_path, "w") as out:
out.write(dispatch_table_header)
gl_data = []
for gl_required, entry_points in sorted(gl_requirements.iteritems()):
gl_data.append(format_requirements_lines(gl_required, entry_points))
gl_extensions_data = []
for extension, entry_points in sorted(gl_extension_requirements.iteritems()):
gl_extensions_data.append(format_extension_requirements_lines(extension, entry_points, "gl"))
gles2_data = []
for gles2_required, entry_points in sorted(gles2_requirements.iteritems()):
gles2_data.append(format_requirements_lines(gles2_required, entry_points))
gles2_extensions_data = []
for extension, entry_points in sorted(gles2_extension_requirements.iteritems()):
gles2_extensions_data.append(format_extension_requirements_lines(extension, entry_points, "gles2"))
both_extensions_data = []
for extension, entry_points in sorted(both_extension_requirements.iteritems()):
both_extensions_data.append(format_extension_requirements_lines(extension, entry_points, "gles2|gl"))
dispatch_table_source = dispatch_table_source_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = dispatch_source_path,
gl_data = "\n\n".join(gl_data),
gl_extensions_data = "\n\n".join(gl_extensions_data),
gles2_data = "\n\n".join(gles2_data),
gles2_extensions_data = "\n\n".join(gles2_extensions_data),
both_extensions_data = "\n\n".join(both_extensions_data),
gl_null_data = "\n\n".join(nullify(gl_data)),
gl_null_extensions_data = "\n\n".join(nullify(gl_extensions_data)),
gles2_null_data = "\n\n".join(nullify(gles2_data)),
gles2_null_extensions_data = "\n\n".join(nullify(gles2_extensions_data)),
both_null_extensions_data = "\n\n".join(nullify(both_extensions_data)))
with open(dispatch_source_path, "w") as out:
out.write(dispatch_table_source)
# Generate the NULL/stub entry points.
# Process the whole set of commands
command_defs = {}
command_decls = {}
for command in xml_root.findall('commands/command'):
proto = command.find('proto')
command_name = proto.find('name').text
entry = ''.join(proto.itertext())
return_type = entry[:-len(command_name)]
entry = return_type + ' INTERNAL_GL_APIENTRY ' + entry[len(return_type):] + 'NULL('
param_text = [format_param(param) for param in command.findall('param')]
entry += ', '.join(param_text) + ')'
command_decls[command_name] = entry + ';'
entry += '\n{\n'
if return_type != 'void ':
entry += ' return static_cast<' + return_type + '>(0);\n'
entry += '}'
command_defs[command_name] = entry
null_decls = [command_decls[entry_point] for entry_point in sorted(all_entry_points)]
null_stubs = [command_defs[entry_point] for entry_point in sorted(all_entry_points)]
null_functions_header = null_functions_header_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = null_functions_header_path,
table_data = "\n".join(null_decls))
with open(null_functions_header_path, "w") as out:
out.write(null_functions_header)
null_functions_source = null_functions_source_template.format(
script_name = os.path.basename(sys.argv[0]),
data_source_name = data_source_name,
year = date.today().year,
file_name = null_functions_source_path,
table_data = "\n\n".join(null_stubs))
with open(null_functions_source_path, "w") as out:
out.write(null_functions_source)
return 0
if __name__ == '__main__':
sys.exit(main())

2
src/libANGLE/renderer/load_functions_table_autogen.cpp
View File

@@ -1,7 +1,7 @@
// GENERATED FILE - DO NOT EDIT.
// Generated by gen_load_functions_table.py using data from load_functions_data.json
//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

167
src/libANGLE/renderer/vulkan/gen_vk_format_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_vk_format_table.py:
# Code generation for vk format map. See vk_format_map.json for data source.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
import json
@@ -95,89 +96,115 @@ static constexpr BufferFormatInitInfo kInfo[] = {{{buffer_list}}};
initBufferFallback(renderer, kInfo, ArraySize(kInfo));
}}"""
def is_packed(format_id):
return "true" if "_PACK" in format_id else "false"
return "true" if "_PACK" in format_id else "false"
def gen_format_case(angle, internal_format, vk_json_data):
vk_map = vk_json_data["map"]
vk_overrides = vk_json_data["overrides"]
vk_fallbacks = vk_json_data["fallbacks"]
args = dict(
format_id=angle,
internal_format=internal_format,
texture_template="",
buffer_template="")
vk_map = vk_json_data["map"]
vk_overrides = vk_json_data["overrides"]
vk_fallbacks = vk_json_data["fallbacks"]
args = dict(
format_id=angle,
internal_format=internal_format,
texture_template="",
buffer_template="")
if ((angle not in vk_map) and (angle not in vk_overrides) and
(angle not in vk_fallbacks)) or angle == 'NONE':
return empty_format_entry_template.format(**args)
if ((angle not in vk_map) and (angle not in vk_overrides) and
(angle not in vk_fallbacks)) or angle == 'NONE':
return empty_format_entry_template.format(**args)
def get_formats(format, type):
format = vk_overrides.get(format, {}).get(type, format)
if format not in vk_map:
return []
fallbacks = vk_fallbacks.get(format, {}).get(type, [])
if not isinstance(fallbacks, list):
fallbacks = [fallbacks]
return [format] + fallbacks
def get_formats(format, type):
format = vk_overrides.get(format, {}).get(type, format)
if format not in vk_map:
return []
fallbacks = vk_fallbacks.get(format, {}).get(type, [])
if not isinstance(fallbacks, list):
fallbacks = [fallbacks]
return [format] + fallbacks
def texture_args(format):
return dict(
texture="angle::FormatID::" + format,
vk_texture_format=vk_map[format],
texture_initializer=angle_format.get_internal_format_initializer(
internal_format, format))
def texture_args(format):
return dict(
texture="angle::FormatID::" + format,
vk_texture_format=vk_map[format],
texture_initializer=angle_format.get_internal_format_initializer(
internal_format, format))
def buffer_args(format):
return dict(
buffer="angle::FormatID::" + format,
vk_buffer_format=vk_map[format],
vk_buffer_format_is_packed=is_packed(vk_map[format]),
vertex_load_function=angle_format.get_vertex_copy_function(
angle, format),
vertex_load_converts='false' if angle == format else 'true',
)
def buffer_args(format):
return dict(
buffer="angle::FormatID::" + format,
vk_buffer_format=vk_map[format],
vk_buffer_format_is_packed=is_packed(vk_map[format]),
vertex_load_function=angle_format.get_vertex_copy_function(
angle, format),
vertex_load_converts='false' if angle == format else 'true',
)
textures = get_formats(angle, "texture")
if len(textures) == 1:
args.update(texture_template=texture_basic_template)
args.update(texture_args(textures[0]))
elif len(textures) > 1:
args.update(
texture_template=texture_fallback_template,
texture_list=", ".join(
texture_struct_template.format(**texture_args(i))
for i in textures))
textures = get_formats(angle, "texture")
if len(textures) == 1:
args.update(texture_template=texture_basic_template)
args.update(texture_args(textures[0]))
elif len(textures) > 1:
args.update(
texture_template=texture_fallback_template,
texture_list=", ".join(
texture_struct_template.format(**texture_args(i))
for i in textures))
buffers = get_formats(angle, "buffer")
if len(buffers) == 1:
args.update(buffer_template=buffer_basic_template)
args.update(buffer_args(buffers[0]))
elif len(buffers) > 1:
args.update(
buffer_template=buffer_fallback_template,
buffer_list=", ".join(
buffer_struct_template.format(**buffer_args(i)) for i in buffers))
buffers = get_formats(angle, "buffer")
if len(buffers) == 1:
args.update(buffer_template=buffer_basic_template)
args.update(buffer_args(buffers[0]))
elif len(buffers) > 1:
args.update(
buffer_template=buffer_fallback_template,
buffer_list=", ".join(
buffer_struct_template.format(**buffer_args(i)) for i in buffers))
return format_entry_template.format(**args).format(**args)
return format_entry_template.format(**args).format(**args)
input_file_name = 'vk_format_map.json'
out_file_name = 'vk_format_table'
def main():
angle_to_gl = angle_format.load_inverse_table(os.path.join('..', 'angle_format_map.json'))
vk_json_data = angle_format.load_json(input_file_name)
vk_cases = [gen_format_case(angle, gl, vk_json_data)
for angle, gl in sorted(angle_to_gl.iteritems())]
input_file_name = 'vk_format_map.json'
out_file_name = 'vk_format_table_autogen.cpp'
output_cpp = template_table_autogen_cpp.format(
copyright_year = date.today().year,
format_case_data = "\n".join(vk_cases),
script_name = __file__,
out_file_name = out_file_name,
input_file_name = input_file_name)
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [
'../angle_format.py',
'../angle_format_map.json',
input_file_name
]
outputs = [out_file_name]
with open(out_file_name + '_autogen.cpp', 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
angle_to_gl = angle_format.load_inverse_table(os.path.join('..', 'angle_format_map.json'))
vk_json_data = angle_format.load_json(input_file_name)
vk_cases = [gen_format_case(angle, gl, vk_json_data)
for angle, gl in sorted(angle_to_gl.iteritems())]
output_cpp = template_table_autogen_cpp.format(
copyright_year = date.today().year,
format_case_data = "\n".join(vk_cases),
script_name = __file__,
out_file_name = out_file_name,
input_file_name = input_file_name)
with open(out_file_name, 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

255
src/libANGLE/renderer/vulkan/gen_vk_internal_shaders.py
View File

@@ -6,6 +6,8 @@
# gen_vk_internal_shaders.py:
# Code generation for internal Vulkan shaders. Should be run when an internal
# shader program is changed, added or removed.
# Because this script can be slow direct invocation is supported. But before
# code upload please run scripts/run_code_generation.py.
from datetime import date
import json
@@ -248,48 +250,8 @@ compact_newlines_regex = re.compile(r"\n\s*\n", re.MULTILINE)
def cleanup_preprocessed_shader(shader_text):
return compact_newlines_regex.sub('\n\n', shader_text.strip())
# STEP 0: Handle inputs/outputs for run_code_generation.py's auto_script
shaders_dir = os.path.join('shaders', 'src')
if not os.path.isdir(shaders_dir):
raise Exception("Could not find shaders directory")
print_inputs = len(sys.argv) == 2 and sys.argv[1] == 'inputs'
print_outputs = len(sys.argv) == 2 and sys.argv[1] == 'outputs'
# If an argument X is given that's not inputs or outputs, compile shaders that match *X*.
# This is useful in development to build only the shader of interest.
shader_files_to_compile = os.listdir(shaders_dir)
if not (print_inputs or print_outputs or len(sys.argv) < 2):
shader_files_to_compile = [f for f in shader_files_to_compile if f.find(sys.argv[1]) != -1]
valid_extensions = ['.vert', '.frag', '.comp']
input_shaders = sorted([os.path.join(shaders_dir, shader)
for shader in os.listdir(shaders_dir)
if any([os.path.splitext(shader)[1] == ext for ext in valid_extensions])])
if print_inputs:
print(",".join(input_shaders))
sys.exit(0)
# STEP 1: Call glslang to generate the internal shaders into small .inc files.
# a) Get the path to the glslang binary from the script directory.
build_path = find_build_path(".")
print("Using glslang_validator from '" + build_path + "'")
result = subprocess.call(['ninja', '-C', build_path, 'glslang_validator'])
if result != 0:
raise Exception("Error building glslang_validator")
glslang_binary = 'glslang_validator'
if os.name == 'nt':
glslang_binary += '.exe'
glslang_path = os.path.join(build_path, glslang_binary)
if not os.path.isfile(glslang_path):
raise Exception("Could not find " + glslang_binary)
# b) Iterate over the shaders and call glslang with the right arguments.
output_shaders = []
def compile_variation(shader_file, shader_basename, flags, enums,
flags_active, enum_indices, flags_bits, enum_bits, do_compile):
def compile_variation(glslang_path, shader_file, shader_basename, flags, enums,
flags_active, enum_indices, flags_bits, enum_bits, output_shaders):
glslang_args = [glslang_path]
@@ -322,7 +284,7 @@ def compile_variation(shader_file, shader_basename, flags, enums,
output_path = get_output_path(output_name)
output_shaders.append(output_path)
if do_compile:
if glslang_path is not None:
glslang_preprocessor_output_args = glslang_args + ['-E']
glslang_preprocessor_output_args.append(shader_file) # Input GLSL shader
@@ -350,40 +312,7 @@ class ShaderAndVariations:
get_variation_bits(self.flags, self.enums)
(self.flags_bits, self.enum_bits) = get_variation_bits(self.flags, self.enums)
input_shaders_and_variations = [ShaderAndVariations(shader_file) for shader_file in input_shaders]
for shader_and_variation in input_shaders_and_variations:
shader_file = shader_and_variation.shader_file
flags = shader_and_variation.flags
enums = shader_and_variation.enums
flags_bits = shader_and_variation.flags_bits
enum_bits = shader_and_variation.enum_bits
# an array where each element i is in [0, len(enums[i])),
# telling which enum is currently selected
enum_indices = [0] * len(enums)
output_name = os.path.basename(shader_file)
while True:
do_compile = not print_outputs and output_name in shader_files_to_compile
# a number where each bit says whether a flag is active or not,
# with values in [0, 2^len(flags))
for flags_active in range(1 << len(flags)):
compile_variation(shader_file, output_name, flags, enums,
flags_active, enum_indices, flags_bits, enum_bits, do_compile)
if not next_enum_variation(enums, enum_indices):
break
output_shaders = sorted(output_shaders)
outputs = output_shaders + [out_file_cpp, out_file_h]
if print_outputs:
print("\n".join(outputs))
sys.exit(0)
# STEP 2: Consolidate the .inc files into an auto-generated cpp/h library.
def get_variation_definition(shader_and_variation):
shader_file = shader_and_variation.shader_file
flags = shader_and_variation.flags
@@ -516,52 +445,134 @@ def get_destroy_call(shader_and_variation):
destroy += '{\nshader.get().destroy(device);\n}'
return destroy
with open(out_file_cpp, 'w') as outfile:
includes = "\n".join([gen_shader_include(shader) for shader in output_shaders])
shader_tables_cpp = '\n'.join([get_shader_table_cpp(s)
for s in input_shaders_and_variations])
shader_destroy_calls = '\n'.join([get_destroy_call(s)
for s in input_shaders_and_variations])
shader_get_functions_cpp = '\n'.join([get_get_function_cpp(s)
for s in input_shaders_and_variations])
outcode = template_shader_library_cpp.format(
script_name = __file__,
copyright_year = date.today().year,
out_file_name = out_file_cpp,
input_file_name = 'shaders/src/*',
internal_shader_includes = includes,
shader_tables_cpp = shader_tables_cpp,
shader_destroy_calls = shader_destroy_calls,
shader_get_functions_cpp = shader_get_functions_cpp)
outfile.write(outcode)
outfile.close()
def main():
# STEP 0: Handle inputs/outputs for run_code_generation.py's auto_script
shaders_dir = os.path.join('shaders', 'src')
if not os.path.isdir(shaders_dir):
raise Exception("Could not find shaders directory")
with open(out_file_h, 'w') as outfile:
shader_variation_definitions = '\n'.join([get_variation_definition(s)
for s in input_shaders_and_variations])
shader_get_functions_h = '\n'.join([get_get_function_h(s)
for s in input_shaders_and_variations])
shader_tables_h = '\n'.join([get_shader_table_h(s)
for s in input_shaders_and_variations])
outcode = template_shader_library_h.format(
script_name = __file__,
copyright_year = date.today().year,
out_file_name = out_file_h,
input_file_name = 'shaders/src/*',
shader_variation_definitions = shader_variation_definitions,
shader_get_functions_h = shader_get_functions_h,
shader_tables_h = shader_tables_h)
outfile.write(outcode)
outfile.close()
print_inputs = len(sys.argv) == 2 and sys.argv[1] == 'inputs'
print_outputs = len(sys.argv) == 2 and sys.argv[1] == 'outputs'
# If an argument X is given that's not inputs or outputs, compile shaders that match *X*.
# This is useful in development to build only the shader of interest.
shader_files_to_compile = os.listdir(shaders_dir)
if not (print_inputs or print_outputs or len(sys.argv) < 2):
shader_files_to_compile = [f for f in shader_files_to_compile if f.find(sys.argv[1]) != -1]
# STEP 3: Create a gni file with the generated files.
with open(out_file_gni, 'w') as outfile:
outcode = template_shader_includes_gni.format(
script_name = __file__,
copyright_year = date.today().year,
out_file_name = out_file_gni,
input_file_name = 'shaders/src/*',
shaders_list = ',\n'.join([' "' + slash(shader) + '"' for shader in output_shaders]))
outfile.write(outcode)
outfile.close()
valid_extensions = ['.vert', '.frag', '.comp']
input_shaders = sorted([os.path.join(shaders_dir, shader)
for shader in os.listdir(shaders_dir)
if any([os.path.splitext(shader)[1] == ext for ext in valid_extensions])])
if print_inputs:
print(",".join(input_shaders))
sys.exit(0)
# STEP 1: Call glslang to generate the internal shaders into small .inc files.
# a) Get the path to the glslang binary from the script directory.
glslang_path = None
if not print_outputs:
build_path = find_build_path(".")
print("Using glslang_validator from '" + build_path + "'")
result = subprocess.call(['ninja', '-C', build_path, 'glslang_validator'])
if result != 0:
raise Exception("Error building glslang_validator")
glslang_binary = 'glslang_validator'
if os.name == 'nt':
glslang_binary += '.exe'
glslang_path = os.path.join(build_path, glslang_binary)
if not os.path.isfile(glslang_path):
raise Exception("Could not find " + glslang_binary)
# b) Iterate over the shaders and call glslang with the right arguments.
output_shaders = []
input_shaders_and_variations = [ShaderAndVariations(shader_file) for shader_file in input_shaders]
for shader_and_variation in input_shaders_and_variations:
shader_file = shader_and_variation.shader_file
flags = shader_and_variation.flags
enums = shader_and_variation.enums
flags_bits = shader_and_variation.flags_bits
enum_bits = shader_and_variation.enum_bits
# an array where each element i is in [0, len(enums[i])),
# telling which enum is currently selected
enum_indices = [0] * len(enums)
output_name = os.path.basename(shader_file)
while True:
do_compile = not print_outputs and output_name in shader_files_to_compile
# a number where each bit says whether a flag is active or not,
# with values in [0, 2^len(flags))
for flags_active in range(1 << len(flags)):
compile_variation(glslang_path, shader_file, output_name, flags, enums,
flags_active, enum_indices, flags_bits, enum_bits, output_shaders)
if not next_enum_variation(enums, enum_indices):
break
output_shaders = sorted(output_shaders)
outputs = output_shaders + [out_file_cpp, out_file_h]
if print_outputs:
print(','.join(outputs))
sys.exit(0)
# STEP 2: Consolidate the .inc files into an auto-generated cpp/h library.
with open(out_file_cpp, 'w') as outfile:
includes = "\n".join([gen_shader_include(shader) for shader in output_shaders])
shader_tables_cpp = '\n'.join([get_shader_table_cpp(s)
for s in input_shaders_and_variations])
shader_destroy_calls = '\n'.join([get_destroy_call(s)
for s in input_shaders_and_variations])
shader_get_functions_cpp = '\n'.join([get_get_function_cpp(s)
for s in input_shaders_and_variations])
outcode = template_shader_library_cpp.format(
script_name = __file__,
copyright_year = date.today().year,
out_file_name = out_file_cpp,
input_file_name = 'shaders/src/*',
internal_shader_includes = includes,
shader_tables_cpp = shader_tables_cpp,
shader_destroy_calls = shader_destroy_calls,
shader_get_functions_cpp = shader_get_functions_cpp)
outfile.write(outcode)
outfile.close()
with open(out_file_h, 'w') as outfile:
shader_variation_definitions = '\n'.join([get_variation_definition(s)
for s in input_shaders_and_variations])
shader_get_functions_h = '\n'.join([get_get_function_h(s)
for s in input_shaders_and_variations])
shader_tables_h = '\n'.join([get_shader_table_h(s)
for s in input_shaders_and_variations])
outcode = template_shader_library_h.format(
script_name = __file__,
copyright_year = date.today().year,
out_file_name = out_file_h,
input_file_name = 'shaders/src/*',
shader_variation_definitions = shader_variation_definitions,
shader_get_functions_h = shader_get_functions_h,
shader_tables_h = shader_tables_h)
outfile.write(outcode)
outfile.close()
# STEP 3: Create a gni file with the generated files.
with open(out_file_gni, 'w') as outfile:
outcode = template_shader_includes_gni.format(
script_name = __file__,
copyright_year = date.today().year,
out_file_name = out_file_gni,
input_file_name = 'shaders/src/*',
shaders_list = ',\n'.join([' "' + slash(shader) + '"' for shader in output_shaders]))
outfile.write(outcode)
outfile.close()
if __name__ == '__main__':
sys.exit(main())

73
src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_vk_mandatory_format_support_table.py:
# Code generation for mandatory formats supported by Vulkan.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
from datetime import date
import sys
@@ -85,30 +86,56 @@ def gen_format_case(index, vk_to_index_to_format_map, vk_map):
buffer_features = buffer_features_str)
input_file_name = 'vk_mandatory_format_support_data.json'
out_file_name = 'vk_mandatory_format_support_table'
def main():
tree = etree.parse(script_relative('../../../../third_party/vulkan-headers/src/registry/vk.xml'))
root = tree.getroot()
vk_format_enums = root.findall(".//enums[@name='VkFormat']/enum")
vk_format_name_to_index_map = {}
num_formats = len(vk_format_enums)
for format_enum in vk_format_enums:
index = int(format_enum.attrib['value'])
vk_format = format_enum.attrib['name']
vk_format_name_to_index_map[index] = vk_format
input_file_name = 'vk_mandatory_format_support_data.json'
out_file_name = 'vk_mandatory_format_support_table_autogen.cpp'
vk_xml_file = '../../../../third_party/vulkan-headers/src/registry/vk.xml'
vk_map = angle_format.load_json(input_file_name)
vk_cases = [gen_format_case(index, vk_format_name_to_index_map, vk_map) for index in vk_format_name_to_index_map]
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [
'../angle_format.py',
input_file_name,
vk_xml_file,
]
outputs = [out_file_name]
output_cpp = template_table_autogen_cpp.format(
copyright_year = date.today().year,
num_formats = num_formats,
format_case_data = "\n,".join(vk_cases),
script_name = __file__,
out_file_name = out_file_name,
input_file_name = input_file_name)
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
print('Invalid script parameters')
return 1
return 0
with open(out_file_name + '_autogen.cpp', 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
tree = etree.parse(script_relative(vk_xml_file))
root = tree.getroot()
vk_format_enums = root.findall(".//enums[@name='VkFormat']/enum")
vk_format_name_to_index_map = {}
num_formats = len(vk_format_enums)
for format_enum in vk_format_enums:
index = int(format_enum.attrib['value'])
vk_format = format_enum.attrib['name']
vk_format_name_to_index_map[index] = vk_format
vk_map = angle_format.load_json(input_file_name)
vk_cases = [gen_format_case(index, vk_format_name_to_index_map, vk_map) for index in vk_format_name_to_index_map]
output_cpp = template_table_autogen_cpp.format(
copyright_year = date.today().year,
num_formats = num_formats,
format_case_data = "\n,".join(vk_cases),
script_name = __file__,
out_file_name = out_file_name,
input_file_name = input_file_name)
with open(out_file_name, 'wt') as out_file:
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())

2
src/libANGLE/renderer/vulkan/vk_format_table_autogen.cpp
View File

@@ -5,7 +5,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// vk_format_table:
// vk_format_table_autogen.cpp:
// Queries for full Vulkan format information based on GL format.
#include "libANGLE/renderer/vulkan/vk_format_utils.h"

2
src/libANGLE/renderer/vulkan/vk_mandatory_format_support_table_autogen.cpp
View File

@@ -7,7 +7,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// vk_mandatory_format_support_table:
// vk_mandatory_format_support_table_autogen.cpp:
// Queries for full Vulkan mandatory format support information based on VK format.
#include "libANGLE/renderer/vulkan/vk_format_utils.h"

2
src/libGLESv2.gni
View File

@@ -464,7 +464,7 @@ libangle_d3d11_sources = [
"src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp",
"src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h",
"src/libANGLE/renderer/d3d/d3d11/dxgi_format_map_autogen.cpp",
"src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.cpp",
"src/libANGLE/renderer/d3d/d3d11/dxgi_support_table_autogen.cpp",
"src/libANGLE/renderer/d3d/d3d11/dxgi_support_table.h",
"src/libANGLE/renderer/d3d/d3d11/Fence11.cpp",
"src/libANGLE/renderer/d3d/d3d11/Fence11.h",

66
src/libGLESv2/gen_proc_table.py
View File

@@ -5,6 +5,7 @@
#
# gen_proc_table.py:
# Code generation for entry point loading tables.
# NOTE: don't run this script directly. Run scripts/run_code_generation.py.
# TODO(jmadill): Should be part of entry point generation.
@@ -55,30 +56,51 @@ size_t g_numProcs = {num_procs};
sys.path.append('../libANGLE/renderer')
import angle_format
json_data = angle_format.load_json(data_source_name)
def main():
all_functions = {}
# auto_script parameters.
if len(sys.argv) > 1:
inputs = [data_source_name]
outputs = [out_file_name]
for description, functions in json_data.iteritems():
for function in functions:
if function.startswith("gl"):
all_functions[function] = "gl::" + function[2:]
# Special handling for EGL_ANGLE_explicit_context extension
if support_egl_ANGLE_explicit_context:
all_functions[function + "ContextANGLE"] = "gl::" + function[2:] + "ContextANGLE"
elif function.startswith("egl"):
all_functions[function] = "EGL_" + function[3:]
if sys.argv[1] == 'inputs':
print ','.join(inputs)
elif sys.argv[1] == 'outputs':
print ','.join(outputs)
else:
all_functions[function] = function
print('Invalid script parameters')
return 1
return 0
proc_data = [(' {"%s", P(%s)}' % (func, angle_func)) for func, angle_func in sorted(all_functions.iteritems())]
json_data = angle_format.load_json(data_source_name)
with open(out_file_name, 'wb') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = data_source_name,
copyright_year = date.today().year,
proc_data = ",\n".join(proc_data),
num_procs = len(proc_data))
out_file.write(output_cpp)
out_file.close()
all_functions = {}
for description, functions in json_data.iteritems():
for function in functions:
if function.startswith("gl"):
all_functions[function] = "gl::" + function[2:]
# Special handling for EGL_ANGLE_explicit_context extension
if support_egl_ANGLE_explicit_context:
all_functions[function + "ContextANGLE"] = "gl::" + function[2:] + "ContextANGLE"
elif function.startswith("egl"):
all_functions[function] = "EGL_" + function[3:]
else:
all_functions[function] = function
proc_data = [(' {"%s", P(%s)}' % (func, angle_func)) for func, angle_func in sorted(all_functions.iteritems())]
with open(out_file_name, 'w') as out_file:
output_cpp = template_cpp.format(
script_name = sys.argv[0],
data_source_name = data_source_name,
copyright_year = date.today().year,
proc_data = ",\n".join(proc_data),
num_procs = len(proc_data))
out_file.write(output_cpp)
out_file.close()
return 0
if __name__ == '__main__':
sys.exit(main())