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 461 matching lines @@
         'expected': 'kViewportWidth',
       },
       {
         'name': 'viewport_height',
         'type': 'GLsizei',
         'default': '1',
         'expected': 'kViewportHeight',
       },
     ],
   },
+  'MatrixMode': {
+    'type': 'Normal',
+    'func': 'MatrixMode',
+    'enum': 'GL_MATRIX_MODE',
+    'extension_flag': 'nv_path_rendering',
+    'states': [
+      {
+        'name': 'matrix_mode',
+        'type': 'GLenum',
+        'default': 'GL_MODELVIEW',
+      }
+    ],
+  },
 }
 
 # This is a list of enum names and their valid values. It is used to map
 # GLenum arguments to a specific set of valid values.
 _ENUM_LISTS = {
   'BlitFilter': {
     'type': 'GLenum',
     'valid': [
       'GL_NEAREST',
       'GL_LINEAR',
@@ skipping 306 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_PROJECTION',
+      'GL_MODELVIEW',
+    ],
+  },
   '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 1713 matching lines @@
     'extension': True,
     'chromium': True,
     'trace_level': 1,
   },
   'DiscardBackbufferCHROMIUM': {
     'type': 'Custom',
     'impl_func': True,
     'extension': True,
     'chromium': True,
   },
+  'MatrixMode': {
+    'type': 'StateSet',
+    'state': 'MatrixMode',
+    'extension': True,
+  },
+  'LoadMatrixf': {
+    'type': 'PUT',
+    'count': 16,
+    'data_type': 'GLfloat',
+    'valid_args': {
+      0: '1.1',
+    },
+    'extension': True,
+  },

[jbauman, 2014/04/11 22:25:25]

LoadIdentity (CHROMIUM) should be added here and should have "'extension': True"
to avoid messing with pepper.

[Kimmo Kinnunen, 2014/04/15 16:16:58]

Done.

 }
 
 
 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 23 matching lines @@
   """Makes a lower-case identifier from words.
 
   Args:
     words: a list of lower-case words.
 
   Returns:
     the lower-case identifier.
   """
   return '_'.join(words)
 
-
 def ToUnderscore(input_string):
   """converts CamelCase to camel_case."""
   words = SplitWords(input_string)
   return Lower(words)
 
+def MakeListPrefixString(iterable_or_str):
+  """Return a string which is comma-separted concatenation of the
+    strings in the iterable_or_str. if iterable_or_str is a string,
+    return it with a comma appended."""
+  if isinstance(iterable_or_str, basestring):
+    result = iterable_or_str
+  else:
+    result = ", ".join(iterable_or_str)
+  if not result:
+    return ""
+  return result + ", "
 
 class CWriter(object):
   """Writes to a file formatting it for Google's style guidelines."""
 
   def __init__(self, filename):
     self.filename = filename
     self.file_num = 0
     self.content = []
 
   def SetFileNum(self, num):
@@ skipping 2106 matching lines @@
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, extra)
 
   def WriteImmediateServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
-  cmd.Init(%(gl_args)s, &temp[0]);
+  cmd.Init(%(gl_args)s&temp[0]);
   EXPECT_CALL(
       *gl_,
-      %(gl_func_name)s(%(gl_args)s, %(data_ref)sreinterpret_cast<
+      %(gl_func_name)s(%(gl_args)s%(data_ref)sreinterpret_cast<
           %(data_type)s*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
     for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
+
+    gl_any_strings.append("_")
     extra = {
       'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
       'data_type': func.GetInfo('data_type'),
       'data_count': func.GetInfo('count'),
       'data_value': func.GetInfo('data_value') or '0',
-      'gl_args': ", ".join(gl_arg_strings),
+      'gl_args':  MakeListPrefixString(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
-  EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
+  EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
   cmd.Init(%(all_but_last_args)s, &temp[0]);
   EXPECT_EQ(error::%(parse_result)s,
             ExecuteImmediateCmd(cmd, sizeof(temp)));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, extra)
 
   def WriteGetDataSizeCode(self, func, file):
@@ skipping 42 matching lines @@
   %(type)s data[%(count)d] = {0};
   struct Cmds {
     cmds::%(name)sImmediate cmd;
     %(type)s data[%(count)d];
   };
 
   for (int jj = 0; jj < %(count)d; ++jj) {
     data[jj] = static_cast<%(type)s>(jj);
   }
   Cmds expected;
-  expected.cmd.Init(%(cmd_args)s, &data[0]);
-  gl_->%(name)s(%(args)s, &data[0]);
+  expected.cmd.Init(%(cmd_args)s&data[0]);
+  gl_->%(name)s(%(args)s&data[0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
     cmd_arg_strings = []
     for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
       cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
     gl_arg_strings = []
     for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
     file.Write(code % {
           'name': func.name,
           'type': func.GetInfo('data_type'),
           'count': func.GetInfo('count'),
-          'args': ", ".join(gl_arg_strings),
-          'cmd_args': ", ".join(cmd_arg_strings),
+          'args': MakeListPrefixString(gl_arg_strings),
+          'cmd_args': MakeListPrefixString(cmd_arg_strings),
         })
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  static uint32 ComputeDataSize() {\n")
     file.Write("    return static_cast<uint32>(\n")
     file.Write("        sizeof(%s) * %d);  // NOLINT\n" %
                (func.info.data_type, func.info.count))
     file.Write("  }\n")
     file.Write("\n")
     file.Write("  static uint32 ComputeSize() {\n")
     file.Write("    return static_cast<uint32>(\n")
     file.Write(
         "        sizeof(ValueType) + ComputeDataSize());  // NOLINT\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSetHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  void SetHeader() {\n")
     file.Write(
         "    header.SetCmdByTotalSize<ValueType>(ComputeSize());\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdInit(self, func, file):
     """Overrriden from TypeHandler."""
+    gl_args = func.MakeTypedCmdArgString("_")
     last_arg = func.GetLastOriginalArg()
-    file.Write("  void Init(%s, %s _%s) {\n" %
-               (func.MakeTypedCmdArgString("_"),
-                last_arg.type, last_arg.name))
+    file.Write("  void Init(%s%s _%s) {\n" %
+               (MakeListPrefixString(gl_args), last_arg.type, last_arg.name))
     file.Write("    SetHeader();\n")
     args = func.GetCmdArgs()
     for arg in args:
       file.Write("    %s = _%s;\n" % (arg.name, arg.name))
     file.Write("    memcpy(ImmediateDataAddress(this),\n")
     file.Write("           _%s, ComputeDataSize());\n" % last_arg.name)
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSet(self, func, file):
     """Overrriden from TypeHandler."""
     last_arg = func.GetLastOriginalArg()
     copy_args = func.MakeCmdArgString("_", False)
     file.Write("  void* Set(void* cmd%s, %s _%s) {\n" %
                (func.MakeTypedCmdArgString("_", True),
                 last_arg.type, last_arg.name))
-    file.Write("    static_cast<ValueType*>(cmd)->Init(%s, _%s);\n" %
-               (copy_args, last_arg.name))
+    file.Write("    static_cast<ValueType*>(cmd)->Init(%s_%s);\n" %
+               (MakeListPrefixString(copy_args), last_arg.name))
     file.Write("    const uint32 size = ComputeSize();\n")
     file.Write("    return NextImmediateCmdAddressTotalSize<ValueType>("
                "cmd, size);\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  void %(name)s(%(typed_args)s) {
     const uint32 size = gles2::cmds::%(name)s::ComputeSize();
@@ skipping 2302 matching lines @@
         for item in state['states']:
           if 'extension_flag' in item:
             file.Write("  if (feature_info_->feature_flags().%s)\n  " %
                        item['extension_flag'])
           file.Write("  gl%s(%s, %s);\n" %
                      (state['func'], item['enum'], item['name']))
       else:
         args = []
         for item in state['states']:
           args.append('%s' % item['name'])
+        if 'extension_flag' in state:
+          file.Write("  if (feature_info_->feature_flags().%s)\n  " %
+                   state['extension_flag'])
         file.Write("  gl%s(%s);\n" % (state['func'], ", ".join(args)))
     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:
@@ skipping 153 matching lines @@
       elif state['type'] == 'NamedParameter':
         for item in state['states']:
           if 'extension_flag' in item:
             continue
           file.Write(
               "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
               (state['func'], item['enum'], item['default']))
           file.Write("      .Times(1)\n")
           file.Write("      .RetiresOnSaturation();\n")
       else:
+        if 'extension_flag' in state:
+          continue
         args = []
         for item in state['states']:
           if 'expected' in item:
             args.append(item['expected'])
           else:
             args.append(item['default'])
         file.Write("  EXPECT_CALL(*gl_, %s(%s))\n" %
                    (state['func'], ", ".join(args)))
         file.Write("      .Times(1)\n")
         file.Write("      .RetiresOnSaturation();\n")
@@ skipping 425 matching lines @@
       "empty. Use this if you want the result stored under gen.")
   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
   for state_name in sorted(_STATES.keys()):
     state = _STATES[state_name]
+    if 'extension_flag' in state:
+      continue
     if 'enum' in state:
       _ENUM_LISTS['GLState']['valid'].append(state['enum'])
     else:
       for item in state['states']:
         if 'extension_flag' in item:
           continue
         _ENUM_LISTS['GLState']['valid'].append(item['enum'])
   for capability in _CAPABILITY_FLAGS:
     _ENUM_LISTS['GLState']['valid'].append("GL_%s" % capability['name'].upper())
 
@@ skipping 83 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:]))