home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / cgkit / glslangparams.py < prev    next >
Encoding:
Python Source  |  2007-01-11  |  13.8 KB  |  378 lines
  1. # ***** BEGIN LICENSE BLOCK *****
  2. # Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. #
  4. # The contents of this file are subject to the Mozilla Public License Version
  5. # 1.1 (the "License"); you may not use this file except in compliance with
  6. # the License. You may obtain a copy of the License at
  7. # http://www.mozilla.org/MPL/
  8. #
  9. # Software distributed under the License is distributed on an "AS IS" basis,
  10. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. # for the specific language governing rights and limitations under the
  12. # License.
  13. #
  14. # The Original Code is the Python Computer Graphics Kit.
  15. #
  16. # The Initial Developer of the Original Code is Matthias Baas.
  17. # Portions created by the Initial Developer are Copyright (C) 2004
  18. # the Initial Developer. All Rights Reserved.
  19. #
  20. # Contributor(s):
  21. #
  22. # Alternatively, the contents of this file may be used under the terms of
  23. # either the GNU General Public License Version 2 or later (the "GPL"), or
  24. # the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  25. # in which case the provisions of the GPL or the LGPL are applicable instead
  26. # of those above. If you wish to allow use of your version of this file only
  27. # under the terms of either the GPL or the LGPL, and not to allow others to
  28. # use your version of this file under the terms of the MPL, indicate your
  29. # decision by deleting the provisions above and replace them with the notice
  30. # and other provisions required by the GPL or the LGPL. If you do not delete
  31. # the provisions above, a recipient may use your version of this file under
  32. # the terms of any one of the MPL, the GPL or the LGPL.
  33. #
  34. # ***** END LICENSE BLOCK *****
  35. # $Id: glslangparams.py,v 1.2 2006/04/12 11:52:09 mbaas Exp $
  36.  
  37. """Extract shader parameters from an OpenGL shader source file.
  38. """
  39.  
  40. import sys, copy
  41. import StringIO
  42. import cgkit.glslangtokenize as glslangtokenize
  43. import cgkit.simplecpp as simplecpp
  44. import cgkit.slparams as slparams
  45. from cgkit.glslangtokenize import WHITESPACE, NAME, NUMBER, STRING, NEWLINE, OPERATOR, CHARACTER, TYPE, QUALIFIER
  46.  
  47. class GLSLangParseError(Exception):
  48.     pass
  49.  
  50. # _GLSLangParser
  51. class _GLSLangParser:
  52.     """Extract variables from a glslang shader.
  53.     """
  54.     
  55.     def __init__(self, file, structs=None):
  56.         """Constructor.
  57.  
  58.         fils is a file-like object.
  59.         structs is a dictionary containing the 'predefined' structs.
  60.         This is used internally when the contents of a struct is
  61.         recursively parsed.
  62.         """
  63.  
  64.         # The following lists receive the result:
  65.  
  66.         # Contains 2-tuples (type, identifier)
  67.         self.attribute = []
  68.         # Contains 3-tuples (type, identifier, arraysize)
  69.         self.varying = []
  70.         # Contains 5-tuples (type, identifier, arraysize, structname, struct)
  71.         self.uniform = []
  72.         # Contains 5-tuples (type, identifier, arraysize, structname, struct)
  73.         self.const = []
  74.         # Contains 5-tuples (type, identifier, arraysize, structname, struct)
  75.         self.other = []
  76.  
  77.         # file
  78.         self.file = file
  79.         # Current state
  80.         self.state = self.initialState
  81.         
  82.         # Current qualifier
  83.         self.qualifier = None
  84.         # Current type
  85.         self.type = None
  86.         # Identifier
  87.         self.identifier = None
  88.         # String with the array size
  89.         self.arraysize = None
  90.         # Struct name
  91.         self.structname = None
  92.         self.struct = None
  93.  
  94.         self.named_structs = {}
  95.         if structs!=None:
  96.             self.named_structs = copy.deepcopy(structs)
  97.  
  98.         # Number of open parentheses
  99.         self.openparen = 0
  100.  
  101.         # The contents of a struct as a string
  102.         # (for calling the parser again on this)
  103.         self.structcontents = ""
  104.         
  105.  
  106.     def read(self):
  107.         """Read the file.
  108.         """
  109.         glslangtokenize.tokenize(self.file.readline, self.tokeater)
  110.  
  111.     def tokeater(self, type, s, start, end, line, filename):
  112.         """Token eater.
  113.  
  114.         This method skips whitespace and newlines and calls the
  115.         current state method.
  116.         """
  117.         if type in [WHITESPACE, NEWLINE]:
  118.             return
  119.  
  120.         self.state(type, s, start, end, line, filename)
  121.  
  122.     def switchState(self, state):
  123.         """Switch to a different state.
  124.  
  125.         state is a callable.
  126.         """
  127.         self.state = state
  128.  
  129.     def variable(self):
  130.         """Store a result variable.
  131.  
  132.         This method is called by the states whenever all information for
  133.         a variable has been read.
  134.         """
  135.         if self.qualifier=="attribute":
  136.             self.attribute.append((self.type, self.identifier))
  137.         elif self.qualifier=="varying":
  138.             self.varying.append((self.type, self.identifier, self.arraysize))
  139.         elif self.qualifier=="uniform":
  140.             self.uniform.append((self.type, self.identifier, self.arraysize, self.structname, self.struct))
  141.         elif self.qualifier=="const":
  142.             self.const.append((self.type, self.identifier, self.arraysize, self.structname, self.struct))
  143.         else:
  144.             self.other.append((self.type, self.identifier, self.arraysize, self.structname, self.struct))
  145.  
  146.     # States:
  147.     # Each state takes the same arguments as a token reader
  148.  
  149.     def initialState(self, type, s, start, end, line, filename):
  150.         """Initial state.
  151.         """
  152.         self.qualifier = None
  153.         self.type = None
  154.         self.identifier = None
  155.         self.arraysize = None
  156.         self.structname = None
  157.         self.struct = None
  158.         if type==QUALIFIER:
  159.             self.qualifier = s
  160.             self.switchState(self.qualifierState)
  161.         elif type==TYPE and s!="struct":
  162.             self.type = s
  163.             self.switchState(self.typeState)
  164.         elif s=="struct":
  165.             self.type = s
  166.             self.switchState(self.structState)
  167.         else:
  168.             # Is the type a previously defined struct?
  169.             if s in self.named_structs:
  170.                 self.type = "struct"
  171.                 self.structname = s
  172.                 self.struct = self.named_structs[s]
  173.                 self.switchState(self.typeState)
  174.             else:
  175.                 raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  176.  
  177.     def qualifierState(self, type, s, start, end, line, filename):
  178.         """A qualifier has been read.
  179.         """
  180.         if type==TYPE and s!="struct":
  181.             self.type = s
  182.             if self.qualifier in ["attribute", "varying"] and s not in ["float", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4"]:
  183.                 raise GLSLangParseError, "%s, line %d: Invalid type for an %s variable: %s"%(filename, start[0], self.qualifier, s)
  184.             self.switchState(self.typeState)
  185.         elif s=="struct":
  186.             self.type = s
  187.             self.switchState(self.structState)
  188.         else:
  189.             # Is the type a previously defined struct?
  190.             if s in self.named_structs:
  191.                 self.type = "struct"
  192.                 self.structname = s
  193.                 self.struct = self.named_structs[s]
  194.                 if self.qualifier in ["attribute", "varying"]:
  195.                     raise GLSLangParseError, "%s, line %d: %s variables cannot be declared as structs"%(filename, start[0], self.qualifier)
  196.                 self.switchState(self.typeState)
  197.             else:
  198.                 raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  199.  
  200.     def typeState(self, type, s, start, end, line, filename):
  201.         """The type of a varibale has been read.
  202.         """
  203.         if type==NAME:
  204.             self.identifier = s
  205.             self.switchState(self.nameState)
  206.         elif s==";":
  207.             self.switchState(self.initialState)
  208.         else:
  209.             raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  210.  
  211.     def nameState(self, type, s, start, end, line, filename):
  212.         """The name of a variable/function has been read.
  213.         """
  214.         if s==",":
  215.             self.variable()
  216.             self.switchState(self.typeState)
  217.         elif s==";":
  218.             self.variable()
  219.             self.switchState(self.initialState)
  220.         elif s=="[":
  221.             self.arraysize = ""
  222.             if self.qualifier=="attribute":
  223.                 raise GLSLangParseError, "%s, line %d: attribute variables cannot be declared as arrays"%(filename, start[0])
  224.             self.switchState(self.arrayState)
  225.         elif s=="(":
  226.             self.openparen = 1
  227.             self.switchState(self.functionState)
  228.         elif s=="=":
  229.             self.switchState(self.initState)
  230.         else:
  231.             raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  232.  
  233.     def initState(self, type, s, start, end, line, filename):
  234.         """A '=' has been encountered.
  235.  
  236.         Skip the initializer.
  237.         """
  238.         if s==";":
  239.             self.variable()
  240.             self.switchState(self.initialState)
  241.  
  242.     def arrayState(self, type, s, start, end, line, filename):
  243.         """A '[' has been encountered.
  244.         """
  245.         if s=="]":
  246.             self.switchState(self.arrayState2)
  247.         else:
  248.             self.arraysize += s
  249.  
  250.     def arrayState2(self, type, s, start, end, line, filename):
  251.         if s==";":
  252.             self.variable()
  253.             self.switchState(self.initialState)
  254.         elif s==",":
  255.             self.variable()
  256.             self.arraysize = None
  257.             self.switchState(self.typeState)
  258.         else:
  259.             raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  260.  
  261.     def functionState(self, type, s, start, end, line, filename):
  262.         """Skip function args.
  263.         """
  264.         if s=="(":
  265.             self.openparen += 1
  266.         elif s==")":
  267.             self.openparen -= 1
  268.             if self.openparen==0:
  269.                 self.switchState(self.functionState2)
  270.             
  271.     def functionState2(self, type, s, start, end, line, filename):
  272.         """Skip function body.
  273.         """
  274.  
  275.         # If this was only a function prototype there will be an immediate
  276.         # semicolon instead of the function body
  277.         if self.openparen==0 and s==";":
  278.             self.switchState(self.initialState)
  279.         elif s=="{":
  280.             self.openparen += 1
  281.         elif s=="}":
  282.             if self.openparen==0:
  283.                 raise GLSLangParseError, "%s, line %d: '{' expected, got '}'"%(filename, start[0])
  284.             self.openparen -= 1
  285.             if self.openparen==0:
  286.                 self.switchState(self.initialState)
  287.         elif self.openparen==0:
  288.             raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  289.  
  290.     def structState(self, type, s, start, end, line, filename):
  291.         """The keyword 'struct' has been read.
  292.         """
  293.         self.structcontents = ""
  294.         if type==NAME:
  295.             self.structname = s
  296.             self.switchState(self.structState2)
  297.         elif s=="{":
  298.             self.switchState(self.structState3)
  299.         else:
  300.             raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  301.  
  302.     def structState2(self, type, s, start, end, line, filename):
  303.         """The struct name has been read.
  304.         """
  305.         if s=="{":
  306.             self.switchState(self.structState3)
  307.         else:
  308.             raise GLSLangParseError, "%s, line %d: Syntax error: %s"%(filename, start[0], s)
  309.  
  310.     def structState3(self, type, s, start, end, line, filename):
  311.         """Collect the struct contents.
  312.         """
  313.         if s=="}":
  314.             f = StringIO.StringIO(self.structcontents)
  315.             p = _GLSLangParser(f, structs=self.named_structs)
  316.             p.read()
  317.             self.struct = p.other
  318.             if self.structname!="":
  319.                 self.named_structs[self.structname] = self.struct
  320.             self.switchState(self.typeState)
  321.         else:
  322.             self.structcontents += s+" "
  323.         
  324.  
  325.  
  326. # glslangparams
  327. def glslangparams(shader=None, cpp=None, cpperrstream=sys.stderr):
  328.     """Extracts the shader parameters from an OpenGL 2 shader source file.
  329.  
  330.     The argument shader is either the name of the shader source file
  331.     or a file-like object that provides the shader sources.
  332.     cpp determines how the shader source is preprocessed. It
  333.     can either be a string containing the name of an external
  334.     preprocessor tool (such as 'cpp') that must take the file name as
  335.     parameter and dump the preprocessed output to stdout or it can be
  336.     a callable that takes shader and cpperrstream as input and returns
  337.     the preprocessed sources as a string. If the external
  338.     preprocessor does not produce any data a PreprocessorNotFound
  339.     exception is thrown.
  340.     The error stream of the preprocessor is written to the object
  341.     that is specified by cpperrstream which must have a write()
  342.     method. If cpperrstream is None, the error stream is ignored.
  343.  
  344.     If cpp is None a simple internal preprocessor based on the
  345.     simplecpp module is used.
  346.  
  347.     The function returns three lists (uniform, attribute, varying)
  348.     that contain the variables with the corresponding qualifier.
  349.  
  350.     A uniform variable is a 5-tuple (type, identifier, arraysize,
  351.     structname, struct). arraysize is a string containing the
  352.     expression for the length of the array (i.e. the value between
  353.     the square brackets). If the variable is no array, arraysize is None.
  354.     When the variable is a struct, type has the value 'struct'. In this
  355.     case, the struct is given in struct (which is itself a list of
  356.     variables as 5-tuples). If the struct has a name, this name is
  357.     given in structname, otherwise structname is None.
  358.  
  359.     An attribute variable is a 2-tuple (type, identifier) and a
  360.     varying variable is a 3-tuple (type, identifier, arraysize) where
  361.     arraysize is defined as in the uniform case.
  362.     """
  363.  
  364.     # Run the preprocessor on the input file...
  365.     
  366.     if cpp==None:
  367.         cpp = simplecpp.PreProcessor()
  368.         
  369.     glslangsrc = slparams.preprocess(cpp, shader, cpperrstream)
  370.     f = StringIO.StringIO(glslangsrc)
  371.  
  372.     # Extract the variables...
  373.     parser = _GLSLangParser(f)
  374.     parser.read()
  375.     return parser.uniform, parser.attribute, parser.varying
  376.  
  377.  
  378.