| import argparse |
| import glob |
| import io |
| import os |
| import re |
| import sys |
| from collections import defaultdict |
| |
| parser = argparse.ArgumentParser(description=""" |
| Process a batch of .glsl files. Minify and export them to C++ strings. |
| |
| Performs the following transformations: |
| * Strip comments. |
| * Strip whitespace. |
| * Strip unused #defines. |
| * Rename stpq and rgba swizzles to xyzw. |
| * Rename variables. |
| - No new name begins with the '_' character, so internal code can begin names with '_' |
| without fear of renaming collisions. |
| - GLSL keywords and builtins are not renamed. |
| - Tokens beginning with '@' have their new name exported to a header file. |
| - Tokens beginning with '$' are not renamed, with the exception of removing the leading '$'. |
| |
| "file.glsl" gets exported to: |
| * "outdir/file.exports.h", with #defines for the rewritten names of each identifier that began |
| with '@' in the original shader. |
| * "outdir/file.glsl.cpp", with a global `const char file_glsl[]` in the rive::glsl |
| namespace that contains the minified shader code. This variable is intentionally declared as a |
| global in order to generate a link error if the user includes the string more than once in |
| the build process. |
| * "outdir/file.minified.glsl" for offline compiling, with all variables renamed except for |
| exported #defines names (since the offline compiling process will set those defines). |
| """) |
| parser.add_argument("files", type=str, nargs="+", help="a list of glsl files") |
| parser.add_argument("-o", "--outdir", required=True, |
| help="OUTPUT directory to store the header files") |
| parser.add_argument("-H", "--human-readable", action='store_true', |
| help="don't rename or strip out comments or whitespace") |
| parser.add_argument("-p", "--ply-path", type=str, help="path to ply module") |
| parser.add_argument("-m", "--msvc", action="store_true", help="set this to generate MSVC-compatible headers") |
| |
| args = parser.parse_args() |
| |
| if args.ply_path: |
| # --ply-path was specified, so add it to the sys path so we can locate the module. |
| # (if it was not specified we'll assume that it's already reachable via the path) |
| |
| # Convert posix path to windows |
| convertedPath = args.ply_path |
| if sys.platform.startswith('win32') and args.ply_path[:2] == '/c': |
| convertedPath = 'C:\\' + args.ply_path[2:] |
| print('Using ply path:' + convertedPath) |
| |
| sys.path.append(convertedPath) |
| |
| import ply.lex as lex |
| |
| # tokens used by PLY to run lexical analysis on our glsl files. |
| tokens = [ |
| "DEFINE", |
| "IFDEF", |
| "DEFINED_ID", |
| "TOKEN_PASTE", |
| "DIRECTIVE", |
| "LINE_COMMENT", |
| "BLOCK_COMMENT", |
| "WHITESPACE", |
| "OP", |
| "FLOAT", |
| "HEX", |
| "INT", |
| "ID", |
| "UNKNOWN", |
| ] |
| |
| # tracks which exported identifiers (identifiers whose @name begins with '@') are used as switches |
| # inside an #ifdef, #if defined(), etc. |
| exported_switches = set() |
| |
| # counts the number of times each ID is seen, to prioritize which IDs get the shortest names |
| all_id_counts = defaultdict(int); |
| all_id_reference_counts = defaultdict(int); |
| def parse_id(name, exports, *, is_reference): |
| all_id_counts[name] += 1 |
| if is_reference: |
| all_id_reference_counts[name] += 1 |
| # identifiers that begin with '@' get exported to C++ through #defines. |
| if name[0] == '@': |
| exports.add(name) |
| |
| # lexing functions used by PLY. |
| def t_DEFINE(tok): |
| r"\#[ \t]*define[ \t]+(?P<id>[\@\$]?[A-Za-z_][A-Za-z0-9_]*)(?P<arglist>\((\n|[^\)])*\))?(?P<val>(((\\\n|.)(?!\/[\/\*]))*))?" |
| tok.define_id = re.match(t_DEFINE.__doc__, tok.value)['id'] |
| arglist = re.match(t_DEFINE.__doc__, tok.value)['arglist'] |
| tok.define_arglist = Minifier(arglist, "", tok.lexer.exports) if arglist else None |
| val = re.match(t_DEFINE.__doc__, tok.value)['val'] |
| tok.define_val = Minifier(val, "", tok.lexer.exports) if val else None |
| parse_id(tok.define_id, tok.lexer.exports, is_reference=False) |
| tok.lexer.lineno += tok.value.count('\n') |
| return tok |
| |
| def t_IFDEF(tok): |
| r"\#[ \t]*(?P<tag>ifn?def)[ \t]+(?P<ifdef_id>[\@\$]?[A-Za-z_][A-Za-z0-9_]*)" |
| tok.ifdef_tag = re.match(t_IFDEF.__doc__, tok.value)['tag'] |
| tok.ifdef_id = re.match(t_IFDEF.__doc__, tok.value)['ifdef_id'] |
| if tok.ifdef_id[0] == '@': |
| exported_switches.add(tok.ifdef_id) |
| parse_id(tok.ifdef_id, tok.lexer.exports, is_reference=True) |
| return tok |
| |
| def t_DEFINED_ID(tok): |
| r"defined\((?P<defined_id>[\@\$]?[A-Za-z_][A-Za-z0-9_]*)\)" |
| tok.defined_id = re.match(t_DEFINED_ID.__doc__, tok.value)['defined_id'] |
| if tok.defined_id[0] == '@': |
| exported_switches.add(tok.defined_id) |
| parse_id(tok.defined_id, tok.lexer.exports, is_reference=True) |
| return tok |
| |
| def t_TOKEN_PASTE(tok): |
| r"\#\#" |
| return tok |
| |
| def t_DIRECTIVE(tok): |
| r"\#[ \t]*(?P<val>(((\\\n|.)(?!\/[\/\*]))*))" |
| val = re.match(t_DIRECTIVE.__doc__, tok.value)['val'] |
| tok.directive_val = Minifier(val, "", tok.lexer.exports) if val else None |
| tok.lexer.lineno += tok.value.count('\n') |
| return tok |
| |
| def t_LINE_COMMENT(tok): |
| r"//(\\\n|.)*" |
| tok.lexer.lineno += tok.value.count('\n') |
| return tok |
| |
| def t_BLOCK_COMMENT(tok): |
| r"\/\*(\*(?!\/)|[^*])*\*\/" |
| tok.lexer.lineno += tok.value.count('\n') |
| return tok |
| |
| def t_WHITESPACE(tok): |
| r"(\s|\\\r?\n)+" |
| tok.lexer.lineno += tok.value.count('\n') |
| return tok |
| |
| def t_OP(tok): |
| r"[~!%^&\*\(\)\-=+\/\[\]{}\?:\<\>\.\,|;]" |
| return tok |
| |
| def t_FLOAT(tok): |
| r"([0-9]*\.[0-9]+|[0-9]+\.)([eE][+\-]?[0-9]+)?|([0-9]+[eE][+\-]?[0-9]+)" |
| return tok |
| |
| def t_HEX(tok): |
| r"0x[0-9a-fA-F]+u?" |
| return tok |
| |
| def t_INT(tok): |
| r"[0-9]+u?" |
| return tok |
| |
| def t_ID(tok): |
| r"[\@\$]?[A-Za-z_][A-Za-z0-9_]*" |
| parse_id(tok.value, tok.lexer.exports, is_reference=True) |
| return tok |
| |
| def t_UNKNOWN(tok): |
| r"." |
| return tok |
| |
| def t_error(tok): |
| raise Exception("Illegal character '%s' at line %d" % (tok.value[0], tok.lexer.lineno)) |
| |
| # identifier names that cannot be renamed |
| glsl_reserved = { |
| 'EmitStreamVertex', 'EmitVertex', 'EndPrimitive', 'EndStreamPrimitive', |
| '__VERSION__', '__pixel_localEXT', '__pixel_local_inEXT', |
| '__pixel_local_outEXT', 'abs', 'acos', 'acosh', 'all', 'allInvocations', |
| 'allInvocationsEqual', 'any', 'anyInvocation', 'asin', 'asinh', 'atan', |
| 'atanh', 'atomicAdd', 'atomicAnd', 'atomicCompSwap', 'atomicCounter', |
| 'atomicCounterAdd', 'atomicCounterAnd', 'atomicCounterCompSwap', |
| 'atomicCounterDecrement', 'atomicCounterExchange', 'atomicCounterIncrement', |
| 'atomicCounterMax', 'atomicCounterMin', 'atomicCounterOr', |
| 'atomicCounterSubtract', 'atomicCounterXor', 'atomicExchange', 'atomicMax', |
| 'atomicMin', 'atomicOr', 'atomicXor', 'barrier', |
| 'beginFragmentShaderOrderingINTEL', 'beginInvocationInterlockARB', |
| 'beginInvocationInterlockNV', 'binding', 'bitCount', 'bitfieldExtract', |
| 'bitfieldInsert', 'bitfieldReverse', 'blend_support_all_equations', |
| 'blend_support_colorburn', 'blend_support_colordodge', |
| 'blend_support_darken', 'blend_support_difference', |
| 'blend_support_exclusion', 'blend_support_hardlight', |
| 'blend_support_lighten', 'blend_support_multiply', 'blend_support_overlay', |
| 'blend_support_screen', 'blend_support_softlight', 'bool', 'break', |
| 'buffer', 'bvec2', 'bvec3', 'bvec4', 'case', 'ceil', 'centroid', 'clamp', |
| 'coherent', 'const', 'constant_id', 'continue', 'cos', 'cosh', 'cross', |
| 'dFdx', 'dFdxCoarse', 'dFdxFine', 'dFdy', 'dFdyCoarse', 'dFdyFine', |
| 'default', 'defined', 'degrees', 'determinant', 'discard', 'distance', 'do', |
| 'dot', 'elif', 'else', 'enable', 'endInvocationInterlockARB', |
| 'endInvocationInterlockNV', 'endif', 'equal', 'exp', 'exp2', 'extension', |
| 'faceforward', 'false', 'findLSB', 'findMSB', 'flat', 'float', |
| 'floatBitsToInt', 'floatBitsToUint', 'floor', 'fma', 'for', 'fract', |
| 'frexp', 'ftransform', 'fwidth', 'fwidthCoarse', 'fwidthFine', |
| 'greaterThan', 'greaterThanEqual', 'groupMemoryBarrier', 'highp', 'if', |
| 'iimage2D', 'image2D', 'imageAtomicAdd', 'imageAtomicAnd', |
| 'imageAtomicCompSwap', 'imageAtomicExchange', 'imageAtomicMax', |
| 'imageAtomicMin', 'imageAtomicOr', 'imageAtomicXor', 'imageLoad', |
| 'imageSamples', 'imageSize', 'imageStore', 'imulExtended', 'in', 'inout', |
| 'input_attachment_index', 'int', 'intBitsToFloat', 'interpolateAtCentroid', |
| 'interpolateAtOffset', 'interpolateAtSample', 'invariant', 'inverse', |
| 'inversesqrt', 'isampler2D', 'isampler2DArray', 'isampler3D', |
| 'isamplerCube', 'isinf', 'isnan', 'ivec2', 'ivec3', 'ivec4', 'layout', |
| 'ldexp', 'length', 'lessThan', 'lessThanEqual', 'location', 'log', 'log2', |
| 'lowp', 'main', 'mat2', 'mat2x2', 'mat2x3', 'mat2x4', 'mat3', 'mat3x2', |
| 'mat3x3', 'mat3x4', 'mat4', 'mat4x2', 'mat4x3', 'mat4x4', 'matrixCompMult', |
| 'max', 'mediump', 'memoryBarrier', 'memoryBarrierAtomicCounter', |
| 'memoryBarrierBuffer', 'memoryBarrierImage', 'memoryBarrierShared', 'min', |
| 'mix', 'mod', 'modf', 'noise1', 'noise2', 'noise3', 'noise4', |
| 'noperspective', 'normalize', 'not', 'notEqual', 'out', 'outerProduct', |
| 'packDouble2x32', 'packHalf2x16', 'packSnorm2x16', 'packSnorm4x8', |
| 'packUnorm2x16', 'packUnorm4x8', 'pixelLocalLoadANGLE', |
| 'pixelLocalStoreANGLE', 'pow', 'pragma', 'precision', 'push_constant', |
| 'r16f', 'r32f', 'r32i', 'r32ui', 'radians', 'readonly', 'reflect', |
| 'refract', 'require', 'return', 'rg16f', 'rgb10_a2', 'rgb_2_yuv', 'rgba8', |
| 'rgba8i', 'rgba8ui', 'round', 'roundEven', 'sampler', 'sampler2D', |
| 'sampler2DArray', 'sampler2DArrayShadow', 'sampler2DShadow', 'sampler3D', |
| 'samplerCube', 'samplerCubeShadow', 'set', 'shadow1D', 'shadow1DLod', |
| 'shadow1DProj', 'shadow1DProjLod', 'shadow2D', 'shadow2DEXT', 'shadow2DLod', |
| 'shadow2DProj', 'shadow2DProjEXT', 'shadow2DProjLod', 'sign', 'sin', 'sinh', |
| 'smooth', 'smoothstep', 'sqrt', 'std140', 'std430', 'step', 'struct', |
| 'subpassInput', 'subpassInputMS', 'subpassLoad', 'switch', 'tan', 'tanh', |
| 'texelFetch', 'texelFetchOffset', 'texture', 'texture1D', 'texture1DLod', |
| 'texture1DProj', 'texture1DProjLod', 'texture2D', 'texture2DGradEXT', |
| 'texture2DLod', 'texture2DLodEXT', 'texture2DProj', 'texture2DProjGradEXT', |
| 'texture2DProjLod', 'texture2DProjLodEXT', 'texture2DRect', |
| 'texture2DRectProj', 'texture3D', 'texture3DLod', 'texture3DProj', |
| 'texture3DProjLod', 'textureCube', 'textureCubeGradEXT', 'textureCubeLod', |
| 'textureCubeLodEXT', 'textureGather', 'textureGatherOffset', |
| 'textureGatherOffsets', 'textureGrad', 'textureGradOffset', 'textureLod', |
| 'textureLodOffset', 'textureOffset', 'textureProj', 'textureProjGrad', |
| 'textureProjGradOffset', 'textureProjLod', 'textureProjLodOffset', |
| 'textureProjOffset', 'textureQueryLevels', 'textureQueryLod', |
| 'textureSamples', 'textureSize', 'textureVideoWEBGL', 'transpose', 'true', |
| 'trunc', 'uaddCarry', 'uimage2D', 'uint', 'uintBitsToFloat', 'umulExtended', |
| 'undef', 'uniform', 'unpackDouble2x32', 'unpackHalf2x16', 'unpackSnorm2x16', |
| 'unpackSnorm4x8', 'unpackUnorm2x16', 'unpackUnorm4x8', 'usampler2D', |
| 'usampler2DArray', 'usampler3D', 'usamplerCube', 'usubBorrow', |
| 'usubpassInput', 'utexture2D', 'uvec2', 'uvec3', 'uvec4', 'vec2', 'vec3', |
| 'vec4', 'void', 'volatile', 'while', 'yuv_2_rgb' |
| } |
| |
| # rgba and stpq get rewritten to xyzw, so we only need to check xyzw here. This way we can keep |
| # renaming to names like, e.g., "rg". |
| xyzw_pattern = re.compile(r"^[xyzw]{1,4}$") |
| |
| # HLSL registers base names can't be overwritten by macro arguments if token pasting (e.g. t##IDX). |
| hlsl_register_base_names = ['t', 's', 'u', 'b'] |
| |
| # HLSL registers (e.g., t0, u1) can't be overwritten by a #define. |
| hlsl_register_pattern = re.compile(r"^[tsub]\d+$") |
| |
| # can we rename to or from 'name'? |
| def is_reserved_keyword(name): |
| return name in glsl_reserved\ |
| or xyzw_pattern.match(name)\ |
| or name in hlsl_register_base_names\ |
| or hlsl_register_pattern.match(name)\ |
| or name.startswith("$")\ |
| or name.startswith("gl_")\ |
| or name.startswith("GL_")\ |
| or name.startswith("__pixel_local")\ |
| or name.endswith("ANGLE") |
| |
| def remove_leading_annotation(name): |
| if name[0] == '@': |
| # A leading '@' indicates identifier names that should be exported. Rename '@my_var' to |
| # '_EXPORTED_my_var' to enforce that '@my_var' and 'my_var' are not interchangeable. |
| return 'EXPORTED_' + name[1:] |
| if name[0] == '$': |
| # A leading '$' indicates identifier names that should not be renamed. |
| return name[1:] |
| return name |
| |
| # Generates new identifier names to rewrite our variables. |
| class NameGenerator: |
| def __init__(self, first_letter_chars, additional_letter_chars): |
| self.first_letter_chars = first_letter_chars |
| self.additional_letter_chars = additional_letter_chars |
| self.name_index = 0 |
| |
| def next_name(self): |
| i = self.name_index |
| # Generate the first character from 'self.first_letter_chars' |
| name = self.first_letter_chars[i % len(self.first_letter_chars)] |
| i = i // len(self.first_letter_chars) |
| while i > 0: |
| # Generate the remaining characters from 'self.additional_letter_chars' |
| name += self.additional_letter_chars[i % len(self.additional_letter_chars)] |
| i = i // len(self.additional_letter_chars) |
| self.name_index = self.name_index + 1 |
| return name |
| |
| # Exported variables only use upper case letters in their names. HLSL semantics are not case |
| # sensitive and may also assign special meaning to numbers. |
| upper_case_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| upper_case_name_generator = NameGenerator(upper_case_chars, upper_case_chars + "_") |
| |
| # Don't begin new names with the the '_' character. Internal code can begin names with '_' without |
| # fear of renaming collisions. |
| lower_and_upper_chars = "abcdefghijklmnopqrstuvwxyz" + upper_case_chars |
| general_name_generator = NameGenerator(lower_and_upper_chars, "_0123456789" + lower_and_upper_chars) |
| |
| used_new_names = set() |
| |
| def generate_new_name(*, force_upper_case): |
| name_generator = upper_case_name_generator if force_upper_case else general_name_generator |
| while True: |
| name = name_generator.next_name() |
| if not is_reserved_keyword(name) and not name in used_new_names: |
| used_new_names.add(name) |
| return name |
| |
| # mapping from original identifiers to new names. |
| new_names = {} |
| def generate_new_names(): |
| for name,count in sorted(all_id_counts.items(), key=lambda x:x[1], reverse=True): |
| new_name = (remove_leading_annotation(name) |
| if args.human_readable or is_reserved_keyword(name) |
| # HLSL semantics are not case sensitive and can assign special meaning to |
| # numbers. Make all exported names upper case with no numbers. |
| else generate_new_name(force_upper_case=name[0] == '@')) |
| new_names[name] = new_name |
| |
| # used to rewrite rgba and stpq swizzles to xyzw. |
| rgba_stpq_pattern = re.compile(r"^([rgba]{1,4}|[stpq]{1,4})$") |
| rgba_stpq_remap = {'r':'x', 'g':'y', 'b':'z', 'a':'w', |
| 's':'x', 't':'y', 'p':'z', 'q':'w',} |
| |
| |
| # minifies a single GLSL file. |
| class Minifier: |
| def __init__(self, code, basename, exports=set()): |
| # parse tokens. |
| lexer = lex.lex() |
| lexer.exports = exports |
| lexer.input(code) |
| self.tokens = [tok for tok in lexer]; |
| self.exports = exports |
| self.basename = basename |
| |
| |
| # Strips unneeded code from the tokens. Called after all Minifiers have been parsed. |
| def strip_tokens(self): |
| assert(not args.human_readable) |
| |
| # strip comments. |
| self.tokens = \ |
| [tok for tok in self.tokens if "COMMENT" not in tok.type] |
| |
| # strip unused defines. |
| self.tokens = [tok for tok in self.tokens if tok.type != "DEFINE"\ |
| or all_id_reference_counts[tok.define_id] > 0] |
| |
| # merge whitespace. |
| unmerged,self.tokens = self.tokens,[] |
| for tok in unmerged: |
| if tok.type == "DEFINE": |
| if tok.define_arglist != None: |
| tok.define_arglist.strip_tokens() |
| if tok.define_val != None: |
| tok.define_val.strip_tokens() |
| if tok.type == "DIRECTIVE": |
| if tok.directive_val != None: |
| tok.directive_val.strip_tokens() |
| if (tok.type == "WHITESPACE" |
| and len(self.tokens) > 0 |
| and self.tokens[-1].type == "WHITESPACE"): |
| self.tokens[-1].value += tok.value |
| else: |
| self.tokens.append(tok) |
| |
| |
| # generates rewritten glsl from our tokens. |
| def emit_tokens_to_rewritten_glsl(self, out, *, preserve_exported_switches, calling_token_type:str=None): |
| # stand-in for a null token. |
| lasttoken = lambda : None |
| lasttoken.type = "" |
| lasttoken.value = "" |
| |
| lasttoken_needs_whitespace = False |
| is_newline = True |
| |
| for tok in self.tokens: |
| if tok.type == "WHITESPACE": |
| if args.human_readable: |
| out.write(tok.value) |
| is_newline = tok.value[-1] == '\n' |
| lasttoken_needs_whitespace = False |
| continue |
| |
| is_directive = tok.type in ["DEFINE", "IFDEF", "DIRECTIVE"] |
| needs_whitespace = tok.type in ["FLOAT", "INT", "HEX", "ID", "DEFINED_ID"] |
| # Adding this calling_token_type != 'DEFINE' prevents us from adding a new line to stringify macros |
| if is_directive and not is_newline and calling_token_type != 'DEFINE': |
| out.write('\n') |
| elif needs_whitespace and lasttoken_needs_whitespace: |
| out.write(' ') |
| |
| # is_newline will be false once we output the token (unless this value otherwise gets |
| # updated). |
| is_newline = False |
| |
| if tok.type == "ID": |
| if (rgba_stpq_pattern.match(tok.value) |
| and lasttoken.type == "OP" |
| and lasttoken.value == "."): |
| # convert rgba and stpq to xyzw. |
| out.write(''.join([rgba_stpq_remap[ch] for ch in tok.value])) |
| else: |
| self.write_identifier(out, tok.value, preserve_exported_switches) |
| |
| elif tok.type == "DEFINE": |
| out.write("#define ") |
| self.write_identifier(out, tok.define_id, preserve_exported_switches) |
| if tok.define_arglist != None: |
| is_newline = tok.define_arglist.emit_tokens_to_rewritten_glsl(\ |
| out,\ |
| preserve_exported_switches=preserve_exported_switches,\ |
| calling_token_type=tok.type) |
| assert(not is_newline) |
| if tok.define_val != None: |
| out.write(' ') |
| is_newline = tok.define_val.emit_tokens_to_rewritten_glsl(\ |
| out,\ |
| preserve_exported_switches=preserve_exported_switches,\ |
| calling_token_type=tok.type) |
| |
| elif tok.type == "IFDEF": |
| out.write('#') |
| out.write(tok.ifdef_tag) |
| out.write(' ') |
| self.write_identifier(out, tok.ifdef_id, preserve_exported_switches) |
| |
| elif tok.type == "DEFINED_ID": |
| out.write('defined(') |
| self.write_identifier(out, tok.defined_id, preserve_exported_switches) |
| out.write(')') |
| |
| elif tok.type == "DIRECTIVE": |
| out.write("#") |
| if tok.directive_val != None: |
| is_newline = tok.directive_val.emit_tokens_to_rewritten_glsl(\ |
| out,\ |
| preserve_exported_switches=preserve_exported_switches,\ |
| calling_token_type=tok.type) |
| |
| else: |
| out.write(tok.value) |
| |
| # Since we preserve whitespace in 'human_readable' mode, the newline after a |
| # preprocessor directive will happen for us automatically unless 'human_readable' is |
| # false. |
| if not args.human_readable and is_directive and not is_newline: |
| out.write('\n') |
| is_newline = True |
| |
| lasttoken = tok |
| lasttoken_needs_whitespace = needs_whitespace |
| |
| return is_newline |
| |
| |
| def write_identifier(self, out, identifier, preserve_exported_switches): |
| if preserve_exported_switches and identifier in exported_switches: |
| assert(identifier[0] == '@') |
| out.write(identifier[1:]) |
| else: |
| out.write(new_names[identifier]) |
| |
| |
| def write_exports(self, outdir): |
| output_path = os.path.join(outdir, f"{self.basename}.exports.h") |
| print(f"Exporting {output_path} <- {self.basename}") |
| out = open(output_path, "w", newline='\n') |
| out.write('#pragma once\n\n') |
| for exp in sorted(self.exports): |
| out.write('#define GLSL_%s "%s"\n' % (exp[1:], new_names[exp])) |
| out.write('#define GLSL_%s_raw %s\n' % (exp[1:], new_names[exp])) |
| out.close() |
| |
| |
| def write_embedded_glsl(self, outdir): |
| output_path = os.path.join(outdir, self.basename + ".hpp") |
| print("Embedding %s <- %s" % (output_path, self.basename)) |
| out = open(output_path, "w", newline='\n') |
| out.write("#pragma once\n\n") |
| |
| out.write(f'#include "{self.basename}.exports.h"\n\n') |
| |
| # emit shader code. |
| root, ext = os.path.splitext(self.basename) |
| cpp_name = root |
| if ext != '.glsl': |
| cpp_name = f"{root}_{ext[1:]}" |
| out.write("namespace rive {\n") |
| out.write("namespace gpu {\n") |
| out.write("namespace glsl {\n") |
| if args.msvc: |
| # MSVC cannot compile raw shaders as strings because of an internal |
| # string length limit. There is, however, no limit on arrays so |
| # instead write it out as an array of individual characters. |
| out.write(f'const char {cpp_name}[] = {{\n ') |
| |
| codeIO = io.StringIO() |
| self.emit_tokens_to_rewritten_glsl(codeIO, preserve_exported_switches=False) |
| |
| out_ch_count = 0 |
| for ch in codeIO.getvalue(): |
| # use `repr` to escape the characters (but we need to handle single |
| # quote manually, since it will represent that as "'" - which will |
| # definitely not compile) |
| |
| out.write(f" {repr(ch)},") if ch != "'" else out.write(" '\\'',") |
| out_ch_count = out_ch_count + 1 |
| CHAR_COUNT_PER_LINE = 12 |
| if (out_ch_count % CHAR_COUNT_PER_LINE) == 0: |
| out.write('\n ') |
| # Null-terminate so the array is a valid C-string when passed to |
| # APIs like ostream::operator<<(const char*), which read until '\0'. |
| out.write(" '\\0'\n};\n") |
| else: |
| # For non-MSVC outputs just output as a raw string |
| out.write(f'const char {cpp_name}[] = R"===(') |
| |
| is_newline = self.emit_tokens_to_rewritten_glsl(out, preserve_exported_switches=False) |
| if not is_newline: |
| out.write('\n') |
| |
| out.write(')===";\n') |
| out.write("} // namespace glsl\n") |
| out.write("} // namespace gpu\n") |
| out.write("} // namespace rive") |
| out.close() |
| |
| def write_offline_glsl(self, outdir): |
| root, ext = os.path.splitext(self.basename) |
| output_path = os.path.join(outdir, f"{root}.minified{ext}") |
| print(f"Minifying f{output_path} <- {self.basename}") |
| out = open(output_path, "w", newline='\n') |
| self.emit_tokens_to_rewritten_glsl(out, preserve_exported_switches=True) |
| out.close() |
| |
| |
| # parse all GLSL files before renaming. This keeps the renaming consistent across files. |
| minifiers = [Minifier(open(f).read(), os.path.basename(f)) for f in args.files] |
| generate_new_names() |
| |
| # minify all GLSL files. |
| if not os.path.exists(args.outdir): |
| os.makedirs(args.outdir) |
| for m in minifiers: |
| if not args.human_readable: |
| m.strip_tokens() |
| m.write_exports(args.outdir) |
| m.write_embedded_glsl(args.outdir) |
| m.write_offline_glsl(args.outdir) |
