Addressing review feedback on last changes....

cg_to_glsl/convert.py

 #!/usr/bin/python
 import optparse
 import os
 import re
 import subprocess
 import sys
 
 # This script takes an o3d cg shader from standard input and does the following:
 #
 # * it extracts entry points to vertex and fragment shaders as specified by
@@ skipping 12 matching lines @@
 #
 # * prints the results to standard output, separating them with SplitMarker
 #   instruction and keeping the MatrixLoadOrder instruction as is.
 
 # Cygwin lies about the OS name ("posix" instead of "nt"), the line
 # separator, and perhaps other things. For most robust behavior, try
 # to find cgc on disk.
 
 def find_o3d_root():
   path = os.path.abspath(sys.path[0])
-  for i in range(0, 5):
+  for i in range(5):
     path = os.path.dirname(path)
     if (os.path.isdir(os.path.join(path, 'o3d')) and
         os.path.isdir(os.path.join(path, 'third_party'))):
       return path
   return ''
 
 def default_cgc():
-  paths = [ '/usr/bin/cgc',
-            'C:/Program Files/NVIDIA Corporation/Cg/bin/cgc.exe',
-            'C:/Program Files (x86)/NVIDIA Corporation/Cg/bin/cgc.exe' ]
+  paths = ['/usr/bin/cgc',
+           'C:/Program Files/NVIDIA Corporation/Cg/bin/cgc.exe',
+           'C:/Program Files (x86)/NVIDIA Corporation/Cg/bin/cgc.exe']
   for path in paths:
     if os.path.exists(path):
       return path
   script_path = os.path.abspath(sys.path[0])
   # Try again looking in the current working directory to match
   # the layout of the prebuilt o3dConverter binaries.
-  cur_dir_paths = [ os.path.join(script_path, 'cgc'),
-                    os.path.join(script_path, 'cgc.exe') ]
+  cur_dir_paths = [os.path.join(script_path, 'cgc'),
+                   os.path.join(script_path, 'cgc.exe')]
   for path in cur_dir_paths:
     if (os.path.exists(path)):
       return path
 
   # Last fallback is to use the binaries in o3d/third_party/cg/files.
   # Unfortunately, because we can't rely on the OS name, we have to
   # actually try running the cgc executable.
   o3d_root = find_o3d_root();
   cg_root = os.path.join(o3d_root, 'third_party', 'cg', 'files')
-  exes = [ os.path.join(cg_root, 'linux', 'bin', 'cgc'),
-           os.path.join(cg_root, 'linux', 'bin64', 'cgc'),
-           os.path.join(cg_root, 'mac', 'bin', 'cgc'),
-           os.path.join(cg_root, 'win', 'bin', 'cgc.exe') ]
-  for exe in exes:
+  exe_paths = ['linux/bin/cgc',
+               'linux/bin64/cgc',
+               'mac/bin/cgc',
+               'win/bin/cgc.exe']
+  for exe_path in exe_paths:
     try:
-      subprocess.call([exe, '-v'],
-                      stdout=open(os.devnull, 'w'),
-                      stderr=open(os.devnull, 'w'))
-      return exe
+      exe = os.path.join(cg_root, exe_path)
+      return_code = subprocess.call([exe, '-v'],
+                                    stdout=open(os.devnull, 'w'),
+                                    stderr=open(os.devnull, 'w'))
+      if return_code == 0 or return_code == 1:
+        return exe
     except:
       pass
 
   # We don't know where cgc lives.
   return ''
 
-def check_cgc(CGC):
-  if not os.path.exists(CGC):
-    print >>sys.stderr, CGC+' is not found, use --cgc option to specify its'
+def check_cgc(cgc_path):
+  if not os.path.exists(cgc_path):
+    print >>sys.stderr, (cgc_path + 
+                         ' is not found, use --cgc option to specify its')
     print >>sys.stderr, 'location.  You may need to install nvidia cg toolkit.'
     sys.exit(1)
 
 # cgc complains about TANGENT1 and BINORMAL1 semantics, so we hack it by
 # replacing standard semantics with ATTR8-ATTR12 and then renaming them back to
 # their original names.
 ATTRIBUTES_TO_SEMANTICS = dict(
     attr8 = 'normal',
     attr9 = 'tangent',
     attr10 = 'binormal',
@@ skipping 115 matching lines @@
   input_mapping = get_input_mapping(header)
   return header + '\n\n' + fix_glsl_body(body, input_mapping)
 
 
 def cg_rename_attributes(cg_shader):
   for new, old in ATTRIBUTES_TO_SEMANTICS.iteritems():
     cg_shader = re.sub(r'\b%s\b' % old.upper(), new.upper(), cg_shader)
   return cg_shader
 
 
-def cg_to_glsl(cg_shader, CGC):
+def cg_to_glsl(cg_shader, cgc_path):
   cg_shader = cg_rename_attributes(cg_shader)
 
   vertex_entry = re.search(r'#o3d\s+VertexShaderEntryPoint\s+(\w+)',
       cg_shader).group(1)
-  p = subprocess.Popen([CGC]+('-profile glslv -entry %s' %
+  p = subprocess.Popen([cgc_path]+('-profile glslv -entry %s' %
                               vertex_entry).split(' '),
       stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   glsl_vertex, err_v = p.communicate(cg_shader)
 
   fragment_entry = re.search(r'#o3d\s+PixelShaderEntryPoint\s+(\w+)',
       cg_shader).group(1)
-  p = subprocess.Popen([CGC]+('-profile glslf -entry %s' %
+  p = subprocess.Popen([cgc_path]+('-profile glslf -entry %s' %
                               fragment_entry).split(' '),
       stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   glsl_fragment, err_f = p.communicate(cg_shader)
 
   log = (
       '// glslv profile log:\n' +
       '\n'.join('// ' + l for l in err_v.splitlines()) + '\n\n'
       '// glslf profile log:\n' +
       '\n'.join('// ' + l for l in err_f.splitlines())) + '\n'
 
   return glsl_vertex, glsl_fragment, log
 
 
 def get_matrixloadorder(cg_shader):
   return re.search(r'(?m)^.*#o3d\s+MatrixLoadOrder\b.*$', cg_shader).group(0)
 
 
-def main(cg_shader, CGC):
+def main(cg_shader, cgc_path):
   matrixloadorder = get_matrixloadorder(cg_shader)
-  glsl_vertex, glsl_fragment, log = cg_to_glsl(cg_shader, CGC)
+  glsl_vertex, glsl_fragment, log = cg_to_glsl(cg_shader, cgc_path)
 
   print log
   print fix_glsl(glsl_vertex)
   print
   print '// #o3d SplitMarker'
   print get_matrixloadorder(cg_shader).strip()
   print
   print fix_glsl(glsl_fragment)
 
 
 if __name__ == '__main__':
-  CGC = default_cgc()
+  cgc_path = default_cgc()
   cmdline_parser = optparse.OptionParser()
   cmdline_parser.add_option('-i', dest='file', default=None,
       help='input shader; standard input if omitted')
-  cmdline_parser.add_option('--cgc', dest='CGC', default=CGC,
+  cmdline_parser.add_option('--cgc', dest='cgc_path', default=cgc_path,
       help='path to cgc [default: %default]')
   options, args = cmdline_parser.parse_args()
-  CGC = options.CGC
-  check_cgc(CGC)
+  cgc_path = options.cgc_path
+  check_cgc(cgc_path)
 
   try:
     if options.file is None:
       f = sys.stdin
     else:
       f = open(options.file)
     input = f.read()
   except KeyboardInterrupt:
     input = None
 
   if not input:
     cmdline_parser.print_help()
   else:
-    main(input, CGC)
+    main(input, cgc_path)