CTCaer/RetroArch
1
0
Fork 0
mirror of https://github.com/CTCaer/RetroArch.git synced 2024-12-21 02:08:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
1cf45d785f
RetroArch/tools/cg2glsl.py
Johannes Schickel 3a658172f8 (tools/cg2glsl.py) Write uniform declarations for fragment shaders. 
Formerly, the fragment shader conversion pass did not write required uniform
declarations. This resulted in use of undefined symbols in some cases. In turn
conversion of some shaders to GLSL were broken.

This fixes conversion of some shaders, most prominently the hq shaders.
2016-03-05 12:49:21 +01:00

755 lines
26 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python3
"""
Python 3 script which converts simple RetroArch Cg shaders to modern GLSL (ES) format.
Author: Hans-Kristian Arntzen (Themaister)
License: Public domain
"""
import os
import errno
import subprocess
import sys
if sys.version_info < (3, 0, 0):
sys.stderr.write("You need python 3.0 or later to run this script\n")
exit(1)
batch_mode = False
def log(*arg):
if not batch_mode:
# FIXME: This causes a syntax error in python2, preventing the version warning from displaying.
print(*arg)
def keep_line_if(func, lines):
ret = []
for line in filter(func, lines):
ret.append(line)
return ret
def remove_comments(source_lines):
lines_without_comments = [line.split('//')[0] for line in source_lines]
return keep_line_if(lambda line: line, lines_without_comments)
def defines_var(line):
return ('//var' in line) or ('#var' in line)
def replace_by_table(source, table):
for orig, new in table:
if orig:
source = source.replace(orig, new)
return source
def replace_global_in(source):
replace_table = [
('IN.video_size', 'InputSize'),
('IN.texture_size', 'TextureSize'),
('IN.output_size', 'OutputSize'),
('IN.frame_count', 'FrameCount'),
('IN.frame_direction', 'FrameDirection'),
]
for line in source.splitlines():
if defines_var(line):
for index, replace in enumerate(replace_table):
orig = line.split()[2]
if replace[0] == orig:
replace_table[index] = (line.split(':')[2].split(' ')[1], replace_table[index][1])
log('Replace globals:', replace_table)
return replace_by_table(source, replace_table)
def replace_global_vertex(source):
source = replace_global_in(source)
replace_table = [
('attribute', 'COMPAT_ATTRIBUTE'),
('varying', 'COMPAT_VARYING'),
('texture2D', 'COMPAT_TEXTURE'),
('POSITION', 'VertexCoord'),
('TEXCOORD1', 'LUTTexCoord'),
('TEXCOORD0', 'TexCoord'),
('TEXCOORD', 'TexCoord'),
('uniform vec4 _modelViewProj1[4];', ''),
('_modelViewProj1', 'MVPMatrix'),
('_IN1._mvp_matrix[0]', 'MVPMatrix[0]'),
('_IN1._mvp_matrix[1]', 'MVPMatrix[1]'),
('_IN1._mvp_matrix[2]', 'MVPMatrix[2]'),
('_IN1._mvp_matrix[3]', 'MVPMatrix[3]'),
('FrameCount', 'float(FrameCount)'),
('FrameDirection', 'float(FrameDirection)'),
('input', 'input_dummy'), # 'input' is reserved in GLSL.
('output', 'output_dummy'), # 'output' is reserved in GLSL.
]
return replace_by_table(source, replace_table)
def translate_varyings(varyings, source, direction):
dictionary = {}
for varying in varyings:
for line in source:
if defines_var(line) and (varying in line) and (direction in line):
log('Found line for', varying + ':', line)
dictionary[varying] = 'VAR' + line.split(':')[0].split('.')[-1].strip()
break
return dictionary
def no_uniform(elem):
banned = [
'_video_size',
'_texture_size',
'_output_size',
'_output_dummy_size',
'_frame_count',
'_frame_direction',
'_mvp_matrix',
'_vertex_coord',
'sampler2D'
]
for ban in banned:
if ban in elem:
return False
return True
def destructify_varyings(source, direction):
# We have to change varying structs that Cg support to single varyings for GL.
# Varying structs aren't supported until later versions
# of GLSL.
# Global structs are sometimes used to store temporary data.
# Don't try to remove this as it breaks compile.
vout_lines = []
for line in source:
if defines_var(line) and (('$vout.' in line) or ('$vin.' in line)):
vout_lines.append(line)
struct_types = []
for line in source[1:]:
if 'struct' in line:
struct_type = line.split()[1]
if struct_type not in struct_types:
struct_types.append(struct_type)
log('Struct types:', struct_types)
last_struct_decl_line = 0
varyings = []
varyings_name = []
# Find all varyings in structs and make them "global" varyings.
for struct in struct_types:
for i, line in enumerate(source):
if ('struct ' + struct) in line:
j = i + 1
while (j < len(source)) and ('};' not in source[j]):
j += 1
lines = ['COMPAT_VARYING ' + string for string in source[(i + 1):j]]
varyings.extend(lines)
names = [string.split()[1].split(';')[0].strip() for string in source[(i + 1):j]]
varyings_name.extend(names)
log('Found elements in struct', struct + ':', names)
last_struct_decl_line = j
# Must have explicit uniform sampler2D in struct.
for index in range(i, j + 1):
if 'sampler2D' in source[index]:
source[index] = 'float _placeholder{};'.format(index)
varyings_tmp = varyings
varyings = []
variables = []
# Don't include useless varyings like IN.video_size, IN.texture_size, etc as they are not actual varyings ...
for i in filter(no_uniform, varyings_tmp):
varyings.append(i)
# Find any global variable struct that is supposed to be the output varying, and redirect all references to it to
# the actual varyings we just declared ...
# Globals only come before main() ...
# Make sure to only look after all struct declarations as there might be overlap.
for line in remove_comments(source[last_struct_decl_line:]):
if 'void main()' in line:
break
for struct in struct_types:
if struct in line:
variable = line.split()[1].split(';')[0]
# Only redirect if the struct is actually used as vertex output.
for vout_line in vout_lines:
if variable in vout_line:
log('Found struct variable for', struct + ':', variable, 'in line:', line)
variables.append(variable)
break
varyings_dict = translate_varyings(varyings_name, source, direction)
log('Varyings dict:', varyings_dict)
# Append all varyings. Keep the structs as they might be used as regular values.
for varying in varyings:
source.insert(1, varying)
log('Variables:', variables)
log('Varying names:', varyings_name)
# Replace struct access with global access, e.g. (_co1._c00 => _c00)
# Also replace mangled Cg name with 'real' name.
for index, _ in enumerate(source):
for variable in variables:
for varying_name in varyings_dict:
trans_from = variable + '.' + varying_name
trans_to = varyings_dict[varying_name]
source[index] = source[index].replace(trans_from, trans_to)
for index, _ in enumerate(source):
for varying_name in varyings_name:
if varying_name in varyings_dict:
source[index] = source[index].replace(varying_name, varyings_dict[varying_name])
# Replace union <struct>. Sometimes we get collision in vertex and fragment.
for index, line in enumerate(source):
for struct_type in struct_types:
line = line.replace('uniform ' + struct_type, struct_type)
source[index] = line
return source
def translate(cg, translations):
if cg in translations:
return translations[cg]
else:
return cg
def translate_varying(cg):
translations = {
'IN.tex_coord': 'TexCoord',
'IN.vertex_coord': 'VertexCoord',
'IN.lut_tex_coord': 'LUTTexCoord',
'ORIG.tex_coord': 'OrigTexCoord',
'FEEDBACK.tex_coord': 'FeedbackTexCoord',
'PREV.tex_coord': 'PrevTexCoord',
'PREV1.tex_coord': 'Prev1TexCoord',
'PREV2.tex_coord': 'Prev2TexCoord',
'PREV3.tex_coord': 'Prev3TexCoord',
'PREV4.tex_coord': 'Prev4TexCoord',
'PREV5.tex_coord': 'Prev5TexCoord',
'PREV6.tex_coord': 'Prev6TexCoord',
'PASS1.tex_coord': 'Pass1TexCoord',
'PASS2.tex_coord': 'Pass2TexCoord',
'PASS3.tex_coord': 'Pass3TexCoord',
'PASS4.tex_coord': 'Pass4TexCoord',
'PASS5.tex_coord': 'Pass5TexCoord',
'PASS6.tex_coord': 'Pass6TexCoord',
'PASS7.tex_coord': 'Pass7TexCoord',
'PASS8.tex_coord': 'Pass8TexCoord',
'PASSPREV2.tex_coord': 'PassPrev2TexCoord',
'PASSPREV3.tex_coord': 'PassPrev3TexCoord',
'PASSPREV4.tex_coord': 'PassPrev4TexCoord',
'PASSPREV5.tex_coord': 'PassPrev5TexCoord',
'PASSPREV6.tex_coord': 'PassPrev6TexCoord',
'PASSPREV7.tex_coord': 'PassPrev7TexCoord',
'PASSPREV8.tex_coord': 'PassPrev8TexCoord',
}
return translate(cg, translations)
def translate_texture_size(cg):
translations = {
'ORIG.texture_size': 'OrigTextureSize',
'FEEDBACK.texture_size': 'FeedbackTextureSize',
'PREV.texture_size': 'PrevTextureSize',
'PREV1.texture_size': 'Prev1TextureSize',
'PREV2.texture_size': 'Prev2TextureSize',
'PREV3.texture_size': 'Prev3TextureSize',
'PREV4.texture_size': 'Prev4TextureSize',
'PREV5.texture_size': 'Prev5TextureSize',
'PREV6.texture_size': 'Prev6TextureSize',
'PASS1.texture_size': 'Pass1TextureSize',
'PASS2.texture_size': 'Pass2TextureSize',
'PASS3.texture_size': 'Pass3TextureSize',
'PASS4.texture_size': 'Pass4TextureSize',
'PASS5.texture_size': 'Pass5TextureSize',
'PASS6.texture_size': 'Pass6TextureSize',
'PASS7.texture_size': 'Pass7TextureSize',
'PASS8.texture_size': 'Pass8TextureSize',
'PASSPREV2.texture_size': 'PassPrev2TextureSize',
'PASSPREV3.texture_size': 'PassPrev3TextureSize',
'PASSPREV4.texture_size': 'PassPrev4TextureSize',
'PASSPREV5.texture_size': 'PassPrev5TextureSize',
'PASSPREV6.texture_size': 'PassPrev6TextureSize',
'PASSPREV7.texture_size': 'PassPrev7TextureSize',
'PASSPREV8.texture_size': 'PassPrev8TextureSize',
'ORIG.video_size': 'OrigInputSize',
'FEEDBACK.video_size': 'FeedbackInputSize',
'PREV.video_size': 'PrevInputSize',
'PREV1.video_size': 'Prev1InputSize',
'PREV2.video_size': 'Prev2InputSize',
'PREV3.video_size': 'Prev3InputSize',
'PREV4.video_size': 'Prev4InputSize',
'PREV5.video_size': 'Prev5InputSize',
'PREV6.video_size': 'Prev6InputSize',
'PASS1.video_size': 'Pass1InputSize',
'PASS2.video_size': 'Pass2InputSize',
'PASS3.video_size': 'Pass3InputSize',
'PASS4.video_size': 'Pass4InputSize',
'PASS5.video_size': 'Pass5InputSize',
'PASS6.video_size': 'Pass6InputSize',
'PASS7.video_size': 'Pass7InputSize',
'PASS8.video_size': 'Pass8InputSize',
'PASSPREV2.video_size': 'PassPrev2InputSize',
'PASSPREV3.video_size': 'PassPrev3InputSize',
'PASSPREV4.video_size': 'PassPrev4InputSize',
'PASSPREV5.video_size': 'PassPrev5InputSize',
'PASSPREV6.video_size': 'PassPrev6InputSize',
'PASSPREV7.video_size': 'PassPrev7InputSize',
'PASSPREV8.video_size': 'PassPrev8InputSize',
}
return translate(cg, translations)
def replace_varyings(source):
ret = []
translations = []
attribs = []
uniforms = []
for index, line in enumerate(source):
if defines_var(line):
func = translate_texture_size
collection = uniforms
if '$vin.' in line:
func = translate_varying
collection = attribs
orig = line.split()[2]
translated = func(orig)
if translated != orig and translated not in collection:
cg_var = line.split(':')[2].split(' ')[1]
if cg_var:
translations.append((cg_var, translated))
collection.append(translated)
for index, line in enumerate(source):
if 'void main()' in line:
for attrib in attribs:
if attrib == 'VertexCoord':
source.insert(index, 'COMPAT_ATTRIBUTE vec4 ' + attrib + ';')
else:
source.insert(index, 'COMPAT_ATTRIBUTE vec2 ' + attrib + ';')
for uniform in uniforms:
source.insert(index, 'uniform COMPAT_PRECISION vec2 ' + uniform + ';')
break
for line in source:
for trans in translations:
line = line.replace(trans[0], trans[1])
ret.append(line)
return ret
def fix_samplers(log_prefix, ref_index, source):
translations = []
added_samplers = []
translated_samplers = []
uniforms = []
struct_texunit0 = False # If True, we have to append uniform sampler2D Texture manually ...
for line in source:
if ('TEXUNIT0' in line) and ('semantic' not in line):
main_sampler = (line.split(':')[2].split(' ')[1], 'Texture')
if main_sampler[0]:
translations.append(main_sampler)
log(log_prefix, 'Sampler:', main_sampler[0], '->', main_sampler[1])
struct_texunit0 = '.' in main_sampler[0]
elif ('//var sampler2D' in line) or ('#var sampler2D' in line):
cg_texture = line.split()[2]
translated = translate_texture(cg_texture)
orig_name = translated
new_name = line.split(':')[2].split(' ')[1]
log(log_prefix, 'Sampler:', new_name, '->', orig_name)
if new_name:
if translated != cg_texture and translated not in translated_samplers:
translated_samplers.append(translated)
added_samplers.append('uniform sampler2D ' + translated + ';')
translations.append((new_name, orig_name))
elif defines_var(line):
orig = line.split()[2]
translated = translate_texture_size(orig)
if translated != orig and translated not in uniforms:
cg_uniform = line.split(':')[2].split(' ')[1]
if cg_uniform:
translations.append((cg_uniform, translated))
uniforms.append(translated)
for sampler in added_samplers:
source.insert(ref_index, sampler)
if struct_texunit0:
source.insert(ref_index, 'uniform sampler2D Texture;')
for uniform in uniforms:
source.insert(ref_index, 'uniform COMPAT_PRECISION vec2 ' + uniform + ';')
for index, line in enumerate(source):
for orig, new in translations:
log(log_prefix, 'Translation:', orig, '->', new)
source[index] = source[index].replace(orig, new)
return source
def hack_source_vertex(source):
ref_index = 0
for index, line in enumerate(source):
if 'void main()' in line:
source.insert(index, 'uniform COMPAT_PRECISION vec2 InputSize;')
source.insert(index, 'uniform COMPAT_PRECISION vec2 TextureSize;')
source.insert(index, 'uniform COMPAT_PRECISION vec2 OutputSize;')
source.insert(index, 'uniform int FrameCount;')
source.insert(index, 'uniform int FrameDirection;')
source.insert(index, 'uniform mat4 MVPMatrix;')
ref_index = index
break
# Fix samplers in vertex shader (supported by GLSL).
source = fix_samplers('Vertex:', ref_index, source)
source = destructify_varyings(source, '$vout.')
source = replace_varyings(source)
return source
def replace_global_fragment(source):
source = replace_global_in(source)
replace_table = [
('varying', 'COMPAT_VARYING'),
('texture2D', 'COMPAT_TEXTURE'),
('FrameCount', 'float(FrameCount)'),
('FrameDirection', 'float(FrameDirection)'),
('input', 'input_dummy'),
('output', 'output_dummy'), # 'output' is reserved in GLSL.
('gl_FragColor', 'FragColor'),
]
return replace_by_table(source, replace_table)
def translate_texture(cg):
translations = {
'ORIG.texture': 'OrigTexture',
'FEEDBACK.texture': 'FeedbackTexture',
'PREV.texture': 'PrevTexture',
'PREV1.texture': 'Prev1Texture',
'PREV2.texture': 'Prev2Texture',
'PREV3.texture': 'Prev3Texture',
'PREV4.texture': 'Prev4Texture',
'PREV5.texture': 'Prev5Texture',
'PREV6.texture': 'Prev6Texture',
'PASS1.texture': 'Pass1Texture',
'PASS2.texture': 'Pass2Texture',
'PASS3.texture': 'Pass3Texture',
'PASS4.texture': 'Pass4Texture',
'PASS5.texture': 'Pass5Texture',
'PASS6.texture': 'Pass6Texture',
'PASS7.texture': 'Pass7Texture',
'PASS8.texture': 'Pass8Texture',
'PASSPREV2.texture': 'PassPrev2Texture',
'PASSPREV3.texture': 'PassPrev3Texture',
'PASSPREV4.texture': 'PassPrev4Texture',
'PASSPREV5.texture': 'PassPrev5Texture',
'PASSPREV6.texture': 'PassPrev6Texture',
'PASSPREV7.texture': 'PassPrev7Texture',
'PASSPREV8.texture': 'PassPrev8Texture',
}
return translate(cg, translations)
def hack_source_fragment(source):
ref_index = 0
for index, line in enumerate(source):
if 'void main()' in line:
source.insert(index, 'uniform COMPAT_PRECISION vec2 InputSize;')
source.insert(index, 'uniform COMPAT_PRECISION vec2 TextureSize;')
source.insert(index, 'uniform COMPAT_PRECISION vec2 OutputSize;')
source.insert(index, 'uniform int FrameCount;')
source.insert(index, 'uniform int FrameDirection;')
ref_index = index
break
source = fix_samplers('Fragment:', ref_index, source)
source = destructify_varyings(source, '$vin.')
return source
def validate_shader(source, target):
log('Shader:')
log('===')
log(source)
log('===')
command = ['cgc', '-noentry', '-ogles']
p = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout_ret, stderr_ret = p.communicate(source.encode())
log('CGC:', stderr_ret.decode())
return p.returncode == 0
def preprocess_vertex(source_data):
input_data = source_data.splitlines()
ret = []
for line in input_data:
if ('uniform' in line) and (('float4x4' in line) or ('half4x4' in line)):
ret.append('#pragma pack_matrix(column_major)\n')
ret.append(line)
ret.append('#pragma pack_matrix(row_major)\n')
else:
ret.append(line)
return '\n'.join(ret)
def convert(source, dest):
# Have to preprocess first to resolve #includes so we can hack potential vertex shaders.
inc_dir = os.path.split(source)[0]
vert_cmd_preprocess = ['cgc', '-E', '-I', '.' if inc_dir == '' else inc_dir, source]
p = subprocess.Popen(vert_cmd_preprocess, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
source_data, stderr_ret = p.communicate()
log(stderr_ret.decode())
if p.returncode != 0:
log('Vertex preprocessing failed ...')
source_data = preprocess_vertex(source_data.decode())
vert_cmd = ['cgc', '-profile', 'glesv', '-entry', 'main_vertex', '-quiet']
p = subprocess.Popen(vert_cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
vertex_source, stderr_ret = p.communicate(input=source_data.encode())
log(stderr_ret.decode())
vertex_source = vertex_source.decode()
if p.returncode != 0:
log('Vertex compilation failed ...')
return 1
frag_cmd = ['cgc', '-profile', 'glesf', '-entry', 'main_fragment', '-quiet']
p = subprocess.Popen(frag_cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
fragment_source, stderr_ret = p.communicate(input=source_data.encode())
log(stderr_ret.decode())
fragment_source = fragment_source.decode()
if p.returncode != 0:
log('Vertex compilation failed ...')
return 1
vertex_source = replace_global_vertex(vertex_source)
fragment_source = replace_global_fragment(fragment_source)
vertex_source = vertex_source.splitlines()
fragment_source = fragment_source.splitlines()
# Cg think we're using row-major matrices, but we're using column major.
# Also, Cg tends to compile matrix multiplications as dot products in GLSL.
# Hack in a fix for this.
log('Hacking vertex')
vertex_source = hack_source_vertex(vertex_source)
log('Hacking fragment')
fragment_source = hack_source_fragment(fragment_source)
# We compile to GLES, but we really just want modern GL ...
vertex_source = keep_line_if(lambda line: 'precision' not in line, vertex_source)
fragment_source = keep_line_if(lambda line: 'precision' not in line, fragment_source)
# Kill all comments. Cg adds lots of useless comments.
# Remove first line. It contains the name of the cg program.
vertex_source = remove_comments(vertex_source[1:])
fragment_source = remove_comments(fragment_source[1:])
vert_hacks = []
vert_hacks.append('''
#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif''')
out_vertex = '\n'.join(vert_hacks + vertex_source)
frag_hacks = []
frag_hacks.append('''
#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif
#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif''')
out_fragment = '\n'.join(frag_hacks + fragment_source)
if not validate_shader(out_vertex, 'glesv'):
log('Vertex shader does not compile ...')
return 1
if not validate_shader(out_fragment, 'glesf'):
log('Fragment shader does not compile ...')
return 1
with open(dest, 'w') as f:
f.write('// GLSL shader autogenerated by cg2glsl.py.\n')
f.write('#if defined(VERTEX)\n')
f.write(out_vertex)
f.write('\n')
f.write('#elif defined(FRAGMENT)\n')
f.write(out_fragment)
f.write('\n')
f.write('#endif\n')
return 0
def convert_cgp(source, dest):
string = ''
with open(source, 'r') as f:
string = f.read().replace('.cg', '.glsl')
open(dest, 'w').write(string)
def path_ext(path):
_, ext = os.path.splitext(path)
return ext
def convert_path(source, source_dir, dest_dir, conv):
index = 0 if source_dir[-1] == '/' else 1
return os.path.join(dest_dir, source.replace(source_dir, '')[index:]).replace(conv[0], conv[1])
def main():
if len(sys.argv) != 3:
print('Usage: {} prog.cg(p) prog.glsl(p)'.format(sys.argv[0]))
print('Batch mode usage: {} cg-dir out-xml-shader-dir'.format(sys.argv[0]))
print('Requires Python 3 and cgc (nvidia-cg-toolkit) 3.1.')
return 1
if os.path.isdir(sys.argv[1]):
global batch_mode
batch_mode = True
try:
os.makedirs(sys.argv[2])
except OSError as e:
if e.errno != errno.EEXIST:
raise
failed_cnt = 0
success_cnt = 0
failed_files = []
for dirname, _, filenames in os.walk(sys.argv[1]):
for source in filter(lambda path: path_ext(path) == '.cg', [os.path.join(dirname, filename) for filename in filenames]):
dest = convert_path(source, sys.argv[1], sys.argv[2], ('.cg', '.glsl'))
dirpath = os.path.split(dest)[0]
print('Dirpath:', dirpath)
if not os.path.isdir(dirpath):
try:
os.makedirs(dirpath)
except OSError as e:
if e.errno != errno.EEXIST:
raise
try:
ret = convert(source, dest)
print(source, '->', dest, '...', 'succeeded!' if ret == 0 else 'failed!')
if ret == 0:
success_cnt += 1
else:
failed_cnt += 1
failed_files.append(source)
except Exception as e:
print(e)
failed_files.append(source)
failed_cnt += 1
for source in filter(lambda path: path_ext(path) == '.cgp', [os.path.join(dirname, filename) for filename in filenames]):
dest = convert_path(source, sys.argv[1], sys.argv[2], ('.cgp', '.glslp'))
dirpath = os.path.split(dest)[0]
print('Dirpath:', dirpath)
if not os.path.isdir(dirpath):
try:
os.makedirs(dirpath)
except OSError as e:
if e.errno != errno.EEXIST:
raise
try:
convert_cgp(source, dest)
success_cnt += 1
except Exception as e:
print(e)
failed_files.append(source)
failed_cnt += 1
print(success_cnt, 'shaders converted successfully.')
print(failed_cnt, 'shaders failed.')
if failed_cnt > 0:
print('Failed shaders:')
for path in failed_files:
print(path)
else:
source = sys.argv[1]
dest = sys.argv[2]
if path_ext(source) == '.cgp':
sys.exit(convert_cgp(source, dest))
else:
sys.exit(convert(source, dest))
if __name__ == '__main__':
sys.exit(main())
Reference in New Issue View Git Blame Copy Permalink