Add initial support for NV_path_rendering extension to gpu command buffer

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """code generator for GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 488 matching lines @@
         'expected': 'kViewportWidth',
       },
       {
         'name': 'viewport_height',
         'type': 'GLsizei',
         'default': '1',
         'expected': 'kViewportHeight',
       },
     ],
   },
+  'MatrixValuesCHROMIUM': {
+    'type': 'NamedParameter',
+    'func': 'MatrixLoadfEXT',
+    'states': [
+      { 'enum': 'GL_PATH_MODELVIEW_MATRIX_CHROMIUM',
+        'enum_set': 'GL_PATH_MODELVIEW_CHROMIUM',
+        'name': 'modelview_matrix',
+        'type': 'GLfloat',
+        'default': [
+          '1.0f', '0.0f','0.0f','0.0f',
+          '0.0f', '1.0f','0.0f','0.0f',
+          '0.0f', '0.0f','1.0f','0.0f',
+          '0.0f', '0.0f','0.0f','1.0f',
+        ],
+        'extension_flag': 'chromium_path_rendering',
+      },
+      { 'enum': 'GL_PATH_PROJECTION_MATRIX_CHROMIUM',
+        'enum_set': 'GL_PATH_PROJECTION_CHROMIUM',
+        'name': 'projection_matrix',
+        'type': 'GLfloat',
+        'default': [
+          '1.0f', '0.0f','0.0f','0.0f',
+          '0.0f', '1.0f','0.0f','0.0f',
+          '0.0f', '0.0f','1.0f','0.0f',
+          '0.0f', '0.0f','0.0f','1.0f',
+        ],
+        'extension_flag': 'chromium_path_rendering',
+      },
+    ],
+  },
 }
 
 # Named type info object represents a named type that is used in OpenGL call
 # arguments.  Each named type defines a set of valid OpenGL call arguments.  The
 # named types are used in 'cmd_buffer_functions.txt'.
 # type: The actual GL type of the named type.
 # valid: The list of values that are valid for both the client and the service.
 # invalid: Examples of invalid values for the type. At least these values
 #          should be tested to be invalid.
 # is_complete: The list of valid values of type are final and will not be
@@ skipping 313 matching lines @@
   },
   'FrameBufferParameter': {
     'type': 'GLenum',
     'valid': [
       'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',
       'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',
       'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',
       'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',
     ],
   },
+  'MatrixMode': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_PATH_PROJECTION_CHROMIUM',
+      'GL_PATH_MODELVIEW_CHROMIUM',
+    ],
+  },
   'ProgramParameter': {
     'type': 'GLenum',
     'valid': [
       'GL_DELETE_STATUS',
       'GL_LINK_STATUS',
       'GL_VALIDATE_STATUS',
       'GL_INFO_LOG_LENGTH',
       'GL_ATTACHED_SHADERS',
       'GL_ACTIVE_ATTRIBUTES',
       'GL_ACTIVE_ATTRIBUTE_MAX_LENGTH',
@@ skipping 1725 matching lines @@
     'chromium': True,
   },
   'ScheduleOverlayPlaneCHROMIUM': {
       'type': 'Custom',
       'impl_func': True,
       'unit_test': False,
       'client_test': False,
       'extension': True,
       'chromium': True,
   },
+  'MatrixLoadfCHROMIUM': {
+    'type': 'PUT',
+    'count': 16,
+    'data_type': 'GLfloat',
+    'decoder_func': 'DoMatrixLoadfCHROMIUM',
+    'gl_test_func': 'glMatrixLoadfEXT',
+    'chromium': True,
+    'extension': True,
+    'extension_flag': 'chromium_path_rendering',
+  },
+  'MatrixLoadIdentityCHROMIUM': {
+    'decoder_func': 'DoMatrixLoadIdentityCHROMIUM',
+    'gl_test_func': 'glMatrixLoadIdentityEXT',
+    'chromium': True,
+    'extension': True,
+    'extension_flag': 'chromium_path_rendering',
+  },
 }
 
 
 def Grouper(n, iterable, fillvalue=None):
   """Collect data into fixed-length chunks or blocks"""
   args = [iter(iterable)] * n
   return itertools.izip_longest(fillvalue=fillvalue, *args)
 
 
 def SplitWords(input_string):
@@ skipping 49 matching lines @@
   uppercase_words = [ 'img', 'ext', 'arb', 'chromium', 'oes', 'amd', 'bgra8888',
                       'egl', 'atc', 'etc1', 'angle']
   parts = extension_flag.split('_')
   return "_".join(
     [part.upper() if part in uppercase_words else part for part in parts])
 
 def ToCamelCase(input_string):
   """converts ABC_underscore_case to ABCUnderscoreCase."""
   return ''.join(w[0].upper() + w[1:] for w in input_string.split('_'))
 
+def GetGLGetTypeConversion(result_type, value_type, value):
+  """Makes a gl compatible type conversion string for accessing state variables.
+
+   Useful when accessing state variables through glGetXXX calls.
+   glGet documetation (for example, the manual pages):
+   [...] If glGetIntegerv is called, [...] most floating-point values are
+   rounded to the nearest integer value. [...]
+
+  Args:
+   result_type: the gl type to be obtained
+   value_type: the GL type of the state variable
+   value: the name of the state variable
+
+  Returns:
+   String that converts the state variable to desired GL type according to GL
+   rules.
+  """
+
+  if result_type == 'GLint':
+    if value_type == 'GLfloat':
+      return 'static_cast<GLint>(round(%s))' % value
+  return 'static_cast<%s>(%s)' % (result_type, value)
+
 class CWriter(object):
   """Writes to a file formatting it for Google's style guidelines."""
 
   def __init__(self, filename):
     self.filename = filename
     self.content = []
 
   def Write(self, string):
     """Writes a string to a file spliting if it's > 80 characters."""
     lines = string.splitlines()
@@ skipping 4795 matching lines @@
     file.Write("struct EnableFlags {\n")
     file.Write("  EnableFlags();\n")
     for capability in _CAPABILITY_FLAGS:
       file.Write("  bool %s;\n" % capability['name'])
       file.Write("  bool cached_%s;\n" % capability['name'])
     file.Write("};\n\n")
 
     for state_name in sorted(_STATES.keys()):
       state = _STATES[state_name]
       for item in state['states']:
-        file.Write("%s %s;\n" % (item['type'], item['name']))
+        if isinstance(item['default'], list):
+          file.Write("%s %s[%d];\n" % (item['type'], item['name'],
+                                       len(item['default'])))
+        else:
+          file.Write("%s %s;\n" % (item['type'], item['name']))
+
         if item.get('cached', False):
-          file.Write("%s cached_%s;\n" % (item['type'], item['name']))
+          if isinstance(item['default'], list):
+            file.Write("%s cached_%s[%d];\n" % (item['type'], item['name'],
+                                                len(item['default'])))
+          else:
+            file.Write("%s cached_%s;\n" % (item['type'], item['name']))
+
     file.Write("\n")
 
     file.Write("""
         inline void SetDeviceCapabilityState(GLenum cap, bool enable) {
           switch (cap) {
         """)
     for capability in _CAPABILITY_FLAGS:
       file.Write("""\
             case GL_%s:
           """ % capability['name'].upper())
@@ skipping 47 matching lines @@
           file.Write("      *num_written = %d;\n" % len(state['states']))
           file.Write("      if (params) {\n")
           for ndx,item in enumerate(state['states']):
             file.Write("        params[%d] = static_cast<%s>(%s);\n" %
                        (ndx, gl_type, item['name']))
           file.Write("      }\n")
           file.Write("      return true;\n")
         else:
           for item in state['states']:
             file.Write("    case %s:\n" % item['enum'])
-            file.Write("      *num_written = 1;\n")
-            file.Write("      if (params) {\n")
-            file.Write("        params[0] = static_cast<%s>(%s);\n" %
-                       (gl_type, item['name']))
+            if isinstance(item['default'], list):
+              item_len = len(item['default'])
+              file.Write("      *num_written = %d;\n" % item_len)
+              file.Write("      if (params) {\n")
+              if item['type'] == gl_type:
+                file.Write("        memcpy(params, %s, sizeof(%s) * %d);\n" %
+                           (item['name'], item['type'], item_len))
+              else:
+                file.Write("        for (size_t i = 0; i < %s; ++i) {\n" %
+                           item_len)
+                file.Write("          params[i] = %s;\n" %
+                           (GetGLGetTypeConversion(gl_type, item['type'],
+                                                   "%s[i]" % item['name'])))
+                file.Write("        }\n");
+            else:
+              file.Write("      *num_written = 1;\n")
+              file.Write("      if (params) {\n")
+              file.Write("        params[0] = %s;\n" %
+                         (GetGLGetTypeConversion(gl_type, item['type'],
+                                                 item['name'])))
             file.Write("      }\n")
             file.Write("      return true;\n")
       for capability in _CAPABILITY_FLAGS:
             file.Write("    case GL_%s:\n" % capability['name'].upper())
             file.Write("      *num_written = 1;\n")
             file.Write("      if (params) {\n")
             file.Write(
                 "        params[0] = static_cast<%s>(enable_flags.%s);\n" %
                 (gl_type, capability['name']))
             file.Write("      }\n")
@@ skipping 18 matching lines @@
                   (capability['name'],
                    ('false', 'true')['default' in capability]))
     file.Write("ContextState::EnableFlags::EnableFlags()\n    : %s {\n}\n" %
                ",\n      ".join(code))
     file.Write("\n")
 
     file.Write("void ContextState::Initialize() {\n")
     for state_name in sorted(_STATES.keys()):
       state = _STATES[state_name]
       for item in state['states']:
-        file.Write("  %s = %s;\n" % (item['name'], item['default']))
+        if isinstance(item['default'], list):
+          for ndx, value in enumerate(item['default']):
+            file.Write("  %s[%d] = %s;\n" % (item['name'], ndx, value))
+        else:
+          file.Write("  %s = %s;\n" % (item['name'], item['default']))
         if item.get('cached', False):
-          file.Write("  cached_%s = %s;\n" % (item['name'], item['default']))
+          if isinstance(item['default'], list):
+            for ndx, value in enumerate(item['default']):
+              file.Write("  cached_%s[%d] = %s;\n" % (item['name'], ndx, value))
+          else:
+            file.Write("  cached_%s = %s;\n" % (item['name'], item['default']))
     file.Write("}\n")
 
     file.Write("""
 void ContextState::InitCapabilities(const ContextState* prev_state) const {
 """)
     def WriteCapabilities(test_prev):
       for capability in _CAPABILITY_FLAGS:
         capability_name = capability['name']
         if test_prev:
           file.Write("""  if (prev_state->enable_flags.cached_%s !=
@@ skipping 33 matching lines @@
             if test_prev:
               file.Write(")\n")
             file.Write(
                 "  gl%s(%s, %s);\n" %
                 (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
         elif state['type'] == 'NamedParameter':
           for item in state['states']:
             item_name = CachedStateName(item)
 
             if 'extension_flag' in item:
-              file.Write("  if (feature_info_->feature_flags().%s)\n  " %
+              file.Write("  if (feature_info_->feature_flags().%s) {\n  " %
                          item['extension_flag'])
             if test_prev:
-              file.Write("  if (prev_state->%s != %s)\n" %
-                         (item_name, item_name))
+              if isinstance(item['default'], list):
+                file.Write("  if (memcmp(prev_state->%s, %s, "
+                           "sizeof(%s) * %d)) {\n" %
+                           (item_name, item_name, item['type'],
+                            len(item['default'])))
+              else:
+                file.Write("  if (prev_state->%s != %s) {\n  " %
+                           (item_name, item_name))
             file.Write("  gl%s(%s, %s);\n" %
-                       (state['func'], item['enum'], item_name))
+                       (state['func'],
+                        (item['enum_set']
+                           if 'enum_set' in item else item['enum']),
+                        item['name']))
+            if test_prev:
+              if 'extension_flag' in item:
+                file.Write("  ")
+              file.Write("  }")
+            if 'extension_flag' in item:
+              file.Write("  }")
         else:
           if 'extension_flag' in state:
             file.Write("  if (feature_info_->feature_flags().%s)\n  " %
                        state['extension_flag'])
           if test_prev:
             file.Write("  if (")
           args = []
           for place, item in enumerate(state['states']):
             item_name = CachedStateName(item)
             args.append('%s' % item_name)
             if test_prev:
               if place > 0:
                 file.Write(' ||\n')
               file.Write("(%s != prev_state->%s)" %
                          (item_name, item_name))
           if test_prev:
             file.Write("    )\n")
           file.Write("  gl%s(%s);\n" % (state['func'], ", ".join(args)))
 
     file.Write("  if (prev_state) {")
     WriteStates(True)
     file.Write("  } else {")
     WriteStates(False)
     file.Write("  }")
-
     file.Write("}\n")
 
     file.Write("""bool ContextState::GetEnabled(GLenum cap) const {
   switch (cap) {
 """)
     for capability in _CAPABILITY_FLAGS:
       file.Write("    case GL_%s:\n" % capability['name'].upper())
       file.Write("      return enable_flags.%s;\n" % capability['name'])
     file.Write("""    default:
       NOTREACHED();
@@ skipping 166 matching lines @@
               "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
               (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
           file.Write("      .Times(1)\n")
           file.Write("      .RetiresOnSaturation();\n")
       elif state['type'] == 'NamedParameter':
         for item in state['states']:
           if 'extension_flag' in item:
             file.Write("  if (group_->feature_info()->feature_flags().%s) {\n" %
                        item['extension_flag'])
             file.Write("  ")
+          expect_value = item['default']
+          if isinstance(expect_value, list):
+            # TODO: Currently we do not check array values.
+            expect_value = "_"
 
           file.Write(
               "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
-              (state['func'], item['enum'], item['default']))
+              (state['func'],
+               (item['enum_set']
+                           if 'enum_set' in item else item['enum']),
+               expect_value))
           file.Write("      .Times(1)\n")
           file.Write("      .RetiresOnSaturation();\n")
           if 'extension_flag' in item:
             file.Write("  }\n")
       else:
         if 'extension_flag' in state:
           file.Write("  if (group_->feature_info()->feature_flags().%s) {\n" %
                      state['extension_flag'])
           file.Write("  ")
         args = []
         for item in state['states']:
           if 'expected' in item:
             args.append(item['expected'])
           else:
             args.append(item['default'])
+        # TODO: Currently we do not check array values.
+        args = ["_" if isinstance(arg, list) else arg for arg in args]
         file.Write("  EXPECT_CALL(*gl_, %s(%s))\n" %
                    (state['func'], ", ".join(args)))
         file.Write("      .Times(1)\n")
         file.Write("      .RetiresOnSaturation();\n")
         if 'extension_flag' in state:
           file.Write("  }\n")
     file.Write("""}
 """)
     file.Close()
 
@@ skipping 459 matching lines @@
   parser.add_option(
       "-v", "--verbose", action="store_true",
       help="prints more output.")
 
   (options, args) = parser.parse_args(args=argv)
 
   # Add in states and capabilites to GLState
   gl_state_valid = _NAMED_TYPE_INFO['GLState']['valid']
   for state_name in sorted(_STATES.keys()):
     state = _STATES[state_name]
+    if 'extension_flag' in state:
+      continue
     if 'enum' in state:
       if not state['enum'] in gl_state_valid:
         gl_state_valid.append(state['enum'])
     else:
       for item in state['states']:
         if 'extension_flag' in item:
           continue
         if not item['enum'] in gl_state_valid:
           gl_state_valid.append(item['enum'])
   for capability in _CAPABILITY_FLAGS:
@@ skipping 98 matching lines @@
       "ppapi/shared_impl/ppb_opengles2_shared.cc"])
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))