Swizzle Uniform Locations

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 os
 import os.path
 import sys
@@ skipping 3563 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     arg_strings = []
     count = 0
     for arg in func.GetOriginalArgs():
       # hardcoded to match unit tests.
       if count == 0:
         # the location of the second element of the first uniform.
-        gl_arg_strings.append("3")
-        arg_strings.append("3")
+        gl_arg_strings.append(arg.GetValidGLArg(func, 2, 2))
+        arg_strings.append(arg.GetValidArg(func, 2, 2))
       elif count == 1:
         # the number of elements that gl will be called with.
         gl_arg_strings.append("2")
         # the number of elements requested in the command.
         arg_strings.append("5")
       else:
         gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
         arg_strings.append(arg.GetValidArg(func, count, 0))
       count += 1
     extra = {
       'gl_args': ", ".join(gl_arg_strings),
       'args': ", ".join(arg_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overridden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s,
           reinterpret_cast<%(data_type)s*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s * 2] = { 0, };
-  cmd.Init(%(gl_args)s, &temp[0]);
+  cmd.Init(%(args)s, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
+    arg_strings = []
     count = 0
     for arg in func.GetOriginalArgs()[0:-1]:
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
+      arg_strings.append(arg.GetValidArg(func, count, 0))
       count += 1
     extra = {
       'data_type': func.GetInfo('data_type'),
       'data_count': func.GetInfo('count'),
+      'args': ", ".join(arg_strings),
       'gl_args': ", ".join(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) {
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
   SpecializedSetup<%(name)s, 0>(false);
@@ skipping 221 matching lines @@
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, Uniform%(count)sfv(%(local_args)s));
   SpecializedSetup<%(name)s, 0>(true);
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     args = func.GetOriginalArgs()
-    local_args = "%s, 1, _" % args[0].GetValidArg(func, 0, 0)
+    local_args = "%s, 1, _" % args[0].GetValidGLArg(func, 0, 0)
     self.WriteValidUnitTest(func, file, valid_test, {
         'count': func.GetInfo('count'),
         'local_args': local_args,
       })
 
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, Uniform%(count)s(_, _, _).Times(0);
   SpecializedSetup<%(name)s, 0>(false);
   %(name)s cmd;
@@ skipping 536 matching lines @@
 
   def GetValidClientSideCmdArg(self, func, offset, index):
     """Gets a valid value for this argument."""
     return 'true'
 
   def GetValidGLArg(self, func, offset, index):
     """Gets a valid GL value for this argument."""
     return 'true'
 
 
+class UniformLocationArgument(Argument):
+  """class for uniform locations."""
+
+  def __init__(self, name):
+    Argument.__init__(self, name, "GLint")
+
+  def WriteGetCode(self, file):
+    """Writes the code to get an argument from a command structure."""
+    code = """  %s %s = program_manager()->UnswizzleLocation(
+      static_cast<%s>(c.%s));
+"""
+    file.Write(code % (self.type, self.name, self.type, self.name))
+
+  def GetValidArg(self, func, offset, index):
+    """Gets a valid value for this argument."""
+    return "program_manager()->SwizzleLocation(%d)" % (offset + 1)
+
+
 class DataSizeArgument(Argument):
   """class for data_size which Bucket commands do not need."""
 
   def __init__(self, name):
     Argument.__init__(self, name, "uint32")
 
   def GetBucketVersion(self):
     return None
 
 
@@ skipping 814 matching lines @@
   elif arg_parts[0].startswith('GLidZero'):
     return ResourceIdZeroArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
   elif arg_parts[0].startswith('GLid'):
     return ResourceIdArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
   elif arg_parts[0].startswith('GLenum') and len(arg_parts[0]) > 6:
     return EnumArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
   elif arg_parts[0].startswith('GLboolean') and len(arg_parts[0]) > 9:
     return ValidatedBoolArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
   elif arg_parts[0].startswith('GLboolean'):
     return BoolArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
+  elif arg_parts[0].startswith('GLintUniformLocation'):
+    return UniformLocationArgument(arg_parts[-1])
   elif (arg_parts[0].startswith('GLint') and len(arg_parts[0]) > 5 and
         not arg_parts[0].startswith('GLintptr')):
     return IntArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
   elif (arg_parts[0].startswith('GLsizeiNotNegative') or
         arg_parts[0].startswith('GLintptrNotNegative')):
     return SizeNotNegativeArgument(arg_parts[-1],
                                    " ".join(arg_parts[0:-1]),
                                    arg_parts[0][0:-11])
   elif arg_parts[0].startswith('GLsize'):
     return SizeArgument(arg_parts[-1], " ".join(arg_parts[0:-1]))
@@ skipping 645 matching lines @@
     gen.WriteCommonUtilsImpl("common/gles2_cmd_utils_implementation_autogen.h")
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))