diff options
25 files changed, 21237 insertions, 4 deletions
diff --git a/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py b/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py new file mode 100644 index 0000000..e62195f --- /dev/null +++ b/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py @@ -0,0 +1,2212 @@ +#!/usr/bin/python +# +# Copyright (c) 2006-2009 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 GL command buffers.""" + +import os +import os.path +import sys +import re +from optparse import OptionParser + +_SIZE_OF_UINT32 = 4 +_SIZE_OF_COMMAND_HEADER = 4 +_FIRST_SPECIFIC_COMMAND_ID = 1024 + +_LICENSE = "\n".join([ + "// Copyright (c) 2006-2008 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.", + "", +]) + +# This table specifies types and other special data for the commands that +# will be generated. +# +# type: defines which handler will be used to generate code. +# DecoderFunc: defines which function to call in the decoder to execute the +# corresponding GL command. If not specified the GL command will +# be called directly. +# cmd_args: The arguments to use for the command. This overrides generating +# them based on the GL function arguments. +# immediate: Whether or not to generate an immediate command for the GL +# function. The default is if there is exactly 1 pointer argument +# in the GL function an immediate command is generated. +# needs_size: If true a data_size field is added to the command. +# data_type: The type of data the command uses. For PUTn or PUT types. +# count: The number of units per element. For PUTn or PUT types. + +_FUNCTION_INFO = { + 'BindAttribLocation': {'type': 'GLchar'}, + 'BindBuffer': {'DecoderFunc': 'DoBindBuffer'}, + 'BufferData': {'type': 'Data'}, + 'BufferSubData': {'type': 'Data'}, + 'ClearDepthf': {'DecoderFunc': 'glClearDepth'}, + 'CompressedTexImage2D': {'type': 'Data'}, + 'CompressedTexSubImage2D': {'type': 'Data'}, + 'CreateProgram': {'type': 'Create'}, + 'CreateShader': {'type': 'Create'}, + 'DeleteBuffers': {'type': 'DELn'}, + 'DeleteFramebuffers': {'type': 'DELn'}, + 'DeleteProgram': {'DecoderFunc': 'DoDeleteProgram'}, + 'DeleteRenderbuffers': {'type': 'DELn'}, + 'DeleteShader': {'DecoderFunc': 'DoDeleteShader'}, + 'DeleteTextures': {'type': 'DELn'}, + 'DepthRangef': {'DecoderFunc': 'glDepthRange'}, + 'DrawElements': { + 'type': 'Manual', + 'cmd_args': 'GLenum mode, GLsizei count, GLenum type, GLuint index_offset', + }, + 'GenBuffers': {'type': 'GENn'}, + 'GenFramebuffers': {'type': 'GENn'}, + 'GenRenderbuffers': {'type': 'GENn'}, + 'GenTextures': {'type': 'GENn'}, + 'GetActiveAttrib': {'type': 'Custom'}, + 'GetActiveUniform': {'type': 'Custom'}, + 'GetAttachedShaders': {'type': 'Custom'}, + 'GetAttribLocation': {'type': 'GLchar'}, + 'GetBooleanv': {'type': 'GETn'}, + 'GetBufferParameteriv': {'type': 'GETn'}, + 'GetError': {'type': 'Is'}, + 'GetFloatv': {'type': 'GETn'}, + 'GetFramebufferAttachmentParameteriv': {'type': 'GETn'}, + 'GetIntegerv': {'type': 'GETn'}, + 'GetProgramiv': {'type': 'GETn'}, + 'GetProgramInfoLog': {'type': 'STRn'}, + 'GetRenderbufferParameteriv': {'type': 'GETn'}, + 'GetShaderiv': {'type': 'GETn'}, + 'GetShaderInfoLog': {'type': 'STRn'}, + 'GetShaderPrecisionFormat': {'type': 'Custom'}, + 'GetShaderSource': {'type': 'STRn'}, + 'GetTexParameterfv': {'type': 'GETn'}, + 'GetTexParameteriv': {'type': 'GETn'}, + 'GetUniformfv': {'type': 'Custom', 'immediate': False}, + 'GetUniformiv': {'type': 'Custom', 'immediate': False}, + 'GetUniformLocation': {'type': 'GLchar'}, + 'GetVertexAttribfv': {'type': 'GETn'}, + 'GetVertexAttribiv': {'type': 'GETn'}, + 'GetVertexAttribPointerv': {'type': 'Custom', 'immediate': False}, + 'IsBuffer': {'type': 'Is'}, + 'IsEnabled': {'type': 'Is'}, + 'IsFramebuffer': {'type': 'Is'}, + 'IsProgram': {'type': 'Is'}, + 'IsRenderbuffer': {'type': 'Is'}, + 'IsShader': {'type': 'Is'}, + 'IsTexture': {'type': 'Is'}, + 'PixelStorei': {'type': 'Custom'}, + 'ReadPixels': {'type': 'Custom', 'immediate': False}, + 'ReleaseShaderCompiler': {'type': 'Noop'}, + 'ShaderBinary': {'type': 'Noop'}, + 'ShaderSource': { + 'type': 'Manual', + 'immediate': True, + 'needs_size': True, + 'cmd_args': + 'GLuint shader, GLsizei count, const char* data', + }, + 'TexImage2D': {'type': 'Data'}, + 'TexParameterfv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 1}, + 'TexParameteriv': {'type': 'PUT', 'data_type': 'GLint', 'count': 1}, + 'TexSubImage2D': {'type': 'Data'}, + 'Uniform1fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 1}, + 'Uniform1iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 1}, + 'Uniform2fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 2}, + 'Uniform2iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 2}, + 'Uniform3fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 3}, + 'Uniform3iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 3}, + 'Uniform4fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 4}, + 'Uniform4iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 4}, + 'UniformMatrix2fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 4}, + 'UniformMatrix3fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 9}, + 'UniformMatrix4fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 16}, + 'VertexAttrib1fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 1}, + 'VertexAttrib2fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 2}, + 'VertexAttrib3fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 3}, + 'VertexAttrib4fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 4}, + 'VertexAttribPointer': { + 'type': 'Manual', + 'cmd_args': 'GLuint indx, GLint size, GLenum type, GLboolean normalized, ' + 'GLsizei stride, GLuint offset', + }, +} + + +class CWriter(object): + """Writes to a file formatting it for Google's style guidelines.""" + + def __init__(self, filename): + self.filename = filename + self.file = open(filename, "w") + + def Write(self, string): + """Writes a string to a file spliting if it's > 80 characters.""" + lines = string.splitlines() + num_lines = len(lines) + for ii in range(0, num_lines): + self.__WriteLine(lines[ii], ii < (num_lines - 1) or string[-1] == '\n') + + def __FindSplit(self, string): + """Finds a place to split a string.""" + splitter = string.find('=') + if splitter >= 0 and not string[splitter + 1] == '=': + return splitter + parts = string.split('(') + if len(parts) > 1: + splitter = len(parts[0]) + for ii in range(1, len(parts)): + if not parts[ii - 1][-3:] == "if ": + return splitter + splitter += len(parts[ii]) + 1 + done = False + end = len(string) + last_splitter = -1 + while not done: + splitter = string[0:end].rfind(',') + if splitter < 0: + return last_splitter + elif splitter >= 80: + end = splitter + else: + return splitter + + def __WriteLine(self, line, ends_with_eol): + """Given a signle line, writes it to a file, splitting if it's > 80 chars""" + if len(line) >= 80: + i = self.__FindSplit(line) + if i > 0: + line1 = line[0:i + 1] + self.file.write(line1 + '\n') + match = re.match("( +)", line1) + indent = "" + if match: + indent = match.group(1) + splitter = line[i] + if not splitter == ',': + indent = " " + indent + self.__WriteLine(indent + line[i + 1:].lstrip(), True) + return + self.file.write(line) + if ends_with_eol: + self.file.write('\n') + + def Close(self): + """Close the file.""" + self.file.close() + + +class TypeHandler(object): + """This class emits code for a particular type of function.""" + + def __init__(self): + pass + + def InitFunction(self, func): + """Add or adjust anything type specific for this function.""" + if func.GetInfo('needs_size'): + func.AddCmdArg(CmdArg('data_size', 'uint32')) + + def AddImmediateFunction(self, generator, func): + """Adds an immediate version of a function.""" + # Generate an immediate command if there is only 1 pointer arg. + immediate = func.GetInfo('immediate') # can be True, False or None + if immediate == True or immediate == None: + if func.num_pointer_args == 1 or immediate: + generator.AddFunction(ImmediateFunction(func)) + + def WriteHandlerImplementation(self, func, file): + """Writes the handler implementation for this command.""" + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" %s(%s);\n" % + (func.GetGLFunctionName(), func.MakeOriginalArgString(""))) + + def WriteCmdSizeTest(self, func, file): + """Writes the size test for a command.""" + file.Write(" EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT\n") + + def WriteFormatTest(self, func, file): + """Writes a format test for a command.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" %s cmd = { 0, };\n" % func.name) + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + args = func.GetCmdArgs() + value = 11 + for arg in args: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(");\n") + value = 11 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + func.type_handler.WriteCmdSizeTest(func, file) + for arg in args: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write("}\n") + file.Write("\n") + + def WriteImmediateFormatTest(self, func, file): + """Writes a format test for an immediate version of a command.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" int8 buf[256] = { 0, };\n") + file.Write(" %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" % + (func.name, func.name)) + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + args = func.GetCmdArgs() + value = 11 + for arg in args: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(");\n") + value = 11 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + func.type_handler.WriteImmediateCmdSizeTest(func, file) + for arg in args: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write("}\n") + file.Write("\n") + + def WriteImmediateCmdSizeTest(self, func, file): + """Writes a size test for an immediate version of a command.""" + file.Write(" // TODO(gman): Compute correct size.\n") + file.Write(" EXPECT_EQ(sizeof(cmd), cmd.header.size * 4);\n") + + def WriteImmediateHandlerImplementation (self, func, file): + """Writes the handler impl for the immediate version of a command.""" + file.Write(" // Immediate version.\n") + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" %s(%s);\n" % + (func.GetGLFunctionName(), func.MakeOriginalArgString(""))) + + def WriteServiceImplementation(self, func, file): + """Writes the service implementation for a command.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + for arg in func.GetOriginalArgs(): + arg.WriteGetCode(file) + func.WriteHandlerImplementation(file) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteImmediateServiceImplementation(self, func, file): + """Writes the service implementation for an immediate version of command.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + for arg in func.GetOriginalArgs(): + arg.WriteGetCode(file) + func.WriteHandlerImplementation(file) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteImmediateValidationCode(self, func, file): + """Writes the validation code for an immediate version of a command.""" + pass + + def WriteGLES2ImplementationHeader(self, func, file): + """Writes the GLES2 Implemention declaration.""" + if func.can_auto_generate: + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" helper_->%s(%s);\n" % + (func.name, func.MakeOriginalArgString(""))) + file.Write("}\n") + file.Write("\n") + else: + file.Write("%s %s(%s);\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Writes the GLES2 Implemention definition.""" + if not func.can_auto_generate: + file.Write("%s GLES2Implementation::%s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + if not func.return_type == "void": + file.Write(" return 0;\n") + file.Write("}\n") + file.Write("\n") + + def WriteImmediateCmdComputeSize(self, func, file): + """Writes the size computation code for the immediate version of a cmd.""" + file.Write(" static uint32 ComputeSize(uint32 size_in_bytes) {\n") + file.Write(" return static_cast<uint32>(\n") + file.Write(" sizeof(ValueType) + // NOLINT\n") + file.Write(" RoundSizeToMultipleOfEntries(size_in_bytes));\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSetHeader(self, func, file): + """Writes the SetHeader function for the immediate version of a cmd.""" + file.Write(" void SetHeader(uint32 size_in_bytes) {\n") + file.Write(" header.SetCmdByTotalSize<ValueType>(size_in_bytes);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdInit(self, func, file): + """Writes the Init function for the immediate version of a command.""" + file.Write(" void Init(%s) {\n" % func.MakeTypedCmdArgString("_")) + file.Write(" SetHeader(0); // TODO(gman): pass in correct size\n") + args = func.GetCmdArgs() + for arg in args: + file.Write(" %s = _%s;\n" % (arg.name, arg.name)) + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSet(self, func, file): + """Writes the Set function for the immediate version of a command.""" + copy_args = func.MakeCmdArgString("_", False) + file.Write(" void* Set(void* cmd%s) {\n" % + func.MakeTypedCmdArgString("_", True)) + file.Write(" // TODO(gman): compute correct size.\n") + file.Write(" const uint32 size = ComputeSize(0);\n") + file.Write(" static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args) + file.Write(" return NextImmediateCmdAddressTotalSize<ValueType>(" + "cmd, size);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdHelper(self, func, file): + """Writes the cmd helper definition for the immediate version of a cmd.""" + args = func.MakeCmdArgString("") + file.Write(" void %s(%s) {\n" % + (func.name, func.MakeTypedCmdArgString(""))) + file.Write(" const uint32 s = 0; // TODO(gman): compute correct size\n") + file.Write(" gles2::%s& c = " + "GetImmediateCmdSpaceTotalSize<gles2::%s>(s);\n" % + (func.name, func.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + +class CustomHandler(TypeHandler): + """Handler for commands that are auto-generated but require minor tweaks.""" + + def __init__(self): + TypeHandler.__init__(self) + + def WriteServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateCmdGetTotalSize(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" uint32 total_size = 0; // TODO(gman): get correct size.") + + def WriteImmediateCmdInit(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" void Init(%s) {\n" % func.MakeTypedCmdArgString("_")) + self.WriteImmediateCmdGetTotalSize(func, file) + file.Write(" SetHeader(total_size);\n") + args = func.GetCmdArgs() + for arg in args: + file.Write(" %s = _%s;\n" % (arg.name, arg.name)) + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSet(self, func, file): + """Overrriden from TypeHandler.""" + copy_args = func.MakeCmdArgString("_", False) + file.Write(" void* Set(void* cmd%s) {\n" % + func.MakeTypedCmdArgString("_", True)) + self.WriteImmediateCmdGetTotalSize(func, file) + file.Write(" static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args) + file.Write(" return NextImmediateCmdAddressTotalSize<ValueType>(" + "cmd, total_size);\n") + file.Write(" }\n") + file.Write("\n") + + +class TodoHandler(CustomHandler): + """Handle for commands that are not yet implemented.""" + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + pass + + +class ManualHandler(CustomHandler): + """Handler for commands that must be written by hand.""" + + def __init__(self): + CustomHandler.__init__(self) + + def WriteServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("// TODO(gman): Implement test for %s\n" % func.name) + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s);\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateCmdGetTotalSize(self, func, file): + """Overrriden from TypeHandler.""" + # TODO(gman): Move this data to _FUNCTION_INFO? + if func.name == 'ShaderSourceImmediate': + file.Write(" uint32 total_size = ComputeSize(_data_size);\n") + else: + CustomHandler.WriteImmediateCmdGetTotalSize(self, func, file) + + +class DataHandler(CustomHandler): + """Handler for glBufferData, glBufferSubData, glTexImage2D, glTexSubImage2D, + glCompressedTexImage2D, glCompressedTexImageSub2D.""" + def __init__(self): + CustomHandler.__init__(self) + + def WriteServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + for arg in func.GetCmdArgs(): + arg.WriteGetCode(file) + + # TODO(gman): Move this data to _FUNCTION_INFO? + if func.name == 'BufferData': + file.Write(" uint32 data_size = size;\n") + elif func.name == 'BufferSubData': + file.Write(" uint32 data_size = size;\n") + elif func.name == 'CompressedTexImage2D': + file.Write(" uint32 data_size = imageSize;\n") + elif func.name == 'CompressedTexSubImage2D': + file.Write(" uint32 data_size = imageSize;\n") + elif func.name == 'TexImage2D': + file.Write(" uint32 pixels_size = GLES2Util::ComputeImageDataSize(\n") + file.Write(" width, height, format, type, unpack_alignment_);\n") + elif func.name == 'TexSubImage2D': + file.Write(" uint32 pixels_size = GLES2Util::ComputeImageDataSize(\n") + file.Write(" width, height, format, type, unpack_alignment_);\n") + else: + file.Write(" uint32 data_size = 0; // TODO(gman): get correct size!\n") + + for arg in func.GetOriginalArgs(): + arg.WriteGetAddress(file) + func.WriteHandlerImplementation(file) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteImmediateCmdGetTotalSize(self, func, file): + """Overrriden from TypeHandler.""" + # TODO(gman): Move this data to _FUNCTION_INFO? + if func.name == 'BufferDataImmediate': + file.Write(" uint32 total_size = ComputeSize(_size);\n") + elif func.name == 'BufferSubDataImmediate': + file.Write(" uint32 total_size = ComputeSize(_size);\n") + elif func.name == 'CompressedTexImage2DImmediate': + file.Write(" uint32 total_size = ComputeSize(_imageSize);\n") + elif func.name == 'CompressedTexSubImage2DImmediate': + file.Write(" uint32 total_size = ComputeSize(_imageSize);\n") + elif func.name == 'TexImage2DImmediate': + file.Write( + " uint32 total_size = 0; // TODO(gman): get correct size\n") + elif func.name == 'TexSubImage2DImmediate': + file.Write( + " uint32 total_size = 0; // TODO(gman): get correct size\n") + + def WriteImmediateCmdSizeTest(self, func, file): + """Overrriden from TypeHandler.""" + # TODO(gman): Move this data to _FUNCTION_INFO? + if func.name == 'BufferDataImmediate': + file.Write(" uint32 total_size = cmd.ComputeSize(cmd.size);\n") + elif func.name == 'BufferSubDataImmediate': + file.Write(" uint32 total_size = cmd.ComputeSize(cmd.size);\n") + elif func.name == 'CompressedTexImage2DImmediate': + file.Write(" uint32 total_size = cmd.ComputeSize(cmd.imageSize);\n") + elif func.name == 'CompressedTexSubImage2DImmediate': + file.Write(" uint32 total_size = cmd.ComputeSize(cmd.imageSize);\n") + elif func.name == 'TexImage2DImmediate': + file.Write( + " uint32 total_size = 0; // TODO(gman): get correct size\n") + elif func.name == 'TexSubImage2DImmediate': + file.Write( + " uint32 total_size = 0; // TODO(gman): get correct size\n") + file.Write(" EXPECT_EQ(sizeof(cmd), total_size);\n") + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + # TODO(gman): Remove this exception. + file.Write("// TODO(gman): Implement test for %s\n" % func.name) + return + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + +class GENnHandler(TypeHandler): + """Handler for glGen___ type functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def InitFunction(self, func): + """Overrriden from TypeHandler.""" + pass + + def WriteHandlerImplementation (self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" GenGLObjects<GL%sHelper>(n, %s);\n" % + (func.name, func.GetLastOriginalArg().name)) + + def WriteImmediateHandlerImplementation(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" GenGLObjects<GL%sHelper>(n, %s);\n" % + (func.original_name, func.GetLastOriginalArg().name)) + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" MakeIds(%s);\n" % func.MakeOriginalArgString("")) + file.Write(" helper_->%sImmediate(%s);\n" % + (func.name, func.MakeOriginalArgString(""))) + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateCmdComputeSize(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" static uint32 ComputeDataSize(GLsizei n) {\n") + file.Write( + " return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + file.Write(" static uint32 ComputeSize(GLsizei n) {\n") + file.Write(" return static_cast<uint32>(\n") + file.Write(" sizeof(ValueType) + ComputeDataSize(n)); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSetHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" void SetHeader(GLsizei n) {\n") + file.Write(" header.SetCmdByTotalSize<ValueType>(ComputeSize(n));\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdInit(self, func, file): + """Overrriden from TypeHandler.""" + last_arg = func.GetLastOriginalArg() + file.Write(" void Init(%s, %s _%s) {\n" % + (func.MakeTypedCmdArgString("_"), + last_arg.type, last_arg.name)) + file.Write(" SetHeader(_n);\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));\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(" const uint32 size = ComputeSize(_n);\n") + file.Write(" return NextImmediateCmdAddressTotalSize<ValueType>(" + "cmd, size);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdHelper(self, func, file): + """Overrriden from TypeHandler.""" + args = func.MakeOriginalArgString("") + file.Write(" void %s(%s) {\n" % + (func.name, func.MakeTypedOriginalArgString(""))) + file.Write(" const uint32 size = gles2::%s::ComputeSize(n);\n" % + func.name) + file.Write(" gles2::%s& c = " + "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" % + (func.name, func.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" static GLuint ids[] = { 12, 23, 34, };\n") + file.Write(" int8 buf[256] = { 0, };\n") + file.Write(" %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" % + (func.name, func.name)) + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + args = func.GetCmdArgs() + value = 11 + for arg in args: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(",\n ids);\n") + args = func.GetCmdArgs() + value = 11 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + file.Write(" EXPECT_EQ(sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(cmd.n * 4),\n") + file.Write(" cmd.header.size * 4); // NOLINT\n") + for arg in args: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write(" // TODO(gman): Check that ids were inserted;\n") + file.Write("}\n") + file.Write("\n") + + +class CreateHandler(TypeHandler): + """Handler for glCreate___ type functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def InitFunction(self, func): + """Overrriden from TypeHandler.""" + func.AddCmdArg(CmdArg("client_id", 'uint32')) + + def WriteHandlerImplementation (self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" uint32 client_id = c.client_id;\n") + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" %sHelper(%s);\n" % + (func.name, func.MakeCmdArgString(""))) + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" GLuint client_id;\n") + file.Write(" MakeIds(1, &client_id);\n") + file.Write(" helper_->%s(%s);\n" % + (func.name, func.MakeCmdArgString(""))) + file.Write(" return client_id;\n") + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + +class DELnHandler(TypeHandler): + """Handler for glDelete___ type functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def WriteHandlerImplementation (self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" DeleteGLObjects<GL%sHelper>(n, %s);\n" % + (func.name, func.GetLastOriginalArg().name)) + + def WriteImmediateHandlerImplementation (self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" DeleteGLObjects<GL%sHelper>(n, %s);\n" % + (func.original_name, func.GetLastOriginalArg().name)) + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" FreeIds(%s);\n" % func.MakeOriginalArgString("")) + file.Write(" helper_->%sImmediate(%s);\n" % + (func.name, func.MakeOriginalArgString(""))) + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateCmdComputeSize(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" static uint32 ComputeDataSize(GLsizei n) {\n") + file.Write( + " return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + file.Write(" static uint32 ComputeSize(GLsizei n) {\n") + file.Write(" return static_cast<uint32>(\n") + file.Write(" sizeof(ValueType) + ComputeDataSize(n)); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSetHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" void SetHeader(GLsizei n) {\n") + file.Write(" header.SetCmdByTotalSize<ValueType>(ComputeSize(n));\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdInit(self, func, file): + """Overrriden from TypeHandler.""" + last_arg = func.GetLastOriginalArg() + file.Write(" void Init(%s, %s _%s) {\n" % + (func.MakeTypedCmdArgString("_"), + last_arg.type, last_arg.name)) + file.Write(" SetHeader(_n);\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));\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(" const uint32 size = ComputeSize(_n);\n") + file.Write(" return NextImmediateCmdAddressTotalSize<ValueType>(" + "cmd, size);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdHelper(self, func, file): + """Overrriden from TypeHandler.""" + args = func.MakeOriginalArgString("") + file.Write(" void %s(%s) {\n" % + (func.name, func.MakeTypedOriginalArgString(""))) + file.Write(" const uint32 size = gles2::%s::ComputeSize(n);\n" % + func.name) + file.Write(" gles2::%s& c = " + "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" % + (func.name, func.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" static GLuint ids[] = { 12, 23, 34, };\n") + file.Write(" int8 buf[256] = { 0, };\n") + file.Write(" %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" % + (func.name, func.name)) + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + args = func.GetCmdArgs() + value = 11 + for arg in args: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(",\n ids);\n") + args = func.GetCmdArgs() + value = 11 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + file.Write(" EXPECT_EQ(sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(cmd.n * 4),\n") + file.Write(" cmd.header.size * 4); // NOLINT\n") + for arg in args: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write(" // TODO(gman): Check that ids were inserted;\n") + file.Write("}\n") + file.Write("\n") + + +class GETnHandler(TypeHandler): + """Handler for GETn for glGetBooleanv, glGetFloatv, ... type functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def AddImmediateFunction(self, generator, func): + """Overrriden from TypeHandler.""" + pass + + def WriteServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + last_arg = func.GetLastOriginalArg() + + all_but_last_args = func.GetOriginalArgs()[:-1] + for arg in all_but_last_args: + arg.WriteGetCode(file) + + file.Write(" %s params;\n" % last_arg.type) + file.Write(" GLsizei num_values = util_.GLGetNumValuesReturned(pname);\n") + file.Write(" uint32 params_size = num_values * sizeof(*params);\n") + file.Write(" params = GetSharedMemoryAs<%s>(\n" % last_arg.type) + file.Write(" c.params_shm_id, c.params_shm_offset, params_size);\n") + func.WriteHandlerImplementation(file) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + all_but_last_args = func.GetOriginalArgs()[:-1] + arg_string = ( + ", ".join(["%s" % arg.name for arg in all_but_last_args])) + file.Write(" helper_->%s(%s, shared_memory_.GetId(), 0);\n" % + (func.name, arg_string)) + file.Write(" int32 token = helper_->InsertToken();\n") + file.Write(" helper_->WaitForToken(token);\n") + file.Write(" GLsizei num_values = util_.GLGetNumValuesReturned(pname);\n") + file.Write(" memcpy(params, shared_memory_.GetAddress(0),\n") + file.Write(" num_values * sizeof(*params));\n") + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + +class PUTHandler(TypeHandler): + """Handler for glTexParameter_v, glVertexAttrib_v functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def WriteImmediateValidationCode(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" if (!CheckImmediateDataSize<%s>(" + "arg_count, 1, sizeof(%s), %d)) {\n" % + (func.name, func.info.data_type, func.info.count)) + file.Write(" return parse_error::kParseOutOfBounds;\n") + file.Write(" }\n") + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" helper_->%sImmediate(%s);\n" % + (func.name, func.MakeOriginalArgString(""))) + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + 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.""" + last_arg = func.GetLastOriginalArg() + file.Write(" void Init(%s, %s _%s) {\n" % + (func.MakeTypedCmdArgString("_"), + 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(" 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.""" + args = func.MakeOriginalArgString("") + file.Write(" void %s(%s) {\n" % + (func.name, func.MakeTypedOriginalArgString(""))) + file.Write(" const uint32 size = gles2::%s::ComputeSize();\n" % + func.name) + file.Write(" gles2::%s& c = " + "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" % + (func.name, func.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" const int kSomeBaseValueToTestWith = 51;\n") + file.Write(" static %s data[] = {\n" % func.info.data_type) + for v in range(0, func.info.count): + file.Write(" static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" % + (func.info.data_type, v)) + file.Write(" };\n") + file.Write(" int8 buf[256] = { 0, };\n") + file.Write(" %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" % + (func.name, func.name)) + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + args = func.GetCmdArgs() + value = 11 + for arg in args: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(",\n data);\n") + args = func.GetCmdArgs() + value = 11 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + file.Write(" EXPECT_EQ(sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)),\n") + file.Write(" cmd.header.size * 4); // NOLINT\n") + for arg in args: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write(" // TODO(gman): Check that data was inserted;\n") + file.Write("}\n") + file.Write("\n") + + +class PUTnHandler(TypeHandler): + """Handler for PUTn 'glUniform__v' type functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def WriteImmediateValidationCode(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" if (!CheckImmediateDataSize<%s>(" + "arg_count, count, sizeof(%s), %d)) {\n" % + (func.name, func.info.data_type, func.info.count)) + file.Write(" return parse_error::kParseOutOfBounds;\n") + file.Write(" }\n") + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" helper_->%sImmediate(%s);\n" % + (func.name, func.MakeOriginalArgString(""))) + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateCmdComputeSize(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" static uint32 ComputeDataSize(GLsizei count) {\n") + file.Write(" return static_cast<uint32>(\n") + file.Write(" sizeof(%s) * %d * count); // NOLINT\n" % + (func.info.data_type, func.info.count)) + file.Write(" }\n") + file.Write("\n") + file.Write(" static uint32 ComputeSize(GLsizei count) {\n") + file.Write(" return static_cast<uint32>(\n") + file.Write( + " sizeof(ValueType) + ComputeDataSize(count)); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSetHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" void SetHeader(GLsizei count) {\n") + file.Write( + " header.SetCmdByTotalSize<ValueType>(ComputeSize(count));\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdInit(self, func, file): + """Overrriden from TypeHandler.""" + last_arg = func.GetLastOriginalArg() + file.Write(" void Init(%s, %s _%s) {\n" % + (func.MakeTypedCmdArgString("_"), + last_arg.type, last_arg.name)) + file.Write(" SetHeader(_count);\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(_count));\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(" const uint32 size = ComputeSize(_count);\n") + file.Write(" return NextImmediateCmdAddressTotalSize<ValueType>(" + "cmd, size);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdHelper(self, func, file): + """Overrriden from TypeHandler.""" + args = func.MakeOriginalArgString("") + file.Write(" void %s(%s) {\n" % + (func.name, func.MakeTypedOriginalArgString(""))) + file.Write(" const uint32 size = gles2::%s::ComputeSize(count);\n" % + func.name) + file.Write(" gles2::%s& c = " + "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" % + (func.name, func.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" const int kSomeBaseValueToTestWith = 51;\n") + file.Write(" static %s data[] = {\n" % func.info.data_type) + for v in range(0, func.info.count * 2): + file.Write(" static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" % + (func.info.data_type, v)) + file.Write(" };\n") + file.Write(" int8 buf[256] = { 0, };\n") + file.Write(" %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" % + (func.name, func.name)) + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + args = func.GetCmdArgs() + value = 1 + for arg in args: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(",\n data);\n") + args = func.GetCmdArgs() + value = 1 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + file.Write(" EXPECT_EQ(sizeof(cmd) +\n") + file.Write(" RoundSizeToMultipleOfEntries(sizeof(data)),\n") + file.Write(" cmd.header.size * 4); // NOLINT\n") + for arg in args: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write(" // TODO(gman): Check that data was inserted;\n") + file.Write("}\n") + file.Write("\n") + + +class GLcharHandler(TypeHandler): + """Handler for glBindAttrLoc, glGetAttibLoc, glGetUniformLoc.""" + + def __init__(self): + TypeHandler.__init__(self) + + def InitFunction(self, func): + """Overrriden from TypeHandler.""" + func.AddCmdArg(CmdArg('data_size', 'uint32')) + + def WriteServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + last_arg = func.GetLastOriginalArg() + + all_but_last_arg = func.GetOriginalArgs()[:-1] + for arg in all_but_last_arg: + arg.WriteGetCode(file) + + file.Write(" uint32 name_size = c.data_size;\n") + file.Write(" const char* name = GetSharedMemoryAs<%s>(\n" % + last_arg.type) + file.Write(" c.%s_shm_id, c.%s_shm_offset, name_size);\n" % + (last_arg.name, last_arg.name)) + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + arg_string = ", ".join(["%s" % arg.name for arg in all_but_last_arg]) + file.Write(" String name_str(name, name_size);\n") + file.Write(" %s(%s, name_str.c_str());\n" % + (func.GetGLFunctionName(), arg_string)) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteImmediateServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + last_arg = func.GetLastOriginalArg() + + all_but_last_arg = func.GetOriginalArgs()[:-1] + for arg in all_but_last_arg: + arg.WriteGetCode(file) + + file.Write(" uint32 name_size = c.data_size;\n") + file.Write( + " const char* name = GetImmediateDataAs<const char*>(c);\n") + file.Write(" // TODO(gman): Make sure validate checks arg_count\n") + file.Write(" // covers data_size.\n") + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + arg_string = ", ".join(["%s" % arg.name for arg in all_but_last_arg]) + file.Write(" String name_str(name, name_size);\n") + file.Write(" %s(%s, name_str.c_str());\n" % + (func.GetGLFunctionName(), arg_string)) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + file.Write(" // TODO(gman): This needs to change to use SendString.\n") + file.Write(" helper_->%sImmediate(%s);\n" % + (func.name, func.MakeOriginalArgString(""))) + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + def WriteImmediateCmdComputeSize(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" static uint32 ComputeDataSize(const char* s) {\n") + file.Write(" return strlen(s);\n") + file.Write(" }\n") + file.Write("\n") + file.Write(" static uint32 ComputeSize(const char* s) {\n") + file.Write(" return static_cast<uint32>(\n") + file.Write(" sizeof(ValueType) + ComputeDataSize(s)); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSetHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write(" void SetHeader(const char* s) {\n") + file.Write(" header.SetCmdByTotalSize<ValueType>(ComputeSize(s));\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdInit(self, func, file): + """Overrriden from TypeHandler.""" + last_arg = func.GetLastOriginalArg() + file.Write(" void Init(%s) {\n" % func.MakeTypedOriginalArgString("_")) + file.Write(" SetHeader(_%s);\n" % last_arg.name) + args = func.GetCmdArgs()[:-1] + for arg in args: + file.Write(" %s = _%s;\n" % (arg.name, arg.name)) + file.Write(" data_size = strlen(_%s);\n" % last_arg.name) + file.Write(" memcpy(ImmediateDataAddress(this), _%s, data_size);\n" % + last_arg.name) + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdSet(self, func, file): + """Overrriden from TypeHandler.""" + last_arg = func.GetLastOriginalArg() + file.Write(" void* Set(void* cmd%s) {\n" % + func.MakeTypedOriginalArgString("_", True)) + file.Write(" static_cast<ValueType*>(cmd)->Init(%s);\n" % + func.MakeOriginalArgString("_")) + file.Write(" const uint32 size = ComputeSize(_%s);\n" % last_arg.name) + file.Write(" return NextImmediateCmdAddressTotalSize<ValueType>(" + "cmd, size);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteImmediateCmdHelper(self, func, file): + """Overrriden from TypeHandler.""" + args = func.MakeOriginalArgString("") + last_arg = func.GetLastOriginalArg() + file.Write(" void %s(%s) {\n" % + (func.name, func.MakeTypedOriginalArgString(""))) + file.Write(" const uint32 size = gles2::%s::ComputeSize(%s);\n" % + (func.name, last_arg.name)) + file.Write(" gles2::%s& c = GetImmediateCmdSpaceTotalSize<gles2::%s>(" + "size);\n" % + (func.name, func.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + def WriteImmediateFormatTest(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name) + file.Write(" int8 buf[256] = { 0, };\n") + file.Write(" %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" % + (func.name, func.name)) + file.Write(" static const char* const test_str = \"test string\";\n") + file.Write(" void* next_cmd = cmd.Set(\n") + file.Write(" &cmd") + all_but_last_arg = func.GetCmdArgs()[:-1] + value = 11 + for arg in all_but_last_arg: + file.Write(",\n static_cast<%s>(%d)" % (arg.type, value)) + value += 1 + file.Write(",\n test_str);\n") + value = 11 + file.Write(" EXPECT_EQ(%s::kCmdId, cmd.header.command);\n" % func.name) + file.Write(" EXPECT_EQ(sizeof(cmd) + // NOLINT\n") + file.Write(" RoundSizeToMultipleOfEntries(strlen(test_str)),\n") + file.Write(" cmd.header.size * 4);\n") + for arg in all_but_last_arg: + file.Write(" EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" % + (arg.type, value, arg.name)) + value += 1 + file.Write(" // TODO(gman): check that string got copied.\n") + file.Write("}\n") + file.Write("\n") + + +class IsHandler(TypeHandler): + """Handler for glIs____ type and glGetError functions.""" + + def __init__(self): + TypeHandler.__init__(self) + + def InitFunction(self, func): + """Overrriden from TypeHandler.""" + func.AddCmdArg(CmdArg("result_shm_id", 'uint32')) + func.AddCmdArg(CmdArg("result_shm_offset", 'uint32')) + + def WriteServiceImplementation(self, func, file): + """Overrriden from TypeHandler.""" + file.Write( + "parse_error::ParseError GLES2Decoder::Handle%s(\n" % func.name) + file.Write( + " unsigned int arg_count, const gles2::%s& c) {\n" % func.name) + args = func.GetOriginalArgs() + for arg in args: + arg.WriteGetCode(file) + + file.Write(" %s* result_dst = GetSharedMemoryAs<%s*>(\n" % + (func.return_type, func.return_type)) + file.Write( + " c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));\n") + file.Write(" parse_error::ParseError result =\n") + file.Write(" Validate%s(this, arg_count%s);\n" % + (func.name, func.MakeOriginalArgString("", True))) + file.Write(" if (result != parse_error::kParseNoError) {\n") + file.Write(" return result;\n") + file.Write(" }\n") + file.Write(" *result_dst = %s(%s);\n" % + (func.GetGLFunctionName(), func.MakeOriginalArgString(""))) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("%s %s(%s) {\n" % + (func.return_type, func.original_name, + func.MakeTypedOriginalArgString(""))) + arg_string = func.MakeOriginalArgString("") + comma = "" + if len(arg_string) > 0: + comma = ", " + file.Write(" helper_->%s(%s%sshared_memory_.GetId(), 0);\n" % + (func.name, arg_string, comma)) + file.Write(" int32 token = helper_->InsertToken();\n") + file.Write(" helper_->WaitForToken(token);\n") + file.Write(" return *shared_memory_.GetAddressAs<%s*>(0);\n" % + func.return_type) + file.Write("}\n") + file.Write("\n") + + def WriteGLES2ImplementationImpl(self, func, file): + """Overrriden from TypeHandler.""" + pass + + +class STRnHandler(TypeHandler): + """Handler for GetProgramInfoLog, GetShaderInfoLog and GetShaderSource.""" + + def __init__(self): + TypeHandler.__init__(self) + + def WriteGLES2ImplementationHeader(self, func, file): + """Overrriden from TypeHandler.""" + file.Write("// TODO(gman): Implement this\n") + TypeHandler.WriteGLES2ImplementationHeader(self, func, file) + + +class FunctionInfo(object): + """Holds info about a function.""" + + def __init__(self, info, type_handler): + for key in info: + setattr(self, key, info[key]) + self.type_handler = type_handler + if not 'type' in info: + self.type = '' + + +class CmdArg(object): + """A class used to represent arguments at the command buffer level.""" + cmd_type_map_ = { + 'GLfloat': 'float', + 'GLclampf': 'float', + } + + def __init__(self, name, type): + self.name = name + self.type = type + + if type in self.cmd_type_map_: + self.cmd_type = self.cmd_type_map_[type] + else: + self.cmd_type = 'uint32' + + def WriteGetCode(self, file): + file.Write(" %s %s = static_cast<%s>(c.%s);\n" % + (self.type, self.name, self.type, self.name)) + + +class Argument(object): + """A class that represents a function argument.""" + + def __init__(self, name, type): + self.name = name + self.type = type + + def AddCmdArgs(self, args): + """Adds command arguments for this argument to the given list.""" + return args.append(CmdArg(self.name, self.type)) + + def WriteGetCode(self, file): + """Writes the code to get an argument from a command structure.""" + file.Write(" %s %s = static_cast<%s>(c.%s);\n" % + (self.type, self.name, self.type, self.name)) + + def WriteValidationCode(self, file): + """Writes the validation code for an argument.""" + pass + + def WriteGetAddress(self, file): + """Writes the code to get the address this argument refers to.""" + pass + + def GetImmediateVersion(self): + """Gets the immediate version of this argument.""" + return self + + +class ImmediatePointerArgument(Argument): + """A class that represents an immediate argument to a function. + + An immediate argument is one where the data follows the command. + """ + + def __init__(self, name, type): + Argument.__init__(self, name, type) + + def AddCmdArgs(self, args): + """Overridden from Argument.""" + pass + + def WriteGetCode(self, file): + """Overridden from Argument.""" + file.Write( + " %s %s = GetImmediateDataAs<%s>(c);\n" % + (self.type, self.name, self.type)) + + def WriteValidationCode(self, file): + """Overridden from Argument.""" + file.Write(" if (%s == NULL) {\n" % self.name) + file.Write(" return parse_error::kParseOutOfBounds;\n") + file.Write(" }\n") + + def GetImmediateVersion(self): + """Overridden from Argument.""" + return None + + +class PointerArgument(Argument): + """A class that represents a pointer argument to a function.""" + + def __init__(self, name, type): + Argument.__init__(self, name, type) + + def AddCmdArgs(self, args): + """Overridden from Argument.""" + args.append(CmdArg("%s_shm_id" % self.name, 'uint32')) + args.append(CmdArg("%s_shm_offset" % self.name, 'uint32')) + + def WriteGetCode(self, file): + """Overridden from Argument.""" + file.Write( + " %s %s = GetSharedMemoryAs<%s>(\n" % + (self.type, self.name, self.type)) + file.Write( + " c.%s_shm_id, c.%s_shm_offset, 0 /* TODO(gman): size */);\n" % + (self.name, self.name)) + + def WriteGetAddress(self, file): + """Overridden from Argument.""" + file.Write( + " %s %s = GetSharedMemoryAs<%s>(\n" % + (self.type, self.name, self.type)) + file.Write( + " %s_shm_id, %s_shm_offset, %s_size);\n" % + (self.name, self.name, self.name)) + + def WriteValidationCode(self, file): + """Overridden from Argument.""" + file.Write(" if (%s == NULL) {\n" % self.name) + file.Write(" return parse_error::kParseOutOfBounds;\n") + file.Write(" }\n") + + def GetImmediateVersion(self): + """Overridden from Argument.""" + return ImmediatePointerArgument(self.name, self.type) + + +class Function(object): + """A class that represents a function.""" + + def __init__(self, name, info, return_type, original_args, args_for_cmds, + cmd_args, num_pointer_args): + self.name = name + self.original_name = name + self.info = info + self.type_handler = info.type_handler + self.return_type = return_type + self.original_args = original_args + self.num_pointer_args = num_pointer_args + self.can_auto_generate = num_pointer_args == 0 and return_type == "void" + self.cmd_args = cmd_args + self.args_for_cmds = args_for_cmds + self.type_handler.InitFunction(self) + + def IsType(self, type_name): + """Returns true if function is a certain type.""" + return self.info.type == type_name + + def GetInfo(self, name): + """Returns a value from the function info for this function.""" + if hasattr(self.info, name): + return getattr(self.info, name) + return None + + def GetGLFunctionName(self): + """Gets the function to call to execute GL for this command.""" + if self.GetInfo('DecoderFunc'): + return self.GetInfo('DecoderFunc') + return "gl%s" % self.original_name + + def AddCmdArg(self, arg): + """Adds a cmd argument to this function.""" + self.cmd_args.append(arg) + + def GetCmdArgs(self): + """Gets the command args for this function.""" + return self.cmd_args + + def GetOriginalArgs(self): + """Gets the original arguments to this function.""" + return self.original_args + + def GetLastOriginalArg(self): + """Gets the last original argument to this function.""" + return self.original_args[len(self.original_args) - 1] + + def __GetArgList(self, arg_string, add_comma): + """Adds a comma if arg_string is not empty and add_comma is true.""" + comma = "" + if add_comma and len(arg_string): + comma = ", " + return "%s%s" % (comma, arg_string) + + def MakeTypedOriginalArgString(self, prefix, add_comma = False): + """Gets a list of arguments as they arg in GL.""" + args = self.GetOriginalArgs() + arg_string = ", ".join( + ["%s %s%s" % (arg.type, prefix, arg.name) for arg in args]) + return self.__GetArgList(arg_string, add_comma) + + def MakeOriginalArgString(self, prefix, add_comma = False): + """Gets the list of arguments as they are in GL.""" + args = self.GetOriginalArgs() + arg_string = ", ".join( + ["%s%s" % (prefix, arg.name) for arg in args]) + return self.__GetArgList(arg_string, add_comma) + + def MakeTypedCmdArgString(self, prefix, add_comma = False): + """Gets a typed list of arguments as they need to be for command buffers.""" + args = self.GetCmdArgs() + arg_string = ", ".join( + ["%s %s%s" % (arg.type, prefix, arg.name) for arg in args]) + return self.__GetArgList(arg_string, add_comma) + + def MakeCmdArgString(self, prefix, add_comma = False): + """Gets the list of arguments as they need to be for command buffers.""" + args = self.GetCmdArgs() + arg_string = ", ".join( + ["%s%s" % (prefix, arg.name) for arg in args]) + return self.__GetArgList(arg_string, add_comma) + + def WriteHandlerImplementation(self, file): + """Writes the handler implementation for this command.""" + self.type_handler.WriteHandlerImplementation(self, file) + + def WriteValidationCode(self, file): + """Writes the validation code for a command.""" + pass + + def WriteCmdArgFlag(self, file): + """Writes the cmd kArgFlags constant.""" + file.Write(" static const cmd::ArgFlags kArgFlags = cmd::kFixed;\n") + + def WriteCmdComputeSize(self, file): + """Writes the ComputeSize function for the command.""" + file.Write(" static uint32 ComputeSize() {\n") + file.Write( + " return static_cast<uint32>(sizeof(ValueType)); // NOLINT\n") + file.Write(" }\n") + file.Write("\n") + + def WriteCmdSetHeader(self, file): + """Writes the cmd's SetHeader function.""" + file.Write(" void SetHeader() {\n") + file.Write(" header.SetCmd<ValueType>();\n") + file.Write(" }\n") + file.Write("\n") + + def WriteCmdInit(self, file): + """Writes the cmd's Init function.""" + file.Write(" void Init(%s) {\n" % self.MakeTypedCmdArgString("_")) + file.Write(" SetHeader();\n") + args = self.GetCmdArgs() + for arg in args: + file.Write(" %s = _%s;\n" % (arg.name, arg.name)) + file.Write(" }\n") + file.Write("\n") + + def WriteCmdSet(self, file): + """Writes the cmd's Set function.""" + copy_args = self.MakeCmdArgString("_", False) + file.Write(" void* Set(void* cmd%s) {\n" % + self.MakeTypedCmdArgString("_", True)) + file.Write(" static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args) + file.Write(" return NextCmdAddress<ValueType>(cmd);\n") + file.Write(" }\n") + file.Write("\n") + + def WriteStruct(self, file): + """Writes a structure that matched the arguments to the function.""" + file.Write("struct %s {\n" % self.name) + file.Write(" typedef %s ValueType;\n" % self.name) + file.Write(" static const CommandId kCmdId = k%s;\n" % self.name) + self.WriteCmdArgFlag(file) + file.Write("\n") + + self.WriteCmdComputeSize(file) + self.WriteCmdSetHeader(file) + self.WriteCmdInit(file) + self.WriteCmdSet(file) + + file.Write(" command_buffer::CommandHeader header;\n") + args = self.GetCmdArgs() + for arg in args: + file.Write(" %s %s;\n" % (arg.cmd_type, arg.name)) + file.Write("};\n") + file.Write("\n") + + size = len(args) * _SIZE_OF_UINT32 + _SIZE_OF_COMMAND_HEADER + file.Write("COMPILE_ASSERT(sizeof(%s) == %d,\n" % (self.name, size)) + file.Write(" Sizeof_%s_is_not_%d);\n" % (self.name, size)) + file.Write("COMPILE_ASSERT(offsetof(%s, header) == 0,\n" % self.name) + file.Write(" OffsetOf_%s_header_not_0);\n" % self.name) + offset = _SIZE_OF_COMMAND_HEADER + for arg in args: + file.Write("COMPILE_ASSERT(offsetof(%s, %s) == %d,\n" % + (self.name, arg.name, offset)) + file.Write(" OffsetOf_%s_%s_not_%d);\n" % + (self.name, arg.name, offset)) + offset += _SIZE_OF_UINT32 + file.Write("\n") + + def WriteCmdHelper(self, file): + """Writes the cmd's helper.""" + args = self.MakeCmdArgString("") + file.Write(" void %s(%s) {\n" % + (self.name, self.MakeTypedCmdArgString(""))) + file.Write(" gles2::%s& c = GetCmdSpace<gles2::%s>();\n" % + (self.name, self.name)) + file.Write(" c.Init(%s);\n" % args) + file.Write(" }\n\n") + + def WriteServiceImplementation(self, file): + """Writes the service implementation for a command.""" + self.type_handler.WriteServiceImplementation(self, file) + + def WriteGLES2ImplementationHeader(self, file): + """Writes the GLES2 Implemention declaration.""" + self.type_handler.WriteGLES2ImplementationHeader(self, file) + + def WriteGLES2ImplementationImpl(self, file): + """Writes the GLES2 Implemention definition.""" + self.type_handler.WriteGLES2ImplementationImpl(self, file) + + def WriteFormatTest(self, file): + """Writes the cmd's format test.""" + self.type_handler.WriteFormatTest(self, file) + + +class ImmediateFunction(Function): + """A class that represnets an immediate function command.""" + + def __init__(self, func): + new_args = [] + for arg in func.GetOriginalArgs(): + new_arg = arg.GetImmediateVersion() + if new_arg: + new_args.append(new_arg) + + cmd_args = [] + new_args_for_cmds = [] + for arg in func.args_for_cmds: + new_arg = arg.GetImmediateVersion() + if new_arg: + new_args_for_cmds.append(new_arg) + new_arg.AddCmdArgs(cmd_args) + + Function.__init__( + self, + "%sImmediate" % func.name, + func.info, + func.return_type, + new_args, + new_args_for_cmds, + cmd_args, + 0) + self.original_name = func.name + + def WriteServiceImplementation(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateServiceImplementation(self, file) + + def WriteHandlerImplementation(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateHandlerImplementation(self, file) + + def WriteValidationCode(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateValidationCode(self, file) + + def WriteCmdArgFlag(self, file): + """Overridden from Function""" + file.Write(" static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;\n") + + def WriteCmdComputeSize(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateCmdComputeSize(self, file) + + def WriteCmdSetHeader(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateCmdSetHeader(self, file) + + def WriteCmdInit(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateCmdInit(self, file) + + def WriteCmdSet(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateCmdSet(self, file) + + def WriteCmdHelper(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateCmdHelper(self, file) + + def WriteFormatTest(self, file): + """Overridden from Function""" + self.type_handler.WriteImmediateFormatTest(self, file) + + +class GLGenerator(object): + """A class to generate GL command buffers.""" + + _function_re = re.compile(r'GL_APICALL(.*?)GL_APIENTRY (.*?) \((.*?)\);') + _non_alnum_re = re.compile(r'[^a-zA-Z0-9]') + + def __init__(self, verbose): + self.original_functions = [] + self.functions = [] + self.verbose = verbose + self._function_info = {} + self._empty_type_handler = TypeHandler() + self._empty_function_info = FunctionInfo({}, self._empty_type_handler) + + self._type_handlers = { + 'Create': CreateHandler(), + 'Custom': CustomHandler(), + 'Data': DataHandler(), + 'DELn': DELnHandler(), + 'GENn': GENnHandler(), + 'GETn': GETnHandler(), + 'GLchar': GLcharHandler(), + 'Is': IsHandler(), + 'Manual': ManualHandler(), + 'PUT': PUTHandler(), + 'PUTn': PUTnHandler(), + 'STRn': STRnHandler(), + 'Todo': TodoHandler(), + } + + for func_name in _FUNCTION_INFO: + info = _FUNCTION_INFO[func_name] + type = '' + if 'type' in info: + type = info['type'] + self._function_info[func_name] = FunctionInfo(info, + self.GetTypeHandler(type)) + + def AddFunction(self, func): + """Adds a function.""" + self.functions.append(func) + + def GetTypeHandler(self, name): + """Gets a type info for the given type.""" + if name in self._type_handlers: + return self._type_handlers[name] + return self._empty_type_handler + + def GetFunctionInfo(self, name): + """Gets a type info for the given function name.""" + if name in self._function_info: + return self._function_info[name] + return self._empty_function_info + + def Log(self, msg): + """Prints something if verbose is true.""" + if self.verbose: + print msg + + def WriteHeader(self, file): + """Writes header to file""" + file.Write( + "// This file is auto-generated. DO NOT EDIT!\n" + "\n") + + def WriteLicense(self, file): + """Writes the license.""" + file.Write(_LICENSE) + + def WriteNamespaceOpen(self, file): + """Writes the code for the namespace.""" + file.Write("namespace command_buffer {\n") + file.Write("namespace gles2 {\n") + file.Write("\n") + + def WriteNamespaceClose(self, file): + """Writes the code to close the namespace.""" + file.Write("} // namespace gles2\n") + file.Write("} // namespace command_buffer\n") + file.Write("\n") + + def MakeGuard(self, filename): + """Creates a header guard id.""" + base = os.path.dirname(os.path.dirname(os.path.dirname( + os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))) + hpath = os.path.abspath(filename)[len(base) + 1:] + return self._non_alnum_re.sub('_', hpath).upper() + + def ParseArgs(self, arg_string): + """Parses a function arg string.""" + args = [] + num_pointer_args = 0 + parts = arg_string.split(',') + for arg in parts: + arg_parts = arg.split() + if len(arg_parts) == 1 and arg_parts[0] == 'void': + pass + # Is this a pointer argument? + elif arg.find('*') >= 0: + num_pointer_args += 1 + args.append(PointerArgument( + arg_parts[-1], + " ".join(arg_parts[0:-1]))) + else: + args.append(Argument( + arg_parts[-1], + " ".join(arg_parts[0:-1]))) + return (args, num_pointer_args) + + def ParseGLH(self, filename): + """Parses the GL2.h file and extracts the functions""" + file = open(filename, "r") + for line in file.readlines(): + match = self._function_re.match(line) + if match: + func_name = match.group(2)[2:] + func_info = self.GetFunctionInfo(func_name) + if func_info.type != 'Noop': + return_type = match.group(1).strip() + arg_string = match.group(3) + (args, num_pointer_args) = self.ParseArgs(arg_string) + args_for_cmds = args + if hasattr(func_info, 'cmd_args'): + (args_for_cmds, num_pointer_args) = ( + self.ParseArgs(getattr(func_info, 'cmd_args'))) + cmd_args = [] + for arg in args_for_cmds: + arg.AddCmdArgs(cmd_args) + f = Function(func_name, func_info, return_type, args, args_for_cmds, + cmd_args, num_pointer_args) + self.original_functions.append(f) + self.AddFunction(f) + f.type_handler.AddImmediateFunction(self, f) + file.close() + + self.Log("Auto Generated Functions : %d" % + len([f for f in self.functions if f.can_auto_generate or + (not f.IsType('') and not f.IsType('Custom') and + not f.IsType('Todo'))])) + + funcs = [f for f in self.functions if not f.can_auto_generate and + (f.IsType('') or f.IsType('Custom') or f.IsType('Todo'))] + self.Log("Non Auto Generated Functions: %d" % len(funcs)) + + for f in funcs: + self.Log(" %-10s %-20s gl%s" % (f.info.type, f.return_type, f.name)) + + def WriteFormat(self, filename): + """Writes the command buffer format""" + guard = self.MakeGuard(filename) + file = CWriter(filename) + self.WriteHeader(file) + file.Write("\n") + file.Write("#ifndef %s\n" % guard) + file.Write("#define %s\n" % guard) + file.Write("\n") + file.Write( + "#include \"gpu/command_buffer/common/gles2_cmd_utils.h\"\n") + file.Write( + "#include \"gpu/command_buffer/common/cmd_buffer_common.h\"\n") + file.Write("\n") + + self.WriteNamespaceOpen(file) + + file.Write("#define GLES2_COMMAND_LIST(OP) \\\n") + command_id = _FIRST_SPECIFIC_COMMAND_ID + for func in self.functions: + file.Write(" %-60s /* %d */ \\\n" % ("OP(%s)" % func.name, command_id)) + command_id += 1 + file.Write("\n") + + file.Write("enum CommandId {\n") + file.Write(" kStartPoint = cmd::kLastCommonId, " + "// All GLES2 commands start after this.\n") + file.Write("#define GLES2_CMD_OP(name) k ## name,\n") + file.Write(" GLES2_COMMAND_LIST(GLES2_CMD_OP)\n") + file.Write("#undef GLES2_CMD_OP\n") + file.Write(" kNumCommands\n") + file.Write("};\n") + file.Write("\n") + file.Write("#pragma pack(push, 1)\n") + file.Write("\n") + + for func in self.functions: + func.WriteStruct(file) + + self.WriteNamespaceClose(file) + + file.Write("#pragma pack(pop)\n") + file.Write("\n") + file.Write("#endif // %s\n" % guard) + file.Close() + + def WriteFormatTest(self, filename): + """Writes the command buffer format test.""" + file = CWriter(filename) + self.WriteHeader(file) + file.Write("// This file contains unit tests for gles2 commmands\n") + file.Write("// It is included by gles2_cmd_format_test.cc\n") + file.Write("\n") + + for func in self.functions: + func.WriteFormatTest(file) + + file.Close() + + def WriteCommandIdTest(self, filename): + """Writes the command id test.""" + file = CWriter(filename) + self.WriteLicense(file) + file.Write("// This file contains unit tests for gles2 commmand ids\n") + file.Write("\n") + file.Write("#include \"tests/common/win/testing_common.h\"\n") + file.Write("#include \"gpu/command_buffer/common/gles2_cmd_format.h\"\n") + file.Write("\n") + + self.WriteNamespaceOpen(file) + + file.Write("// *** These IDs MUST NOT CHANGE!!! ***\n") + file.Write("// Changing them will break all client programs.\n") + file.Write("TEST(GLES2CommandIdTest, CommandIdsMatch) {\n") + command_id = 1024 + for func in self.functions: + file.Write(" COMPILE_ASSERT(%s::kCmdId == %d,\n" % + (func.name, command_id)) + file.Write(" GLES2_%s_kCmdId_mismatch);\n" % func.name) + command_id += 1 + + file.Write("}\n") + + self.WriteNamespaceClose(file) + + file.Close() + + def WriteCmdHelperHeader(self, filename): + """Writes the gles2 command helper.""" + file = CWriter(filename) + + for func in self.functions: + func.WriteCmdHelper(file) + + file.Close() + + def WriteServiceImplementation(self, filename): + """Writes the service decorder implementation.""" + file = CWriter(filename) + self.WriteHeader(file) + file.Write("// It is included by gles2_cmd_decoder.cc\n") + file.Write("\n") + + for func in self.functions: + func.WriteServiceImplementation(file) + + file.Close() + + def WriteServiceValidation(self, filename): + file = CWriter(filename) + self.WriteLicense(file) + file.Write("\n") + self.WriteNamespaceOpen(file) + file.Write("namespace {\n") + file.Write("\n") + for func in self.functions: + file.Write("parse_error::ParseError Validate%s(\n" % func.name) + file.Write(" GLES2Decoder* decoder, unsigned int arg_count%s) {\n" % + func.MakeTypedOriginalArgString("", True)) + for arg in func.GetOriginalArgs(): + arg.WriteValidationCode(file) + func.WriteValidationCode(file) + file.Write(" return parse_error::kParseNoError;\n") + file.Write("}\n") + file.Write("} // anonymous namespace\n") + self.WriteNamespaceClose(file) + file.Close() + + def WriteGLES2LibHeader(self, filename): + """Writes the GLES2 lib header.""" + file = CWriter(filename) + self.WriteHeader(file) + file.Write("\n") + file.Write("// These functions emluate GLES2 over command buffers.\n") + file.Write("\n") + file.Write("\n") + + for func in self.original_functions: + file.Write("inline %s gl%s(%s) {\n" % + (func.return_type, func.name, + func.MakeTypedOriginalArgString(""))) + return_string = "return " + if func.return_type == "void": + return_string = "" + file.Write(" %sg_gl_impl->%s(%s);\n" % + (return_string, func.original_name, + func.MakeOriginalArgString(""))) + file.Write("}\n") + + file.Write("\n") + + file.Close() + + def WriteGLES2ImplementationHeader(self, filename): + """Writes the GLES2 helper header.""" + file = CWriter(filename) + self.WriteHeader(file) + file.Write( + "// This file is included by gles2_implementation.h to declare the\n") + file.Write("// GL api functions.\n") + for func in self.original_functions: + func.WriteGLES2ImplementationHeader(file) + file.Close() + + def WriteGLES2ImplementationImpl(self, filename): + """Writes the gles2 helper implementation.""" + file = CWriter(filename) + self.WriteLicense(file) + file.Write("\n") + file.Write("// A class to emluate GLES2 over command buffers.\n") + file.Write("\n") + file.Write( + "#include \"gpu/command_buffer/client/gles2_implementation.h\"\n") + file.Write("\n") + self.WriteNamespaceOpen(file) + for func in self.original_functions: + func.WriteGLES2ImplementationImpl(file) + file.Write("\n") + + self.WriteNamespaceClose(file) + file.Close() + + +def main(argv): + """This is the main function.""" + parser = OptionParser() + parser.add_option( + "-g", "--generate-implementation-templates", action="store_true", + help="generates files that are generally hand edited..") + parser.add_option( + "--generate-command-id-tests", action="store_true", + help="generate tests for commands ids. Commands MUST not change ID!") + parser.add_option( + "-v", "--verbose", action="store_true", + help="prints more output.") + + (options, args) = parser.parse_args(args=argv) + + gen = GLGenerator(options.verbose) + gen.ParseGLH("common/GLES2/gl2.h") + gen.WriteFormat("common/gles2_cmd_format.h") + gen.WriteFormatTest("common/gles2_cmd_format_test_autogen.h") + gen.WriteGLES2ImplementationHeader("client/gles2_implementation_autogen.h") + gen.WriteGLES2LibHeader("client/gles2_lib_autogen.h") + gen.WriteCmdHelperHeader("client/gles2_cmd_helper_autogen.h") + gen.WriteServiceImplementation("service/gles2_cmd_decoder_autogen.h") + + if options.generate_implementation_templates: + gen.WriteGLES2ImplementationImpl("client/gles2_implementation_gen.h") + gen.WriteServiceValidation("service/gles2_cmd_decoder_validate.h") + + if options.generate_command_id_tests: + gen.WriteCommandIdTest("common/gles2_cmd_id_test.cc") + + +if __name__ == '__main__': + main(sys.argv[1:]) + diff --git a/o3d/gpu/command_buffer/client/cmd_buffer_helper.h b/o3d/gpu/command_buffer/client/cmd_buffer_helper.h index d63a53e..f416baa 100644 --- a/o3d/gpu/command_buffer/client/cmd_buffer_helper.h +++ b/o3d/gpu/command_buffer/client/cmd_buffer_helper.h @@ -162,9 +162,18 @@ class CommandBufferHelper { // Typed version of GetSpace for immediate commands. template <typename T> - T& GetImmediateCmdSpace(size_t space) { + T& GetImmediateCmdSpace(size_t data_space) { COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); - uint32 space_needed = ComputeNumEntries(sizeof(T) + space); + uint32 space_needed = ComputeNumEntries(sizeof(T) + data_space); + void* data = GetSpace(space_needed); + return *reinterpret_cast<T*>(data); + } + + // Typed version of GetSpace for immediate commands. + template <typename T> + T& GetImmediateCmdSpaceTotalSize(size_t total_space) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + uint32 space_needed = ComputeNumEntries(total_space); void* data = GetSpace(space_needed); return *reinterpret_cast<T*>(data); } diff --git a/o3d/gpu/command_buffer/client/gles2_cmd_helper.cc b/o3d/gpu/command_buffer/client/gles2_cmd_helper.cc new file mode 100644 index 0000000..1dff914 --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_cmd_helper.cc @@ -0,0 +1,14 @@ +// Copyright (c) 2006-2009 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. + +#include "gpu/command_buffer/client/gles2_cmd_helper.h" + +namespace command_buffer { + +// Currently this is a place holder. + +} // namespace command_buffer + + + diff --git a/o3d/gpu/command_buffer/client/gles2_cmd_helper.h b/o3d/gpu/command_buffer/client/gles2_cmd_helper.h new file mode 100644 index 0000000..87f3054 --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_cmd_helper.h @@ -0,0 +1,39 @@ +// Copyright (c) 2006-2009 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. + +#ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_H +#define GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_H + +#include "gpu/command_buffer/client/cmd_buffer_helper.h" +#include "gpu/command_buffer/common/gles2_cmd_utils.h" +#include "gpu/command_buffer/common/gles2_cmd_format.h" + +namespace command_buffer { +namespace gles2 { + +// A class that helps write GL command buffers. +class GLES2CmdHelper : public CommandBufferHelper { + public: + GLES2CmdHelper( + NPP npp, + const gpu_plugin::NPObjectPointer<gpu_plugin::CommandBuffer>& + command_buffer) + : CommandBufferHelper(npp, command_buffer) { + } + virtual ~GLES2CmdHelper() { + } + + // Include the auto-generated part of this class. We split this because it + // means we can easily edit the non-auto generated parts right here in this + // file instead of having to edit some template or the code generator. + #include "gpu/command_buffer/client/gles2_cmd_helper_autogen.h" + + DISALLOW_COPY_AND_ASSIGN(GLES2CmdHelper); +}; + +} // namespace gles2 +} // namespace command_buffer + +#endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_H + diff --git a/o3d/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/o3d/gpu/command_buffer/client/gles2_cmd_helper_autogen.h new file mode 100644 index 0000000..9af93cd --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_cmd_helper_autogen.h @@ -0,0 +1,1138 @@ + void ActiveTexture(GLenum texture) { + gles2::ActiveTexture& c = GetCmdSpace<gles2::ActiveTexture>(); + c.Init(texture); + } + + void AttachShader(GLuint program, GLuint shader) { + gles2::AttachShader& c = GetCmdSpace<gles2::AttachShader>(); + c.Init(program, shader); + } + + void BindAttribLocation( + GLuint program, GLuint index, uint32 name_shm_id, uint32 name_shm_offset, + uint32 data_size) { + gles2::BindAttribLocation& c = GetCmdSpace<gles2::BindAttribLocation>(); + c.Init(program, index, name_shm_id, name_shm_offset, data_size); + } + + void BindAttribLocationImmediate( + GLuint program, GLuint index, const char* name) { + const uint32 size = gles2::BindAttribLocationImmediate::ComputeSize(name); + gles2::BindAttribLocationImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::BindAttribLocationImmediate>( + size); + c.Init(program, index, name); + } + + void BindBuffer(GLenum target, GLuint buffer) { + gles2::BindBuffer& c = GetCmdSpace<gles2::BindBuffer>(); + c.Init(target, buffer); + } + + void BindFramebuffer(GLenum target, GLuint framebuffer) { + gles2::BindFramebuffer& c = GetCmdSpace<gles2::BindFramebuffer>(); + c.Init(target, framebuffer); + } + + void BindRenderbuffer(GLenum target, GLuint renderbuffer) { + gles2::BindRenderbuffer& c = GetCmdSpace<gles2::BindRenderbuffer>(); + c.Init(target, renderbuffer); + } + + void BindTexture(GLenum target, GLuint texture) { + gles2::BindTexture& c = GetCmdSpace<gles2::BindTexture>(); + c.Init(target, texture); + } + + void BlendColor( + GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + gles2::BlendColor& c = GetCmdSpace<gles2::BlendColor>(); + c.Init(red, green, blue, alpha); + } + + void BlendEquation(GLenum mode) { + gles2::BlendEquation& c = GetCmdSpace<gles2::BlendEquation>(); + c.Init(mode); + } + + void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { + gles2::BlendEquationSeparate& c = + GetCmdSpace<gles2::BlendEquationSeparate>(); + c.Init(modeRGB, modeAlpha); + } + + void BlendFunc(GLenum sfactor, GLenum dfactor) { + gles2::BlendFunc& c = GetCmdSpace<gles2::BlendFunc>(); + c.Init(sfactor, dfactor); + } + + void BlendFuncSeparate( + GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { + gles2::BlendFuncSeparate& c = GetCmdSpace<gles2::BlendFuncSeparate>(); + c.Init(srcRGB, dstRGB, srcAlpha, dstAlpha); + } + + void BufferData( + GLenum target, GLsizeiptr size, uint32 data_shm_id, + uint32 data_shm_offset, GLenum usage) { + gles2::BufferData& c = GetCmdSpace<gles2::BufferData>(); + c.Init(target, size, data_shm_id, data_shm_offset, usage); + } + + void BufferDataImmediate(GLenum target, GLsizeiptr size, GLenum usage) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::BufferDataImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::BufferDataImmediate>(s); + c.Init(target, size, usage); + } + + void BufferSubData( + GLenum target, GLintptr offset, GLsizeiptr size, uint32 data_shm_id, + uint32 data_shm_offset) { + gles2::BufferSubData& c = GetCmdSpace<gles2::BufferSubData>(); + c.Init(target, offset, size, data_shm_id, data_shm_offset); + } + + void BufferSubDataImmediate( + GLenum target, GLintptr offset, GLsizeiptr size) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::BufferSubDataImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::BufferSubDataImmediate>(s); + c.Init(target, offset, size); + } + + void CheckFramebufferStatus(GLenum target) { + gles2::CheckFramebufferStatus& c = + GetCmdSpace<gles2::CheckFramebufferStatus>(); + c.Init(target); + } + + void Clear(GLbitfield mask) { + gles2::Clear& c = GetCmdSpace<gles2::Clear>(); + c.Init(mask); + } + + void ClearColor( + GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + gles2::ClearColor& c = GetCmdSpace<gles2::ClearColor>(); + c.Init(red, green, blue, alpha); + } + + void ClearDepthf(GLclampf depth) { + gles2::ClearDepthf& c = GetCmdSpace<gles2::ClearDepthf>(); + c.Init(depth); + } + + void ClearStencil(GLint s) { + gles2::ClearStencil& c = GetCmdSpace<gles2::ClearStencil>(); + c.Init(s); + } + + void ColorMask( + GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { + gles2::ColorMask& c = GetCmdSpace<gles2::ColorMask>(); + c.Init(red, green, blue, alpha); + } + + void CompileShader(GLuint shader) { + gles2::CompileShader& c = GetCmdSpace<gles2::CompileShader>(); + c.Init(shader); + } + + void CompressedTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLsizei width, + GLsizei height, GLint border, GLsizei imageSize, uint32 data_shm_id, + uint32 data_shm_offset) { + gles2::CompressedTexImage2D& c = + GetCmdSpace<gles2::CompressedTexImage2D>(); + c.Init( + target, level, internalformat, width, height, border, imageSize, + data_shm_id, data_shm_offset); + } + + void CompressedTexImage2DImmediate( + GLenum target, GLint level, GLenum internalformat, GLsizei width, + GLsizei height, GLint border, GLsizei imageSize) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::CompressedTexImage2DImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::CompressedTexImage2DImmediate>(s); + c.Init(target, level, internalformat, width, height, border, imageSize); + } + + void CompressedTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLsizei imageSize, uint32 data_shm_id, + uint32 data_shm_offset) { + gles2::CompressedTexSubImage2D& c = + GetCmdSpace<gles2::CompressedTexSubImage2D>(); + c.Init( + target, level, xoffset, yoffset, width, height, format, imageSize, + data_shm_id, data_shm_offset); + } + + void CompressedTexSubImage2DImmediate( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLsizei imageSize) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::CompressedTexSubImage2DImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::CompressedTexSubImage2DImmediate>( + s); + c.Init(target, level, xoffset, yoffset, width, height, format, imageSize); + } + + void CopyTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, + GLsizei width, GLsizei height, GLint border) { + gles2::CopyTexImage2D& c = GetCmdSpace<gles2::CopyTexImage2D>(); + c.Init(target, level, internalformat, x, y, width, height, border); + } + + void CopyTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, + GLint y, GLsizei width, GLsizei height) { + gles2::CopyTexSubImage2D& c = GetCmdSpace<gles2::CopyTexSubImage2D>(); + c.Init(target, level, xoffset, yoffset, x, y, width, height); + } + + void CreateProgram(uint32 client_id) { + gles2::CreateProgram& c = GetCmdSpace<gles2::CreateProgram>(); + c.Init(client_id); + } + + void CreateShader(GLenum type, uint32 client_id) { + gles2::CreateShader& c = GetCmdSpace<gles2::CreateShader>(); + c.Init(type, client_id); + } + + void CullFace(GLenum mode) { + gles2::CullFace& c = GetCmdSpace<gles2::CullFace>(); + c.Init(mode); + } + + void DeleteBuffers( + GLsizei n, uint32 buffers_shm_id, uint32 buffers_shm_offset) { + gles2::DeleteBuffers& c = GetCmdSpace<gles2::DeleteBuffers>(); + c.Init(n, buffers_shm_id, buffers_shm_offset); + } + + void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) { + const uint32 size = gles2::DeleteBuffersImmediate::ComputeSize(n); + gles2::DeleteBuffersImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::DeleteBuffersImmediate>(size); + c.Init(n, buffers); + } + + void DeleteFramebuffers( + GLsizei n, uint32 framebuffers_shm_id, uint32 framebuffers_shm_offset) { + gles2::DeleteFramebuffers& c = GetCmdSpace<gles2::DeleteFramebuffers>(); + c.Init(n, framebuffers_shm_id, framebuffers_shm_offset); + } + + void DeleteFramebuffersImmediate(GLsizei n, const GLuint* framebuffers) { + const uint32 size = gles2::DeleteFramebuffersImmediate::ComputeSize(n); + gles2::DeleteFramebuffersImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::DeleteFramebuffersImmediate>( + size); + c.Init(n, framebuffers); + } + + void DeleteProgram(GLuint program) { + gles2::DeleteProgram& c = GetCmdSpace<gles2::DeleteProgram>(); + c.Init(program); + } + + void DeleteRenderbuffers( + GLsizei n, uint32 renderbuffers_shm_id, + uint32 renderbuffers_shm_offset) { + gles2::DeleteRenderbuffers& c = GetCmdSpace<gles2::DeleteRenderbuffers>(); + c.Init(n, renderbuffers_shm_id, renderbuffers_shm_offset); + } + + void DeleteRenderbuffersImmediate(GLsizei n, const GLuint* renderbuffers) { + const uint32 size = gles2::DeleteRenderbuffersImmediate::ComputeSize(n); + gles2::DeleteRenderbuffersImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::DeleteRenderbuffersImmediate>( + size); + c.Init(n, renderbuffers); + } + + void DeleteShader(GLuint shader) { + gles2::DeleteShader& c = GetCmdSpace<gles2::DeleteShader>(); + c.Init(shader); + } + + void DeleteTextures( + GLsizei n, uint32 textures_shm_id, uint32 textures_shm_offset) { + gles2::DeleteTextures& c = GetCmdSpace<gles2::DeleteTextures>(); + c.Init(n, textures_shm_id, textures_shm_offset); + } + + void DeleteTexturesImmediate(GLsizei n, const GLuint* textures) { + const uint32 size = gles2::DeleteTexturesImmediate::ComputeSize(n); + gles2::DeleteTexturesImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::DeleteTexturesImmediate>(size); + c.Init(n, textures); + } + + void DepthFunc(GLenum func) { + gles2::DepthFunc& c = GetCmdSpace<gles2::DepthFunc>(); + c.Init(func); + } + + void DepthMask(GLboolean flag) { + gles2::DepthMask& c = GetCmdSpace<gles2::DepthMask>(); + c.Init(flag); + } + + void DepthRangef(GLclampf zNear, GLclampf zFar) { + gles2::DepthRangef& c = GetCmdSpace<gles2::DepthRangef>(); + c.Init(zNear, zFar); + } + + void DetachShader(GLuint program, GLuint shader) { + gles2::DetachShader& c = GetCmdSpace<gles2::DetachShader>(); + c.Init(program, shader); + } + + void Disable(GLenum cap) { + gles2::Disable& c = GetCmdSpace<gles2::Disable>(); + c.Init(cap); + } + + void DisableVertexAttribArray(GLuint index) { + gles2::DisableVertexAttribArray& c = + GetCmdSpace<gles2::DisableVertexAttribArray>(); + c.Init(index); + } + + void DrawArrays(GLenum mode, GLint first, GLsizei count) { + gles2::DrawArrays& c = GetCmdSpace<gles2::DrawArrays>(); + c.Init(mode, first, count); + } + + void DrawElements( + GLenum mode, GLsizei count, GLenum type, GLuint index_offset) { + gles2::DrawElements& c = GetCmdSpace<gles2::DrawElements>(); + c.Init(mode, count, type, index_offset); + } + + void Enable(GLenum cap) { + gles2::Enable& c = GetCmdSpace<gles2::Enable>(); + c.Init(cap); + } + + void EnableVertexAttribArray(GLuint index) { + gles2::EnableVertexAttribArray& c = + GetCmdSpace<gles2::EnableVertexAttribArray>(); + c.Init(index); + } + + void Finish() { + gles2::Finish& c = GetCmdSpace<gles2::Finish>(); + c.Init(); + } + + void Flush() { + gles2::Flush& c = GetCmdSpace<gles2::Flush>(); + c.Init(); + } + + void FramebufferRenderbuffer( + GLenum target, GLenum attachment, GLenum renderbuffertarget, + GLuint renderbuffer) { + gles2::FramebufferRenderbuffer& c = + GetCmdSpace<gles2::FramebufferRenderbuffer>(); + c.Init(target, attachment, renderbuffertarget, renderbuffer); + } + + void FramebufferTexture2D( + GLenum target, GLenum attachment, GLenum textarget, GLuint texture, + GLint level) { + gles2::FramebufferTexture2D& c = + GetCmdSpace<gles2::FramebufferTexture2D>(); + c.Init(target, attachment, textarget, texture, level); + } + + void FrontFace(GLenum mode) { + gles2::FrontFace& c = GetCmdSpace<gles2::FrontFace>(); + c.Init(mode); + } + + void GenBuffers( + GLsizei n, uint32 buffers_shm_id, uint32 buffers_shm_offset) { + gles2::GenBuffers& c = GetCmdSpace<gles2::GenBuffers>(); + c.Init(n, buffers_shm_id, buffers_shm_offset); + } + + void GenBuffersImmediate(GLsizei n, GLuint* buffers) { + const uint32 size = gles2::GenBuffersImmediate::ComputeSize(n); + gles2::GenBuffersImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::GenBuffersImmediate>(size); + c.Init(n, buffers); + } + + void GenerateMipmap(GLenum target) { + gles2::GenerateMipmap& c = GetCmdSpace<gles2::GenerateMipmap>(); + c.Init(target); + } + + void GenFramebuffers( + GLsizei n, uint32 framebuffers_shm_id, uint32 framebuffers_shm_offset) { + gles2::GenFramebuffers& c = GetCmdSpace<gles2::GenFramebuffers>(); + c.Init(n, framebuffers_shm_id, framebuffers_shm_offset); + } + + void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) { + const uint32 size = gles2::GenFramebuffersImmediate::ComputeSize(n); + gles2::GenFramebuffersImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::GenFramebuffersImmediate>(size); + c.Init(n, framebuffers); + } + + void GenRenderbuffers( + GLsizei n, uint32 renderbuffers_shm_id, + uint32 renderbuffers_shm_offset) { + gles2::GenRenderbuffers& c = GetCmdSpace<gles2::GenRenderbuffers>(); + c.Init(n, renderbuffers_shm_id, renderbuffers_shm_offset); + } + + void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) { + const uint32 size = gles2::GenRenderbuffersImmediate::ComputeSize(n); + gles2::GenRenderbuffersImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::GenRenderbuffersImmediate>(size); + c.Init(n, renderbuffers); + } + + void GenTextures( + GLsizei n, uint32 textures_shm_id, uint32 textures_shm_offset) { + gles2::GenTextures& c = GetCmdSpace<gles2::GenTextures>(); + c.Init(n, textures_shm_id, textures_shm_offset); + } + + void GenTexturesImmediate(GLsizei n, GLuint* textures) { + const uint32 size = gles2::GenTexturesImmediate::ComputeSize(n); + gles2::GenTexturesImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::GenTexturesImmediate>(size); + c.Init(n, textures); + } + + void GetActiveAttrib( + GLuint program, GLuint index, GLsizei bufsize, uint32 length_shm_id, + uint32 length_shm_offset, uint32 size_shm_id, uint32 size_shm_offset, + uint32 type_shm_id, uint32 type_shm_offset, uint32 name_shm_id, + uint32 name_shm_offset) { + gles2::GetActiveAttrib& c = GetCmdSpace<gles2::GetActiveAttrib>(); + c.Init( + program, index, bufsize, length_shm_id, length_shm_offset, size_shm_id, + size_shm_offset, type_shm_id, type_shm_offset, name_shm_id, + name_shm_offset); + } + + void GetActiveUniform( + GLuint program, GLuint index, GLsizei bufsize, uint32 length_shm_id, + uint32 length_shm_offset, uint32 size_shm_id, uint32 size_shm_offset, + uint32 type_shm_id, uint32 type_shm_offset, uint32 name_shm_id, + uint32 name_shm_offset) { + gles2::GetActiveUniform& c = GetCmdSpace<gles2::GetActiveUniform>(); + c.Init( + program, index, bufsize, length_shm_id, length_shm_offset, size_shm_id, + size_shm_offset, type_shm_id, type_shm_offset, name_shm_id, + name_shm_offset); + } + + void GetAttachedShaders( + GLuint program, GLsizei maxcount, uint32 count_shm_id, + uint32 count_shm_offset, uint32 shaders_shm_id, + uint32 shaders_shm_offset) { + gles2::GetAttachedShaders& c = GetCmdSpace<gles2::GetAttachedShaders>(); + c.Init( + program, maxcount, count_shm_id, count_shm_offset, shaders_shm_id, + shaders_shm_offset); + } + + void GetAttribLocation( + GLuint program, uint32 name_shm_id, uint32 name_shm_offset, + uint32 data_size) { + gles2::GetAttribLocation& c = GetCmdSpace<gles2::GetAttribLocation>(); + c.Init(program, name_shm_id, name_shm_offset, data_size); + } + + void GetAttribLocationImmediate(GLuint program, const char* name) { + const uint32 size = gles2::GetAttribLocationImmediate::ComputeSize(name); + gles2::GetAttribLocationImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::GetAttribLocationImmediate>(size); + c.Init(program, name); + } + + void GetBooleanv( + GLenum pname, uint32 params_shm_id, uint32 params_shm_offset) { + gles2::GetBooleanv& c = GetCmdSpace<gles2::GetBooleanv>(); + c.Init(pname, params_shm_id, params_shm_offset); + } + + void GetBufferParameteriv( + GLenum target, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetBufferParameteriv& c = + GetCmdSpace<gles2::GetBufferParameteriv>(); + c.Init(target, pname, params_shm_id, params_shm_offset); + } + + void GetError(uint32 result_shm_id, uint32 result_shm_offset) { + gles2::GetError& c = GetCmdSpace<gles2::GetError>(); + c.Init(result_shm_id, result_shm_offset); + } + + void GetFloatv( + GLenum pname, uint32 params_shm_id, uint32 params_shm_offset) { + gles2::GetFloatv& c = GetCmdSpace<gles2::GetFloatv>(); + c.Init(pname, params_shm_id, params_shm_offset); + } + + void GetFramebufferAttachmentParameteriv( + GLenum target, GLenum attachment, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetFramebufferAttachmentParameteriv& c = + GetCmdSpace<gles2::GetFramebufferAttachmentParameteriv>(); + c.Init(target, attachment, pname, params_shm_id, params_shm_offset); + } + + void GetIntegerv( + GLenum pname, uint32 params_shm_id, uint32 params_shm_offset) { + gles2::GetIntegerv& c = GetCmdSpace<gles2::GetIntegerv>(); + c.Init(pname, params_shm_id, params_shm_offset); + } + + void GetProgramiv( + GLuint program, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetProgramiv& c = GetCmdSpace<gles2::GetProgramiv>(); + c.Init(program, pname, params_shm_id, params_shm_offset); + } + + void GetProgramInfoLog( + GLuint program, GLsizei bufsize, uint32 length_shm_id, + uint32 length_shm_offset, uint32 infolog_shm_id, + uint32 infolog_shm_offset) { + gles2::GetProgramInfoLog& c = GetCmdSpace<gles2::GetProgramInfoLog>(); + c.Init( + program, bufsize, length_shm_id, length_shm_offset, infolog_shm_id, + infolog_shm_offset); + } + + void GetRenderbufferParameteriv( + GLenum target, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetRenderbufferParameteriv& c = + GetCmdSpace<gles2::GetRenderbufferParameteriv>(); + c.Init(target, pname, params_shm_id, params_shm_offset); + } + + void GetShaderiv( + GLuint shader, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetShaderiv& c = GetCmdSpace<gles2::GetShaderiv>(); + c.Init(shader, pname, params_shm_id, params_shm_offset); + } + + void GetShaderInfoLog( + GLuint shader, GLsizei bufsize, uint32 length_shm_id, + uint32 length_shm_offset, uint32 infolog_shm_id, + uint32 infolog_shm_offset) { + gles2::GetShaderInfoLog& c = GetCmdSpace<gles2::GetShaderInfoLog>(); + c.Init( + shader, bufsize, length_shm_id, length_shm_offset, infolog_shm_id, + infolog_shm_offset); + } + + void GetShaderPrecisionFormat( + GLenum shadertype, GLenum precisiontype, uint32 range_shm_id, + uint32 range_shm_offset, uint32 precision_shm_id, + uint32 precision_shm_offset) { + gles2::GetShaderPrecisionFormat& c = + GetCmdSpace<gles2::GetShaderPrecisionFormat>(); + c.Init( + shadertype, precisiontype, range_shm_id, range_shm_offset, + precision_shm_id, precision_shm_offset); + } + + void GetShaderSource( + GLuint shader, GLsizei bufsize, uint32 length_shm_id, + uint32 length_shm_offset, uint32 source_shm_id, + uint32 source_shm_offset) { + gles2::GetShaderSource& c = GetCmdSpace<gles2::GetShaderSource>(); + c.Init( + shader, bufsize, length_shm_id, length_shm_offset, source_shm_id, + source_shm_offset); + } + + void GetString(GLenum name) { + gles2::GetString& c = GetCmdSpace<gles2::GetString>(); + c.Init(name); + } + + void GetTexParameterfv( + GLenum target, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetTexParameterfv& c = GetCmdSpace<gles2::GetTexParameterfv>(); + c.Init(target, pname, params_shm_id, params_shm_offset); + } + + void GetTexParameteriv( + GLenum target, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetTexParameteriv& c = GetCmdSpace<gles2::GetTexParameteriv>(); + c.Init(target, pname, params_shm_id, params_shm_offset); + } + + void GetUniformfv( + GLuint program, GLint location, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetUniformfv& c = GetCmdSpace<gles2::GetUniformfv>(); + c.Init(program, location, params_shm_id, params_shm_offset); + } + + void GetUniformiv( + GLuint program, GLint location, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetUniformiv& c = GetCmdSpace<gles2::GetUniformiv>(); + c.Init(program, location, params_shm_id, params_shm_offset); + } + + void GetUniformLocation( + GLuint program, uint32 name_shm_id, uint32 name_shm_offset, + uint32 data_size) { + gles2::GetUniformLocation& c = GetCmdSpace<gles2::GetUniformLocation>(); + c.Init(program, name_shm_id, name_shm_offset, data_size); + } + + void GetUniformLocationImmediate(GLuint program, const char* name) { + const uint32 size = gles2::GetUniformLocationImmediate::ComputeSize(name); + gles2::GetUniformLocationImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::GetUniformLocationImmediate>( + size); + c.Init(program, name); + } + + void GetVertexAttribfv( + GLuint index, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetVertexAttribfv& c = GetCmdSpace<gles2::GetVertexAttribfv>(); + c.Init(index, pname, params_shm_id, params_shm_offset); + } + + void GetVertexAttribiv( + GLuint index, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::GetVertexAttribiv& c = GetCmdSpace<gles2::GetVertexAttribiv>(); + c.Init(index, pname, params_shm_id, params_shm_offset); + } + + void GetVertexAttribPointerv( + GLuint index, GLenum pname, uint32 pointer_shm_id, + uint32 pointer_shm_offset) { + gles2::GetVertexAttribPointerv& c = + GetCmdSpace<gles2::GetVertexAttribPointerv>(); + c.Init(index, pname, pointer_shm_id, pointer_shm_offset); + } + + void Hint(GLenum target, GLenum mode) { + gles2::Hint& c = GetCmdSpace<gles2::Hint>(); + c.Init(target, mode); + } + + void IsBuffer( + GLuint buffer, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsBuffer& c = GetCmdSpace<gles2::IsBuffer>(); + c.Init(buffer, result_shm_id, result_shm_offset); + } + + void IsEnabled(GLenum cap, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsEnabled& c = GetCmdSpace<gles2::IsEnabled>(); + c.Init(cap, result_shm_id, result_shm_offset); + } + + void IsFramebuffer( + GLuint framebuffer, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsFramebuffer& c = GetCmdSpace<gles2::IsFramebuffer>(); + c.Init(framebuffer, result_shm_id, result_shm_offset); + } + + void IsProgram( + GLuint program, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsProgram& c = GetCmdSpace<gles2::IsProgram>(); + c.Init(program, result_shm_id, result_shm_offset); + } + + void IsRenderbuffer( + GLuint renderbuffer, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsRenderbuffer& c = GetCmdSpace<gles2::IsRenderbuffer>(); + c.Init(renderbuffer, result_shm_id, result_shm_offset); + } + + void IsShader( + GLuint shader, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsShader& c = GetCmdSpace<gles2::IsShader>(); + c.Init(shader, result_shm_id, result_shm_offset); + } + + void IsTexture( + GLuint texture, uint32 result_shm_id, uint32 result_shm_offset) { + gles2::IsTexture& c = GetCmdSpace<gles2::IsTexture>(); + c.Init(texture, result_shm_id, result_shm_offset); + } + + void LineWidth(GLfloat width) { + gles2::LineWidth& c = GetCmdSpace<gles2::LineWidth>(); + c.Init(width); + } + + void LinkProgram(GLuint program) { + gles2::LinkProgram& c = GetCmdSpace<gles2::LinkProgram>(); + c.Init(program); + } + + void PixelStorei(GLenum pname, GLint param) { + gles2::PixelStorei& c = GetCmdSpace<gles2::PixelStorei>(); + c.Init(pname, param); + } + + void PolygonOffset(GLfloat factor, GLfloat units) { + gles2::PolygonOffset& c = GetCmdSpace<gles2::PolygonOffset>(); + c.Init(factor, units); + } + + void ReadPixels( + GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, + GLenum type, uint32 pixels_shm_id, uint32 pixels_shm_offset) { + gles2::ReadPixels& c = GetCmdSpace<gles2::ReadPixels>(); + c.Init( + x, y, width, height, format, type, pixels_shm_id, pixels_shm_offset); + } + + void RenderbufferStorage( + GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + gles2::RenderbufferStorage& c = GetCmdSpace<gles2::RenderbufferStorage>(); + c.Init(target, internalformat, width, height); + } + + void SampleCoverage(GLclampf value, GLboolean invert) { + gles2::SampleCoverage& c = GetCmdSpace<gles2::SampleCoverage>(); + c.Init(value, invert); + } + + void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) { + gles2::Scissor& c = GetCmdSpace<gles2::Scissor>(); + c.Init(x, y, width, height); + } + + void ShaderSource( + GLuint shader, GLsizei count, uint32 data_shm_id, uint32 data_shm_offset, + uint32 data_size) { + gles2::ShaderSource& c = GetCmdSpace<gles2::ShaderSource>(); + c.Init(shader, count, data_shm_id, data_shm_offset, data_size); + } + + void ShaderSourceImmediate(GLuint shader, GLsizei count, uint32 data_size) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::ShaderSourceImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::ShaderSourceImmediate>(s); + c.Init(shader, count, data_size); + } + + void StencilFunc(GLenum func, GLint ref, GLuint mask) { + gles2::StencilFunc& c = GetCmdSpace<gles2::StencilFunc>(); + c.Init(func, ref, mask); + } + + void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { + gles2::StencilFuncSeparate& c = GetCmdSpace<gles2::StencilFuncSeparate>(); + c.Init(face, func, ref, mask); + } + + void StencilMask(GLuint mask) { + gles2::StencilMask& c = GetCmdSpace<gles2::StencilMask>(); + c.Init(mask); + } + + void StencilMaskSeparate(GLenum face, GLuint mask) { + gles2::StencilMaskSeparate& c = GetCmdSpace<gles2::StencilMaskSeparate>(); + c.Init(face, mask); + } + + void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) { + gles2::StencilOp& c = GetCmdSpace<gles2::StencilOp>(); + c.Init(fail, zfail, zpass); + } + + void StencilOpSeparate( + GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { + gles2::StencilOpSeparate& c = GetCmdSpace<gles2::StencilOpSeparate>(); + c.Init(face, fail, zfail, zpass); + } + + void TexImage2D( + GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + uint32 pixels_shm_id, uint32 pixels_shm_offset) { + gles2::TexImage2D& c = GetCmdSpace<gles2::TexImage2D>(); + c.Init( + target, level, internalformat, width, height, border, format, type, + pixels_shm_id, pixels_shm_offset); + } + + void TexImage2DImmediate( + GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::TexImage2DImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::TexImage2DImmediate>(s); + c.Init(target, level, internalformat, width, height, border, format, type); + } + + void TexParameterf(GLenum target, GLenum pname, GLfloat param) { + gles2::TexParameterf& c = GetCmdSpace<gles2::TexParameterf>(); + c.Init(target, pname, param); + } + + void TexParameterfv( + GLenum target, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::TexParameterfv& c = GetCmdSpace<gles2::TexParameterfv>(); + c.Init(target, pname, params_shm_id, params_shm_offset); + } + + void TexParameterfvImmediate( + GLenum target, GLenum pname, const GLfloat* params) { + const uint32 size = gles2::TexParameterfvImmediate::ComputeSize(); + gles2::TexParameterfvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::TexParameterfvImmediate>(size); + c.Init(target, pname, params); + } + + void TexParameteri(GLenum target, GLenum pname, GLint param) { + gles2::TexParameteri& c = GetCmdSpace<gles2::TexParameteri>(); + c.Init(target, pname, param); + } + + void TexParameteriv( + GLenum target, GLenum pname, uint32 params_shm_id, + uint32 params_shm_offset) { + gles2::TexParameteriv& c = GetCmdSpace<gles2::TexParameteriv>(); + c.Init(target, pname, params_shm_id, params_shm_offset); + } + + void TexParameterivImmediate( + GLenum target, GLenum pname, const GLint* params) { + const uint32 size = gles2::TexParameterivImmediate::ComputeSize(); + gles2::TexParameterivImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::TexParameterivImmediate>(size); + c.Init(target, pname, params); + } + + void TexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLenum type, uint32 pixels_shm_id, + uint32 pixels_shm_offset) { + gles2::TexSubImage2D& c = GetCmdSpace<gles2::TexSubImage2D>(); + c.Init( + target, level, xoffset, yoffset, width, height, format, type, + pixels_shm_id, pixels_shm_offset); + } + + void TexSubImage2DImmediate( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLenum type) { + const uint32 s = 0; // TODO(gman): compute correct size + gles2::TexSubImage2DImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::TexSubImage2DImmediate>(s); + c.Init(target, level, xoffset, yoffset, width, height, format, type); + } + + void Uniform1f(GLint location, GLfloat x) { + gles2::Uniform1f& c = GetCmdSpace<gles2::Uniform1f>(); + c.Init(location, x); + } + + void Uniform1fv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform1fv& c = GetCmdSpace<gles2::Uniform1fv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform1fvImmediate(GLint location, GLsizei count, const GLfloat* v) { + const uint32 size = gles2::Uniform1fvImmediate::ComputeSize(count); + gles2::Uniform1fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform1fvImmediate>(size); + c.Init(location, count, v); + } + + void Uniform1i(GLint location, GLint x) { + gles2::Uniform1i& c = GetCmdSpace<gles2::Uniform1i>(); + c.Init(location, x); + } + + void Uniform1iv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform1iv& c = GetCmdSpace<gles2::Uniform1iv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform1ivImmediate(GLint location, GLsizei count, const GLint* v) { + const uint32 size = gles2::Uniform1ivImmediate::ComputeSize(count); + gles2::Uniform1ivImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform1ivImmediate>(size); + c.Init(location, count, v); + } + + void Uniform2f(GLint location, GLfloat x, GLfloat y) { + gles2::Uniform2f& c = GetCmdSpace<gles2::Uniform2f>(); + c.Init(location, x, y); + } + + void Uniform2fv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform2fv& c = GetCmdSpace<gles2::Uniform2fv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform2fvImmediate(GLint location, GLsizei count, const GLfloat* v) { + const uint32 size = gles2::Uniform2fvImmediate::ComputeSize(count); + gles2::Uniform2fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform2fvImmediate>(size); + c.Init(location, count, v); + } + + void Uniform2i(GLint location, GLint x, GLint y) { + gles2::Uniform2i& c = GetCmdSpace<gles2::Uniform2i>(); + c.Init(location, x, y); + } + + void Uniform2iv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform2iv& c = GetCmdSpace<gles2::Uniform2iv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform2ivImmediate(GLint location, GLsizei count, const GLint* v) { + const uint32 size = gles2::Uniform2ivImmediate::ComputeSize(count); + gles2::Uniform2ivImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform2ivImmediate>(size); + c.Init(location, count, v); + } + + void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { + gles2::Uniform3f& c = GetCmdSpace<gles2::Uniform3f>(); + c.Init(location, x, y, z); + } + + void Uniform3fv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform3fv& c = GetCmdSpace<gles2::Uniform3fv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform3fvImmediate(GLint location, GLsizei count, const GLfloat* v) { + const uint32 size = gles2::Uniform3fvImmediate::ComputeSize(count); + gles2::Uniform3fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform3fvImmediate>(size); + c.Init(location, count, v); + } + + void Uniform3i(GLint location, GLint x, GLint y, GLint z) { + gles2::Uniform3i& c = GetCmdSpace<gles2::Uniform3i>(); + c.Init(location, x, y, z); + } + + void Uniform3iv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform3iv& c = GetCmdSpace<gles2::Uniform3iv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform3ivImmediate(GLint location, GLsizei count, const GLint* v) { + const uint32 size = gles2::Uniform3ivImmediate::ComputeSize(count); + gles2::Uniform3ivImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform3ivImmediate>(size); + c.Init(location, count, v); + } + + void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + gles2::Uniform4f& c = GetCmdSpace<gles2::Uniform4f>(); + c.Init(location, x, y, z, w); + } + + void Uniform4fv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform4fv& c = GetCmdSpace<gles2::Uniform4fv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform4fvImmediate(GLint location, GLsizei count, const GLfloat* v) { + const uint32 size = gles2::Uniform4fvImmediate::ComputeSize(count); + gles2::Uniform4fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform4fvImmediate>(size); + c.Init(location, count, v); + } + + void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { + gles2::Uniform4i& c = GetCmdSpace<gles2::Uniform4i>(); + c.Init(location, x, y, z, w); + } + + void Uniform4iv( + GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) { + gles2::Uniform4iv& c = GetCmdSpace<gles2::Uniform4iv>(); + c.Init(location, count, v_shm_id, v_shm_offset); + } + + void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) { + const uint32 size = gles2::Uniform4ivImmediate::ComputeSize(count); + gles2::Uniform4ivImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::Uniform4ivImmediate>(size); + c.Init(location, count, v); + } + + void UniformMatrix2fv( + GLint location, GLsizei count, GLboolean transpose, uint32 value_shm_id, + uint32 value_shm_offset) { + gles2::UniformMatrix2fv& c = GetCmdSpace<gles2::UniformMatrix2fv>(); + c.Init(location, count, transpose, value_shm_id, value_shm_offset); + } + + void UniformMatrix2fvImmediate( + GLint location, GLsizei count, GLboolean transpose, + const GLfloat* value) { + const uint32 size = gles2::UniformMatrix2fvImmediate::ComputeSize(count); + gles2::UniformMatrix2fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::UniformMatrix2fvImmediate>(size); + c.Init(location, count, transpose, value); + } + + void UniformMatrix3fv( + GLint location, GLsizei count, GLboolean transpose, uint32 value_shm_id, + uint32 value_shm_offset) { + gles2::UniformMatrix3fv& c = GetCmdSpace<gles2::UniformMatrix3fv>(); + c.Init(location, count, transpose, value_shm_id, value_shm_offset); + } + + void UniformMatrix3fvImmediate( + GLint location, GLsizei count, GLboolean transpose, + const GLfloat* value) { + const uint32 size = gles2::UniformMatrix3fvImmediate::ComputeSize(count); + gles2::UniformMatrix3fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::UniformMatrix3fvImmediate>(size); + c.Init(location, count, transpose, value); + } + + void UniformMatrix4fv( + GLint location, GLsizei count, GLboolean transpose, uint32 value_shm_id, + uint32 value_shm_offset) { + gles2::UniformMatrix4fv& c = GetCmdSpace<gles2::UniformMatrix4fv>(); + c.Init(location, count, transpose, value_shm_id, value_shm_offset); + } + + void UniformMatrix4fvImmediate( + GLint location, GLsizei count, GLboolean transpose, + const GLfloat* value) { + const uint32 size = gles2::UniformMatrix4fvImmediate::ComputeSize(count); + gles2::UniformMatrix4fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::UniformMatrix4fvImmediate>(size); + c.Init(location, count, transpose, value); + } + + void UseProgram(GLuint program) { + gles2::UseProgram& c = GetCmdSpace<gles2::UseProgram>(); + c.Init(program); + } + + void ValidateProgram(GLuint program) { + gles2::ValidateProgram& c = GetCmdSpace<gles2::ValidateProgram>(); + c.Init(program); + } + + void VertexAttrib1f(GLuint indx, GLfloat x) { + gles2::VertexAttrib1f& c = GetCmdSpace<gles2::VertexAttrib1f>(); + c.Init(indx, x); + } + + void VertexAttrib1fv( + GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) { + gles2::VertexAttrib1fv& c = GetCmdSpace<gles2::VertexAttrib1fv>(); + c.Init(indx, values_shm_id, values_shm_offset); + } + + void VertexAttrib1fvImmediate(GLuint indx, const GLfloat* values) { + const uint32 size = gles2::VertexAttrib1fvImmediate::ComputeSize(); + gles2::VertexAttrib1fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib1fvImmediate>(size); + c.Init(indx, values); + } + + void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { + gles2::VertexAttrib2f& c = GetCmdSpace<gles2::VertexAttrib2f>(); + c.Init(indx, x, y); + } + + void VertexAttrib2fv( + GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) { + gles2::VertexAttrib2fv& c = GetCmdSpace<gles2::VertexAttrib2fv>(); + c.Init(indx, values_shm_id, values_shm_offset); + } + + void VertexAttrib2fvImmediate(GLuint indx, const GLfloat* values) { + const uint32 size = gles2::VertexAttrib2fvImmediate::ComputeSize(); + gles2::VertexAttrib2fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib2fvImmediate>(size); + c.Init(indx, values); + } + + void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { + gles2::VertexAttrib3f& c = GetCmdSpace<gles2::VertexAttrib3f>(); + c.Init(indx, x, y, z); + } + + void VertexAttrib3fv( + GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) { + gles2::VertexAttrib3fv& c = GetCmdSpace<gles2::VertexAttrib3fv>(); + c.Init(indx, values_shm_id, values_shm_offset); + } + + void VertexAttrib3fvImmediate(GLuint indx, const GLfloat* values) { + const uint32 size = gles2::VertexAttrib3fvImmediate::ComputeSize(); + gles2::VertexAttrib3fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib3fvImmediate>(size); + c.Init(indx, values); + } + + void VertexAttrib4f( + GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + gles2::VertexAttrib4f& c = GetCmdSpace<gles2::VertexAttrib4f>(); + c.Init(indx, x, y, z, w); + } + + void VertexAttrib4fv( + GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) { + gles2::VertexAttrib4fv& c = GetCmdSpace<gles2::VertexAttrib4fv>(); + c.Init(indx, values_shm_id, values_shm_offset); + } + + void VertexAttrib4fvImmediate(GLuint indx, const GLfloat* values) { + const uint32 size = gles2::VertexAttrib4fvImmediate::ComputeSize(); + gles2::VertexAttrib4fvImmediate& c = + GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib4fvImmediate>(size); + c.Init(indx, values); + } + + void VertexAttribPointer( + GLuint indx, GLint size, GLenum type, GLboolean normalized, + GLsizei stride, GLuint offset) { + gles2::VertexAttribPointer& c = GetCmdSpace<gles2::VertexAttribPointer>(); + c.Init(indx, size, type, normalized, stride, offset); + } + + void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) { + gles2::Viewport& c = GetCmdSpace<gles2::Viewport>(); + c.Init(x, y, width, height); + } + diff --git a/o3d/gpu/command_buffer/client/gles2_implementation.cc b/o3d/gpu/command_buffer/client/gles2_implementation.cc new file mode 100644 index 0000000..c13d63c --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_implementation.cc @@ -0,0 +1,141 @@ +// Copyright (c) 2006-2009 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. + +// A class to emluate GLES2 over command buffers. + +#include "gpu/command_buffer/client/gles2_implementation.h" +#include "gpu/command_buffer/client/gles2_implementation_gen.h" +#include "gpu/command_buffer/common/gles2_cmd_utils.h" + +namespace command_buffer { +namespace gles2 { + +GLES2Implementation::GLES2Implementation( + GLES2CmdHelper* helper, + ResourceId shared_memory_id, + void* shared_memory_address) + : util_(0), // TODO(gman): Get real number of compressed texture formats. + helper_(helper), + shared_memory_(shared_memory_id, shared_memory_address), + pack_alignment_(4), + unpack_alignment_(4) { +} + +void GLES2Implementation::MakeIds(GLsizei n, GLuint* ids) { + for (GLsizei ii = 0; ii < n; ++ii) { + ids[ii] = id_allocator_.AllocateID(); + } +} + +void GLES2Implementation::FreeIds(GLsizei n, const GLuint* ids) { + for (GLsizei ii = 0; ii < n; ++ii) { + id_allocator_.FreeID(ids[ii]); + } +} + +void GLES2Implementation::ShaderSource( + GLuint shader, GLsizei count, const char** string, const GLint* length) { + // TODO(gman): change to use buckets and check that there is enough room. + uint32* offsets = shared_memory_.GetAddressAs<uint32*>(0); + char* strings = reinterpret_cast<char*>(offsets + count); + + uint32 offset = count * sizeof(*offsets); + for (GLsizei ii = 0; ii < count; ++ii) { + uint32 len = length ? length[ii] : strlen(string[ii]); + memcpy(strings + offset, string[ii], len); + offset += len; + offsets[ii] = offset; + } + + helper_->ShaderSource(shader, count, shared_memory_.GetId(), 0, offset); + // TODO(gman): Should insert token but not wait until we need shared memory + // again. Really, I should implement a shared memory manager that puts + // things in the next unused part of shared memory and only blocks + // when it needs more memory. + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + +void GLES2Implementation::BufferData( + GLenum target, GLsizeiptr size, const void* data, GLenum usage) { + // TODO(gman): Switch to use buckets alwayst or at least if no room in shared + // memory. + memcpy(shared_memory_.GetAddress(0), data, size); + helper_->BufferData(target, size, shared_memory_.GetId(), 0, usage); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + +void GLES2Implementation::BufferSubData( + GLenum target, GLintptr offset, GLsizeiptr size, const void* data) { + // TODO(gman): Switch to use buckets alwayst or at least if no room in shared + // memory. + memcpy(shared_memory_.GetAddress(0), data, size); + helper_->BufferSubData(target, offset, size, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + +void GLES2Implementation::CompressedTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLsizei width, + GLsizei height, GLint border, GLsizei imageSize, const void* data) { + // TODO(gman): Switch to use buckets alwayst or at least if no room in shared + // memory. + memcpy(shared_memory_.GetAddress(0), data, imageSize); + helper_->CompressedTexImage2D( + target, level, internalformat, width, height, border, imageSize, + shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + +void GLES2Implementation::CompressedTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLsizei imageSize, const void* data) { + // TODO(gman): Switch to use buckets alwayst or at least if no room in shared + // memory. + memcpy(shared_memory_.GetAddress(0), data, imageSize); + helper_->CompressedTexSubImage2D( + target, level, xoffset, yoffset, width, height, format, imageSize, + shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + +void GLES2Implementation::TexImage2D( + GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + const void* pixels) { + // TODO(gman): Switch to use buckets alwayst or at least if no room in shared + // memory. + uint32 pixels_size = GLES2Util::ComputeImageDataSize( + width, height, format, type, unpack_alignment_); + memcpy(shared_memory_.GetAddress(0), pixels, pixels_size); + helper_->TexImage2D( + target, level, internalformat, width, height, border, format, type, + shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + +void GLES2Implementation::TexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLenum type, const void* pixels) { + // TODO(gman): Switch to use buckets alwayst or at least if no room in shared + // memory. + uint32 pixels_size = GLES2Util::ComputeImageDataSize( + width, height, format, type, unpack_alignment_); + memcpy(shared_memory_.GetAddress(0), pixels, pixels_size); + helper_->TexSubImage2D( + target, level, xoffset, yoffset, width, height, format, type, + shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); +} + + +} // namespace gles2 +} // namespace command_buffer + + diff --git a/o3d/gpu/command_buffer/client/gles2_implementation.h b/o3d/gpu/command_buffer/client/gles2_implementation.h new file mode 100644 index 0000000..c8484ec --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_implementation.h @@ -0,0 +1,93 @@ +// Copyright (c) 2006-2009 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. + +#ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_HELPER_H +#define GPU_COMMAND_BUFFER_CLIENT_GLES2_HELPER_H + +#include "gpu/command_buffer/client/gles2_cmd_helper.h" +#include "gpu/command_buffer/client/id_allocator.h" + +namespace command_buffer { +namespace gles2 { + +// A class to help with shared memory. +class SharedMemoryHelper { + public: + SharedMemoryHelper( + unsigned int id, + void* address) + : id_(id), + address_(address) { + } + + unsigned int GetOffset(void* address) const { + return static_cast<int8*>(address) - + static_cast<int8*>(address_); + } + + void* GetAddress(unsigned int offset) const { + return static_cast<int8*>(address_) + offset; + } + + template <typename T> + T GetAddressAs(unsigned int offset) const { + return static_cast<T>(GetAddress(offset)); + } + + unsigned int GetId() const { + return id_; + } + + private: + ResourceId id_; + void* address_; + + DISALLOW_COPY_AND_ASSIGN(SharedMemoryHelper); +}; + +// This class emulates GLES2 over command buffers. It can be used by a client +// program so that the program does not need deal with shared memory and command +// buffer management. See gl2_lib.h. Note that there is a performance gain to +// be had by changing your code to use command buffers directly by using the +// GLES2CmdHelper but that entails changing your code to use and deal with +// shared memory and synchronization issues. +class GLES2Implementation { + public: + GLES2Implementation( + GLES2CmdHelper* helper, + ResourceId shared_memory_id, + void* shared_memory); + + // Include the auto-generated part of this class. We split this because + // it means we can easily edit the non-auto generated parts right here in + // this file instead of having to edit some template or the code generator. + #include "gpu/command_buffer/client/gles2_implementation_autogen.h" + + private: + // Makes a set of Ids for glGen___ functions. + void MakeIds(GLsizei n, GLuint* ids); + + // Frees a set of Ids for glDelete___ functions. + void FreeIds(GLsizei n, const GLuint* ids); + + GLES2Util util_; + GLES2CmdHelper* helper_; + IdAllocator id_allocator_; + SharedMemoryHelper shared_memory_; + + // pack alignment as last set by glPixelStorei + GLint pack_alignment_; + + // unpack alignment as last set by glPixelStorei + GLint unpack_alignment_; + + DISALLOW_COPY_AND_ASSIGN(GLES2Implementation); +}; + + +} // namespace gles2 +} // namespace command_buffer + +#endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_HELPER_H + diff --git a/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h b/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h new file mode 100644 index 0000000..0d86245 --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h @@ -0,0 +1,670 @@ +// This file is auto-generated. DO NOT EDIT! + +// This file is included by gles2_implementation.h to declare the +// GL api functions. +void ActiveTexture(GLenum texture) { + helper_->ActiveTexture(texture); +} + +void AttachShader(GLuint program, GLuint shader) { + helper_->AttachShader(program, shader); +} + +void BindAttribLocation(GLuint program, GLuint index, const char* name) { + // TODO(gman): This needs to change to use SendString. + helper_->BindAttribLocationImmediate(program, index, name); +} + +void BindBuffer(GLenum target, GLuint buffer) { + helper_->BindBuffer(target, buffer); +} + +void BindFramebuffer(GLenum target, GLuint framebuffer) { + helper_->BindFramebuffer(target, framebuffer); +} + +void BindRenderbuffer(GLenum target, GLuint renderbuffer) { + helper_->BindRenderbuffer(target, renderbuffer); +} + +void BindTexture(GLenum target, GLuint texture) { + helper_->BindTexture(target, texture); +} + +void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + helper_->BlendColor(red, green, blue, alpha); +} + +void BlendEquation(GLenum mode) { + helper_->BlendEquation(mode); +} + +void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { + helper_->BlendEquationSeparate(modeRGB, modeAlpha); +} + +void BlendFunc(GLenum sfactor, GLenum dfactor) { + helper_->BlendFunc(sfactor, dfactor); +} + +void BlendFuncSeparate( + GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { + helper_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void BufferData( + GLenum target, GLsizeiptr size, const void* data, GLenum usage); + +void BufferSubData( + GLenum target, GLintptr offset, GLsizeiptr size, const void* data); + +GLenum CheckFramebufferStatus(GLenum target); + +void Clear(GLbitfield mask) { + helper_->Clear(mask); +} + +void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + helper_->ClearColor(red, green, blue, alpha); +} + +void ClearDepthf(GLclampf depth) { + helper_->ClearDepthf(depth); +} + +void ClearStencil(GLint s) { + helper_->ClearStencil(s); +} + +void ColorMask( + GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { + helper_->ColorMask(red, green, blue, alpha); +} + +void CompileShader(GLuint shader) { + helper_->CompileShader(shader); +} + +void CompressedTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLsizei width, + GLsizei height, GLint border, GLsizei imageSize, const void* data); + +void CompressedTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLsizei imageSize, const void* data); + +void CopyTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, + GLsizei width, GLsizei height, GLint border) { + helper_->CopyTexImage2D( + target, level, internalformat, x, y, width, height, border); +} + +void CopyTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, + GLsizei width, GLsizei height) { + helper_->CopyTexSubImage2D( + target, level, xoffset, yoffset, x, y, width, height); +} + +GLuint CreateProgram() { + GLuint client_id; + MakeIds(1, &client_id); + helper_->CreateProgram(client_id); + return client_id; +} + +GLuint CreateShader(GLenum type) { + GLuint client_id; + MakeIds(1, &client_id); + helper_->CreateShader(type, client_id); + return client_id; +} + +void CullFace(GLenum mode) { + helper_->CullFace(mode); +} + +void DeleteBuffers(GLsizei n, const GLuint* buffers) { + FreeIds(n, buffers); + helper_->DeleteBuffersImmediate(n, buffers); +} + +void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) { + FreeIds(n, framebuffers); + helper_->DeleteFramebuffersImmediate(n, framebuffers); +} + +void DeleteProgram(GLuint program) { + helper_->DeleteProgram(program); +} + +void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) { + FreeIds(n, renderbuffers); + helper_->DeleteRenderbuffersImmediate(n, renderbuffers); +} + +void DeleteShader(GLuint shader) { + helper_->DeleteShader(shader); +} + +void DeleteTextures(GLsizei n, const GLuint* textures) { + FreeIds(n, textures); + helper_->DeleteTexturesImmediate(n, textures); +} + +void DepthFunc(GLenum func) { + helper_->DepthFunc(func); +} + +void DepthMask(GLboolean flag) { + helper_->DepthMask(flag); +} + +void DepthRangef(GLclampf zNear, GLclampf zFar) { + helper_->DepthRangef(zNear, zFar); +} + +void DetachShader(GLuint program, GLuint shader) { + helper_->DetachShader(program, shader); +} + +void Disable(GLenum cap) { + helper_->Disable(cap); +} + +void DisableVertexAttribArray(GLuint index) { + helper_->DisableVertexAttribArray(index); +} + +void DrawArrays(GLenum mode, GLint first, GLsizei count) { + helper_->DrawArrays(mode, first, count); +} + +void DrawElements( + GLenum mode, GLsizei count, GLenum type, const void* indices); + +void Enable(GLenum cap) { + helper_->Enable(cap); +} + +void EnableVertexAttribArray(GLuint index) { + helper_->EnableVertexAttribArray(index); +} + +void Finish() { + helper_->Finish(); +} + +void Flush() { + helper_->Flush(); +} + +void FramebufferRenderbuffer( + GLenum target, GLenum attachment, GLenum renderbuffertarget, + GLuint renderbuffer) { + helper_->FramebufferRenderbuffer( + target, attachment, renderbuffertarget, renderbuffer); +} + +void FramebufferTexture2D( + GLenum target, GLenum attachment, GLenum textarget, GLuint texture, + GLint level) { + helper_->FramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void FrontFace(GLenum mode) { + helper_->FrontFace(mode); +} + +void GenBuffers(GLsizei n, GLuint* buffers) { + MakeIds(n, buffers); + helper_->GenBuffersImmediate(n, buffers); +} + +void GenerateMipmap(GLenum target) { + helper_->GenerateMipmap(target); +} + +void GenFramebuffers(GLsizei n, GLuint* framebuffers) { + MakeIds(n, framebuffers); + helper_->GenFramebuffersImmediate(n, framebuffers); +} + +void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) { + MakeIds(n, renderbuffers); + helper_->GenRenderbuffersImmediate(n, renderbuffers); +} + +void GenTextures(GLsizei n, GLuint* textures) { + MakeIds(n, textures); + helper_->GenTexturesImmediate(n, textures); +} + +void GetActiveAttrib( + GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, + GLenum* type, char* name); + +void GetActiveUniform( + GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, + GLenum* type, char* name); + +void GetAttachedShaders( + GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders); + +int GetAttribLocation(GLuint program, const char* name) { + // TODO(gman): This needs to change to use SendString. + helper_->GetAttribLocationImmediate(program, name); +} + +void GetBooleanv(GLenum pname, GLboolean* params) { + helper_->GetBooleanv(pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { + helper_->GetBufferParameteriv(target, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +GLenum GetError() { + helper_->GetError(shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLenum*>(0); +} + +void GetFloatv(GLenum pname, GLfloat* params) { + helper_->GetFloatv(pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetFramebufferAttachmentParameteriv( + GLenum target, GLenum attachment, GLenum pname, GLint* params) { + helper_->GetFramebufferAttachmentParameteriv( + target, attachment, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetIntegerv(GLenum pname, GLint* params) { + helper_->GetIntegerv(pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetProgramiv(GLuint program, GLenum pname, GLint* params) { + helper_->GetProgramiv(program, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +// TODO(gman): Implement this +void GetProgramInfoLog( + GLuint program, GLsizei bufsize, GLsizei* length, char* infolog); + +void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) { + helper_->GetRenderbufferParameteriv( + target, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetShaderiv(GLuint shader, GLenum pname, GLint* params) { + helper_->GetShaderiv(shader, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +// TODO(gman): Implement this +void GetShaderInfoLog( + GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog); + +void GetShaderPrecisionFormat( + GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision); + +// TODO(gman): Implement this +void GetShaderSource( + GLuint shader, GLsizei bufsize, GLsizei* length, char* source); + +const GLubyte* GetString(GLenum name); + +void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { + helper_->GetTexParameterfv(target, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) { + helper_->GetTexParameteriv(target, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetUniformfv(GLuint program, GLint location, GLfloat* params); + +void GetUniformiv(GLuint program, GLint location, GLint* params); + +int GetUniformLocation(GLuint program, const char* name) { + // TODO(gman): This needs to change to use SendString. + helper_->GetUniformLocationImmediate(program, name); +} + +void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { + helper_->GetVertexAttribfv(index, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { + helper_->GetVertexAttribiv(index, pname, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + memcpy(params, shared_memory_.GetAddress(0), + num_values * sizeof(*params)); +} + +void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer); + +void Hint(GLenum target, GLenum mode) { + helper_->Hint(target, mode); +} + +GLboolean IsBuffer(GLuint buffer) { + helper_->IsBuffer(buffer, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +GLboolean IsEnabled(GLenum cap) { + helper_->IsEnabled(cap, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +GLboolean IsFramebuffer(GLuint framebuffer) { + helper_->IsFramebuffer(framebuffer, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +GLboolean IsProgram(GLuint program) { + helper_->IsProgram(program, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +GLboolean IsRenderbuffer(GLuint renderbuffer) { + helper_->IsRenderbuffer(renderbuffer, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +GLboolean IsShader(GLuint shader) { + helper_->IsShader(shader, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +GLboolean IsTexture(GLuint texture) { + helper_->IsTexture(texture, shared_memory_.GetId(), 0); + int32 token = helper_->InsertToken(); + helper_->WaitForToken(token); + return *shared_memory_.GetAddressAs<GLboolean*>(0); +} + +void LineWidth(GLfloat width) { + helper_->LineWidth(width); +} + +void LinkProgram(GLuint program) { + helper_->LinkProgram(program); +} + +void PixelStorei(GLenum pname, GLint param) { + helper_->PixelStorei(pname, param); +} + +void PolygonOffset(GLfloat factor, GLfloat units) { + helper_->PolygonOffset(factor, units); +} + +void ReadPixels( + GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, + void* pixels); + +void RenderbufferStorage( + GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + helper_->RenderbufferStorage(target, internalformat, width, height); +} + +void SampleCoverage(GLclampf value, GLboolean invert) { + helper_->SampleCoverage(value, invert); +} + +void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) { + helper_->Scissor(x, y, width, height); +} + +void ShaderSource( + GLuint shader, GLsizei count, const char** string, const GLint* length); + +void StencilFunc(GLenum func, GLint ref, GLuint mask) { + helper_->StencilFunc(func, ref, mask); +} + +void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { + helper_->StencilFuncSeparate(face, func, ref, mask); +} + +void StencilMask(GLuint mask) { + helper_->StencilMask(mask); +} + +void StencilMaskSeparate(GLenum face, GLuint mask) { + helper_->StencilMaskSeparate(face, mask); +} + +void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) { + helper_->StencilOp(fail, zfail, zpass); +} + +void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { + helper_->StencilOpSeparate(face, fail, zfail, zpass); +} + +void TexImage2D( + GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + const void* pixels); + +void TexParameterf(GLenum target, GLenum pname, GLfloat param) { + helper_->TexParameterf(target, pname, param); +} + +void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { + helper_->TexParameterfvImmediate(target, pname, params); +} + +void TexParameteri(GLenum target, GLenum pname, GLint param) { + helper_->TexParameteri(target, pname, param); +} + +void TexParameteriv(GLenum target, GLenum pname, const GLint* params) { + helper_->TexParameterivImmediate(target, pname, params); +} + +void TexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLenum type, const void* pixels); + +void Uniform1f(GLint location, GLfloat x) { + helper_->Uniform1f(location, x); +} + +void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) { + helper_->Uniform1fvImmediate(location, count, v); +} + +void Uniform1i(GLint location, GLint x) { + helper_->Uniform1i(location, x); +} + +void Uniform1iv(GLint location, GLsizei count, const GLint* v) { + helper_->Uniform1ivImmediate(location, count, v); +} + +void Uniform2f(GLint location, GLfloat x, GLfloat y) { + helper_->Uniform2f(location, x, y); +} + +void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) { + helper_->Uniform2fvImmediate(location, count, v); +} + +void Uniform2i(GLint location, GLint x, GLint y) { + helper_->Uniform2i(location, x, y); +} + +void Uniform2iv(GLint location, GLsizei count, const GLint* v) { + helper_->Uniform2ivImmediate(location, count, v); +} + +void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { + helper_->Uniform3f(location, x, y, z); +} + +void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) { + helper_->Uniform3fvImmediate(location, count, v); +} + +void Uniform3i(GLint location, GLint x, GLint y, GLint z) { + helper_->Uniform3i(location, x, y, z); +} + +void Uniform3iv(GLint location, GLsizei count, const GLint* v) { + helper_->Uniform3ivImmediate(location, count, v); +} + +void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + helper_->Uniform4f(location, x, y, z, w); +} + +void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) { + helper_->Uniform4fvImmediate(location, count, v); +} + +void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { + helper_->Uniform4i(location, x, y, z, w); +} + +void Uniform4iv(GLint location, GLsizei count, const GLint* v) { + helper_->Uniform4ivImmediate(location, count, v); +} + +void UniformMatrix2fv( + GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { + helper_->UniformMatrix2fvImmediate(location, count, transpose, value); +} + +void UniformMatrix3fv( + GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { + helper_->UniformMatrix3fvImmediate(location, count, transpose, value); +} + +void UniformMatrix4fv( + GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { + helper_->UniformMatrix4fvImmediate(location, count, transpose, value); +} + +void UseProgram(GLuint program) { + helper_->UseProgram(program); +} + +void ValidateProgram(GLuint program) { + helper_->ValidateProgram(program); +} + +void VertexAttrib1f(GLuint indx, GLfloat x) { + helper_->VertexAttrib1f(indx, x); +} + +void VertexAttrib1fv(GLuint indx, const GLfloat* values) { + helper_->VertexAttrib1fvImmediate(indx, values); +} + +void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { + helper_->VertexAttrib2f(indx, x, y); +} + +void VertexAttrib2fv(GLuint indx, const GLfloat* values) { + helper_->VertexAttrib2fvImmediate(indx, values); +} + +void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { + helper_->VertexAttrib3f(indx, x, y, z); +} + +void VertexAttrib3fv(GLuint indx, const GLfloat* values) { + helper_->VertexAttrib3fvImmediate(indx, values); +} + +void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + helper_->VertexAttrib4f(indx, x, y, z, w); +} + +void VertexAttrib4fv(GLuint indx, const GLfloat* values) { + helper_->VertexAttrib4fvImmediate(indx, values); +} + +void VertexAttribPointer( + GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, + const void* ptr); + +void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) { + helper_->Viewport(x, y, width, height); +} + diff --git a/o3d/gpu/command_buffer/client/gles2_implementation_gen.h b/o3d/gpu/command_buffer/client/gles2_implementation_gen.h new file mode 100644 index 0000000..848a2f5 --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_implementation_gen.h @@ -0,0 +1,70 @@ +// Copyright (c) 2006-2008 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. + +// A class to emluate GLES2 over command buffers. + +#include "gpu/command_buffer/client/gles2_implementation.h" + +namespace command_buffer { +namespace gles2 { + +GLenum GLES2Implementation::CheckFramebufferStatus(GLenum target) { + return 0; +} + +void GLES2Implementation::GetActiveAttrib( + GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, + GLenum* type, char* name) { +} + +void GLES2Implementation::GetActiveUniform( + GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, + GLenum* type, char* name) { +} + +void GLES2Implementation::GetAttachedShaders( + GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { +} + +void GLES2Implementation::GetProgramInfoLog( + GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) { +} + +void GLES2Implementation::GetShaderInfoLog( + GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) { +} + +void GLES2Implementation::GetShaderPrecisionFormat( + GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { +} + +void GLES2Implementation::GetShaderSource( + GLuint shader, GLsizei bufsize, GLsizei* length, char* source) { +} + +const GLubyte* GLES2Implementation::GetString(GLenum name) { + return 0; +} + +void GLES2Implementation::GetUniformfv( + GLuint program, GLint location, GLfloat* params) { +} + +void GLES2Implementation::GetUniformiv( + GLuint program, GLint location, GLint* params) { +} + +void GLES2Implementation::GetVertexAttribPointerv( + GLuint index, GLenum pname, void** pointer) { +} + +void GLES2Implementation::ReadPixels( + GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, + void* pixels) { +} + + +} // namespace gles2 +} // namespace command_buffer + diff --git a/o3d/gpu/command_buffer/client/gles2_lib.cc b/o3d/gpu/command_buffer/client/gles2_lib.cc new file mode 100644 index 0000000..924eb19 --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_lib.cc @@ -0,0 +1,15 @@ +// Copyright (c) 2006-2009 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. + +#include "gpu/command_buffer/client/gles2_lib.h" + +namespace gles2 { + +// Currently this is a place holder. + +} // namespace gles2 + + + + diff --git a/o3d/gpu/command_buffer/client/gles2_lib.h b/o3d/gpu/command_buffer/client/gles2_lib.h new file mode 100644 index 0000000..6cb413f --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_lib.h @@ -0,0 +1,24 @@ +// Copyright (c) 2006-2009 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. + +// These functions emluate GLES2 over command buffers. + +#ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_LIB_H +#define GPU_COMMAND_BUFFER_CLIENT_GLES2_LIB_H + +#include "gpu/command_buffer/client/gles2_implementation.h" + +namespace gles2 { + +extern ::command_buffer::gles2::GLES2Implementation* g_gl_impl; + +// Include the auto-generated part of this file. We split this because it means +// we can easily edit the non-auto generated parts right here in this file +// instead of having to edit some template or the code generator. +#include "gpu/command_buffer/client/gles2_lib_autogen.h" + +} // namespace gles2 + +#endif // GPU_COMMAND_BUFFER_CLIENT_GLES2_LIB_H + diff --git a/o3d/gpu/command_buffer/client/gles2_lib_autogen.h b/o3d/gpu/command_buffer/client/gles2_lib_autogen.h new file mode 100644 index 0000000..d928c8c --- /dev/null +++ b/o3d/gpu/command_buffer/client/gles2_lib_autogen.h @@ -0,0 +1,493 @@ +// This file is auto-generated. DO NOT EDIT! + + +// These functions emluate GLES2 over command buffers. + + +inline void glActiveTexture(GLenum texture) { + g_gl_impl->ActiveTexture(texture); +} +inline void glAttachShader(GLuint program, GLuint shader) { + g_gl_impl->AttachShader(program, shader); +} +inline void glBindAttribLocation( + GLuint program, GLuint index, const char* name) { + g_gl_impl->BindAttribLocation(program, index, name); +} +inline void glBindBuffer(GLenum target, GLuint buffer) { + g_gl_impl->BindBuffer(target, buffer); +} +inline void glBindFramebuffer(GLenum target, GLuint framebuffer) { + g_gl_impl->BindFramebuffer(target, framebuffer); +} +inline void glBindRenderbuffer(GLenum target, GLuint renderbuffer) { + g_gl_impl->BindRenderbuffer(target, renderbuffer); +} +inline void glBindTexture(GLenum target, GLuint texture) { + g_gl_impl->BindTexture(target, texture); +} +inline void glBlendColor( + GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + g_gl_impl->BlendColor(red, green, blue, alpha); +} +inline void glBlendEquation(GLenum mode) { + g_gl_impl->BlendEquation(mode); +} +inline void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { + g_gl_impl->BlendEquationSeparate(modeRGB, modeAlpha); +} +inline void glBlendFunc(GLenum sfactor, GLenum dfactor) { + g_gl_impl->BlendFunc(sfactor, dfactor); +} +inline void glBlendFuncSeparate( + GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { + g_gl_impl->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); +} +inline void glBufferData( + GLenum target, GLsizeiptr size, const void* data, GLenum usage) { + g_gl_impl->BufferData(target, size, data, usage); +} +inline void glBufferSubData( + GLenum target, GLintptr offset, GLsizeiptr size, const void* data) { + g_gl_impl->BufferSubData(target, offset, size, data); +} +inline GLenum glCheckFramebufferStatus(GLenum target) { + return g_gl_impl->CheckFramebufferStatus(target); +} +inline void glClear(GLbitfield mask) { + g_gl_impl->Clear(mask); +} +inline void glClearColor( + GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { + g_gl_impl->ClearColor(red, green, blue, alpha); +} +inline void glClearDepthf(GLclampf depth) { + g_gl_impl->ClearDepthf(depth); +} +inline void glClearStencil(GLint s) { + g_gl_impl->ClearStencil(s); +} +inline void glColorMask( + GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { + g_gl_impl->ColorMask(red, green, blue, alpha); +} +inline void glCompileShader(GLuint shader) { + g_gl_impl->CompileShader(shader); +} +inline void glCompressedTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLsizei width, + GLsizei height, GLint border, GLsizei imageSize, const void* data) { + g_gl_impl->CompressedTexImage2D( + target, level, internalformat, width, height, border, imageSize, data); +} +inline void glCompressedTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLsizei imageSize, const void* data) { + g_gl_impl->CompressedTexSubImage2D( + target, level, xoffset, yoffset, width, height, format, imageSize, data); +} +inline void glCopyTexImage2D( + GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, + GLsizei width, GLsizei height, GLint border) { + g_gl_impl->CopyTexImage2D( + target, level, internalformat, x, y, width, height, border); +} +inline void glCopyTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, + GLsizei width, GLsizei height) { + g_gl_impl->CopyTexSubImage2D( + target, level, xoffset, yoffset, x, y, width, height); +} +inline GLuint glCreateProgram() { + return g_gl_impl->CreateProgram(); +} +inline GLuint glCreateShader(GLenum type) { + return g_gl_impl->CreateShader(type); +} +inline void glCullFace(GLenum mode) { + g_gl_impl->CullFace(mode); +} +inline void glDeleteBuffers(GLsizei n, const GLuint* buffers) { + g_gl_impl->DeleteBuffers(n, buffers); +} +inline void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) { + g_gl_impl->DeleteFramebuffers(n, framebuffers); +} +inline void glDeleteProgram(GLuint program) { + g_gl_impl->DeleteProgram(program); +} +inline void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) { + g_gl_impl->DeleteRenderbuffers(n, renderbuffers); +} +inline void glDeleteShader(GLuint shader) { + g_gl_impl->DeleteShader(shader); +} +inline void glDeleteTextures(GLsizei n, const GLuint* textures) { + g_gl_impl->DeleteTextures(n, textures); +} +inline void glDepthFunc(GLenum func) { + g_gl_impl->DepthFunc(func); +} +inline void glDepthMask(GLboolean flag) { + g_gl_impl->DepthMask(flag); +} +inline void glDepthRangef(GLclampf zNear, GLclampf zFar) { + g_gl_impl->DepthRangef(zNear, zFar); +} +inline void glDetachShader(GLuint program, GLuint shader) { + g_gl_impl->DetachShader(program, shader); +} +inline void glDisable(GLenum cap) { + g_gl_impl->Disable(cap); +} +inline void glDisableVertexAttribArray(GLuint index) { + g_gl_impl->DisableVertexAttribArray(index); +} +inline void glDrawArrays(GLenum mode, GLint first, GLsizei count) { + g_gl_impl->DrawArrays(mode, first, count); +} +inline void glDrawElements( + GLenum mode, GLsizei count, GLenum type, const void* indices) { + g_gl_impl->DrawElements(mode, count, type, indices); +} +inline void glEnable(GLenum cap) { + g_gl_impl->Enable(cap); +} +inline void glEnableVertexAttribArray(GLuint index) { + g_gl_impl->EnableVertexAttribArray(index); +} +inline void glFinish() { + g_gl_impl->Finish(); +} +inline void glFlush() { + g_gl_impl->Flush(); +} +inline void glFramebufferRenderbuffer( + GLenum target, GLenum attachment, GLenum renderbuffertarget, + GLuint renderbuffer) { + g_gl_impl->FramebufferRenderbuffer( + target, attachment, renderbuffertarget, renderbuffer); +} +inline void glFramebufferTexture2D( + GLenum target, GLenum attachment, GLenum textarget, GLuint texture, + GLint level) { + g_gl_impl->FramebufferTexture2D( + target, attachment, textarget, texture, level); +} +inline void glFrontFace(GLenum mode) { + g_gl_impl->FrontFace(mode); +} +inline void glGenBuffers(GLsizei n, GLuint* buffers) { + g_gl_impl->GenBuffers(n, buffers); +} +inline void glGenerateMipmap(GLenum target) { + g_gl_impl->GenerateMipmap(target); +} +inline void glGenFramebuffers(GLsizei n, GLuint* framebuffers) { + g_gl_impl->GenFramebuffers(n, framebuffers); +} +inline void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { + g_gl_impl->GenRenderbuffers(n, renderbuffers); +} +inline void glGenTextures(GLsizei n, GLuint* textures) { + g_gl_impl->GenTextures(n, textures); +} +inline void glGetActiveAttrib( + GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, + GLenum* type, char* name) { + g_gl_impl->GetActiveAttrib( + program, index, bufsize, length, size, type, name); +} +inline void glGetActiveUniform( + GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, + GLenum* type, char* name) { + g_gl_impl->GetActiveUniform( + program, index, bufsize, length, size, type, name); +} +inline void glGetAttachedShaders( + GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { + g_gl_impl->GetAttachedShaders(program, maxcount, count, shaders); +} +inline int glGetAttribLocation(GLuint program, const char* name) { + return g_gl_impl->GetAttribLocation(program, name); +} +inline void glGetBooleanv(GLenum pname, GLboolean* params) { + g_gl_impl->GetBooleanv(pname, params); +} +inline void glGetBufferParameteriv( + GLenum target, GLenum pname, GLint* params) { + g_gl_impl->GetBufferParameteriv(target, pname, params); +} +inline GLenum glGetError() { + return g_gl_impl->GetError(); +} +inline void glGetFloatv(GLenum pname, GLfloat* params) { + g_gl_impl->GetFloatv(pname, params); +} +inline void glGetFramebufferAttachmentParameteriv( + GLenum target, GLenum attachment, GLenum pname, GLint* params) { + g_gl_impl->GetFramebufferAttachmentParameteriv( + target, attachment, pname, params); +} +inline void glGetIntegerv(GLenum pname, GLint* params) { + g_gl_impl->GetIntegerv(pname, params); +} +inline void glGetProgramiv(GLuint program, GLenum pname, GLint* params) { + g_gl_impl->GetProgramiv(program, pname, params); +} +inline void glGetProgramInfoLog( + GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) { + g_gl_impl->GetProgramInfoLog(program, bufsize, length, infolog); +} +inline void glGetRenderbufferParameteriv( + GLenum target, GLenum pname, GLint* params) { + g_gl_impl->GetRenderbufferParameteriv(target, pname, params); +} +inline void glGetShaderiv(GLuint shader, GLenum pname, GLint* params) { + g_gl_impl->GetShaderiv(shader, pname, params); +} +inline void glGetShaderInfoLog( + GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) { + g_gl_impl->GetShaderInfoLog(shader, bufsize, length, infolog); +} +inline void glGetShaderPrecisionFormat( + GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { + g_gl_impl->GetShaderPrecisionFormat( + shadertype, precisiontype, range, precision); +} +inline void glGetShaderSource( + GLuint shader, GLsizei bufsize, GLsizei* length, char* source) { + g_gl_impl->GetShaderSource(shader, bufsize, length, source); +} +inline const GLubyte* glGetString(GLenum name) { + return g_gl_impl->GetString(name); +} +inline void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { + g_gl_impl->GetTexParameterfv(target, pname, params); +} +inline void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { + g_gl_impl->GetTexParameteriv(target, pname, params); +} +inline void glGetUniformfv(GLuint program, GLint location, GLfloat* params) { + g_gl_impl->GetUniformfv(program, location, params); +} +inline void glGetUniformiv(GLuint program, GLint location, GLint* params) { + g_gl_impl->GetUniformiv(program, location, params); +} +inline int glGetUniformLocation(GLuint program, const char* name) { + return g_gl_impl->GetUniformLocation(program, name); +} +inline void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { + g_gl_impl->GetVertexAttribfv(index, pname, params); +} +inline void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { + g_gl_impl->GetVertexAttribiv(index, pname, params); +} +inline void glGetVertexAttribPointerv( + GLuint index, GLenum pname, void** pointer) { + g_gl_impl->GetVertexAttribPointerv(index, pname, pointer); +} +inline void glHint(GLenum target, GLenum mode) { + g_gl_impl->Hint(target, mode); +} +inline GLboolean glIsBuffer(GLuint buffer) { + return g_gl_impl->IsBuffer(buffer); +} +inline GLboolean glIsEnabled(GLenum cap) { + return g_gl_impl->IsEnabled(cap); +} +inline GLboolean glIsFramebuffer(GLuint framebuffer) { + return g_gl_impl->IsFramebuffer(framebuffer); +} +inline GLboolean glIsProgram(GLuint program) { + return g_gl_impl->IsProgram(program); +} +inline GLboolean glIsRenderbuffer(GLuint renderbuffer) { + return g_gl_impl->IsRenderbuffer(renderbuffer); +} +inline GLboolean glIsShader(GLuint shader) { + return g_gl_impl->IsShader(shader); +} +inline GLboolean glIsTexture(GLuint texture) { + return g_gl_impl->IsTexture(texture); +} +inline void glLineWidth(GLfloat width) { + g_gl_impl->LineWidth(width); +} +inline void glLinkProgram(GLuint program) { + g_gl_impl->LinkProgram(program); +} +inline void glPixelStorei(GLenum pname, GLint param) { + g_gl_impl->PixelStorei(pname, param); +} +inline void glPolygonOffset(GLfloat factor, GLfloat units) { + g_gl_impl->PolygonOffset(factor, units); +} +inline void glReadPixels( + GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, + void* pixels) { + g_gl_impl->ReadPixels(x, y, width, height, format, type, pixels); +} +inline void glRenderbufferStorage( + GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + g_gl_impl->RenderbufferStorage(target, internalformat, width, height); +} +inline void glSampleCoverage(GLclampf value, GLboolean invert) { + g_gl_impl->SampleCoverage(value, invert); +} +inline void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { + g_gl_impl->Scissor(x, y, width, height); +} +inline void glShaderSource( + GLuint shader, GLsizei count, const char** string, const GLint* length) { + g_gl_impl->ShaderSource(shader, count, string, length); +} +inline void glStencilFunc(GLenum func, GLint ref, GLuint mask) { + g_gl_impl->StencilFunc(func, ref, mask); +} +inline void glStencilFuncSeparate( + GLenum face, GLenum func, GLint ref, GLuint mask) { + g_gl_impl->StencilFuncSeparate(face, func, ref, mask); +} +inline void glStencilMask(GLuint mask) { + g_gl_impl->StencilMask(mask); +} +inline void glStencilMaskSeparate(GLenum face, GLuint mask) { + g_gl_impl->StencilMaskSeparate(face, mask); +} +inline void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { + g_gl_impl->StencilOp(fail, zfail, zpass); +} +inline void glStencilOpSeparate( + GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { + g_gl_impl->StencilOpSeparate(face, fail, zfail, zpass); +} +inline void glTexImage2D( + GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, + const void* pixels) { + g_gl_impl->TexImage2D( + target, level, internalformat, width, height, border, format, type, + pixels); +} +inline void glTexParameterf(GLenum target, GLenum pname, GLfloat param) { + g_gl_impl->TexParameterf(target, pname, param); +} +inline void glTexParameterfv( + GLenum target, GLenum pname, const GLfloat* params) { + g_gl_impl->TexParameterfv(target, pname, params); +} +inline void glTexParameteri(GLenum target, GLenum pname, GLint param) { + g_gl_impl->TexParameteri(target, pname, param); +} +inline void glTexParameteriv( + GLenum target, GLenum pname, const GLint* params) { + g_gl_impl->TexParameteriv(target, pname, params); +} +inline void glTexSubImage2D( + GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, + GLsizei height, GLenum format, GLenum type, const void* pixels) { + g_gl_impl->TexSubImage2D( + target, level, xoffset, yoffset, width, height, format, type, pixels); +} +inline void glUniform1f(GLint location, GLfloat x) { + g_gl_impl->Uniform1f(location, x); +} +inline void glUniform1fv(GLint location, GLsizei count, const GLfloat* v) { + g_gl_impl->Uniform1fv(location, count, v); +} +inline void glUniform1i(GLint location, GLint x) { + g_gl_impl->Uniform1i(location, x); +} +inline void glUniform1iv(GLint location, GLsizei count, const GLint* v) { + g_gl_impl->Uniform1iv(location, count, v); +} +inline void glUniform2f(GLint location, GLfloat x, GLfloat y) { + g_gl_impl->Uniform2f(location, x, y); +} +inline void glUniform2fv(GLint location, GLsizei count, const GLfloat* v) { + g_gl_impl->Uniform2fv(location, count, v); +} +inline void glUniform2i(GLint location, GLint x, GLint y) { + g_gl_impl->Uniform2i(location, x, y); +} +inline void glUniform2iv(GLint location, GLsizei count, const GLint* v) { + g_gl_impl->Uniform2iv(location, count, v); +} +inline void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { + g_gl_impl->Uniform3f(location, x, y, z); +} +inline void glUniform3fv(GLint location, GLsizei count, const GLfloat* v) { + g_gl_impl->Uniform3fv(location, count, v); +} +inline void glUniform3i(GLint location, GLint x, GLint y, GLint z) { + g_gl_impl->Uniform3i(location, x, y, z); +} +inline void glUniform3iv(GLint location, GLsizei count, const GLint* v) { + g_gl_impl->Uniform3iv(location, count, v); +} +inline void glUniform4f( + GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + g_gl_impl->Uniform4f(location, x, y, z, w); +} +inline void glUniform4fv(GLint location, GLsizei count, const GLfloat* v) { + g_gl_impl->Uniform4fv(location, count, v); +} +inline void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { + g_gl_impl->Uniform4i(location, x, y, z, w); +} +inline void glUniform4iv(GLint location, GLsizei count, const GLint* v) { + g_gl_impl->Uniform4iv(location, count, v); +} +inline void glUniformMatrix2fv( + GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { + g_gl_impl->UniformMatrix2fv(location, count, transpose, value); +} +inline void glUniformMatrix3fv( + GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { + g_gl_impl->UniformMatrix3fv(location, count, transpose, value); +} +inline void glUniformMatrix4fv( + GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { + g_gl_impl->UniformMatrix4fv(location, count, transpose, value); +} +inline void glUseProgram(GLuint program) { + g_gl_impl->UseProgram(program); +} +inline void glValidateProgram(GLuint program) { + g_gl_impl->ValidateProgram(program); +} +inline void glVertexAttrib1f(GLuint indx, GLfloat x) { + g_gl_impl->VertexAttrib1f(indx, x); +} +inline void glVertexAttrib1fv(GLuint indx, const GLfloat* values) { + g_gl_impl->VertexAttrib1fv(indx, values); +} +inline void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { + g_gl_impl->VertexAttrib2f(indx, x, y); +} +inline void glVertexAttrib2fv(GLuint indx, const GLfloat* values) { + g_gl_impl->VertexAttrib2fv(indx, values); +} +inline void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { + g_gl_impl->VertexAttrib3f(indx, x, y, z); +} +inline void glVertexAttrib3fv(GLuint indx, const GLfloat* values) { + g_gl_impl->VertexAttrib3fv(indx, values); +} +inline void glVertexAttrib4f( + GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + g_gl_impl->VertexAttrib4f(indx, x, y, z, w); +} +inline void glVertexAttrib4fv(GLuint indx, const GLfloat* values) { + g_gl_impl->VertexAttrib4fv(indx, values); +} +inline void glVertexAttribPointer( + GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, + const void* ptr) { + g_gl_impl->VertexAttribPointer(indx, size, type, normalized, stride, ptr); +} +inline void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { + g_gl_impl->Viewport(x, y, width, height); +} + diff --git a/o3d/gpu/command_buffer/common/cmd_buffer_common.h b/o3d/gpu/command_buffer/common/cmd_buffer_common.h index 0e44f86..b17b135 100644 --- a/o3d/gpu/command_buffer/common/cmd_buffer_common.h +++ b/o3d/gpu/command_buffer/common/cmd_buffer_common.h @@ -80,11 +80,20 @@ struct CommandHeader { Init(T::kCmdId, ComputeNumEntries(sizeof(T))); // NOLINT } + // Sets the header by a size in bytes of the immediate data after the command. + template <typename T> + void SetCmdBySize(uint32 size_of_data_in_bytes) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + Init(T::kCmdId, + ComputeNumEntries(sizeof(T) + size_of_data_in_bytes)); // NOLINT + } + // Sets the header by a size in bytes. template <typename T> - void SetCmdBySize(uint32 size_in_bytes) { + void SetCmdByTotalSize(uint32 size_in_bytes) { COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); - Init(T::kCmdId, ComputeNumEntries(sizeof(T) + size_in_bytes)); // NOLINT + DCHECK_GE(size_in_bytes, sizeof(T)); // NOLINT + Init(T::kCmdId, ComputeNumEntries(size_in_bytes)); } }; @@ -139,6 +148,19 @@ void* NextImmediateCmdAddress(void* cmd, uint32 size_of_data_in_bytes) { RoundSizeToMultipleOfEntries(size_of_data_in_bytes); } +// Gets the address of the place to put the next command in a typesafe way. +// This can only be used for variable sized command like IMMEDIATE commands. +// Parameters: +// cmd: Address of command. +// size_of_cmd_in_bytes: Size of the cmd and data. +template <typename T> +void* NextImmediateCmdAddressTotalSize(void* cmd, uint32 total_size_in_bytes) { + COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); + DCHECK_GE(total_size_in_bytes, sizeof(T)); // NOLINT + return reinterpret_cast<char*>(cmd) + + RoundSizeToMultipleOfEntries(total_size_in_bytes); +} + struct SharedMemory { void Init(uint32 _id, uint32 _offset) { id = _id; diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_format.cc b/o3d/gpu/command_buffer/common/gles2_cmd_format.cc new file mode 100644 index 0000000..ab8cb5c --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_format.cc @@ -0,0 +1,29 @@ +// Copyright (c) 2006-2009 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. + +// This file contains the binary format definition of the command buffer and +// command buffer commands. + +#include "gpu/command_buffer/common/gles2_cmd_format.h" + +namespace command_buffer { +namespace gles2 { + +const char* GetCommandName(CommandId id) { + static const char* const names[] = { + #define GLES2_CMD_OP(name) "k" # name, + + GLES2_COMMAND_LIST(GLES2_CMD_OP) + + #undef GLES2_CMD_OP + }; + + return (static_cast<int>(id) >= 0 && static_cast<int>(id) < kNumCommands) ? + names[id] : "*unknown-command*"; +} + +} // namespace gles2 +} // namespace command_buffer + + diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_format.h b/o3d/gpu/command_buffer/common/gles2_cmd_format.h new file mode 100644 index 0000000..4c40c1f --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_format.h @@ -0,0 +1,8447 @@ +// This file is auto-generated. DO NOT EDIT! + + +#ifndef O3D_SPUD_O3D_GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H +#define O3D_SPUD_O3D_GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H + +#include "gpu/command_buffer/common/gles2_cmd_utils.h" +#include "gpu/command_buffer/common/cmd_buffer_common.h" + +namespace command_buffer { +namespace gles2 { + +#define GLES2_COMMAND_LIST(OP) \ + OP(ActiveTexture) /* 1024 */ \ + OP(AttachShader) /* 1025 */ \ + OP(BindAttribLocation) /* 1026 */ \ + OP(BindAttribLocationImmediate) /* 1027 */ \ + OP(BindBuffer) /* 1028 */ \ + OP(BindFramebuffer) /* 1029 */ \ + OP(BindRenderbuffer) /* 1030 */ \ + OP(BindTexture) /* 1031 */ \ + OP(BlendColor) /* 1032 */ \ + OP(BlendEquation) /* 1033 */ \ + OP(BlendEquationSeparate) /* 1034 */ \ + OP(BlendFunc) /* 1035 */ \ + OP(BlendFuncSeparate) /* 1036 */ \ + OP(BufferData) /* 1037 */ \ + OP(BufferDataImmediate) /* 1038 */ \ + OP(BufferSubData) /* 1039 */ \ + OP(BufferSubDataImmediate) /* 1040 */ \ + OP(CheckFramebufferStatus) /* 1041 */ \ + OP(Clear) /* 1042 */ \ + OP(ClearColor) /* 1043 */ \ + OP(ClearDepthf) /* 1044 */ \ + OP(ClearStencil) /* 1045 */ \ + OP(ColorMask) /* 1046 */ \ + OP(CompileShader) /* 1047 */ \ + OP(CompressedTexImage2D) /* 1048 */ \ + OP(CompressedTexImage2DImmediate) /* 1049 */ \ + OP(CompressedTexSubImage2D) /* 1050 */ \ + OP(CompressedTexSubImage2DImmediate) /* 1051 */ \ + OP(CopyTexImage2D) /* 1052 */ \ + OP(CopyTexSubImage2D) /* 1053 */ \ + OP(CreateProgram) /* 1054 */ \ + OP(CreateShader) /* 1055 */ \ + OP(CullFace) /* 1056 */ \ + OP(DeleteBuffers) /* 1057 */ \ + OP(DeleteBuffersImmediate) /* 1058 */ \ + OP(DeleteFramebuffers) /* 1059 */ \ + OP(DeleteFramebuffersImmediate) /* 1060 */ \ + OP(DeleteProgram) /* 1061 */ \ + OP(DeleteRenderbuffers) /* 1062 */ \ + OP(DeleteRenderbuffersImmediate) /* 1063 */ \ + OP(DeleteShader) /* 1064 */ \ + OP(DeleteTextures) /* 1065 */ \ + OP(DeleteTexturesImmediate) /* 1066 */ \ + OP(DepthFunc) /* 1067 */ \ + OP(DepthMask) /* 1068 */ \ + OP(DepthRangef) /* 1069 */ \ + OP(DetachShader) /* 1070 */ \ + OP(Disable) /* 1071 */ \ + OP(DisableVertexAttribArray) /* 1072 */ \ + OP(DrawArrays) /* 1073 */ \ + OP(DrawElements) /* 1074 */ \ + OP(Enable) /* 1075 */ \ + OP(EnableVertexAttribArray) /* 1076 */ \ + OP(Finish) /* 1077 */ \ + OP(Flush) /* 1078 */ \ + OP(FramebufferRenderbuffer) /* 1079 */ \ + OP(FramebufferTexture2D) /* 1080 */ \ + OP(FrontFace) /* 1081 */ \ + OP(GenBuffers) /* 1082 */ \ + OP(GenBuffersImmediate) /* 1083 */ \ + OP(GenerateMipmap) /* 1084 */ \ + OP(GenFramebuffers) /* 1085 */ \ + OP(GenFramebuffersImmediate) /* 1086 */ \ + OP(GenRenderbuffers) /* 1087 */ \ + OP(GenRenderbuffersImmediate) /* 1088 */ \ + OP(GenTextures) /* 1089 */ \ + OP(GenTexturesImmediate) /* 1090 */ \ + OP(GetActiveAttrib) /* 1091 */ \ + OP(GetActiveUniform) /* 1092 */ \ + OP(GetAttachedShaders) /* 1093 */ \ + OP(GetAttribLocation) /* 1094 */ \ + OP(GetAttribLocationImmediate) /* 1095 */ \ + OP(GetBooleanv) /* 1096 */ \ + OP(GetBufferParameteriv) /* 1097 */ \ + OP(GetError) /* 1098 */ \ + OP(GetFloatv) /* 1099 */ \ + OP(GetFramebufferAttachmentParameteriv) /* 1100 */ \ + OP(GetIntegerv) /* 1101 */ \ + OP(GetProgramiv) /* 1102 */ \ + OP(GetProgramInfoLog) /* 1103 */ \ + OP(GetRenderbufferParameteriv) /* 1104 */ \ + OP(GetShaderiv) /* 1105 */ \ + OP(GetShaderInfoLog) /* 1106 */ \ + OP(GetShaderPrecisionFormat) /* 1107 */ \ + OP(GetShaderSource) /* 1108 */ \ + OP(GetString) /* 1109 */ \ + OP(GetTexParameterfv) /* 1110 */ \ + OP(GetTexParameteriv) /* 1111 */ \ + OP(GetUniformfv) /* 1112 */ \ + OP(GetUniformiv) /* 1113 */ \ + OP(GetUniformLocation) /* 1114 */ \ + OP(GetUniformLocationImmediate) /* 1115 */ \ + OP(GetVertexAttribfv) /* 1116 */ \ + OP(GetVertexAttribiv) /* 1117 */ \ + OP(GetVertexAttribPointerv) /* 1118 */ \ + OP(Hint) /* 1119 */ \ + OP(IsBuffer) /* 1120 */ \ + OP(IsEnabled) /* 1121 */ \ + OP(IsFramebuffer) /* 1122 */ \ + OP(IsProgram) /* 1123 */ \ + OP(IsRenderbuffer) /* 1124 */ \ + OP(IsShader) /* 1125 */ \ + OP(IsTexture) /* 1126 */ \ + OP(LineWidth) /* 1127 */ \ + OP(LinkProgram) /* 1128 */ \ + OP(PixelStorei) /* 1129 */ \ + OP(PolygonOffset) /* 1130 */ \ + OP(ReadPixels) /* 1131 */ \ + OP(RenderbufferStorage) /* 1132 */ \ + OP(SampleCoverage) /* 1133 */ \ + OP(Scissor) /* 1134 */ \ + OP(ShaderSource) /* 1135 */ \ + OP(ShaderSourceImmediate) /* 1136 */ \ + OP(StencilFunc) /* 1137 */ \ + OP(StencilFuncSeparate) /* 1138 */ \ + OP(StencilMask) /* 1139 */ \ + OP(StencilMaskSeparate) /* 1140 */ \ + OP(StencilOp) /* 1141 */ \ + OP(StencilOpSeparate) /* 1142 */ \ + OP(TexImage2D) /* 1143 */ \ + OP(TexImage2DImmediate) /* 1144 */ \ + OP(TexParameterf) /* 1145 */ \ + OP(TexParameterfv) /* 1146 */ \ + OP(TexParameterfvImmediate) /* 1147 */ \ + OP(TexParameteri) /* 1148 */ \ + OP(TexParameteriv) /* 1149 */ \ + OP(TexParameterivImmediate) /* 1150 */ \ + OP(TexSubImage2D) /* 1151 */ \ + OP(TexSubImage2DImmediate) /* 1152 */ \ + OP(Uniform1f) /* 1153 */ \ + OP(Uniform1fv) /* 1154 */ \ + OP(Uniform1fvImmediate) /* 1155 */ \ + OP(Uniform1i) /* 1156 */ \ + OP(Uniform1iv) /* 1157 */ \ + OP(Uniform1ivImmediate) /* 1158 */ \ + OP(Uniform2f) /* 1159 */ \ + OP(Uniform2fv) /* 1160 */ \ + OP(Uniform2fvImmediate) /* 1161 */ \ + OP(Uniform2i) /* 1162 */ \ + OP(Uniform2iv) /* 1163 */ \ + OP(Uniform2ivImmediate) /* 1164 */ \ + OP(Uniform3f) /* 1165 */ \ + OP(Uniform3fv) /* 1166 */ \ + OP(Uniform3fvImmediate) /* 1167 */ \ + OP(Uniform3i) /* 1168 */ \ + OP(Uniform3iv) /* 1169 */ \ + OP(Uniform3ivImmediate) /* 1170 */ \ + OP(Uniform4f) /* 1171 */ \ + OP(Uniform4fv) /* 1172 */ \ + OP(Uniform4fvImmediate) /* 1173 */ \ + OP(Uniform4i) /* 1174 */ \ + OP(Uniform4iv) /* 1175 */ \ + OP(Uniform4ivImmediate) /* 1176 */ \ + OP(UniformMatrix2fv) /* 1177 */ \ + OP(UniformMatrix2fvImmediate) /* 1178 */ \ + OP(UniformMatrix3fv) /* 1179 */ \ + OP(UniformMatrix3fvImmediate) /* 1180 */ \ + OP(UniformMatrix4fv) /* 1181 */ \ + OP(UniformMatrix4fvImmediate) /* 1182 */ \ + OP(UseProgram) /* 1183 */ \ + OP(ValidateProgram) /* 1184 */ \ + OP(VertexAttrib1f) /* 1185 */ \ + OP(VertexAttrib1fv) /* 1186 */ \ + OP(VertexAttrib1fvImmediate) /* 1187 */ \ + OP(VertexAttrib2f) /* 1188 */ \ + OP(VertexAttrib2fv) /* 1189 */ \ + OP(VertexAttrib2fvImmediate) /* 1190 */ \ + OP(VertexAttrib3f) /* 1191 */ \ + OP(VertexAttrib3fv) /* 1192 */ \ + OP(VertexAttrib3fvImmediate) /* 1193 */ \ + OP(VertexAttrib4f) /* 1194 */ \ + OP(VertexAttrib4fv) /* 1195 */ \ + OP(VertexAttrib4fvImmediate) /* 1196 */ \ + OP(VertexAttribPointer) /* 1197 */ \ + OP(Viewport) /* 1198 */ \ + +enum CommandId { + kStartPoint = cmd::kLastCommonId, // All GLES2 commands start after this. +#define GLES2_CMD_OP(name) k ## name, + GLES2_COMMAND_LIST(GLES2_CMD_OP) +#undef GLES2_CMD_OP + kNumCommands +}; + +#pragma pack(push, 1) + +struct ActiveTexture { + typedef ActiveTexture ValueType; + static const CommandId kCmdId = kActiveTexture; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _texture) { + SetHeader(); + texture = _texture; + } + + void* Set(void* cmd, GLenum _texture) { + static_cast<ValueType*>(cmd)->Init(_texture); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 texture; +}; + +COMPILE_ASSERT(sizeof(ActiveTexture) == 8, + Sizeof_ActiveTexture_is_not_8); +COMPILE_ASSERT(offsetof(ActiveTexture, header) == 0, + OffsetOf_ActiveTexture_header_not_0); +COMPILE_ASSERT(offsetof(ActiveTexture, texture) == 4, + OffsetOf_ActiveTexture_texture_not_4); + +struct AttachShader { + typedef AttachShader ValueType; + static const CommandId kCmdId = kAttachShader; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _program, GLuint _shader) { + SetHeader(); + program = _program; + shader = _shader; + } + + void* Set(void* cmd, GLuint _program, GLuint _shader) { + static_cast<ValueType*>(cmd)->Init(_program, _shader); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 shader; +}; + +COMPILE_ASSERT(sizeof(AttachShader) == 12, + Sizeof_AttachShader_is_not_12); +COMPILE_ASSERT(offsetof(AttachShader, header) == 0, + OffsetOf_AttachShader_header_not_0); +COMPILE_ASSERT(offsetof(AttachShader, program) == 4, + OffsetOf_AttachShader_program_not_4); +COMPILE_ASSERT(offsetof(AttachShader, shader) == 8, + OffsetOf_AttachShader_shader_not_8); + +struct BindAttribLocation { + typedef BindAttribLocation ValueType; + static const CommandId kCmdId = kBindAttribLocation; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLuint _index, uint32 _name_shm_id, + uint32 _name_shm_offset, uint32 _data_size) { + SetHeader(); + program = _program; + index = _index; + name_shm_id = _name_shm_id; + name_shm_offset = _name_shm_offset; + data_size = _data_size; + } + + void* Set( + void* cmd, GLuint _program, GLuint _index, uint32 _name_shm_id, + uint32 _name_shm_offset, uint32 _data_size) { + static_cast<ValueType*>( + cmd)->Init( + _program, _index, _name_shm_id, _name_shm_offset, _data_size); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 index; + uint32 name_shm_id; + uint32 name_shm_offset; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(BindAttribLocation) == 24, + Sizeof_BindAttribLocation_is_not_24); +COMPILE_ASSERT(offsetof(BindAttribLocation, header) == 0, + OffsetOf_BindAttribLocation_header_not_0); +COMPILE_ASSERT(offsetof(BindAttribLocation, program) == 4, + OffsetOf_BindAttribLocation_program_not_4); +COMPILE_ASSERT(offsetof(BindAttribLocation, index) == 8, + OffsetOf_BindAttribLocation_index_not_8); +COMPILE_ASSERT(offsetof(BindAttribLocation, name_shm_id) == 12, + OffsetOf_BindAttribLocation_name_shm_id_not_12); +COMPILE_ASSERT(offsetof(BindAttribLocation, name_shm_offset) == 16, + OffsetOf_BindAttribLocation_name_shm_offset_not_16); +COMPILE_ASSERT(offsetof(BindAttribLocation, data_size) == 20, + OffsetOf_BindAttribLocation_data_size_not_20); + +struct BindAttribLocationImmediate { + typedef BindAttribLocationImmediate ValueType; + static const CommandId kCmdId = kBindAttribLocationImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(const char* s) { + return strlen(s); + } + + static uint32 ComputeSize(const char* s) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(s)); // NOLINT + } + + void SetHeader(const char* s) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(s)); + } + + void Init(GLuint _program, GLuint _index, const char* _name) { + SetHeader(_name); + program = _program; + index = _index; + data_size = strlen(_name); + memcpy(ImmediateDataAddress(this), _name, data_size); + } + + void* Set(void* cmd, GLuint _program, GLuint _index, const char* _name) { + static_cast<ValueType*>(cmd)->Init(_program, _index, _name); + const uint32 size = ComputeSize(_name); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 index; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(BindAttribLocationImmediate) == 16, + Sizeof_BindAttribLocationImmediate_is_not_16); +COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, header) == 0, + OffsetOf_BindAttribLocationImmediate_header_not_0); +COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, program) == 4, + OffsetOf_BindAttribLocationImmediate_program_not_4); +COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, index) == 8, + OffsetOf_BindAttribLocationImmediate_index_not_8); +COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, data_size) == 12, + OffsetOf_BindAttribLocationImmediate_data_size_not_12); + +struct BindBuffer { + typedef BindBuffer ValueType; + static const CommandId kCmdId = kBindBuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLuint _buffer) { + SetHeader(); + target = _target; + buffer = _buffer; + } + + void* Set(void* cmd, GLenum _target, GLuint _buffer) { + static_cast<ValueType*>(cmd)->Init(_target, _buffer); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 buffer; +}; + +COMPILE_ASSERT(sizeof(BindBuffer) == 12, + Sizeof_BindBuffer_is_not_12); +COMPILE_ASSERT(offsetof(BindBuffer, header) == 0, + OffsetOf_BindBuffer_header_not_0); +COMPILE_ASSERT(offsetof(BindBuffer, target) == 4, + OffsetOf_BindBuffer_target_not_4); +COMPILE_ASSERT(offsetof(BindBuffer, buffer) == 8, + OffsetOf_BindBuffer_buffer_not_8); + +struct BindFramebuffer { + typedef BindFramebuffer ValueType; + static const CommandId kCmdId = kBindFramebuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLuint _framebuffer) { + SetHeader(); + target = _target; + framebuffer = _framebuffer; + } + + void* Set(void* cmd, GLenum _target, GLuint _framebuffer) { + static_cast<ValueType*>(cmd)->Init(_target, _framebuffer); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 framebuffer; +}; + +COMPILE_ASSERT(sizeof(BindFramebuffer) == 12, + Sizeof_BindFramebuffer_is_not_12); +COMPILE_ASSERT(offsetof(BindFramebuffer, header) == 0, + OffsetOf_BindFramebuffer_header_not_0); +COMPILE_ASSERT(offsetof(BindFramebuffer, target) == 4, + OffsetOf_BindFramebuffer_target_not_4); +COMPILE_ASSERT(offsetof(BindFramebuffer, framebuffer) == 8, + OffsetOf_BindFramebuffer_framebuffer_not_8); + +struct BindRenderbuffer { + typedef BindRenderbuffer ValueType; + static const CommandId kCmdId = kBindRenderbuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLuint _renderbuffer) { + SetHeader(); + target = _target; + renderbuffer = _renderbuffer; + } + + void* Set(void* cmd, GLenum _target, GLuint _renderbuffer) { + static_cast<ValueType*>(cmd)->Init(_target, _renderbuffer); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 renderbuffer; +}; + +COMPILE_ASSERT(sizeof(BindRenderbuffer) == 12, + Sizeof_BindRenderbuffer_is_not_12); +COMPILE_ASSERT(offsetof(BindRenderbuffer, header) == 0, + OffsetOf_BindRenderbuffer_header_not_0); +COMPILE_ASSERT(offsetof(BindRenderbuffer, target) == 4, + OffsetOf_BindRenderbuffer_target_not_4); +COMPILE_ASSERT(offsetof(BindRenderbuffer, renderbuffer) == 8, + OffsetOf_BindRenderbuffer_renderbuffer_not_8); + +struct BindTexture { + typedef BindTexture ValueType; + static const CommandId kCmdId = kBindTexture; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLuint _texture) { + SetHeader(); + target = _target; + texture = _texture; + } + + void* Set(void* cmd, GLenum _target, GLuint _texture) { + static_cast<ValueType*>(cmd)->Init(_target, _texture); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 texture; +}; + +COMPILE_ASSERT(sizeof(BindTexture) == 12, + Sizeof_BindTexture_is_not_12); +COMPILE_ASSERT(offsetof(BindTexture, header) == 0, + OffsetOf_BindTexture_header_not_0); +COMPILE_ASSERT(offsetof(BindTexture, target) == 4, + OffsetOf_BindTexture_target_not_4); +COMPILE_ASSERT(offsetof(BindTexture, texture) == 8, + OffsetOf_BindTexture_texture_not_8); + +struct BlendColor { + typedef BlendColor ValueType; + static const CommandId kCmdId = kBlendColor; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { + SetHeader(); + red = _red; + green = _green; + blue = _blue; + alpha = _alpha; + } + + void* Set( + void* cmd, GLclampf _red, GLclampf _green, GLclampf _blue, + GLclampf _alpha) { + static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float red; + float green; + float blue; + float alpha; +}; + +COMPILE_ASSERT(sizeof(BlendColor) == 20, + Sizeof_BlendColor_is_not_20); +COMPILE_ASSERT(offsetof(BlendColor, header) == 0, + OffsetOf_BlendColor_header_not_0); +COMPILE_ASSERT(offsetof(BlendColor, red) == 4, + OffsetOf_BlendColor_red_not_4); +COMPILE_ASSERT(offsetof(BlendColor, green) == 8, + OffsetOf_BlendColor_green_not_8); +COMPILE_ASSERT(offsetof(BlendColor, blue) == 12, + OffsetOf_BlendColor_blue_not_12); +COMPILE_ASSERT(offsetof(BlendColor, alpha) == 16, + OffsetOf_BlendColor_alpha_not_16); + +struct BlendEquation { + typedef BlendEquation ValueType; + static const CommandId kCmdId = kBlendEquation; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _mode) { + SetHeader(); + mode = _mode; + } + + void* Set(void* cmd, GLenum _mode) { + static_cast<ValueType*>(cmd)->Init(_mode); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mode; +}; + +COMPILE_ASSERT(sizeof(BlendEquation) == 8, + Sizeof_BlendEquation_is_not_8); +COMPILE_ASSERT(offsetof(BlendEquation, header) == 0, + OffsetOf_BlendEquation_header_not_0); +COMPILE_ASSERT(offsetof(BlendEquation, mode) == 4, + OffsetOf_BlendEquation_mode_not_4); + +struct BlendEquationSeparate { + typedef BlendEquationSeparate ValueType; + static const CommandId kCmdId = kBlendEquationSeparate; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _modeRGB, GLenum _modeAlpha) { + SetHeader(); + modeRGB = _modeRGB; + modeAlpha = _modeAlpha; + } + + void* Set(void* cmd, GLenum _modeRGB, GLenum _modeAlpha) { + static_cast<ValueType*>(cmd)->Init(_modeRGB, _modeAlpha); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 modeRGB; + uint32 modeAlpha; +}; + +COMPILE_ASSERT(sizeof(BlendEquationSeparate) == 12, + Sizeof_BlendEquationSeparate_is_not_12); +COMPILE_ASSERT(offsetof(BlendEquationSeparate, header) == 0, + OffsetOf_BlendEquationSeparate_header_not_0); +COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeRGB) == 4, + OffsetOf_BlendEquationSeparate_modeRGB_not_4); +COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeAlpha) == 8, + OffsetOf_BlendEquationSeparate_modeAlpha_not_8); + +struct BlendFunc { + typedef BlendFunc ValueType; + static const CommandId kCmdId = kBlendFunc; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _sfactor, GLenum _dfactor) { + SetHeader(); + sfactor = _sfactor; + dfactor = _dfactor; + } + + void* Set(void* cmd, GLenum _sfactor, GLenum _dfactor) { + static_cast<ValueType*>(cmd)->Init(_sfactor, _dfactor); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 sfactor; + uint32 dfactor; +}; + +COMPILE_ASSERT(sizeof(BlendFunc) == 12, + Sizeof_BlendFunc_is_not_12); +COMPILE_ASSERT(offsetof(BlendFunc, header) == 0, + OffsetOf_BlendFunc_header_not_0); +COMPILE_ASSERT(offsetof(BlendFunc, sfactor) == 4, + OffsetOf_BlendFunc_sfactor_not_4); +COMPILE_ASSERT(offsetof(BlendFunc, dfactor) == 8, + OffsetOf_BlendFunc_dfactor_not_8); + +struct BlendFuncSeparate { + typedef BlendFuncSeparate ValueType; + static const CommandId kCmdId = kBlendFuncSeparate; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _srcRGB, GLenum _dstRGB, GLenum _srcAlpha, GLenum _dstAlpha) { + SetHeader(); + srcRGB = _srcRGB; + dstRGB = _dstRGB; + srcAlpha = _srcAlpha; + dstAlpha = _dstAlpha; + } + + void* Set( + void* cmd, GLenum _srcRGB, GLenum _dstRGB, GLenum _srcAlpha, + GLenum _dstAlpha) { + static_cast<ValueType*>(cmd)->Init(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 srcRGB; + uint32 dstRGB; + uint32 srcAlpha; + uint32 dstAlpha; +}; + +COMPILE_ASSERT(sizeof(BlendFuncSeparate) == 20, + Sizeof_BlendFuncSeparate_is_not_20); +COMPILE_ASSERT(offsetof(BlendFuncSeparate, header) == 0, + OffsetOf_BlendFuncSeparate_header_not_0); +COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcRGB) == 4, + OffsetOf_BlendFuncSeparate_srcRGB_not_4); +COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstRGB) == 8, + OffsetOf_BlendFuncSeparate_dstRGB_not_8); +COMPILE_ASSERT(offsetof(BlendFuncSeparate, srcAlpha) == 12, + OffsetOf_BlendFuncSeparate_srcAlpha_not_12); +COMPILE_ASSERT(offsetof(BlendFuncSeparate, dstAlpha) == 16, + OffsetOf_BlendFuncSeparate_dstAlpha_not_16); + +struct BufferData { + typedef BufferData ValueType; + static const CommandId kCmdId = kBufferData; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLsizeiptr _size, uint32 _data_shm_id, + uint32 _data_shm_offset, GLenum _usage) { + SetHeader(); + target = _target; + size = _size; + data_shm_id = _data_shm_id; + data_shm_offset = _data_shm_offset; + usage = _usage; + } + + void* Set( + void* cmd, GLenum _target, GLsizeiptr _size, uint32 _data_shm_id, + uint32 _data_shm_offset, GLenum _usage) { + static_cast<ValueType*>( + cmd)->Init(_target, _size, _data_shm_id, _data_shm_offset, _usage); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 size; + uint32 data_shm_id; + uint32 data_shm_offset; + uint32 usage; +}; + +COMPILE_ASSERT(sizeof(BufferData) == 24, + Sizeof_BufferData_is_not_24); +COMPILE_ASSERT(offsetof(BufferData, header) == 0, + OffsetOf_BufferData_header_not_0); +COMPILE_ASSERT(offsetof(BufferData, target) == 4, + OffsetOf_BufferData_target_not_4); +COMPILE_ASSERT(offsetof(BufferData, size) == 8, + OffsetOf_BufferData_size_not_8); +COMPILE_ASSERT(offsetof(BufferData, data_shm_id) == 12, + OffsetOf_BufferData_data_shm_id_not_12); +COMPILE_ASSERT(offsetof(BufferData, data_shm_offset) == 16, + OffsetOf_BufferData_data_shm_offset_not_16); +COMPILE_ASSERT(offsetof(BufferData, usage) == 20, + OffsetOf_BufferData_usage_not_20); + +struct BufferDataImmediate { + typedef BufferDataImmediate ValueType; + static const CommandId kCmdId = kBufferDataImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init(GLenum _target, GLsizeiptr _size, GLenum _usage) { + uint32 total_size = ComputeSize(_size); + SetHeader(total_size); + target = _target; + size = _size; + usage = _usage; + } + + void* Set(void* cmd, GLenum _target, GLsizeiptr _size, GLenum _usage) { + uint32 total_size = ComputeSize(_size); + static_cast<ValueType*>(cmd)->Init(_target, _size, _usage); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 size; + uint32 usage; +}; + +COMPILE_ASSERT(sizeof(BufferDataImmediate) == 16, + Sizeof_BufferDataImmediate_is_not_16); +COMPILE_ASSERT(offsetof(BufferDataImmediate, header) == 0, + OffsetOf_BufferDataImmediate_header_not_0); +COMPILE_ASSERT(offsetof(BufferDataImmediate, target) == 4, + OffsetOf_BufferDataImmediate_target_not_4); +COMPILE_ASSERT(offsetof(BufferDataImmediate, size) == 8, + OffsetOf_BufferDataImmediate_size_not_8); +COMPILE_ASSERT(offsetof(BufferDataImmediate, usage) == 12, + OffsetOf_BufferDataImmediate_usage_not_12); + +struct BufferSubData { + typedef BufferSubData ValueType; + static const CommandId kCmdId = kBufferSubData; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLintptr _offset, GLsizeiptr _size, uint32 _data_shm_id, + uint32 _data_shm_offset) { + SetHeader(); + target = _target; + offset = _offset; + size = _size; + data_shm_id = _data_shm_id; + data_shm_offset = _data_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLintptr _offset, GLsizeiptr _size, + uint32 _data_shm_id, uint32 _data_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _offset, _size, _data_shm_id, _data_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 offset; + uint32 size; + uint32 data_shm_id; + uint32 data_shm_offset; +}; + +COMPILE_ASSERT(sizeof(BufferSubData) == 24, + Sizeof_BufferSubData_is_not_24); +COMPILE_ASSERT(offsetof(BufferSubData, header) == 0, + OffsetOf_BufferSubData_header_not_0); +COMPILE_ASSERT(offsetof(BufferSubData, target) == 4, + OffsetOf_BufferSubData_target_not_4); +COMPILE_ASSERT(offsetof(BufferSubData, offset) == 8, + OffsetOf_BufferSubData_offset_not_8); +COMPILE_ASSERT(offsetof(BufferSubData, size) == 12, + OffsetOf_BufferSubData_size_not_12); +COMPILE_ASSERT(offsetof(BufferSubData, data_shm_id) == 16, + OffsetOf_BufferSubData_data_shm_id_not_16); +COMPILE_ASSERT(offsetof(BufferSubData, data_shm_offset) == 20, + OffsetOf_BufferSubData_data_shm_offset_not_20); + +struct BufferSubDataImmediate { + typedef BufferSubDataImmediate ValueType; + static const CommandId kCmdId = kBufferSubDataImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init(GLenum _target, GLintptr _offset, GLsizeiptr _size) { + uint32 total_size = ComputeSize(_size); + SetHeader(total_size); + target = _target; + offset = _offset; + size = _size; + } + + void* Set(void* cmd, GLenum _target, GLintptr _offset, GLsizeiptr _size) { + uint32 total_size = ComputeSize(_size); + static_cast<ValueType*>(cmd)->Init(_target, _offset, _size); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 offset; + uint32 size; +}; + +COMPILE_ASSERT(sizeof(BufferSubDataImmediate) == 16, + Sizeof_BufferSubDataImmediate_is_not_16); +COMPILE_ASSERT(offsetof(BufferSubDataImmediate, header) == 0, + OffsetOf_BufferSubDataImmediate_header_not_0); +COMPILE_ASSERT(offsetof(BufferSubDataImmediate, target) == 4, + OffsetOf_BufferSubDataImmediate_target_not_4); +COMPILE_ASSERT(offsetof(BufferSubDataImmediate, offset) == 8, + OffsetOf_BufferSubDataImmediate_offset_not_8); +COMPILE_ASSERT(offsetof(BufferSubDataImmediate, size) == 12, + OffsetOf_BufferSubDataImmediate_size_not_12); + +struct CheckFramebufferStatus { + typedef CheckFramebufferStatus ValueType; + static const CommandId kCmdId = kCheckFramebufferStatus; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target) { + SetHeader(); + target = _target; + } + + void* Set(void* cmd, GLenum _target) { + static_cast<ValueType*>(cmd)->Init(_target); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; +}; + +COMPILE_ASSERT(sizeof(CheckFramebufferStatus) == 8, + Sizeof_CheckFramebufferStatus_is_not_8); +COMPILE_ASSERT(offsetof(CheckFramebufferStatus, header) == 0, + OffsetOf_CheckFramebufferStatus_header_not_0); +COMPILE_ASSERT(offsetof(CheckFramebufferStatus, target) == 4, + OffsetOf_CheckFramebufferStatus_target_not_4); + +struct Clear { + typedef Clear ValueType; + static const CommandId kCmdId = kClear; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLbitfield _mask) { + SetHeader(); + mask = _mask; + } + + void* Set(void* cmd, GLbitfield _mask) { + static_cast<ValueType*>(cmd)->Init(_mask); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mask; +}; + +COMPILE_ASSERT(sizeof(Clear) == 8, + Sizeof_Clear_is_not_8); +COMPILE_ASSERT(offsetof(Clear, header) == 0, + OffsetOf_Clear_header_not_0); +COMPILE_ASSERT(offsetof(Clear, mask) == 4, + OffsetOf_Clear_mask_not_4); + +struct ClearColor { + typedef ClearColor ValueType; + static const CommandId kCmdId = kClearColor; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) { + SetHeader(); + red = _red; + green = _green; + blue = _blue; + alpha = _alpha; + } + + void* Set( + void* cmd, GLclampf _red, GLclampf _green, GLclampf _blue, + GLclampf _alpha) { + static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float red; + float green; + float blue; + float alpha; +}; + +COMPILE_ASSERT(sizeof(ClearColor) == 20, + Sizeof_ClearColor_is_not_20); +COMPILE_ASSERT(offsetof(ClearColor, header) == 0, + OffsetOf_ClearColor_header_not_0); +COMPILE_ASSERT(offsetof(ClearColor, red) == 4, + OffsetOf_ClearColor_red_not_4); +COMPILE_ASSERT(offsetof(ClearColor, green) == 8, + OffsetOf_ClearColor_green_not_8); +COMPILE_ASSERT(offsetof(ClearColor, blue) == 12, + OffsetOf_ClearColor_blue_not_12); +COMPILE_ASSERT(offsetof(ClearColor, alpha) == 16, + OffsetOf_ClearColor_alpha_not_16); + +struct ClearDepthf { + typedef ClearDepthf ValueType; + static const CommandId kCmdId = kClearDepthf; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLclampf _depth) { + SetHeader(); + depth = _depth; + } + + void* Set(void* cmd, GLclampf _depth) { + static_cast<ValueType*>(cmd)->Init(_depth); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float depth; +}; + +COMPILE_ASSERT(sizeof(ClearDepthf) == 8, + Sizeof_ClearDepthf_is_not_8); +COMPILE_ASSERT(offsetof(ClearDepthf, header) == 0, + OffsetOf_ClearDepthf_header_not_0); +COMPILE_ASSERT(offsetof(ClearDepthf, depth) == 4, + OffsetOf_ClearDepthf_depth_not_4); + +struct ClearStencil { + typedef ClearStencil ValueType; + static const CommandId kCmdId = kClearStencil; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _s) { + SetHeader(); + s = _s; + } + + void* Set(void* cmd, GLint _s) { + static_cast<ValueType*>(cmd)->Init(_s); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 s; +}; + +COMPILE_ASSERT(sizeof(ClearStencil) == 8, + Sizeof_ClearStencil_is_not_8); +COMPILE_ASSERT(offsetof(ClearStencil, header) == 0, + OffsetOf_ClearStencil_header_not_0); +COMPILE_ASSERT(offsetof(ClearStencil, s) == 4, + OffsetOf_ClearStencil_s_not_4); + +struct ColorMask { + typedef ColorMask ValueType; + static const CommandId kCmdId = kColorMask; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLboolean _red, GLboolean _green, GLboolean _blue, GLboolean _alpha) { + SetHeader(); + red = _red; + green = _green; + blue = _blue; + alpha = _alpha; + } + + void* Set( + void* cmd, GLboolean _red, GLboolean _green, GLboolean _blue, + GLboolean _alpha) { + static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 red; + uint32 green; + uint32 blue; + uint32 alpha; +}; + +COMPILE_ASSERT(sizeof(ColorMask) == 20, + Sizeof_ColorMask_is_not_20); +COMPILE_ASSERT(offsetof(ColorMask, header) == 0, + OffsetOf_ColorMask_header_not_0); +COMPILE_ASSERT(offsetof(ColorMask, red) == 4, + OffsetOf_ColorMask_red_not_4); +COMPILE_ASSERT(offsetof(ColorMask, green) == 8, + OffsetOf_ColorMask_green_not_8); +COMPILE_ASSERT(offsetof(ColorMask, blue) == 12, + OffsetOf_ColorMask_blue_not_12); +COMPILE_ASSERT(offsetof(ColorMask, alpha) == 16, + OffsetOf_ColorMask_alpha_not_16); + +struct CompileShader { + typedef CompileShader ValueType; + static const CommandId kCmdId = kCompileShader; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _shader) { + SetHeader(); + shader = _shader; + } + + void* Set(void* cmd, GLuint _shader) { + static_cast<ValueType*>(cmd)->Init(_shader); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; +}; + +COMPILE_ASSERT(sizeof(CompileShader) == 8, + Sizeof_CompileShader_is_not_8); +COMPILE_ASSERT(offsetof(CompileShader, header) == 0, + OffsetOf_CompileShader_header_not_0); +COMPILE_ASSERT(offsetof(CompileShader, shader) == 4, + OffsetOf_CompileShader_shader_not_4); + +struct CompressedTexImage2D { + typedef CompressedTexImage2D ValueType; + static const CommandId kCmdId = kCompressedTexImage2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, + GLsizei _height, GLint _border, GLsizei _imageSize, uint32 _data_shm_id, + uint32 _data_shm_offset) { + SetHeader(); + target = _target; + level = _level; + internalformat = _internalformat; + width = _width; + height = _height; + border = _border; + imageSize = _imageSize; + data_shm_id = _data_shm_id; + data_shm_offset = _data_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLenum _internalformat, + GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize, + uint32 _data_shm_id, uint32 _data_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _internalformat, _width, _height, _border, + _imageSize, _data_shm_id, _data_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 internalformat; + uint32 width; + uint32 height; + uint32 border; + uint32 imageSize; + uint32 data_shm_id; + uint32 data_shm_offset; +}; + +COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 40, + Sizeof_CompressedTexImage2D_is_not_40); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, header) == 0, + OffsetOf_CompressedTexImage2D_header_not_0); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, target) == 4, + OffsetOf_CompressedTexImage2D_target_not_4); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, level) == 8, + OffsetOf_CompressedTexImage2D_level_not_8); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, internalformat) == 12, + OffsetOf_CompressedTexImage2D_internalformat_not_12); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, width) == 16, + OffsetOf_CompressedTexImage2D_width_not_16); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, height) == 20, + OffsetOf_CompressedTexImage2D_height_not_20); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, border) == 24, + OffsetOf_CompressedTexImage2D_border_not_24); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, imageSize) == 28, + OffsetOf_CompressedTexImage2D_imageSize_not_28); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 32, + OffsetOf_CompressedTexImage2D_data_shm_id_not_32); +COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 36, + OffsetOf_CompressedTexImage2D_data_shm_offset_not_36); + +struct CompressedTexImage2DImmediate { + typedef CompressedTexImage2DImmediate ValueType; + static const CommandId kCmdId = kCompressedTexImage2DImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init( + GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, + GLsizei _height, GLint _border, GLsizei _imageSize) { + uint32 total_size = ComputeSize(_imageSize); + SetHeader(total_size); + target = _target; + level = _level; + internalformat = _internalformat; + width = _width; + height = _height; + border = _border; + imageSize = _imageSize; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLenum _internalformat, + GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize) { + uint32 total_size = ComputeSize(_imageSize); + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _internalformat, _width, _height, _border, + _imageSize); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 internalformat; + uint32 width; + uint32 height; + uint32 border; + uint32 imageSize; +}; + +COMPILE_ASSERT(sizeof(CompressedTexImage2DImmediate) == 32, + Sizeof_CompressedTexImage2DImmediate_is_not_32); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, header) == 0, + OffsetOf_CompressedTexImage2DImmediate_header_not_0); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, target) == 4, + OffsetOf_CompressedTexImage2DImmediate_target_not_4); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, level) == 8, + OffsetOf_CompressedTexImage2DImmediate_level_not_8); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, internalformat) == 12, + OffsetOf_CompressedTexImage2DImmediate_internalformat_not_12); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, width) == 16, + OffsetOf_CompressedTexImage2DImmediate_width_not_16); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, height) == 20, + OffsetOf_CompressedTexImage2DImmediate_height_not_20); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, border) == 24, + OffsetOf_CompressedTexImage2DImmediate_border_not_24); +COMPILE_ASSERT(offsetof(CompressedTexImage2DImmediate, imageSize) == 28, + OffsetOf_CompressedTexImage2DImmediate_imageSize_not_28); + +struct CompressedTexSubImage2D { + typedef CompressedTexSubImage2D ValueType; + static const CommandId kCmdId = kCompressedTexSubImage2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize, + uint32 _data_shm_id, uint32 _data_shm_offset) { + SetHeader(); + target = _target; + level = _level; + xoffset = _xoffset; + yoffset = _yoffset; + width = _width; + height = _height; + format = _format; + imageSize = _imageSize; + data_shm_id = _data_shm_id; + data_shm_offset = _data_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize, + uint32 _data_shm_id, uint32 _data_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _xoffset, _yoffset, _width, _height, _format, + _imageSize, _data_shm_id, _data_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 xoffset; + uint32 yoffset; + uint32 width; + uint32 height; + uint32 format; + uint32 imageSize; + uint32 data_shm_id; + uint32 data_shm_offset; +}; + +COMPILE_ASSERT(sizeof(CompressedTexSubImage2D) == 44, + Sizeof_CompressedTexSubImage2D_is_not_44); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, header) == 0, + OffsetOf_CompressedTexSubImage2D_header_not_0); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, target) == 4, + OffsetOf_CompressedTexSubImage2D_target_not_4); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, level) == 8, + OffsetOf_CompressedTexSubImage2D_level_not_8); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, xoffset) == 12, + OffsetOf_CompressedTexSubImage2D_xoffset_not_12); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, yoffset) == 16, + OffsetOf_CompressedTexSubImage2D_yoffset_not_16); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, width) == 20, + OffsetOf_CompressedTexSubImage2D_width_not_20); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, height) == 24, + OffsetOf_CompressedTexSubImage2D_height_not_24); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, format) == 28, + OffsetOf_CompressedTexSubImage2D_format_not_28); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, imageSize) == 32, + OffsetOf_CompressedTexSubImage2D_imageSize_not_32); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_id) == 36, + OffsetOf_CompressedTexSubImage2D_data_shm_id_not_36); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40, + OffsetOf_CompressedTexSubImage2D_data_shm_offset_not_40); + +struct CompressedTexSubImage2DImmediate { + typedef CompressedTexSubImage2DImmediate ValueType; + static const CommandId kCmdId = kCompressedTexSubImage2DImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init( + GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize) { + uint32 total_size = ComputeSize(_imageSize); + SetHeader(total_size); + target = _target; + level = _level; + xoffset = _xoffset; + yoffset = _yoffset; + width = _width; + height = _height; + format = _format; + imageSize = _imageSize; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize) { + uint32 total_size = ComputeSize(_imageSize); + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _xoffset, _yoffset, _width, _height, _format, + _imageSize); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 xoffset; + uint32 yoffset; + uint32 width; + uint32 height; + uint32 format; + uint32 imageSize; +}; + +COMPILE_ASSERT(sizeof(CompressedTexSubImage2DImmediate) == 36, + Sizeof_CompressedTexSubImage2DImmediate_is_not_36); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, header) == 0, + OffsetOf_CompressedTexSubImage2DImmediate_header_not_0); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, target) == 4, + OffsetOf_CompressedTexSubImage2DImmediate_target_not_4); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, level) == 8, + OffsetOf_CompressedTexSubImage2DImmediate_level_not_8); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, xoffset) == 12, + OffsetOf_CompressedTexSubImage2DImmediate_xoffset_not_12); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, yoffset) == 16, + OffsetOf_CompressedTexSubImage2DImmediate_yoffset_not_16); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, width) == 20, + OffsetOf_CompressedTexSubImage2DImmediate_width_not_20); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, height) == 24, + OffsetOf_CompressedTexSubImage2DImmediate_height_not_24); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, format) == 28, + OffsetOf_CompressedTexSubImage2DImmediate_format_not_28); +COMPILE_ASSERT(offsetof(CompressedTexSubImage2DImmediate, imageSize) == 32, + OffsetOf_CompressedTexSubImage2DImmediate_imageSize_not_32); + +struct CopyTexImage2D { + typedef CopyTexImage2D ValueType; + static const CommandId kCmdId = kCopyTexImage2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLint _level, GLenum _internalformat, GLint _x, GLint _y, + GLsizei _width, GLsizei _height, GLint _border) { + SetHeader(); + target = _target; + level = _level; + internalformat = _internalformat; + x = _x; + y = _y; + width = _width; + height = _height; + border = _border; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLenum _internalformat, GLint _x, + GLint _y, GLsizei _width, GLsizei _height, GLint _border) { + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _internalformat, _x, _y, _width, _height, + _border); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 internalformat; + uint32 x; + uint32 y; + uint32 width; + uint32 height; + uint32 border; +}; + +COMPILE_ASSERT(sizeof(CopyTexImage2D) == 36, + Sizeof_CopyTexImage2D_is_not_36); +COMPILE_ASSERT(offsetof(CopyTexImage2D, header) == 0, + OffsetOf_CopyTexImage2D_header_not_0); +COMPILE_ASSERT(offsetof(CopyTexImage2D, target) == 4, + OffsetOf_CopyTexImage2D_target_not_4); +COMPILE_ASSERT(offsetof(CopyTexImage2D, level) == 8, + OffsetOf_CopyTexImage2D_level_not_8); +COMPILE_ASSERT(offsetof(CopyTexImage2D, internalformat) == 12, + OffsetOf_CopyTexImage2D_internalformat_not_12); +COMPILE_ASSERT(offsetof(CopyTexImage2D, x) == 16, + OffsetOf_CopyTexImage2D_x_not_16); +COMPILE_ASSERT(offsetof(CopyTexImage2D, y) == 20, + OffsetOf_CopyTexImage2D_y_not_20); +COMPILE_ASSERT(offsetof(CopyTexImage2D, width) == 24, + OffsetOf_CopyTexImage2D_width_not_24); +COMPILE_ASSERT(offsetof(CopyTexImage2D, height) == 28, + OffsetOf_CopyTexImage2D_height_not_28); +COMPILE_ASSERT(offsetof(CopyTexImage2D, border) == 32, + OffsetOf_CopyTexImage2D_border_not_32); + +struct CopyTexSubImage2D { + typedef CopyTexSubImage2D ValueType; + static const CommandId kCmdId = kCopyTexSubImage2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, GLint _x, + GLint _y, GLsizei _width, GLsizei _height) { + SetHeader(); + target = _target; + level = _level; + xoffset = _xoffset; + yoffset = _yoffset; + x = _x; + y = _y; + width = _width; + height = _height; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLint _x, GLint _y, GLsizei _width, GLsizei _height) { + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _xoffset, _yoffset, _x, _y, _width, _height); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 xoffset; + uint32 yoffset; + uint32 x; + uint32 y; + uint32 width; + uint32 height; +}; + +COMPILE_ASSERT(sizeof(CopyTexSubImage2D) == 36, + Sizeof_CopyTexSubImage2D_is_not_36); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, header) == 0, + OffsetOf_CopyTexSubImage2D_header_not_0); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, target) == 4, + OffsetOf_CopyTexSubImage2D_target_not_4); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, level) == 8, + OffsetOf_CopyTexSubImage2D_level_not_8); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, xoffset) == 12, + OffsetOf_CopyTexSubImage2D_xoffset_not_12); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, yoffset) == 16, + OffsetOf_CopyTexSubImage2D_yoffset_not_16); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, x) == 20, + OffsetOf_CopyTexSubImage2D_x_not_20); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, y) == 24, + OffsetOf_CopyTexSubImage2D_y_not_24); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, width) == 28, + OffsetOf_CopyTexSubImage2D_width_not_28); +COMPILE_ASSERT(offsetof(CopyTexSubImage2D, height) == 32, + OffsetOf_CopyTexSubImage2D_height_not_32); + +struct CreateProgram { + typedef CreateProgram ValueType; + static const CommandId kCmdId = kCreateProgram; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _client_id) { + SetHeader(); + client_id = _client_id; + } + + void* Set(void* cmd, uint32 _client_id) { + static_cast<ValueType*>(cmd)->Init(_client_id); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 client_id; +}; + +COMPILE_ASSERT(sizeof(CreateProgram) == 8, + Sizeof_CreateProgram_is_not_8); +COMPILE_ASSERT(offsetof(CreateProgram, header) == 0, + OffsetOf_CreateProgram_header_not_0); +COMPILE_ASSERT(offsetof(CreateProgram, client_id) == 4, + OffsetOf_CreateProgram_client_id_not_4); + +struct CreateShader { + typedef CreateShader ValueType; + static const CommandId kCmdId = kCreateShader; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _type, uint32 _client_id) { + SetHeader(); + type = _type; + client_id = _client_id; + } + + void* Set(void* cmd, GLenum _type, uint32 _client_id) { + static_cast<ValueType*>(cmd)->Init(_type, _client_id); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 type; + uint32 client_id; +}; + +COMPILE_ASSERT(sizeof(CreateShader) == 12, + Sizeof_CreateShader_is_not_12); +COMPILE_ASSERT(offsetof(CreateShader, header) == 0, + OffsetOf_CreateShader_header_not_0); +COMPILE_ASSERT(offsetof(CreateShader, type) == 4, + OffsetOf_CreateShader_type_not_4); +COMPILE_ASSERT(offsetof(CreateShader, client_id) == 8, + OffsetOf_CreateShader_client_id_not_8); + +struct CullFace { + typedef CullFace ValueType; + static const CommandId kCmdId = kCullFace; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _mode) { + SetHeader(); + mode = _mode; + } + + void* Set(void* cmd, GLenum _mode) { + static_cast<ValueType*>(cmd)->Init(_mode); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mode; +}; + +COMPILE_ASSERT(sizeof(CullFace) == 8, + Sizeof_CullFace_is_not_8); +COMPILE_ASSERT(offsetof(CullFace, header) == 0, + OffsetOf_CullFace_header_not_0); +COMPILE_ASSERT(offsetof(CullFace, mode) == 4, + OffsetOf_CullFace_mode_not_4); + +struct DeleteBuffers { + typedef DeleteBuffers ValueType; + static const CommandId kCmdId = kDeleteBuffers; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLsizei _n, uint32 _buffers_shm_id, uint32 _buffers_shm_offset) { + SetHeader(); + n = _n; + buffers_shm_id = _buffers_shm_id; + buffers_shm_offset = _buffers_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _buffers_shm_id, + uint32 _buffers_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 buffers_shm_id; + uint32 buffers_shm_offset; +}; + +COMPILE_ASSERT(sizeof(DeleteBuffers) == 16, + Sizeof_DeleteBuffers_is_not_16); +COMPILE_ASSERT(offsetof(DeleteBuffers, header) == 0, + OffsetOf_DeleteBuffers_header_not_0); +COMPILE_ASSERT(offsetof(DeleteBuffers, n) == 4, + OffsetOf_DeleteBuffers_n_not_4); +COMPILE_ASSERT(offsetof(DeleteBuffers, buffers_shm_id) == 8, + OffsetOf_DeleteBuffers_buffers_shm_id_not_8); +COMPILE_ASSERT(offsetof(DeleteBuffers, buffers_shm_offset) == 12, + OffsetOf_DeleteBuffers_buffers_shm_offset_not_12); + +struct DeleteBuffersImmediate { + typedef DeleteBuffersImmediate ValueType; + static const CommandId kCmdId = kDeleteBuffersImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, const GLuint* _buffers) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _buffers, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) { + static_cast<ValueType*>(cmd)->Init(_n, _buffers); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8, + Sizeof_DeleteBuffersImmediate_is_not_8); +COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0, + OffsetOf_DeleteBuffersImmediate_header_not_0); +COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4, + OffsetOf_DeleteBuffersImmediate_n_not_4); + +struct DeleteFramebuffers { + typedef DeleteFramebuffers ValueType; + static const CommandId kCmdId = kDeleteFramebuffers; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLsizei _n, uint32 _framebuffers_shm_id, + uint32 _framebuffers_shm_offset) { + SetHeader(); + n = _n; + framebuffers_shm_id = _framebuffers_shm_id; + framebuffers_shm_offset = _framebuffers_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _framebuffers_shm_id, + uint32 _framebuffers_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 framebuffers_shm_id; + uint32 framebuffers_shm_offset; +}; + +COMPILE_ASSERT(sizeof(DeleteFramebuffers) == 16, + Sizeof_DeleteFramebuffers_is_not_16); +COMPILE_ASSERT(offsetof(DeleteFramebuffers, header) == 0, + OffsetOf_DeleteFramebuffers_header_not_0); +COMPILE_ASSERT(offsetof(DeleteFramebuffers, n) == 4, + OffsetOf_DeleteFramebuffers_n_not_4); +COMPILE_ASSERT(offsetof(DeleteFramebuffers, framebuffers_shm_id) == 8, + OffsetOf_DeleteFramebuffers_framebuffers_shm_id_not_8); +COMPILE_ASSERT(offsetof(DeleteFramebuffers, framebuffers_shm_offset) == 12, + OffsetOf_DeleteFramebuffers_framebuffers_shm_offset_not_12); + +struct DeleteFramebuffersImmediate { + typedef DeleteFramebuffersImmediate ValueType; + static const CommandId kCmdId = kDeleteFramebuffersImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, const GLuint* _framebuffers) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _framebuffers, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) { + static_cast<ValueType*>(cmd)->Init(_n, _framebuffers); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8, + Sizeof_DeleteFramebuffersImmediate_is_not_8); +COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, header) == 0, + OffsetOf_DeleteFramebuffersImmediate_header_not_0); +COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, n) == 4, + OffsetOf_DeleteFramebuffersImmediate_n_not_4); + +struct DeleteProgram { + typedef DeleteProgram ValueType; + static const CommandId kCmdId = kDeleteProgram; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _program) { + SetHeader(); + program = _program; + } + + void* Set(void* cmd, GLuint _program) { + static_cast<ValueType*>(cmd)->Init(_program); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; +}; + +COMPILE_ASSERT(sizeof(DeleteProgram) == 8, + Sizeof_DeleteProgram_is_not_8); +COMPILE_ASSERT(offsetof(DeleteProgram, header) == 0, + OffsetOf_DeleteProgram_header_not_0); +COMPILE_ASSERT(offsetof(DeleteProgram, program) == 4, + OffsetOf_DeleteProgram_program_not_4); + +struct DeleteRenderbuffers { + typedef DeleteRenderbuffers ValueType; + static const CommandId kCmdId = kDeleteRenderbuffers; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLsizei _n, uint32 _renderbuffers_shm_id, + uint32 _renderbuffers_shm_offset) { + SetHeader(); + n = _n; + renderbuffers_shm_id = _renderbuffers_shm_id; + renderbuffers_shm_offset = _renderbuffers_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id, + uint32 _renderbuffers_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 renderbuffers_shm_id; + uint32 renderbuffers_shm_offset; +}; + +COMPILE_ASSERT(sizeof(DeleteRenderbuffers) == 16, + Sizeof_DeleteRenderbuffers_is_not_16); +COMPILE_ASSERT(offsetof(DeleteRenderbuffers, header) == 0, + OffsetOf_DeleteRenderbuffers_header_not_0); +COMPILE_ASSERT(offsetof(DeleteRenderbuffers, n) == 4, + OffsetOf_DeleteRenderbuffers_n_not_4); +COMPILE_ASSERT(offsetof(DeleteRenderbuffers, renderbuffers_shm_id) == 8, + OffsetOf_DeleteRenderbuffers_renderbuffers_shm_id_not_8); +COMPILE_ASSERT(offsetof(DeleteRenderbuffers, renderbuffers_shm_offset) == 12, + OffsetOf_DeleteRenderbuffers_renderbuffers_shm_offset_not_12); + +struct DeleteRenderbuffersImmediate { + typedef DeleteRenderbuffersImmediate ValueType; + static const CommandId kCmdId = kDeleteRenderbuffersImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, const GLuint* _renderbuffers) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _renderbuffers, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) { + static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8, + Sizeof_DeleteRenderbuffersImmediate_is_not_8); +COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, header) == 0, + OffsetOf_DeleteRenderbuffersImmediate_header_not_0); +COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, n) == 4, + OffsetOf_DeleteRenderbuffersImmediate_n_not_4); + +struct DeleteShader { + typedef DeleteShader ValueType; + static const CommandId kCmdId = kDeleteShader; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _shader) { + SetHeader(); + shader = _shader; + } + + void* Set(void* cmd, GLuint _shader) { + static_cast<ValueType*>(cmd)->Init(_shader); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; +}; + +COMPILE_ASSERT(sizeof(DeleteShader) == 8, + Sizeof_DeleteShader_is_not_8); +COMPILE_ASSERT(offsetof(DeleteShader, header) == 0, + OffsetOf_DeleteShader_header_not_0); +COMPILE_ASSERT(offsetof(DeleteShader, shader) == 4, + OffsetOf_DeleteShader_shader_not_4); + +struct DeleteTextures { + typedef DeleteTextures ValueType; + static const CommandId kCmdId = kDeleteTextures; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLsizei _n, uint32 _textures_shm_id, uint32 _textures_shm_offset) { + SetHeader(); + n = _n; + textures_shm_id = _textures_shm_id; + textures_shm_offset = _textures_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _textures_shm_id, + uint32 _textures_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _textures_shm_id, _textures_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 textures_shm_id; + uint32 textures_shm_offset; +}; + +COMPILE_ASSERT(sizeof(DeleteTextures) == 16, + Sizeof_DeleteTextures_is_not_16); +COMPILE_ASSERT(offsetof(DeleteTextures, header) == 0, + OffsetOf_DeleteTextures_header_not_0); +COMPILE_ASSERT(offsetof(DeleteTextures, n) == 4, + OffsetOf_DeleteTextures_n_not_4); +COMPILE_ASSERT(offsetof(DeleteTextures, textures_shm_id) == 8, + OffsetOf_DeleteTextures_textures_shm_id_not_8); +COMPILE_ASSERT(offsetof(DeleteTextures, textures_shm_offset) == 12, + OffsetOf_DeleteTextures_textures_shm_offset_not_12); + +struct DeleteTexturesImmediate { + typedef DeleteTexturesImmediate ValueType; + static const CommandId kCmdId = kDeleteTexturesImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, const GLuint* _textures) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _textures, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, const GLuint* _textures) { + static_cast<ValueType*>(cmd)->Init(_n, _textures); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8, + Sizeof_DeleteTexturesImmediate_is_not_8); +COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, header) == 0, + OffsetOf_DeleteTexturesImmediate_header_not_0); +COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, n) == 4, + OffsetOf_DeleteTexturesImmediate_n_not_4); + +struct DepthFunc { + typedef DepthFunc ValueType; + static const CommandId kCmdId = kDepthFunc; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _func) { + SetHeader(); + func = _func; + } + + void* Set(void* cmd, GLenum _func) { + static_cast<ValueType*>(cmd)->Init(_func); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 func; +}; + +COMPILE_ASSERT(sizeof(DepthFunc) == 8, + Sizeof_DepthFunc_is_not_8); +COMPILE_ASSERT(offsetof(DepthFunc, header) == 0, + OffsetOf_DepthFunc_header_not_0); +COMPILE_ASSERT(offsetof(DepthFunc, func) == 4, + OffsetOf_DepthFunc_func_not_4); + +struct DepthMask { + typedef DepthMask ValueType; + static const CommandId kCmdId = kDepthMask; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLboolean _flag) { + SetHeader(); + flag = _flag; + } + + void* Set(void* cmd, GLboolean _flag) { + static_cast<ValueType*>(cmd)->Init(_flag); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 flag; +}; + +COMPILE_ASSERT(sizeof(DepthMask) == 8, + Sizeof_DepthMask_is_not_8); +COMPILE_ASSERT(offsetof(DepthMask, header) == 0, + OffsetOf_DepthMask_header_not_0); +COMPILE_ASSERT(offsetof(DepthMask, flag) == 4, + OffsetOf_DepthMask_flag_not_4); + +struct DepthRangef { + typedef DepthRangef ValueType; + static const CommandId kCmdId = kDepthRangef; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLclampf _zNear, GLclampf _zFar) { + SetHeader(); + zNear = _zNear; + zFar = _zFar; + } + + void* Set(void* cmd, GLclampf _zNear, GLclampf _zFar) { + static_cast<ValueType*>(cmd)->Init(_zNear, _zFar); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float zNear; + float zFar; +}; + +COMPILE_ASSERT(sizeof(DepthRangef) == 12, + Sizeof_DepthRangef_is_not_12); +COMPILE_ASSERT(offsetof(DepthRangef, header) == 0, + OffsetOf_DepthRangef_header_not_0); +COMPILE_ASSERT(offsetof(DepthRangef, zNear) == 4, + OffsetOf_DepthRangef_zNear_not_4); +COMPILE_ASSERT(offsetof(DepthRangef, zFar) == 8, + OffsetOf_DepthRangef_zFar_not_8); + +struct DetachShader { + typedef DetachShader ValueType; + static const CommandId kCmdId = kDetachShader; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _program, GLuint _shader) { + SetHeader(); + program = _program; + shader = _shader; + } + + void* Set(void* cmd, GLuint _program, GLuint _shader) { + static_cast<ValueType*>(cmd)->Init(_program, _shader); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 shader; +}; + +COMPILE_ASSERT(sizeof(DetachShader) == 12, + Sizeof_DetachShader_is_not_12); +COMPILE_ASSERT(offsetof(DetachShader, header) == 0, + OffsetOf_DetachShader_header_not_0); +COMPILE_ASSERT(offsetof(DetachShader, program) == 4, + OffsetOf_DetachShader_program_not_4); +COMPILE_ASSERT(offsetof(DetachShader, shader) == 8, + OffsetOf_DetachShader_shader_not_8); + +struct Disable { + typedef Disable ValueType; + static const CommandId kCmdId = kDisable; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _cap) { + SetHeader(); + cap = _cap; + } + + void* Set(void* cmd, GLenum _cap) { + static_cast<ValueType*>(cmd)->Init(_cap); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 cap; +}; + +COMPILE_ASSERT(sizeof(Disable) == 8, + Sizeof_Disable_is_not_8); +COMPILE_ASSERT(offsetof(Disable, header) == 0, + OffsetOf_Disable_header_not_0); +COMPILE_ASSERT(offsetof(Disable, cap) == 4, + OffsetOf_Disable_cap_not_4); + +struct DisableVertexAttribArray { + typedef DisableVertexAttribArray ValueType; + static const CommandId kCmdId = kDisableVertexAttribArray; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _index) { + SetHeader(); + index = _index; + } + + void* Set(void* cmd, GLuint _index) { + static_cast<ValueType*>(cmd)->Init(_index); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 index; +}; + +COMPILE_ASSERT(sizeof(DisableVertexAttribArray) == 8, + Sizeof_DisableVertexAttribArray_is_not_8); +COMPILE_ASSERT(offsetof(DisableVertexAttribArray, header) == 0, + OffsetOf_DisableVertexAttribArray_header_not_0); +COMPILE_ASSERT(offsetof(DisableVertexAttribArray, index) == 4, + OffsetOf_DisableVertexAttribArray_index_not_4); + +struct DrawArrays { + typedef DrawArrays ValueType; + static const CommandId kCmdId = kDrawArrays; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _mode, GLint _first, GLsizei _count) { + SetHeader(); + mode = _mode; + first = _first; + count = _count; + } + + void* Set(void* cmd, GLenum _mode, GLint _first, GLsizei _count) { + static_cast<ValueType*>(cmd)->Init(_mode, _first, _count); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mode; + uint32 first; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(DrawArrays) == 16, + Sizeof_DrawArrays_is_not_16); +COMPILE_ASSERT(offsetof(DrawArrays, header) == 0, + OffsetOf_DrawArrays_header_not_0); +COMPILE_ASSERT(offsetof(DrawArrays, mode) == 4, + OffsetOf_DrawArrays_mode_not_4); +COMPILE_ASSERT(offsetof(DrawArrays, first) == 8, + OffsetOf_DrawArrays_first_not_8); +COMPILE_ASSERT(offsetof(DrawArrays, count) == 12, + OffsetOf_DrawArrays_count_not_12); + +struct DrawElements { + typedef DrawElements ValueType; + static const CommandId kCmdId = kDrawElements; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset) { + SetHeader(); + mode = _mode; + count = _count; + type = _type; + index_offset = _index_offset; + } + + void* Set( + void* cmd, GLenum _mode, GLsizei _count, GLenum _type, + GLuint _index_offset) { + static_cast<ValueType*>(cmd)->Init(_mode, _count, _type, _index_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mode; + uint32 count; + uint32 type; + uint32 index_offset; +}; + +COMPILE_ASSERT(sizeof(DrawElements) == 20, + Sizeof_DrawElements_is_not_20); +COMPILE_ASSERT(offsetof(DrawElements, header) == 0, + OffsetOf_DrawElements_header_not_0); +COMPILE_ASSERT(offsetof(DrawElements, mode) == 4, + OffsetOf_DrawElements_mode_not_4); +COMPILE_ASSERT(offsetof(DrawElements, count) == 8, + OffsetOf_DrawElements_count_not_8); +COMPILE_ASSERT(offsetof(DrawElements, type) == 12, + OffsetOf_DrawElements_type_not_12); +COMPILE_ASSERT(offsetof(DrawElements, index_offset) == 16, + OffsetOf_DrawElements_index_offset_not_16); + +struct Enable { + typedef Enable ValueType; + static const CommandId kCmdId = kEnable; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _cap) { + SetHeader(); + cap = _cap; + } + + void* Set(void* cmd, GLenum _cap) { + static_cast<ValueType*>(cmd)->Init(_cap); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 cap; +}; + +COMPILE_ASSERT(sizeof(Enable) == 8, + Sizeof_Enable_is_not_8); +COMPILE_ASSERT(offsetof(Enable, header) == 0, + OffsetOf_Enable_header_not_0); +COMPILE_ASSERT(offsetof(Enable, cap) == 4, + OffsetOf_Enable_cap_not_4); + +struct EnableVertexAttribArray { + typedef EnableVertexAttribArray ValueType; + static const CommandId kCmdId = kEnableVertexAttribArray; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _index) { + SetHeader(); + index = _index; + } + + void* Set(void* cmd, GLuint _index) { + static_cast<ValueType*>(cmd)->Init(_index); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 index; +}; + +COMPILE_ASSERT(sizeof(EnableVertexAttribArray) == 8, + Sizeof_EnableVertexAttribArray_is_not_8); +COMPILE_ASSERT(offsetof(EnableVertexAttribArray, header) == 0, + OffsetOf_EnableVertexAttribArray_header_not_0); +COMPILE_ASSERT(offsetof(EnableVertexAttribArray, index) == 4, + OffsetOf_EnableVertexAttribArray_index_not_4); + +struct Finish { + typedef Finish ValueType; + static const CommandId kCmdId = kFinish; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init() { + SetHeader(); + } + + void* Set(void* cmd) { + static_cast<ValueType*>(cmd)->Init(); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; +}; + +COMPILE_ASSERT(sizeof(Finish) == 4, + Sizeof_Finish_is_not_4); +COMPILE_ASSERT(offsetof(Finish, header) == 0, + OffsetOf_Finish_header_not_0); + +struct Flush { + typedef Flush ValueType; + static const CommandId kCmdId = kFlush; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init() { + SetHeader(); + } + + void* Set(void* cmd) { + static_cast<ValueType*>(cmd)->Init(); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; +}; + +COMPILE_ASSERT(sizeof(Flush) == 4, + Sizeof_Flush_is_not_4); +COMPILE_ASSERT(offsetof(Flush, header) == 0, + OffsetOf_Flush_header_not_0); + +struct FramebufferRenderbuffer { + typedef FramebufferRenderbuffer ValueType; + static const CommandId kCmdId = kFramebufferRenderbuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _attachment, GLenum _renderbuffertarget, + GLuint _renderbuffer) { + SetHeader(); + target = _target; + attachment = _attachment; + renderbuffertarget = _renderbuffertarget; + renderbuffer = _renderbuffer; + } + + void* Set( + void* cmd, GLenum _target, GLenum _attachment, GLenum _renderbuffertarget, + GLuint _renderbuffer) { + static_cast<ValueType*>( + cmd)->Init(_target, _attachment, _renderbuffertarget, _renderbuffer); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 attachment; + uint32 renderbuffertarget; + uint32 renderbuffer; +}; + +COMPILE_ASSERT(sizeof(FramebufferRenderbuffer) == 20, + Sizeof_FramebufferRenderbuffer_is_not_20); +COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, header) == 0, + OffsetOf_FramebufferRenderbuffer_header_not_0); +COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, target) == 4, + OffsetOf_FramebufferRenderbuffer_target_not_4); +COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, attachment) == 8, + OffsetOf_FramebufferRenderbuffer_attachment_not_8); +COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffertarget) == 12, + OffsetOf_FramebufferRenderbuffer_renderbuffertarget_not_12); +COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, renderbuffer) == 16, + OffsetOf_FramebufferRenderbuffer_renderbuffer_not_16); + +struct FramebufferTexture2D { + typedef FramebufferTexture2D ValueType; + static const CommandId kCmdId = kFramebufferTexture2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _attachment, GLenum _textarget, GLuint _texture, + GLint _level) { + SetHeader(); + target = _target; + attachment = _attachment; + textarget = _textarget; + texture = _texture; + level = _level; + } + + void* Set( + void* cmd, GLenum _target, GLenum _attachment, GLenum _textarget, + GLuint _texture, GLint _level) { + static_cast<ValueType*>( + cmd)->Init(_target, _attachment, _textarget, _texture, _level); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 attachment; + uint32 textarget; + uint32 texture; + uint32 level; +}; + +COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 24, + Sizeof_FramebufferTexture2D_is_not_24); +COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0, + OffsetOf_FramebufferTexture2D_header_not_0); +COMPILE_ASSERT(offsetof(FramebufferTexture2D, target) == 4, + OffsetOf_FramebufferTexture2D_target_not_4); +COMPILE_ASSERT(offsetof(FramebufferTexture2D, attachment) == 8, + OffsetOf_FramebufferTexture2D_attachment_not_8); +COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12, + OffsetOf_FramebufferTexture2D_textarget_not_12); +COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16, + OffsetOf_FramebufferTexture2D_texture_not_16); +COMPILE_ASSERT(offsetof(FramebufferTexture2D, level) == 20, + OffsetOf_FramebufferTexture2D_level_not_20); + +struct FrontFace { + typedef FrontFace ValueType; + static const CommandId kCmdId = kFrontFace; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _mode) { + SetHeader(); + mode = _mode; + } + + void* Set(void* cmd, GLenum _mode) { + static_cast<ValueType*>(cmd)->Init(_mode); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mode; +}; + +COMPILE_ASSERT(sizeof(FrontFace) == 8, + Sizeof_FrontFace_is_not_8); +COMPILE_ASSERT(offsetof(FrontFace, header) == 0, + OffsetOf_FrontFace_header_not_0); +COMPILE_ASSERT(offsetof(FrontFace, mode) == 4, + OffsetOf_FrontFace_mode_not_4); + +struct GenBuffers { + typedef GenBuffers ValueType; + static const CommandId kCmdId = kGenBuffers; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLsizei _n, uint32 _buffers_shm_id, uint32 _buffers_shm_offset) { + SetHeader(); + n = _n; + buffers_shm_id = _buffers_shm_id; + buffers_shm_offset = _buffers_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _buffers_shm_id, + uint32 _buffers_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 buffers_shm_id; + uint32 buffers_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GenBuffers) == 16, + Sizeof_GenBuffers_is_not_16); +COMPILE_ASSERT(offsetof(GenBuffers, header) == 0, + OffsetOf_GenBuffers_header_not_0); +COMPILE_ASSERT(offsetof(GenBuffers, n) == 4, + OffsetOf_GenBuffers_n_not_4); +COMPILE_ASSERT(offsetof(GenBuffers, buffers_shm_id) == 8, + OffsetOf_GenBuffers_buffers_shm_id_not_8); +COMPILE_ASSERT(offsetof(GenBuffers, buffers_shm_offset) == 12, + OffsetOf_GenBuffers_buffers_shm_offset_not_12); + +struct GenBuffersImmediate { + typedef GenBuffersImmediate ValueType; + static const CommandId kCmdId = kGenBuffersImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, GLuint* _buffers) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _buffers, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, GLuint* _buffers) { + static_cast<ValueType*>(cmd)->Init(_n, _buffers); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8, + Sizeof_GenBuffersImmediate_is_not_8); +COMPILE_ASSERT(offsetof(GenBuffersImmediate, header) == 0, + OffsetOf_GenBuffersImmediate_header_not_0); +COMPILE_ASSERT(offsetof(GenBuffersImmediate, n) == 4, + OffsetOf_GenBuffersImmediate_n_not_4); + +struct GenerateMipmap { + typedef GenerateMipmap ValueType; + static const CommandId kCmdId = kGenerateMipmap; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target) { + SetHeader(); + target = _target; + } + + void* Set(void* cmd, GLenum _target) { + static_cast<ValueType*>(cmd)->Init(_target); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; +}; + +COMPILE_ASSERT(sizeof(GenerateMipmap) == 8, + Sizeof_GenerateMipmap_is_not_8); +COMPILE_ASSERT(offsetof(GenerateMipmap, header) == 0, + OffsetOf_GenerateMipmap_header_not_0); +COMPILE_ASSERT(offsetof(GenerateMipmap, target) == 4, + OffsetOf_GenerateMipmap_target_not_4); + +struct GenFramebuffers { + typedef GenFramebuffers ValueType; + static const CommandId kCmdId = kGenFramebuffers; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLsizei _n, uint32 _framebuffers_shm_id, + uint32 _framebuffers_shm_offset) { + SetHeader(); + n = _n; + framebuffers_shm_id = _framebuffers_shm_id; + framebuffers_shm_offset = _framebuffers_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _framebuffers_shm_id, + uint32 _framebuffers_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 framebuffers_shm_id; + uint32 framebuffers_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GenFramebuffers) == 16, + Sizeof_GenFramebuffers_is_not_16); +COMPILE_ASSERT(offsetof(GenFramebuffers, header) == 0, + OffsetOf_GenFramebuffers_header_not_0); +COMPILE_ASSERT(offsetof(GenFramebuffers, n) == 4, + OffsetOf_GenFramebuffers_n_not_4); +COMPILE_ASSERT(offsetof(GenFramebuffers, framebuffers_shm_id) == 8, + OffsetOf_GenFramebuffers_framebuffers_shm_id_not_8); +COMPILE_ASSERT(offsetof(GenFramebuffers, framebuffers_shm_offset) == 12, + OffsetOf_GenFramebuffers_framebuffers_shm_offset_not_12); + +struct GenFramebuffersImmediate { + typedef GenFramebuffersImmediate ValueType; + static const CommandId kCmdId = kGenFramebuffersImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, GLuint* _framebuffers) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _framebuffers, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) { + static_cast<ValueType*>(cmd)->Init(_n, _framebuffers); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8, + Sizeof_GenFramebuffersImmediate_is_not_8); +COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0, + OffsetOf_GenFramebuffersImmediate_header_not_0); +COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4, + OffsetOf_GenFramebuffersImmediate_n_not_4); + +struct GenRenderbuffers { + typedef GenRenderbuffers ValueType; + static const CommandId kCmdId = kGenRenderbuffers; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLsizei _n, uint32 _renderbuffers_shm_id, + uint32 _renderbuffers_shm_offset) { + SetHeader(); + n = _n; + renderbuffers_shm_id = _renderbuffers_shm_id; + renderbuffers_shm_offset = _renderbuffers_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id, + uint32 _renderbuffers_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 renderbuffers_shm_id; + uint32 renderbuffers_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GenRenderbuffers) == 16, + Sizeof_GenRenderbuffers_is_not_16); +COMPILE_ASSERT(offsetof(GenRenderbuffers, header) == 0, + OffsetOf_GenRenderbuffers_header_not_0); +COMPILE_ASSERT(offsetof(GenRenderbuffers, n) == 4, + OffsetOf_GenRenderbuffers_n_not_4); +COMPILE_ASSERT(offsetof(GenRenderbuffers, renderbuffers_shm_id) == 8, + OffsetOf_GenRenderbuffers_renderbuffers_shm_id_not_8); +COMPILE_ASSERT(offsetof(GenRenderbuffers, renderbuffers_shm_offset) == 12, + OffsetOf_GenRenderbuffers_renderbuffers_shm_offset_not_12); + +struct GenRenderbuffersImmediate { + typedef GenRenderbuffersImmediate ValueType; + static const CommandId kCmdId = kGenRenderbuffersImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, GLuint* _renderbuffers) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _renderbuffers, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) { + static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8, + Sizeof_GenRenderbuffersImmediate_is_not_8); +COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0, + OffsetOf_GenRenderbuffersImmediate_header_not_0); +COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4, + OffsetOf_GenRenderbuffersImmediate_n_not_4); + +struct GenTextures { + typedef GenTextures ValueType; + static const CommandId kCmdId = kGenTextures; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLsizei _n, uint32 _textures_shm_id, uint32 _textures_shm_offset) { + SetHeader(); + n = _n; + textures_shm_id = _textures_shm_id; + textures_shm_offset = _textures_shm_offset; + } + + void* Set( + void* cmd, GLsizei _n, uint32 _textures_shm_id, + uint32 _textures_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_n, _textures_shm_id, _textures_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 n; + uint32 textures_shm_id; + uint32 textures_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GenTextures) == 16, + Sizeof_GenTextures_is_not_16); +COMPILE_ASSERT(offsetof(GenTextures, header) == 0, + OffsetOf_GenTextures_header_not_0); +COMPILE_ASSERT(offsetof(GenTextures, n) == 4, + OffsetOf_GenTextures_n_not_4); +COMPILE_ASSERT(offsetof(GenTextures, textures_shm_id) == 8, + OffsetOf_GenTextures_textures_shm_id_not_8); +COMPILE_ASSERT(offsetof(GenTextures, textures_shm_offset) == 12, + OffsetOf_GenTextures_textures_shm_offset_not_12); + +struct GenTexturesImmediate { + typedef GenTexturesImmediate ValueType; + static const CommandId kCmdId = kGenTexturesImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei n) { + return static_cast<uint32>(sizeof(GLuint) * n); // NOLINT + } + + static uint32 ComputeSize(GLsizei n) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(n)); // NOLINT + } + + void SetHeader(GLsizei n) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(n)); + } + + void Init(GLsizei _n, GLuint* _textures) { + SetHeader(_n); + n = _n; + memcpy(ImmediateDataAddress(this), + _textures, ComputeDataSize(_n)); + } + + void* Set(void* cmd, GLsizei _n, GLuint* _textures) { + static_cast<ValueType*>(cmd)->Init(_n, _textures); + const uint32 size = ComputeSize(_n); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 n; +}; + +COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8, + Sizeof_GenTexturesImmediate_is_not_8); +COMPILE_ASSERT(offsetof(GenTexturesImmediate, header) == 0, + OffsetOf_GenTexturesImmediate_header_not_0); +COMPILE_ASSERT(offsetof(GenTexturesImmediate, n) == 4, + OffsetOf_GenTexturesImmediate_n_not_4); + +struct GetActiveAttrib { + typedef GetActiveAttrib ValueType; + static const CommandId kCmdId = kGetActiveAttrib; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLuint _index, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _size_shm_id, uint32 _size_shm_offset, + uint32 _type_shm_id, uint32 _type_shm_offset, uint32 _name_shm_id, + uint32 _name_shm_offset) { + SetHeader(); + program = _program; + index = _index; + bufsize = _bufsize; + length_shm_id = _length_shm_id; + length_shm_offset = _length_shm_offset; + size_shm_id = _size_shm_id; + size_shm_offset = _size_shm_offset; + type_shm_id = _type_shm_id; + type_shm_offset = _type_shm_offset; + name_shm_id = _name_shm_id; + name_shm_offset = _name_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLuint _index, GLsizei _bufsize, + uint32 _length_shm_id, uint32 _length_shm_offset, uint32 _size_shm_id, + uint32 _size_shm_offset, uint32 _type_shm_id, uint32 _type_shm_offset, + uint32 _name_shm_id, uint32 _name_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _program, _index, _bufsize, _length_shm_id, _length_shm_offset, + _size_shm_id, _size_shm_offset, _type_shm_id, _type_shm_offset, + _name_shm_id, _name_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 index; + uint32 bufsize; + uint32 length_shm_id; + uint32 length_shm_offset; + uint32 size_shm_id; + uint32 size_shm_offset; + uint32 type_shm_id; + uint32 type_shm_offset; + uint32 name_shm_id; + uint32 name_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetActiveAttrib) == 48, + Sizeof_GetActiveAttrib_is_not_48); +COMPILE_ASSERT(offsetof(GetActiveAttrib, header) == 0, + OffsetOf_GetActiveAttrib_header_not_0); +COMPILE_ASSERT(offsetof(GetActiveAttrib, program) == 4, + OffsetOf_GetActiveAttrib_program_not_4); +COMPILE_ASSERT(offsetof(GetActiveAttrib, index) == 8, + OffsetOf_GetActiveAttrib_index_not_8); +COMPILE_ASSERT(offsetof(GetActiveAttrib, bufsize) == 12, + OffsetOf_GetActiveAttrib_bufsize_not_12); +COMPILE_ASSERT(offsetof(GetActiveAttrib, length_shm_id) == 16, + OffsetOf_GetActiveAttrib_length_shm_id_not_16); +COMPILE_ASSERT(offsetof(GetActiveAttrib, length_shm_offset) == 20, + OffsetOf_GetActiveAttrib_length_shm_offset_not_20); +COMPILE_ASSERT(offsetof(GetActiveAttrib, size_shm_id) == 24, + OffsetOf_GetActiveAttrib_size_shm_id_not_24); +COMPILE_ASSERT(offsetof(GetActiveAttrib, size_shm_offset) == 28, + OffsetOf_GetActiveAttrib_size_shm_offset_not_28); +COMPILE_ASSERT(offsetof(GetActiveAttrib, type_shm_id) == 32, + OffsetOf_GetActiveAttrib_type_shm_id_not_32); +COMPILE_ASSERT(offsetof(GetActiveAttrib, type_shm_offset) == 36, + OffsetOf_GetActiveAttrib_type_shm_offset_not_36); +COMPILE_ASSERT(offsetof(GetActiveAttrib, name_shm_id) == 40, + OffsetOf_GetActiveAttrib_name_shm_id_not_40); +COMPILE_ASSERT(offsetof(GetActiveAttrib, name_shm_offset) == 44, + OffsetOf_GetActiveAttrib_name_shm_offset_not_44); + +struct GetActiveUniform { + typedef GetActiveUniform ValueType; + static const CommandId kCmdId = kGetActiveUniform; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLuint _index, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _size_shm_id, uint32 _size_shm_offset, + uint32 _type_shm_id, uint32 _type_shm_offset, uint32 _name_shm_id, + uint32 _name_shm_offset) { + SetHeader(); + program = _program; + index = _index; + bufsize = _bufsize; + length_shm_id = _length_shm_id; + length_shm_offset = _length_shm_offset; + size_shm_id = _size_shm_id; + size_shm_offset = _size_shm_offset; + type_shm_id = _type_shm_id; + type_shm_offset = _type_shm_offset; + name_shm_id = _name_shm_id; + name_shm_offset = _name_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLuint _index, GLsizei _bufsize, + uint32 _length_shm_id, uint32 _length_shm_offset, uint32 _size_shm_id, + uint32 _size_shm_offset, uint32 _type_shm_id, uint32 _type_shm_offset, + uint32 _name_shm_id, uint32 _name_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _program, _index, _bufsize, _length_shm_id, _length_shm_offset, + _size_shm_id, _size_shm_offset, _type_shm_id, _type_shm_offset, + _name_shm_id, _name_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 index; + uint32 bufsize; + uint32 length_shm_id; + uint32 length_shm_offset; + uint32 size_shm_id; + uint32 size_shm_offset; + uint32 type_shm_id; + uint32 type_shm_offset; + uint32 name_shm_id; + uint32 name_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetActiveUniform) == 48, + Sizeof_GetActiveUniform_is_not_48); +COMPILE_ASSERT(offsetof(GetActiveUniform, header) == 0, + OffsetOf_GetActiveUniform_header_not_0); +COMPILE_ASSERT(offsetof(GetActiveUniform, program) == 4, + OffsetOf_GetActiveUniform_program_not_4); +COMPILE_ASSERT(offsetof(GetActiveUniform, index) == 8, + OffsetOf_GetActiveUniform_index_not_8); +COMPILE_ASSERT(offsetof(GetActiveUniform, bufsize) == 12, + OffsetOf_GetActiveUniform_bufsize_not_12); +COMPILE_ASSERT(offsetof(GetActiveUniform, length_shm_id) == 16, + OffsetOf_GetActiveUniform_length_shm_id_not_16); +COMPILE_ASSERT(offsetof(GetActiveUniform, length_shm_offset) == 20, + OffsetOf_GetActiveUniform_length_shm_offset_not_20); +COMPILE_ASSERT(offsetof(GetActiveUniform, size_shm_id) == 24, + OffsetOf_GetActiveUniform_size_shm_id_not_24); +COMPILE_ASSERT(offsetof(GetActiveUniform, size_shm_offset) == 28, + OffsetOf_GetActiveUniform_size_shm_offset_not_28); +COMPILE_ASSERT(offsetof(GetActiveUniform, type_shm_id) == 32, + OffsetOf_GetActiveUniform_type_shm_id_not_32); +COMPILE_ASSERT(offsetof(GetActiveUniform, type_shm_offset) == 36, + OffsetOf_GetActiveUniform_type_shm_offset_not_36); +COMPILE_ASSERT(offsetof(GetActiveUniform, name_shm_id) == 40, + OffsetOf_GetActiveUniform_name_shm_id_not_40); +COMPILE_ASSERT(offsetof(GetActiveUniform, name_shm_offset) == 44, + OffsetOf_GetActiveUniform_name_shm_offset_not_44); + +struct GetAttachedShaders { + typedef GetAttachedShaders ValueType; + static const CommandId kCmdId = kGetAttachedShaders; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLsizei _maxcount, uint32 _count_shm_id, + uint32 _count_shm_offset, uint32 _shaders_shm_id, + uint32 _shaders_shm_offset) { + SetHeader(); + program = _program; + maxcount = _maxcount; + count_shm_id = _count_shm_id; + count_shm_offset = _count_shm_offset; + shaders_shm_id = _shaders_shm_id; + shaders_shm_offset = _shaders_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLsizei _maxcount, uint32 _count_shm_id, + uint32 _count_shm_offset, uint32 _shaders_shm_id, + uint32 _shaders_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _program, _maxcount, _count_shm_id, _count_shm_offset, + _shaders_shm_id, _shaders_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 maxcount; + uint32 count_shm_id; + uint32 count_shm_offset; + uint32 shaders_shm_id; + uint32 shaders_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetAttachedShaders) == 28, + Sizeof_GetAttachedShaders_is_not_28); +COMPILE_ASSERT(offsetof(GetAttachedShaders, header) == 0, + OffsetOf_GetAttachedShaders_header_not_0); +COMPILE_ASSERT(offsetof(GetAttachedShaders, program) == 4, + OffsetOf_GetAttachedShaders_program_not_4); +COMPILE_ASSERT(offsetof(GetAttachedShaders, maxcount) == 8, + OffsetOf_GetAttachedShaders_maxcount_not_8); +COMPILE_ASSERT(offsetof(GetAttachedShaders, count_shm_id) == 12, + OffsetOf_GetAttachedShaders_count_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetAttachedShaders, count_shm_offset) == 16, + OffsetOf_GetAttachedShaders_count_shm_offset_not_16); +COMPILE_ASSERT(offsetof(GetAttachedShaders, shaders_shm_id) == 20, + OffsetOf_GetAttachedShaders_shaders_shm_id_not_20); +COMPILE_ASSERT(offsetof(GetAttachedShaders, shaders_shm_offset) == 24, + OffsetOf_GetAttachedShaders_shaders_shm_offset_not_24); + +struct GetAttribLocation { + typedef GetAttribLocation ValueType; + static const CommandId kCmdId = kGetAttribLocation; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset, + uint32 _data_size) { + SetHeader(); + program = _program; + name_shm_id = _name_shm_id; + name_shm_offset = _name_shm_offset; + data_size = _data_size; + } + + void* Set( + void* cmd, GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset, + uint32 _data_size) { + static_cast<ValueType*>( + cmd)->Init(_program, _name_shm_id, _name_shm_offset, _data_size); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 name_shm_id; + uint32 name_shm_offset; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(GetAttribLocation) == 20, + Sizeof_GetAttribLocation_is_not_20); +COMPILE_ASSERT(offsetof(GetAttribLocation, header) == 0, + OffsetOf_GetAttribLocation_header_not_0); +COMPILE_ASSERT(offsetof(GetAttribLocation, program) == 4, + OffsetOf_GetAttribLocation_program_not_4); +COMPILE_ASSERT(offsetof(GetAttribLocation, name_shm_id) == 8, + OffsetOf_GetAttribLocation_name_shm_id_not_8); +COMPILE_ASSERT(offsetof(GetAttribLocation, name_shm_offset) == 12, + OffsetOf_GetAttribLocation_name_shm_offset_not_12); +COMPILE_ASSERT(offsetof(GetAttribLocation, data_size) == 16, + OffsetOf_GetAttribLocation_data_size_not_16); + +struct GetAttribLocationImmediate { + typedef GetAttribLocationImmediate ValueType; + static const CommandId kCmdId = kGetAttribLocationImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(const char* s) { + return strlen(s); + } + + static uint32 ComputeSize(const char* s) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(s)); // NOLINT + } + + void SetHeader(const char* s) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(s)); + } + + void Init(GLuint _program, const char* _name) { + SetHeader(_name); + program = _program; + data_size = strlen(_name); + memcpy(ImmediateDataAddress(this), _name, data_size); + } + + void* Set(void* cmd, GLuint _program, const char* _name) { + static_cast<ValueType*>(cmd)->Init(_program, _name); + const uint32 size = ComputeSize(_name); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(GetAttribLocationImmediate) == 12, + Sizeof_GetAttribLocationImmediate_is_not_12); +COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, header) == 0, + OffsetOf_GetAttribLocationImmediate_header_not_0); +COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, program) == 4, + OffsetOf_GetAttribLocationImmediate_program_not_4); +COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, data_size) == 8, + OffsetOf_GetAttribLocationImmediate_data_size_not_8); + +struct GetBooleanv { + typedef GetBooleanv ValueType; + static const CommandId kCmdId = kGetBooleanv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { + SetHeader(); + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetBooleanv) == 16, + Sizeof_GetBooleanv_is_not_16); +COMPILE_ASSERT(offsetof(GetBooleanv, header) == 0, + OffsetOf_GetBooleanv_header_not_0); +COMPILE_ASSERT(offsetof(GetBooleanv, pname) == 4, + OffsetOf_GetBooleanv_pname_not_4); +COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_id) == 8, + OffsetOf_GetBooleanv_params_shm_id_not_8); +COMPILE_ASSERT(offsetof(GetBooleanv, params_shm_offset) == 12, + OffsetOf_GetBooleanv_params_shm_offset_not_12); + +struct GetBufferParameteriv { + typedef GetBufferParameteriv ValueType; + static const CommandId kCmdId = kGetBufferParameteriv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetBufferParameteriv) == 20, + Sizeof_GetBufferParameteriv_is_not_20); +COMPILE_ASSERT(offsetof(GetBufferParameteriv, header) == 0, + OffsetOf_GetBufferParameteriv_header_not_0); +COMPILE_ASSERT(offsetof(GetBufferParameteriv, target) == 4, + OffsetOf_GetBufferParameteriv_target_not_4); +COMPILE_ASSERT(offsetof(GetBufferParameteriv, pname) == 8, + OffsetOf_GetBufferParameteriv_pname_not_8); +COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_id) == 12, + OffsetOf_GetBufferParameteriv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetBufferParameteriv, params_shm_offset) == 16, + OffsetOf_GetBufferParameteriv_params_shm_offset_not_16); + +struct GetError { + typedef GetError ValueType; + static const CommandId kCmdId = kGetError; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set(void* cmd, uint32 _result_shm_id, uint32 _result_shm_offset) { + static_cast<ValueType*>(cmd)->Init(_result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetError) == 12, + Sizeof_GetError_is_not_12); +COMPILE_ASSERT(offsetof(GetError, header) == 0, + OffsetOf_GetError_header_not_0); +COMPILE_ASSERT(offsetof(GetError, result_shm_id) == 4, + OffsetOf_GetError_result_shm_id_not_4); +COMPILE_ASSERT(offsetof(GetError, result_shm_offset) == 8, + OffsetOf_GetError_result_shm_offset_not_8); + +struct GetFloatv { + typedef GetFloatv ValueType; + static const CommandId kCmdId = kGetFloatv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { + SetHeader(); + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetFloatv) == 16, + Sizeof_GetFloatv_is_not_16); +COMPILE_ASSERT(offsetof(GetFloatv, header) == 0, + OffsetOf_GetFloatv_header_not_0); +COMPILE_ASSERT(offsetof(GetFloatv, pname) == 4, + OffsetOf_GetFloatv_pname_not_4); +COMPILE_ASSERT(offsetof(GetFloatv, params_shm_id) == 8, + OffsetOf_GetFloatv_params_shm_id_not_8); +COMPILE_ASSERT(offsetof(GetFloatv, params_shm_offset) == 12, + OffsetOf_GetFloatv_params_shm_offset_not_12); + +struct GetFramebufferAttachmentParameteriv { + typedef GetFramebufferAttachmentParameteriv ValueType; + static const CommandId kCmdId = kGetFramebufferAttachmentParameteriv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _attachment, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + attachment = _attachment; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _attachment, GLenum _pname, + uint32 _params_shm_id, uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _target, _attachment, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 attachment; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetFramebufferAttachmentParameteriv) == 24, + Sizeof_GetFramebufferAttachmentParameteriv_is_not_24); +COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, header) == 0, + OffsetOf_GetFramebufferAttachmentParameteriv_header_not_0); +COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, target) == 4, + OffsetOf_GetFramebufferAttachmentParameteriv_target_not_4); +COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, attachment) == 8, + OffsetOf_GetFramebufferAttachmentParameteriv_attachment_not_8); +COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, pname) == 12, + OffsetOf_GetFramebufferAttachmentParameteriv_pname_not_12); +COMPILE_ASSERT( + offsetof(GetFramebufferAttachmentParameteriv, params_shm_id) == 16, + OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_id_not_16); +COMPILE_ASSERT( + offsetof(GetFramebufferAttachmentParameteriv, params_shm_offset) == 20, + OffsetOf_GetFramebufferAttachmentParameteriv_params_shm_offset_not_20); + +struct GetIntegerv { + typedef GetIntegerv ValueType; + static const CommandId kCmdId = kGetIntegerv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _pname, uint32 _params_shm_id, uint32 _params_shm_offset) { + SetHeader(); + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetIntegerv) == 16, + Sizeof_GetIntegerv_is_not_16); +COMPILE_ASSERT(offsetof(GetIntegerv, header) == 0, + OffsetOf_GetIntegerv_header_not_0); +COMPILE_ASSERT(offsetof(GetIntegerv, pname) == 4, + OffsetOf_GetIntegerv_pname_not_4); +COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_id) == 8, + OffsetOf_GetIntegerv_params_shm_id_not_8); +COMPILE_ASSERT(offsetof(GetIntegerv, params_shm_offset) == 12, + OffsetOf_GetIntegerv_params_shm_offset_not_12); + +struct GetProgramiv { + typedef GetProgramiv ValueType; + static const CommandId kCmdId = kGetProgramiv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + program = _program; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_program, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetProgramiv) == 20, + Sizeof_GetProgramiv_is_not_20); +COMPILE_ASSERT(offsetof(GetProgramiv, header) == 0, + OffsetOf_GetProgramiv_header_not_0); +COMPILE_ASSERT(offsetof(GetProgramiv, program) == 4, + OffsetOf_GetProgramiv_program_not_4); +COMPILE_ASSERT(offsetof(GetProgramiv, pname) == 8, + OffsetOf_GetProgramiv_pname_not_8); +COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_id) == 12, + OffsetOf_GetProgramiv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetProgramiv, params_shm_offset) == 16, + OffsetOf_GetProgramiv_params_shm_offset_not_16); + +struct GetProgramInfoLog { + typedef GetProgramInfoLog ValueType; + static const CommandId kCmdId = kGetProgramInfoLog; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _infolog_shm_id, + uint32 _infolog_shm_offset) { + SetHeader(); + program = _program; + bufsize = _bufsize; + length_shm_id = _length_shm_id; + length_shm_offset = _length_shm_offset; + infolog_shm_id = _infolog_shm_id; + infolog_shm_offset = _infolog_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _infolog_shm_id, + uint32 _infolog_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _program, _bufsize, _length_shm_id, _length_shm_offset, + _infolog_shm_id, _infolog_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 bufsize; + uint32 length_shm_id; + uint32 length_shm_offset; + uint32 infolog_shm_id; + uint32 infolog_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 28, + Sizeof_GetProgramInfoLog_is_not_28); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, header) == 0, + OffsetOf_GetProgramInfoLog_header_not_0); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, program) == 4, + OffsetOf_GetProgramInfoLog_program_not_4); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, bufsize) == 8, + OffsetOf_GetProgramInfoLog_bufsize_not_8); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, length_shm_id) == 12, + OffsetOf_GetProgramInfoLog_length_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, length_shm_offset) == 16, + OffsetOf_GetProgramInfoLog_length_shm_offset_not_16); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, infolog_shm_id) == 20, + OffsetOf_GetProgramInfoLog_infolog_shm_id_not_20); +COMPILE_ASSERT(offsetof(GetProgramInfoLog, infolog_shm_offset) == 24, + OffsetOf_GetProgramInfoLog_infolog_shm_offset_not_24); + +struct GetRenderbufferParameteriv { + typedef GetRenderbufferParameteriv ValueType; + static const CommandId kCmdId = kGetRenderbufferParameteriv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetRenderbufferParameteriv) == 20, + Sizeof_GetRenderbufferParameteriv_is_not_20); +COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, header) == 0, + OffsetOf_GetRenderbufferParameteriv_header_not_0); +COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, target) == 4, + OffsetOf_GetRenderbufferParameteriv_target_not_4); +COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, pname) == 8, + OffsetOf_GetRenderbufferParameteriv_pname_not_8); +COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_id) == 12, + OffsetOf_GetRenderbufferParameteriv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, params_shm_offset) == 16, + OffsetOf_GetRenderbufferParameteriv_params_shm_offset_not_16); + +struct GetShaderiv { + typedef GetShaderiv ValueType; + static const CommandId kCmdId = kGetShaderiv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _shader, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + shader = _shader; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLuint _shader, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_shader, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetShaderiv) == 20, + Sizeof_GetShaderiv_is_not_20); +COMPILE_ASSERT(offsetof(GetShaderiv, header) == 0, + OffsetOf_GetShaderiv_header_not_0); +COMPILE_ASSERT(offsetof(GetShaderiv, shader) == 4, + OffsetOf_GetShaderiv_shader_not_4); +COMPILE_ASSERT(offsetof(GetShaderiv, pname) == 8, + OffsetOf_GetShaderiv_pname_not_8); +COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_id) == 12, + OffsetOf_GetShaderiv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetShaderiv, params_shm_offset) == 16, + OffsetOf_GetShaderiv_params_shm_offset_not_16); + +struct GetShaderInfoLog { + typedef GetShaderInfoLog ValueType; + static const CommandId kCmdId = kGetShaderInfoLog; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _shader, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _infolog_shm_id, + uint32 _infolog_shm_offset) { + SetHeader(); + shader = _shader; + bufsize = _bufsize; + length_shm_id = _length_shm_id; + length_shm_offset = _length_shm_offset; + infolog_shm_id = _infolog_shm_id; + infolog_shm_offset = _infolog_shm_offset; + } + + void* Set( + void* cmd, GLuint _shader, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _infolog_shm_id, + uint32 _infolog_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _shader, _bufsize, _length_shm_id, _length_shm_offset, + _infolog_shm_id, _infolog_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; + uint32 bufsize; + uint32 length_shm_id; + uint32 length_shm_offset; + uint32 infolog_shm_id; + uint32 infolog_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 28, + Sizeof_GetShaderInfoLog_is_not_28); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, header) == 0, + OffsetOf_GetShaderInfoLog_header_not_0); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, shader) == 4, + OffsetOf_GetShaderInfoLog_shader_not_4); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, bufsize) == 8, + OffsetOf_GetShaderInfoLog_bufsize_not_8); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, length_shm_id) == 12, + OffsetOf_GetShaderInfoLog_length_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, length_shm_offset) == 16, + OffsetOf_GetShaderInfoLog_length_shm_offset_not_16); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, infolog_shm_id) == 20, + OffsetOf_GetShaderInfoLog_infolog_shm_id_not_20); +COMPILE_ASSERT(offsetof(GetShaderInfoLog, infolog_shm_offset) == 24, + OffsetOf_GetShaderInfoLog_infolog_shm_offset_not_24); + +struct GetShaderPrecisionFormat { + typedef GetShaderPrecisionFormat ValueType; + static const CommandId kCmdId = kGetShaderPrecisionFormat; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _shadertype, GLenum _precisiontype, uint32 _range_shm_id, + uint32 _range_shm_offset, uint32 _precision_shm_id, + uint32 _precision_shm_offset) { + SetHeader(); + shadertype = _shadertype; + precisiontype = _precisiontype; + range_shm_id = _range_shm_id; + range_shm_offset = _range_shm_offset; + precision_shm_id = _precision_shm_id; + precision_shm_offset = _precision_shm_offset; + } + + void* Set( + void* cmd, GLenum _shadertype, GLenum _precisiontype, + uint32 _range_shm_id, uint32 _range_shm_offset, uint32 _precision_shm_id, + uint32 _precision_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _shadertype, _precisiontype, _range_shm_id, _range_shm_offset, + _precision_shm_id, _precision_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shadertype; + uint32 precisiontype; + uint32 range_shm_id; + uint32 range_shm_offset; + uint32 precision_shm_id; + uint32 precision_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetShaderPrecisionFormat) == 28, + Sizeof_GetShaderPrecisionFormat_is_not_28); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, header) == 0, + OffsetOf_GetShaderPrecisionFormat_header_not_0); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, shadertype) == 4, + OffsetOf_GetShaderPrecisionFormat_shadertype_not_4); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, precisiontype) == 8, + OffsetOf_GetShaderPrecisionFormat_precisiontype_not_8); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, range_shm_id) == 12, + OffsetOf_GetShaderPrecisionFormat_range_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, range_shm_offset) == 16, + OffsetOf_GetShaderPrecisionFormat_range_shm_offset_not_16); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, precision_shm_id) == 20, + OffsetOf_GetShaderPrecisionFormat_precision_shm_id_not_20); +COMPILE_ASSERT(offsetof(GetShaderPrecisionFormat, precision_shm_offset) == 24, + OffsetOf_GetShaderPrecisionFormat_precision_shm_offset_not_24); + +struct GetShaderSource { + typedef GetShaderSource ValueType; + static const CommandId kCmdId = kGetShaderSource; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _shader, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _source_shm_id, + uint32 _source_shm_offset) { + SetHeader(); + shader = _shader; + bufsize = _bufsize; + length_shm_id = _length_shm_id; + length_shm_offset = _length_shm_offset; + source_shm_id = _source_shm_id; + source_shm_offset = _source_shm_offset; + } + + void* Set( + void* cmd, GLuint _shader, GLsizei _bufsize, uint32 _length_shm_id, + uint32 _length_shm_offset, uint32 _source_shm_id, + uint32 _source_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _shader, _bufsize, _length_shm_id, _length_shm_offset, + _source_shm_id, _source_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; + uint32 bufsize; + uint32 length_shm_id; + uint32 length_shm_offset; + uint32 source_shm_id; + uint32 source_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetShaderSource) == 28, + Sizeof_GetShaderSource_is_not_28); +COMPILE_ASSERT(offsetof(GetShaderSource, header) == 0, + OffsetOf_GetShaderSource_header_not_0); +COMPILE_ASSERT(offsetof(GetShaderSource, shader) == 4, + OffsetOf_GetShaderSource_shader_not_4); +COMPILE_ASSERT(offsetof(GetShaderSource, bufsize) == 8, + OffsetOf_GetShaderSource_bufsize_not_8); +COMPILE_ASSERT(offsetof(GetShaderSource, length_shm_id) == 12, + OffsetOf_GetShaderSource_length_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetShaderSource, length_shm_offset) == 16, + OffsetOf_GetShaderSource_length_shm_offset_not_16); +COMPILE_ASSERT(offsetof(GetShaderSource, source_shm_id) == 20, + OffsetOf_GetShaderSource_source_shm_id_not_20); +COMPILE_ASSERT(offsetof(GetShaderSource, source_shm_offset) == 24, + OffsetOf_GetShaderSource_source_shm_offset_not_24); + +struct GetString { + typedef GetString ValueType; + static const CommandId kCmdId = kGetString; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _name) { + SetHeader(); + name = _name; + } + + void* Set(void* cmd, GLenum _name) { + static_cast<ValueType*>(cmd)->Init(_name); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 name; +}; + +COMPILE_ASSERT(sizeof(GetString) == 8, + Sizeof_GetString_is_not_8); +COMPILE_ASSERT(offsetof(GetString, header) == 0, + OffsetOf_GetString_header_not_0); +COMPILE_ASSERT(offsetof(GetString, name) == 4, + OffsetOf_GetString_name_not_4); + +struct GetTexParameterfv { + typedef GetTexParameterfv ValueType; + static const CommandId kCmdId = kGetTexParameterfv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetTexParameterfv) == 20, + Sizeof_GetTexParameterfv_is_not_20); +COMPILE_ASSERT(offsetof(GetTexParameterfv, header) == 0, + OffsetOf_GetTexParameterfv_header_not_0); +COMPILE_ASSERT(offsetof(GetTexParameterfv, target) == 4, + OffsetOf_GetTexParameterfv_target_not_4); +COMPILE_ASSERT(offsetof(GetTexParameterfv, pname) == 8, + OffsetOf_GetTexParameterfv_pname_not_8); +COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_id) == 12, + OffsetOf_GetTexParameterfv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetTexParameterfv, params_shm_offset) == 16, + OffsetOf_GetTexParameterfv_params_shm_offset_not_16); + +struct GetTexParameteriv { + typedef GetTexParameteriv ValueType; + static const CommandId kCmdId = kGetTexParameteriv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetTexParameteriv) == 20, + Sizeof_GetTexParameteriv_is_not_20); +COMPILE_ASSERT(offsetof(GetTexParameteriv, header) == 0, + OffsetOf_GetTexParameteriv_header_not_0); +COMPILE_ASSERT(offsetof(GetTexParameteriv, target) == 4, + OffsetOf_GetTexParameteriv_target_not_4); +COMPILE_ASSERT(offsetof(GetTexParameteriv, pname) == 8, + OffsetOf_GetTexParameteriv_pname_not_8); +COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_id) == 12, + OffsetOf_GetTexParameteriv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetTexParameteriv, params_shm_offset) == 16, + OffsetOf_GetTexParameteriv_params_shm_offset_not_16); + +struct GetUniformfv { + typedef GetUniformfv ValueType; + static const CommandId kCmdId = kGetUniformfv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLint _location, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + program = _program; + location = _location; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 location; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetUniformfv) == 20, + Sizeof_GetUniformfv_is_not_20); +COMPILE_ASSERT(offsetof(GetUniformfv, header) == 0, + OffsetOf_GetUniformfv_header_not_0); +COMPILE_ASSERT(offsetof(GetUniformfv, program) == 4, + OffsetOf_GetUniformfv_program_not_4); +COMPILE_ASSERT(offsetof(GetUniformfv, location) == 8, + OffsetOf_GetUniformfv_location_not_8); +COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_id) == 12, + OffsetOf_GetUniformfv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetUniformfv, params_shm_offset) == 16, + OffsetOf_GetUniformfv_params_shm_offset_not_16); + +struct GetUniformiv { + typedef GetUniformiv ValueType; + static const CommandId kCmdId = kGetUniformiv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, GLint _location, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + program = _program; + location = _location; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 location; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetUniformiv) == 20, + Sizeof_GetUniformiv_is_not_20); +COMPILE_ASSERT(offsetof(GetUniformiv, header) == 0, + OffsetOf_GetUniformiv_header_not_0); +COMPILE_ASSERT(offsetof(GetUniformiv, program) == 4, + OffsetOf_GetUniformiv_program_not_4); +COMPILE_ASSERT(offsetof(GetUniformiv, location) == 8, + OffsetOf_GetUniformiv_location_not_8); +COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_id) == 12, + OffsetOf_GetUniformiv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetUniformiv, params_shm_offset) == 16, + OffsetOf_GetUniformiv_params_shm_offset_not_16); + +struct GetUniformLocation { + typedef GetUniformLocation ValueType; + static const CommandId kCmdId = kGetUniformLocation; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset, + uint32 _data_size) { + SetHeader(); + program = _program; + name_shm_id = _name_shm_id; + name_shm_offset = _name_shm_offset; + data_size = _data_size; + } + + void* Set( + void* cmd, GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset, + uint32 _data_size) { + static_cast<ValueType*>( + cmd)->Init(_program, _name_shm_id, _name_shm_offset, _data_size); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 name_shm_id; + uint32 name_shm_offset; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(GetUniformLocation) == 20, + Sizeof_GetUniformLocation_is_not_20); +COMPILE_ASSERT(offsetof(GetUniformLocation, header) == 0, + OffsetOf_GetUniformLocation_header_not_0); +COMPILE_ASSERT(offsetof(GetUniformLocation, program) == 4, + OffsetOf_GetUniformLocation_program_not_4); +COMPILE_ASSERT(offsetof(GetUniformLocation, name_shm_id) == 8, + OffsetOf_GetUniformLocation_name_shm_id_not_8); +COMPILE_ASSERT(offsetof(GetUniformLocation, name_shm_offset) == 12, + OffsetOf_GetUniformLocation_name_shm_offset_not_12); +COMPILE_ASSERT(offsetof(GetUniformLocation, data_size) == 16, + OffsetOf_GetUniformLocation_data_size_not_16); + +struct GetUniformLocationImmediate { + typedef GetUniformLocationImmediate ValueType; + static const CommandId kCmdId = kGetUniformLocationImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(const char* s) { + return strlen(s); + } + + static uint32 ComputeSize(const char* s) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(s)); // NOLINT + } + + void SetHeader(const char* s) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(s)); + } + + void Init(GLuint _program, const char* _name) { + SetHeader(_name); + program = _program; + data_size = strlen(_name); + memcpy(ImmediateDataAddress(this), _name, data_size); + } + + void* Set(void* cmd, GLuint _program, const char* _name) { + static_cast<ValueType*>(cmd)->Init(_program, _name); + const uint32 size = ComputeSize(_name); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(GetUniformLocationImmediate) == 12, + Sizeof_GetUniformLocationImmediate_is_not_12); +COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, header) == 0, + OffsetOf_GetUniformLocationImmediate_header_not_0); +COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, program) == 4, + OffsetOf_GetUniformLocationImmediate_program_not_4); +COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, data_size) == 8, + OffsetOf_GetUniformLocationImmediate_data_size_not_8); + +struct GetVertexAttribfv { + typedef GetVertexAttribfv ValueType; + static const CommandId kCmdId = kGetVertexAttribfv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _index, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + index = _index; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLuint _index, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_index, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 index; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetVertexAttribfv) == 20, + Sizeof_GetVertexAttribfv_is_not_20); +COMPILE_ASSERT(offsetof(GetVertexAttribfv, header) == 0, + OffsetOf_GetVertexAttribfv_header_not_0); +COMPILE_ASSERT(offsetof(GetVertexAttribfv, index) == 4, + OffsetOf_GetVertexAttribfv_index_not_4); +COMPILE_ASSERT(offsetof(GetVertexAttribfv, pname) == 8, + OffsetOf_GetVertexAttribfv_pname_not_8); +COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_id) == 12, + OffsetOf_GetVertexAttribfv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetVertexAttribfv, params_shm_offset) == 16, + OffsetOf_GetVertexAttribfv_params_shm_offset_not_16); + +struct GetVertexAttribiv { + typedef GetVertexAttribiv ValueType; + static const CommandId kCmdId = kGetVertexAttribiv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _index, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + index = _index; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLuint _index, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_index, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 index; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetVertexAttribiv) == 20, + Sizeof_GetVertexAttribiv_is_not_20); +COMPILE_ASSERT(offsetof(GetVertexAttribiv, header) == 0, + OffsetOf_GetVertexAttribiv_header_not_0); +COMPILE_ASSERT(offsetof(GetVertexAttribiv, index) == 4, + OffsetOf_GetVertexAttribiv_index_not_4); +COMPILE_ASSERT(offsetof(GetVertexAttribiv, pname) == 8, + OffsetOf_GetVertexAttribiv_pname_not_8); +COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_id) == 12, + OffsetOf_GetVertexAttribiv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetVertexAttribiv, params_shm_offset) == 16, + OffsetOf_GetVertexAttribiv_params_shm_offset_not_16); + +struct GetVertexAttribPointerv { + typedef GetVertexAttribPointerv ValueType; + static const CommandId kCmdId = kGetVertexAttribPointerv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _index, GLenum _pname, uint32 _pointer_shm_id, + uint32 _pointer_shm_offset) { + SetHeader(); + index = _index; + pname = _pname; + pointer_shm_id = _pointer_shm_id; + pointer_shm_offset = _pointer_shm_offset; + } + + void* Set( + void* cmd, GLuint _index, GLenum _pname, uint32 _pointer_shm_id, + uint32 _pointer_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_index, _pname, _pointer_shm_id, _pointer_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 index; + uint32 pname; + uint32 pointer_shm_id; + uint32 pointer_shm_offset; +}; + +COMPILE_ASSERT(sizeof(GetVertexAttribPointerv) == 20, + Sizeof_GetVertexAttribPointerv_is_not_20); +COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, header) == 0, + OffsetOf_GetVertexAttribPointerv_header_not_0); +COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, index) == 4, + OffsetOf_GetVertexAttribPointerv_index_not_4); +COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pname) == 8, + OffsetOf_GetVertexAttribPointerv_pname_not_8); +COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_id) == 12, + OffsetOf_GetVertexAttribPointerv_pointer_shm_id_not_12); +COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, pointer_shm_offset) == 16, + OffsetOf_GetVertexAttribPointerv_pointer_shm_offset_not_16); + +struct Hint { + typedef Hint ValueType; + static const CommandId kCmdId = kHint; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLenum _mode) { + SetHeader(); + target = _target; + mode = _mode; + } + + void* Set(void* cmd, GLenum _target, GLenum _mode) { + static_cast<ValueType*>(cmd)->Init(_target, _mode); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 mode; +}; + +COMPILE_ASSERT(sizeof(Hint) == 12, + Sizeof_Hint_is_not_12); +COMPILE_ASSERT(offsetof(Hint, header) == 0, + OffsetOf_Hint_header_not_0); +COMPILE_ASSERT(offsetof(Hint, target) == 4, + OffsetOf_Hint_target_not_4); +COMPILE_ASSERT(offsetof(Hint, mode) == 8, + OffsetOf_Hint_mode_not_8); + +struct IsBuffer { + typedef IsBuffer ValueType; + static const CommandId kCmdId = kIsBuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _buffer, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + buffer = _buffer; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLuint _buffer, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_buffer, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 buffer; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsBuffer) == 16, + Sizeof_IsBuffer_is_not_16); +COMPILE_ASSERT(offsetof(IsBuffer, header) == 0, + OffsetOf_IsBuffer_header_not_0); +COMPILE_ASSERT(offsetof(IsBuffer, buffer) == 4, + OffsetOf_IsBuffer_buffer_not_4); +COMPILE_ASSERT(offsetof(IsBuffer, result_shm_id) == 8, + OffsetOf_IsBuffer_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsBuffer, result_shm_offset) == 12, + OffsetOf_IsBuffer_result_shm_offset_not_12); + +struct IsEnabled { + typedef IsEnabled ValueType; + static const CommandId kCmdId = kIsEnabled; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _cap, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + cap = _cap; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLenum _cap, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_cap, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 cap; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsEnabled) == 16, + Sizeof_IsEnabled_is_not_16); +COMPILE_ASSERT(offsetof(IsEnabled, header) == 0, + OffsetOf_IsEnabled_header_not_0); +COMPILE_ASSERT(offsetof(IsEnabled, cap) == 4, + OffsetOf_IsEnabled_cap_not_4); +COMPILE_ASSERT(offsetof(IsEnabled, result_shm_id) == 8, + OffsetOf_IsEnabled_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsEnabled, result_shm_offset) == 12, + OffsetOf_IsEnabled_result_shm_offset_not_12); + +struct IsFramebuffer { + typedef IsFramebuffer ValueType; + static const CommandId kCmdId = kIsFramebuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _framebuffer, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + framebuffer = _framebuffer; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLuint _framebuffer, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_framebuffer, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 framebuffer; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsFramebuffer) == 16, + Sizeof_IsFramebuffer_is_not_16); +COMPILE_ASSERT(offsetof(IsFramebuffer, header) == 0, + OffsetOf_IsFramebuffer_header_not_0); +COMPILE_ASSERT(offsetof(IsFramebuffer, framebuffer) == 4, + OffsetOf_IsFramebuffer_framebuffer_not_4); +COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_id) == 8, + OffsetOf_IsFramebuffer_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsFramebuffer, result_shm_offset) == 12, + OffsetOf_IsFramebuffer_result_shm_offset_not_12); + +struct IsProgram { + typedef IsProgram ValueType; + static const CommandId kCmdId = kIsProgram; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _program, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + program = _program; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLuint _program, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_program, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsProgram) == 16, + Sizeof_IsProgram_is_not_16); +COMPILE_ASSERT(offsetof(IsProgram, header) == 0, + OffsetOf_IsProgram_header_not_0); +COMPILE_ASSERT(offsetof(IsProgram, program) == 4, + OffsetOf_IsProgram_program_not_4); +COMPILE_ASSERT(offsetof(IsProgram, result_shm_id) == 8, + OffsetOf_IsProgram_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsProgram, result_shm_offset) == 12, + OffsetOf_IsProgram_result_shm_offset_not_12); + +struct IsRenderbuffer { + typedef IsRenderbuffer ValueType; + static const CommandId kCmdId = kIsRenderbuffer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _renderbuffer, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + renderbuffer = _renderbuffer; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLuint _renderbuffer, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_renderbuffer, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 renderbuffer; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsRenderbuffer) == 16, + Sizeof_IsRenderbuffer_is_not_16); +COMPILE_ASSERT(offsetof(IsRenderbuffer, header) == 0, + OffsetOf_IsRenderbuffer_header_not_0); +COMPILE_ASSERT(offsetof(IsRenderbuffer, renderbuffer) == 4, + OffsetOf_IsRenderbuffer_renderbuffer_not_4); +COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_id) == 8, + OffsetOf_IsRenderbuffer_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsRenderbuffer, result_shm_offset) == 12, + OffsetOf_IsRenderbuffer_result_shm_offset_not_12); + +struct IsShader { + typedef IsShader ValueType; + static const CommandId kCmdId = kIsShader; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _shader, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + shader = _shader; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLuint _shader, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_shader, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsShader) == 16, + Sizeof_IsShader_is_not_16); +COMPILE_ASSERT(offsetof(IsShader, header) == 0, + OffsetOf_IsShader_header_not_0); +COMPILE_ASSERT(offsetof(IsShader, shader) == 4, + OffsetOf_IsShader_shader_not_4); +COMPILE_ASSERT(offsetof(IsShader, result_shm_id) == 8, + OffsetOf_IsShader_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsShader, result_shm_offset) == 12, + OffsetOf_IsShader_result_shm_offset_not_12); + +struct IsTexture { + typedef IsTexture ValueType; + static const CommandId kCmdId = kIsTexture; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _texture, uint32 _result_shm_id, uint32 _result_shm_offset) { + SetHeader(); + texture = _texture; + result_shm_id = _result_shm_id; + result_shm_offset = _result_shm_offset; + } + + void* Set( + void* cmd, GLuint _texture, uint32 _result_shm_id, + uint32 _result_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_texture, _result_shm_id, _result_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 texture; + uint32 result_shm_id; + uint32 result_shm_offset; +}; + +COMPILE_ASSERT(sizeof(IsTexture) == 16, + Sizeof_IsTexture_is_not_16); +COMPILE_ASSERT(offsetof(IsTexture, header) == 0, + OffsetOf_IsTexture_header_not_0); +COMPILE_ASSERT(offsetof(IsTexture, texture) == 4, + OffsetOf_IsTexture_texture_not_4); +COMPILE_ASSERT(offsetof(IsTexture, result_shm_id) == 8, + OffsetOf_IsTexture_result_shm_id_not_8); +COMPILE_ASSERT(offsetof(IsTexture, result_shm_offset) == 12, + OffsetOf_IsTexture_result_shm_offset_not_12); + +struct LineWidth { + typedef LineWidth ValueType; + static const CommandId kCmdId = kLineWidth; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLfloat _width) { + SetHeader(); + width = _width; + } + + void* Set(void* cmd, GLfloat _width) { + static_cast<ValueType*>(cmd)->Init(_width); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float width; +}; + +COMPILE_ASSERT(sizeof(LineWidth) == 8, + Sizeof_LineWidth_is_not_8); +COMPILE_ASSERT(offsetof(LineWidth, header) == 0, + OffsetOf_LineWidth_header_not_0); +COMPILE_ASSERT(offsetof(LineWidth, width) == 4, + OffsetOf_LineWidth_width_not_4); + +struct LinkProgram { + typedef LinkProgram ValueType; + static const CommandId kCmdId = kLinkProgram; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _program) { + SetHeader(); + program = _program; + } + + void* Set(void* cmd, GLuint _program) { + static_cast<ValueType*>(cmd)->Init(_program); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; +}; + +COMPILE_ASSERT(sizeof(LinkProgram) == 8, + Sizeof_LinkProgram_is_not_8); +COMPILE_ASSERT(offsetof(LinkProgram, header) == 0, + OffsetOf_LinkProgram_header_not_0); +COMPILE_ASSERT(offsetof(LinkProgram, program) == 4, + OffsetOf_LinkProgram_program_not_4); + +struct PixelStorei { + typedef PixelStorei ValueType; + static const CommandId kCmdId = kPixelStorei; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _pname, GLint _param) { + SetHeader(); + pname = _pname; + param = _param; + } + + void* Set(void* cmd, GLenum _pname, GLint _param) { + static_cast<ValueType*>(cmd)->Init(_pname, _param); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 pname; + uint32 param; +}; + +COMPILE_ASSERT(sizeof(PixelStorei) == 12, + Sizeof_PixelStorei_is_not_12); +COMPILE_ASSERT(offsetof(PixelStorei, header) == 0, + OffsetOf_PixelStorei_header_not_0); +COMPILE_ASSERT(offsetof(PixelStorei, pname) == 4, + OffsetOf_PixelStorei_pname_not_4); +COMPILE_ASSERT(offsetof(PixelStorei, param) == 8, + OffsetOf_PixelStorei_param_not_8); + +struct PolygonOffset { + typedef PolygonOffset ValueType; + static const CommandId kCmdId = kPolygonOffset; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLfloat _factor, GLfloat _units) { + SetHeader(); + factor = _factor; + units = _units; + } + + void* Set(void* cmd, GLfloat _factor, GLfloat _units) { + static_cast<ValueType*>(cmd)->Init(_factor, _units); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float factor; + float units; +}; + +COMPILE_ASSERT(sizeof(PolygonOffset) == 12, + Sizeof_PolygonOffset_is_not_12); +COMPILE_ASSERT(offsetof(PolygonOffset, header) == 0, + OffsetOf_PolygonOffset_header_not_0); +COMPILE_ASSERT(offsetof(PolygonOffset, factor) == 4, + OffsetOf_PolygonOffset_factor_not_4); +COMPILE_ASSERT(offsetof(PolygonOffset, units) == 8, + OffsetOf_PolygonOffset_units_not_8); + +struct ReadPixels { + typedef ReadPixels ValueType; + static const CommandId kCmdId = kReadPixels; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _x, GLint _y, GLsizei _width, GLsizei _height, GLenum _format, + GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { + SetHeader(); + x = _x; + y = _y; + width = _width; + height = _height; + format = _format; + type = _type; + pixels_shm_id = _pixels_shm_id; + pixels_shm_offset = _pixels_shm_offset; + } + + void* Set( + void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height, + GLenum _format, GLenum _type, uint32 _pixels_shm_id, + uint32 _pixels_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _x, _y, _width, _height, _format, _type, _pixels_shm_id, + _pixels_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 x; + uint32 y; + uint32 width; + uint32 height; + uint32 format; + uint32 type; + uint32 pixels_shm_id; + uint32 pixels_shm_offset; +}; + +COMPILE_ASSERT(sizeof(ReadPixels) == 36, + Sizeof_ReadPixels_is_not_36); +COMPILE_ASSERT(offsetof(ReadPixels, header) == 0, + OffsetOf_ReadPixels_header_not_0); +COMPILE_ASSERT(offsetof(ReadPixels, x) == 4, + OffsetOf_ReadPixels_x_not_4); +COMPILE_ASSERT(offsetof(ReadPixels, y) == 8, + OffsetOf_ReadPixels_y_not_8); +COMPILE_ASSERT(offsetof(ReadPixels, width) == 12, + OffsetOf_ReadPixels_width_not_12); +COMPILE_ASSERT(offsetof(ReadPixels, height) == 16, + OffsetOf_ReadPixels_height_not_16); +COMPILE_ASSERT(offsetof(ReadPixels, format) == 20, + OffsetOf_ReadPixels_format_not_20); +COMPILE_ASSERT(offsetof(ReadPixels, type) == 24, + OffsetOf_ReadPixels_type_not_24); +COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_id) == 28, + OffsetOf_ReadPixels_pixels_shm_id_not_28); +COMPILE_ASSERT(offsetof(ReadPixels, pixels_shm_offset) == 32, + OffsetOf_ReadPixels_pixels_shm_offset_not_32); + +struct RenderbufferStorage { + typedef RenderbufferStorage ValueType; + static const CommandId kCmdId = kRenderbufferStorage; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _internalformat, GLsizei _width, + GLsizei _height) { + SetHeader(); + target = _target; + internalformat = _internalformat; + width = _width; + height = _height; + } + + void* Set( + void* cmd, GLenum _target, GLenum _internalformat, GLsizei _width, + GLsizei _height) { + static_cast<ValueType*>( + cmd)->Init(_target, _internalformat, _width, _height); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 internalformat; + uint32 width; + uint32 height; +}; + +COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20, + Sizeof_RenderbufferStorage_is_not_20); +COMPILE_ASSERT(offsetof(RenderbufferStorage, header) == 0, + OffsetOf_RenderbufferStorage_header_not_0); +COMPILE_ASSERT(offsetof(RenderbufferStorage, target) == 4, + OffsetOf_RenderbufferStorage_target_not_4); +COMPILE_ASSERT(offsetof(RenderbufferStorage, internalformat) == 8, + OffsetOf_RenderbufferStorage_internalformat_not_8); +COMPILE_ASSERT(offsetof(RenderbufferStorage, width) == 12, + OffsetOf_RenderbufferStorage_width_not_12); +COMPILE_ASSERT(offsetof(RenderbufferStorage, height) == 16, + OffsetOf_RenderbufferStorage_height_not_16); + +struct SampleCoverage { + typedef SampleCoverage ValueType; + static const CommandId kCmdId = kSampleCoverage; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLclampf _value, GLboolean _invert) { + SetHeader(); + value = _value; + invert = _invert; + } + + void* Set(void* cmd, GLclampf _value, GLboolean _invert) { + static_cast<ValueType*>(cmd)->Init(_value, _invert); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + float value; + uint32 invert; +}; + +COMPILE_ASSERT(sizeof(SampleCoverage) == 12, + Sizeof_SampleCoverage_is_not_12); +COMPILE_ASSERT(offsetof(SampleCoverage, header) == 0, + OffsetOf_SampleCoverage_header_not_0); +COMPILE_ASSERT(offsetof(SampleCoverage, value) == 4, + OffsetOf_SampleCoverage_value_not_4); +COMPILE_ASSERT(offsetof(SampleCoverage, invert) == 8, + OffsetOf_SampleCoverage_invert_not_8); + +struct Scissor { + typedef Scissor ValueType; + static const CommandId kCmdId = kScissor; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) { + SetHeader(); + x = _x; + y = _y; + width = _width; + height = _height; + } + + void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { + static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 x; + uint32 y; + uint32 width; + uint32 height; +}; + +COMPILE_ASSERT(sizeof(Scissor) == 20, + Sizeof_Scissor_is_not_20); +COMPILE_ASSERT(offsetof(Scissor, header) == 0, + OffsetOf_Scissor_header_not_0); +COMPILE_ASSERT(offsetof(Scissor, x) == 4, + OffsetOf_Scissor_x_not_4); +COMPILE_ASSERT(offsetof(Scissor, y) == 8, + OffsetOf_Scissor_y_not_8); +COMPILE_ASSERT(offsetof(Scissor, width) == 12, + OffsetOf_Scissor_width_not_12); +COMPILE_ASSERT(offsetof(Scissor, height) == 16, + OffsetOf_Scissor_height_not_16); + +struct ShaderSource { + typedef ShaderSource ValueType; + static const CommandId kCmdId = kShaderSource; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _shader, GLsizei _count, uint32 _data_shm_id, + uint32 _data_shm_offset, uint32 _data_size) { + SetHeader(); + shader = _shader; + count = _count; + data_shm_id = _data_shm_id; + data_shm_offset = _data_shm_offset; + data_size = _data_size; + } + + void* Set( + void* cmd, GLuint _shader, GLsizei _count, uint32 _data_shm_id, + uint32 _data_shm_offset, uint32 _data_size) { + static_cast<ValueType*>( + cmd)->Init( + _shader, _count, _data_shm_id, _data_shm_offset, _data_size); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 shader; + uint32 count; + uint32 data_shm_id; + uint32 data_shm_offset; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(ShaderSource) == 24, + Sizeof_ShaderSource_is_not_24); +COMPILE_ASSERT(offsetof(ShaderSource, header) == 0, + OffsetOf_ShaderSource_header_not_0); +COMPILE_ASSERT(offsetof(ShaderSource, shader) == 4, + OffsetOf_ShaderSource_shader_not_4); +COMPILE_ASSERT(offsetof(ShaderSource, count) == 8, + OffsetOf_ShaderSource_count_not_8); +COMPILE_ASSERT(offsetof(ShaderSource, data_shm_id) == 12, + OffsetOf_ShaderSource_data_shm_id_not_12); +COMPILE_ASSERT(offsetof(ShaderSource, data_shm_offset) == 16, + OffsetOf_ShaderSource_data_shm_offset_not_16); +COMPILE_ASSERT(offsetof(ShaderSource, data_size) == 20, + OffsetOf_ShaderSource_data_size_not_20); + +struct ShaderSourceImmediate { + typedef ShaderSourceImmediate ValueType; + static const CommandId kCmdId = kShaderSourceImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init(GLuint _shader, GLsizei _count, uint32 _data_size) { + uint32 total_size = ComputeSize(_data_size); + SetHeader(total_size); + shader = _shader; + count = _count; + data_size = _data_size; + } + + void* Set(void* cmd, GLuint _shader, GLsizei _count, uint32 _data_size) { + uint32 total_size = ComputeSize(_data_size); + static_cast<ValueType*>(cmd)->Init(_shader, _count, _data_size); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 shader; + uint32 count; + uint32 data_size; +}; + +COMPILE_ASSERT(sizeof(ShaderSourceImmediate) == 16, + Sizeof_ShaderSourceImmediate_is_not_16); +COMPILE_ASSERT(offsetof(ShaderSourceImmediate, header) == 0, + OffsetOf_ShaderSourceImmediate_header_not_0); +COMPILE_ASSERT(offsetof(ShaderSourceImmediate, shader) == 4, + OffsetOf_ShaderSourceImmediate_shader_not_4); +COMPILE_ASSERT(offsetof(ShaderSourceImmediate, count) == 8, + OffsetOf_ShaderSourceImmediate_count_not_8); +COMPILE_ASSERT(offsetof(ShaderSourceImmediate, data_size) == 12, + OffsetOf_ShaderSourceImmediate_data_size_not_12); + +struct StencilFunc { + typedef StencilFunc ValueType; + static const CommandId kCmdId = kStencilFunc; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _func, GLint _ref, GLuint _mask) { + SetHeader(); + func = _func; + ref = _ref; + mask = _mask; + } + + void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) { + static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 func; + uint32 ref; + uint32 mask; +}; + +COMPILE_ASSERT(sizeof(StencilFunc) == 16, + Sizeof_StencilFunc_is_not_16); +COMPILE_ASSERT(offsetof(StencilFunc, header) == 0, + OffsetOf_StencilFunc_header_not_0); +COMPILE_ASSERT(offsetof(StencilFunc, func) == 4, + OffsetOf_StencilFunc_func_not_4); +COMPILE_ASSERT(offsetof(StencilFunc, ref) == 8, + OffsetOf_StencilFunc_ref_not_8); +COMPILE_ASSERT(offsetof(StencilFunc, mask) == 12, + OffsetOf_StencilFunc_mask_not_12); + +struct StencilFuncSeparate { + typedef StencilFuncSeparate ValueType; + static const CommandId kCmdId = kStencilFuncSeparate; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _face, GLenum _func, GLint _ref, GLuint _mask) { + SetHeader(); + face = _face; + func = _func; + ref = _ref; + mask = _mask; + } + + void* Set(void* cmd, GLenum _face, GLenum _func, GLint _ref, GLuint _mask) { + static_cast<ValueType*>(cmd)->Init(_face, _func, _ref, _mask); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 face; + uint32 func; + uint32 ref; + uint32 mask; +}; + +COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20, + Sizeof_StencilFuncSeparate_is_not_20); +COMPILE_ASSERT(offsetof(StencilFuncSeparate, header) == 0, + OffsetOf_StencilFuncSeparate_header_not_0); +COMPILE_ASSERT(offsetof(StencilFuncSeparate, face) == 4, + OffsetOf_StencilFuncSeparate_face_not_4); +COMPILE_ASSERT(offsetof(StencilFuncSeparate, func) == 8, + OffsetOf_StencilFuncSeparate_func_not_8); +COMPILE_ASSERT(offsetof(StencilFuncSeparate, ref) == 12, + OffsetOf_StencilFuncSeparate_ref_not_12); +COMPILE_ASSERT(offsetof(StencilFuncSeparate, mask) == 16, + OffsetOf_StencilFuncSeparate_mask_not_16); + +struct StencilMask { + typedef StencilMask ValueType; + static const CommandId kCmdId = kStencilMask; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _mask) { + SetHeader(); + mask = _mask; + } + + void* Set(void* cmd, GLuint _mask) { + static_cast<ValueType*>(cmd)->Init(_mask); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 mask; +}; + +COMPILE_ASSERT(sizeof(StencilMask) == 8, + Sizeof_StencilMask_is_not_8); +COMPILE_ASSERT(offsetof(StencilMask, header) == 0, + OffsetOf_StencilMask_header_not_0); +COMPILE_ASSERT(offsetof(StencilMask, mask) == 4, + OffsetOf_StencilMask_mask_not_4); + +struct StencilMaskSeparate { + typedef StencilMaskSeparate ValueType; + static const CommandId kCmdId = kStencilMaskSeparate; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _face, GLuint _mask) { + SetHeader(); + face = _face; + mask = _mask; + } + + void* Set(void* cmd, GLenum _face, GLuint _mask) { + static_cast<ValueType*>(cmd)->Init(_face, _mask); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 face; + uint32 mask; +}; + +COMPILE_ASSERT(sizeof(StencilMaskSeparate) == 12, + Sizeof_StencilMaskSeparate_is_not_12); +COMPILE_ASSERT(offsetof(StencilMaskSeparate, header) == 0, + OffsetOf_StencilMaskSeparate_header_not_0); +COMPILE_ASSERT(offsetof(StencilMaskSeparate, face) == 4, + OffsetOf_StencilMaskSeparate_face_not_4); +COMPILE_ASSERT(offsetof(StencilMaskSeparate, mask) == 8, + OffsetOf_StencilMaskSeparate_mask_not_8); + +struct StencilOp { + typedef StencilOp ValueType; + static const CommandId kCmdId = kStencilOp; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _fail, GLenum _zfail, GLenum _zpass) { + SetHeader(); + fail = _fail; + zfail = _zfail; + zpass = _zpass; + } + + void* Set(void* cmd, GLenum _fail, GLenum _zfail, GLenum _zpass) { + static_cast<ValueType*>(cmd)->Init(_fail, _zfail, _zpass); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 fail; + uint32 zfail; + uint32 zpass; +}; + +COMPILE_ASSERT(sizeof(StencilOp) == 16, + Sizeof_StencilOp_is_not_16); +COMPILE_ASSERT(offsetof(StencilOp, header) == 0, + OffsetOf_StencilOp_header_not_0); +COMPILE_ASSERT(offsetof(StencilOp, fail) == 4, + OffsetOf_StencilOp_fail_not_4); +COMPILE_ASSERT(offsetof(StencilOp, zfail) == 8, + OffsetOf_StencilOp_zfail_not_8); +COMPILE_ASSERT(offsetof(StencilOp, zpass) == 12, + OffsetOf_StencilOp_zpass_not_12); + +struct StencilOpSeparate { + typedef StencilOpSeparate ValueType; + static const CommandId kCmdId = kStencilOpSeparate; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) { + SetHeader(); + face = _face; + fail = _fail; + zfail = _zfail; + zpass = _zpass; + } + + void* Set( + void* cmd, GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) { + static_cast<ValueType*>(cmd)->Init(_face, _fail, _zfail, _zpass); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 face; + uint32 fail; + uint32 zfail; + uint32 zpass; +}; + +COMPILE_ASSERT(sizeof(StencilOpSeparate) == 20, + Sizeof_StencilOpSeparate_is_not_20); +COMPILE_ASSERT(offsetof(StencilOpSeparate, header) == 0, + OffsetOf_StencilOpSeparate_header_not_0); +COMPILE_ASSERT(offsetof(StencilOpSeparate, face) == 4, + OffsetOf_StencilOpSeparate_face_not_4); +COMPILE_ASSERT(offsetof(StencilOpSeparate, fail) == 8, + OffsetOf_StencilOpSeparate_fail_not_8); +COMPILE_ASSERT(offsetof(StencilOpSeparate, zfail) == 12, + OffsetOf_StencilOpSeparate_zfail_not_12); +COMPILE_ASSERT(offsetof(StencilOpSeparate, zpass) == 16, + OffsetOf_StencilOpSeparate_zpass_not_16); + +struct TexImage2D { + typedef TexImage2D ValueType; + static const CommandId kCmdId = kTexImage2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, + GLsizei _height, GLint _border, GLenum _format, GLenum _type, + uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { + SetHeader(); + target = _target; + level = _level; + internalformat = _internalformat; + width = _width; + height = _height; + border = _border; + format = _format; + type = _type; + pixels_shm_id = _pixels_shm_id; + pixels_shm_offset = _pixels_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _internalformat, + GLsizei _width, GLsizei _height, GLint _border, GLenum _format, + GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _internalformat, _width, _height, _border, _format, + _type, _pixels_shm_id, _pixels_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 internalformat; + uint32 width; + uint32 height; + uint32 border; + uint32 format; + uint32 type; + uint32 pixels_shm_id; + uint32 pixels_shm_offset; +}; + +COMPILE_ASSERT(sizeof(TexImage2D) == 44, + Sizeof_TexImage2D_is_not_44); +COMPILE_ASSERT(offsetof(TexImage2D, header) == 0, + OffsetOf_TexImage2D_header_not_0); +COMPILE_ASSERT(offsetof(TexImage2D, target) == 4, + OffsetOf_TexImage2D_target_not_4); +COMPILE_ASSERT(offsetof(TexImage2D, level) == 8, + OffsetOf_TexImage2D_level_not_8); +COMPILE_ASSERT(offsetof(TexImage2D, internalformat) == 12, + OffsetOf_TexImage2D_internalformat_not_12); +COMPILE_ASSERT(offsetof(TexImage2D, width) == 16, + OffsetOf_TexImage2D_width_not_16); +COMPILE_ASSERT(offsetof(TexImage2D, height) == 20, + OffsetOf_TexImage2D_height_not_20); +COMPILE_ASSERT(offsetof(TexImage2D, border) == 24, + OffsetOf_TexImage2D_border_not_24); +COMPILE_ASSERT(offsetof(TexImage2D, format) == 28, + OffsetOf_TexImage2D_format_not_28); +COMPILE_ASSERT(offsetof(TexImage2D, type) == 32, + OffsetOf_TexImage2D_type_not_32); +COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 36, + OffsetOf_TexImage2D_pixels_shm_id_not_36); +COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 40, + OffsetOf_TexImage2D_pixels_shm_offset_not_40); + +struct TexImage2DImmediate { + typedef TexImage2DImmediate ValueType; + static const CommandId kCmdId = kTexImage2DImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init( + GLenum _target, GLint _level, GLint _internalformat, GLsizei _width, + GLsizei _height, GLint _border, GLenum _format, GLenum _type) { + uint32 total_size = 0; // TODO(gman): get correct size + SetHeader(total_size); + target = _target; + level = _level; + internalformat = _internalformat; + width = _width; + height = _height; + border = _border; + format = _format; + type = _type; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _internalformat, + GLsizei _width, GLsizei _height, GLint _border, GLenum _format, + GLenum _type) { + uint32 total_size = 0; // TODO(gman): get correct size + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _internalformat, _width, _height, _border, _format, + _type); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 internalformat; + uint32 width; + uint32 height; + uint32 border; + uint32 format; + uint32 type; +}; + +COMPILE_ASSERT(sizeof(TexImage2DImmediate) == 36, + Sizeof_TexImage2DImmediate_is_not_36); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, header) == 0, + OffsetOf_TexImage2DImmediate_header_not_0); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, target) == 4, + OffsetOf_TexImage2DImmediate_target_not_4); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, level) == 8, + OffsetOf_TexImage2DImmediate_level_not_8); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, internalformat) == 12, + OffsetOf_TexImage2DImmediate_internalformat_not_12); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, width) == 16, + OffsetOf_TexImage2DImmediate_width_not_16); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, height) == 20, + OffsetOf_TexImage2DImmediate_height_not_20); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, border) == 24, + OffsetOf_TexImage2DImmediate_border_not_24); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, format) == 28, + OffsetOf_TexImage2DImmediate_format_not_28); +COMPILE_ASSERT(offsetof(TexImage2DImmediate, type) == 32, + OffsetOf_TexImage2DImmediate_type_not_32); + +struct TexParameterf { + typedef TexParameterf ValueType; + static const CommandId kCmdId = kTexParameterf; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLenum _pname, GLfloat _param) { + SetHeader(); + target = _target; + pname = _pname; + param = _param; + } + + void* Set(void* cmd, GLenum _target, GLenum _pname, GLfloat _param) { + static_cast<ValueType*>(cmd)->Init(_target, _pname, _param); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + float param; +}; + +COMPILE_ASSERT(sizeof(TexParameterf) == 16, + Sizeof_TexParameterf_is_not_16); +COMPILE_ASSERT(offsetof(TexParameterf, header) == 0, + OffsetOf_TexParameterf_header_not_0); +COMPILE_ASSERT(offsetof(TexParameterf, target) == 4, + OffsetOf_TexParameterf_target_not_4); +COMPILE_ASSERT(offsetof(TexParameterf, pname) == 8, + OffsetOf_TexParameterf_pname_not_8); +COMPILE_ASSERT(offsetof(TexParameterf, param) == 12, + OffsetOf_TexParameterf_param_not_12); + +struct TexParameterfv { + typedef TexParameterfv ValueType; + static const CommandId kCmdId = kTexParameterfv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(TexParameterfv) == 20, + Sizeof_TexParameterfv_is_not_20); +COMPILE_ASSERT(offsetof(TexParameterfv, header) == 0, + OffsetOf_TexParameterfv_header_not_0); +COMPILE_ASSERT(offsetof(TexParameterfv, target) == 4, + OffsetOf_TexParameterfv_target_not_4); +COMPILE_ASSERT(offsetof(TexParameterfv, pname) == 8, + OffsetOf_TexParameterfv_pname_not_8); +COMPILE_ASSERT(offsetof(TexParameterfv, params_shm_id) == 12, + OffsetOf_TexParameterfv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(TexParameterfv, params_shm_offset) == 16, + OffsetOf_TexParameterfv_params_shm_offset_not_16); + +struct TexParameterfvImmediate { + typedef TexParameterfvImmediate ValueType; + static const CommandId kCmdId = kTexParameterfvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize() { + return static_cast<uint32>( + sizeof(GLfloat) * 1); // NOLINT + } + + static uint32 ComputeSize() { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize()); // NOLINT + } + + void SetHeader() { + header.SetCmdByTotalSize<ValueType>(ComputeSize()); + } + + void Init(GLenum _target, GLenum _pname, const GLfloat* _params) { + SetHeader(); + target = _target; + pname = _pname; + memcpy(ImmediateDataAddress(this), + _params, ComputeDataSize()); + } + + void* Set(void* cmd, GLenum _target, GLenum _pname, const GLfloat* _params) { + static_cast<ValueType*>(cmd)->Init(_target, _pname, _params); + const uint32 size = ComputeSize(); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; +}; + +COMPILE_ASSERT(sizeof(TexParameterfvImmediate) == 12, + Sizeof_TexParameterfvImmediate_is_not_12); +COMPILE_ASSERT(offsetof(TexParameterfvImmediate, header) == 0, + OffsetOf_TexParameterfvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(TexParameterfvImmediate, target) == 4, + OffsetOf_TexParameterfvImmediate_target_not_4); +COMPILE_ASSERT(offsetof(TexParameterfvImmediate, pname) == 8, + OffsetOf_TexParameterfvImmediate_pname_not_8); + +struct TexParameteri { + typedef TexParameteri ValueType; + static const CommandId kCmdId = kTexParameteri; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLenum _target, GLenum _pname, GLint _param) { + SetHeader(); + target = _target; + pname = _pname; + param = _param; + } + + void* Set(void* cmd, GLenum _target, GLenum _pname, GLint _param) { + static_cast<ValueType*>(cmd)->Init(_target, _pname, _param); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 param; +}; + +COMPILE_ASSERT(sizeof(TexParameteri) == 16, + Sizeof_TexParameteri_is_not_16); +COMPILE_ASSERT(offsetof(TexParameteri, header) == 0, + OffsetOf_TexParameteri_header_not_0); +COMPILE_ASSERT(offsetof(TexParameteri, target) == 4, + OffsetOf_TexParameteri_target_not_4); +COMPILE_ASSERT(offsetof(TexParameteri, pname) == 8, + OffsetOf_TexParameteri_pname_not_8); +COMPILE_ASSERT(offsetof(TexParameteri, param) == 12, + OffsetOf_TexParameteri_param_not_12); + +struct TexParameteriv { + typedef TexParameteriv ValueType; + static const CommandId kCmdId = kTexParameteriv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + SetHeader(); + target = _target; + pname = _pname; + params_shm_id = _params_shm_id; + params_shm_offset = _params_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id, + uint32 _params_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; + uint32 params_shm_id; + uint32 params_shm_offset; +}; + +COMPILE_ASSERT(sizeof(TexParameteriv) == 20, + Sizeof_TexParameteriv_is_not_20); +COMPILE_ASSERT(offsetof(TexParameteriv, header) == 0, + OffsetOf_TexParameteriv_header_not_0); +COMPILE_ASSERT(offsetof(TexParameteriv, target) == 4, + OffsetOf_TexParameteriv_target_not_4); +COMPILE_ASSERT(offsetof(TexParameteriv, pname) == 8, + OffsetOf_TexParameteriv_pname_not_8); +COMPILE_ASSERT(offsetof(TexParameteriv, params_shm_id) == 12, + OffsetOf_TexParameteriv_params_shm_id_not_12); +COMPILE_ASSERT(offsetof(TexParameteriv, params_shm_offset) == 16, + OffsetOf_TexParameteriv_params_shm_offset_not_16); + +struct TexParameterivImmediate { + typedef TexParameterivImmediate ValueType; + static const CommandId kCmdId = kTexParameterivImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize() { + return static_cast<uint32>( + sizeof(GLint) * 1); // NOLINT + } + + static uint32 ComputeSize() { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize()); // NOLINT + } + + void SetHeader() { + header.SetCmdByTotalSize<ValueType>(ComputeSize()); + } + + void Init(GLenum _target, GLenum _pname, const GLint* _params) { + SetHeader(); + target = _target; + pname = _pname; + memcpy(ImmediateDataAddress(this), + _params, ComputeDataSize()); + } + + void* Set(void* cmd, GLenum _target, GLenum _pname, const GLint* _params) { + static_cast<ValueType*>(cmd)->Init(_target, _pname, _params); + const uint32 size = ComputeSize(); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 pname; +}; + +COMPILE_ASSERT(sizeof(TexParameterivImmediate) == 12, + Sizeof_TexParameterivImmediate_is_not_12); +COMPILE_ASSERT(offsetof(TexParameterivImmediate, header) == 0, + OffsetOf_TexParameterivImmediate_header_not_0); +COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4, + OffsetOf_TexParameterivImmediate_target_not_4); +COMPILE_ASSERT(offsetof(TexParameterivImmediate, pname) == 8, + OffsetOf_TexParameterivImmediate_pname_not_8); + +struct TexSubImage2D { + typedef TexSubImage2D ValueType; + static const CommandId kCmdId = kTexSubImage2D; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, + uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { + SetHeader(); + target = _target; + level = _level; + xoffset = _xoffset; + yoffset = _yoffset; + width = _width; + height = _height; + format = _format; + type = _type; + pixels_shm_id = _pixels_shm_id; + pixels_shm_offset = _pixels_shm_offset; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLenum _type, + uint32 _pixels_shm_id, uint32 _pixels_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _xoffset, _yoffset, _width, _height, _format, + _type, _pixels_shm_id, _pixels_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 xoffset; + uint32 yoffset; + uint32 width; + uint32 height; + uint32 format; + uint32 type; + uint32 pixels_shm_id; + uint32 pixels_shm_offset; +}; + +COMPILE_ASSERT(sizeof(TexSubImage2D) == 44, + Sizeof_TexSubImage2D_is_not_44); +COMPILE_ASSERT(offsetof(TexSubImage2D, header) == 0, + OffsetOf_TexSubImage2D_header_not_0); +COMPILE_ASSERT(offsetof(TexSubImage2D, target) == 4, + OffsetOf_TexSubImage2D_target_not_4); +COMPILE_ASSERT(offsetof(TexSubImage2D, level) == 8, + OffsetOf_TexSubImage2D_level_not_8); +COMPILE_ASSERT(offsetof(TexSubImage2D, xoffset) == 12, + OffsetOf_TexSubImage2D_xoffset_not_12); +COMPILE_ASSERT(offsetof(TexSubImage2D, yoffset) == 16, + OffsetOf_TexSubImage2D_yoffset_not_16); +COMPILE_ASSERT(offsetof(TexSubImage2D, width) == 20, + OffsetOf_TexSubImage2D_width_not_20); +COMPILE_ASSERT(offsetof(TexSubImage2D, height) == 24, + OffsetOf_TexSubImage2D_height_not_24); +COMPILE_ASSERT(offsetof(TexSubImage2D, format) == 28, + OffsetOf_TexSubImage2D_format_not_28); +COMPILE_ASSERT(offsetof(TexSubImage2D, type) == 32, + OffsetOf_TexSubImage2D_type_not_32); +COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_id) == 36, + OffsetOf_TexSubImage2D_pixels_shm_id_not_36); +COMPILE_ASSERT(offsetof(TexSubImage2D, pixels_shm_offset) == 40, + OffsetOf_TexSubImage2D_pixels_shm_offset_not_40); + +struct TexSubImage2DImmediate { + typedef TexSubImage2DImmediate ValueType; + static const CommandId kCmdId = kTexSubImage2DImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeSize(uint32 size_in_bytes) { + return static_cast<uint32>( + sizeof(ValueType) + // NOLINT + RoundSizeToMultipleOfEntries(size_in_bytes)); + } + + void SetHeader(uint32 size_in_bytes) { + header.SetCmdByTotalSize<ValueType>(size_in_bytes); + } + + void Init( + GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLenum _type) { + uint32 total_size = 0; // TODO(gman): get correct size + SetHeader(total_size); + target = _target; + level = _level; + xoffset = _xoffset; + yoffset = _yoffset; + width = _width; + height = _height; + format = _format; + type = _type; + } + + void* Set( + void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset, + GLsizei _width, GLsizei _height, GLenum _format, GLenum _type) { + uint32 total_size = 0; // TODO(gman): get correct size + static_cast<ValueType*>( + cmd)->Init( + _target, _level, _xoffset, _yoffset, _width, _height, _format, + _type); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size); + } + + command_buffer::CommandHeader header; + uint32 target; + uint32 level; + uint32 xoffset; + uint32 yoffset; + uint32 width; + uint32 height; + uint32 format; + uint32 type; +}; + +COMPILE_ASSERT(sizeof(TexSubImage2DImmediate) == 36, + Sizeof_TexSubImage2DImmediate_is_not_36); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, header) == 0, + OffsetOf_TexSubImage2DImmediate_header_not_0); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, target) == 4, + OffsetOf_TexSubImage2DImmediate_target_not_4); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, level) == 8, + OffsetOf_TexSubImage2DImmediate_level_not_8); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, xoffset) == 12, + OffsetOf_TexSubImage2DImmediate_xoffset_not_12); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, yoffset) == 16, + OffsetOf_TexSubImage2DImmediate_yoffset_not_16); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, width) == 20, + OffsetOf_TexSubImage2DImmediate_width_not_20); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, height) == 24, + OffsetOf_TexSubImage2DImmediate_height_not_24); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, format) == 28, + OffsetOf_TexSubImage2DImmediate_format_not_28); +COMPILE_ASSERT(offsetof(TexSubImage2DImmediate, type) == 32, + OffsetOf_TexSubImage2DImmediate_type_not_32); + +struct Uniform1f { + typedef Uniform1f ValueType; + static const CommandId kCmdId = kUniform1f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLfloat _x) { + SetHeader(); + location = _location; + x = _x; + } + + void* Set(void* cmd, GLint _location, GLfloat _x) { + static_cast<ValueType*>(cmd)->Init(_location, _x); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + float x; +}; + +COMPILE_ASSERT(sizeof(Uniform1f) == 12, + Sizeof_Uniform1f_is_not_12); +COMPILE_ASSERT(offsetof(Uniform1f, header) == 0, + OffsetOf_Uniform1f_header_not_0); +COMPILE_ASSERT(offsetof(Uniform1f, location) == 4, + OffsetOf_Uniform1f_location_not_4); +COMPILE_ASSERT(offsetof(Uniform1f, x) == 8, + OffsetOf_Uniform1f_x_not_8); + +struct Uniform1fv { + typedef Uniform1fv ValueType; + static const CommandId kCmdId = kUniform1fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform1fv) == 20, + Sizeof_Uniform1fv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform1fv, header) == 0, + OffsetOf_Uniform1fv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform1fv, location) == 4, + OffsetOf_Uniform1fv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform1fv, count) == 8, + OffsetOf_Uniform1fv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform1fv, v_shm_id) == 12, + OffsetOf_Uniform1fv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform1fv, v_shm_offset) == 16, + OffsetOf_Uniform1fv_v_shm_offset_not_16); + +struct Uniform1fvImmediate { + typedef Uniform1fvImmediate ValueType; + static const CommandId kCmdId = kUniform1fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 1 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLfloat* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12, + Sizeof_Uniform1fvImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform1fvImmediate, header) == 0, + OffsetOf_Uniform1fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform1fvImmediate, location) == 4, + OffsetOf_Uniform1fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform1fvImmediate, count) == 8, + OffsetOf_Uniform1fvImmediate_count_not_8); + +struct Uniform1i { + typedef Uniform1i ValueType; + static const CommandId kCmdId = kUniform1i; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLint _x) { + SetHeader(); + location = _location; + x = _x; + } + + void* Set(void* cmd, GLint _location, GLint _x) { + static_cast<ValueType*>(cmd)->Init(_location, _x); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 x; +}; + +COMPILE_ASSERT(sizeof(Uniform1i) == 12, + Sizeof_Uniform1i_is_not_12); +COMPILE_ASSERT(offsetof(Uniform1i, header) == 0, + OffsetOf_Uniform1i_header_not_0); +COMPILE_ASSERT(offsetof(Uniform1i, location) == 4, + OffsetOf_Uniform1i_location_not_4); +COMPILE_ASSERT(offsetof(Uniform1i, x) == 8, + OffsetOf_Uniform1i_x_not_8); + +struct Uniform1iv { + typedef Uniform1iv ValueType; + static const CommandId kCmdId = kUniform1iv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform1iv) == 20, + Sizeof_Uniform1iv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform1iv, header) == 0, + OffsetOf_Uniform1iv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform1iv, location) == 4, + OffsetOf_Uniform1iv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform1iv, count) == 8, + OffsetOf_Uniform1iv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform1iv, v_shm_id) == 12, + OffsetOf_Uniform1iv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform1iv, v_shm_offset) == 16, + OffsetOf_Uniform1iv_v_shm_offset_not_16); + +struct Uniform1ivImmediate { + typedef Uniform1ivImmediate ValueType; + static const CommandId kCmdId = kUniform1ivImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLint) * 1 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLint* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12, + Sizeof_Uniform1ivImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform1ivImmediate, header) == 0, + OffsetOf_Uniform1ivImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4, + OffsetOf_Uniform1ivImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform1ivImmediate, count) == 8, + OffsetOf_Uniform1ivImmediate_count_not_8); + +struct Uniform2f { + typedef Uniform2f ValueType; + static const CommandId kCmdId = kUniform2f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLfloat _x, GLfloat _y) { + SetHeader(); + location = _location; + x = _x; + y = _y; + } + + void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y) { + static_cast<ValueType*>(cmd)->Init(_location, _x, _y); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + float x; + float y; +}; + +COMPILE_ASSERT(sizeof(Uniform2f) == 16, + Sizeof_Uniform2f_is_not_16); +COMPILE_ASSERT(offsetof(Uniform2f, header) == 0, + OffsetOf_Uniform2f_header_not_0); +COMPILE_ASSERT(offsetof(Uniform2f, location) == 4, + OffsetOf_Uniform2f_location_not_4); +COMPILE_ASSERT(offsetof(Uniform2f, x) == 8, + OffsetOf_Uniform2f_x_not_8); +COMPILE_ASSERT(offsetof(Uniform2f, y) == 12, + OffsetOf_Uniform2f_y_not_12); + +struct Uniform2fv { + typedef Uniform2fv ValueType; + static const CommandId kCmdId = kUniform2fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform2fv) == 20, + Sizeof_Uniform2fv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform2fv, header) == 0, + OffsetOf_Uniform2fv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform2fv, location) == 4, + OffsetOf_Uniform2fv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform2fv, count) == 8, + OffsetOf_Uniform2fv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform2fv, v_shm_id) == 12, + OffsetOf_Uniform2fv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform2fv, v_shm_offset) == 16, + OffsetOf_Uniform2fv_v_shm_offset_not_16); + +struct Uniform2fvImmediate { + typedef Uniform2fvImmediate ValueType; + static const CommandId kCmdId = kUniform2fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 2 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLfloat* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12, + Sizeof_Uniform2fvImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform2fvImmediate, header) == 0, + OffsetOf_Uniform2fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform2fvImmediate, location) == 4, + OffsetOf_Uniform2fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform2fvImmediate, count) == 8, + OffsetOf_Uniform2fvImmediate_count_not_8); + +struct Uniform2i { + typedef Uniform2i ValueType; + static const CommandId kCmdId = kUniform2i; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLint _x, GLint _y) { + SetHeader(); + location = _location; + x = _x; + y = _y; + } + + void* Set(void* cmd, GLint _location, GLint _x, GLint _y) { + static_cast<ValueType*>(cmd)->Init(_location, _x, _y); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 x; + uint32 y; +}; + +COMPILE_ASSERT(sizeof(Uniform2i) == 16, + Sizeof_Uniform2i_is_not_16); +COMPILE_ASSERT(offsetof(Uniform2i, header) == 0, + OffsetOf_Uniform2i_header_not_0); +COMPILE_ASSERT(offsetof(Uniform2i, location) == 4, + OffsetOf_Uniform2i_location_not_4); +COMPILE_ASSERT(offsetof(Uniform2i, x) == 8, + OffsetOf_Uniform2i_x_not_8); +COMPILE_ASSERT(offsetof(Uniform2i, y) == 12, + OffsetOf_Uniform2i_y_not_12); + +struct Uniform2iv { + typedef Uniform2iv ValueType; + static const CommandId kCmdId = kUniform2iv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform2iv) == 20, + Sizeof_Uniform2iv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform2iv, header) == 0, + OffsetOf_Uniform2iv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform2iv, location) == 4, + OffsetOf_Uniform2iv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform2iv, count) == 8, + OffsetOf_Uniform2iv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform2iv, v_shm_id) == 12, + OffsetOf_Uniform2iv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform2iv, v_shm_offset) == 16, + OffsetOf_Uniform2iv_v_shm_offset_not_16); + +struct Uniform2ivImmediate { + typedef Uniform2ivImmediate ValueType; + static const CommandId kCmdId = kUniform2ivImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLint) * 2 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLint* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12, + Sizeof_Uniform2ivImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform2ivImmediate, header) == 0, + OffsetOf_Uniform2ivImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4, + OffsetOf_Uniform2ivImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform2ivImmediate, count) == 8, + OffsetOf_Uniform2ivImmediate_count_not_8); + +struct Uniform3f { + typedef Uniform3f ValueType; + static const CommandId kCmdId = kUniform3f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) { + SetHeader(); + location = _location; + x = _x; + y = _y; + z = _z; + } + + void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) { + static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + float x; + float y; + float z; +}; + +COMPILE_ASSERT(sizeof(Uniform3f) == 20, + Sizeof_Uniform3f_is_not_20); +COMPILE_ASSERT(offsetof(Uniform3f, header) == 0, + OffsetOf_Uniform3f_header_not_0); +COMPILE_ASSERT(offsetof(Uniform3f, location) == 4, + OffsetOf_Uniform3f_location_not_4); +COMPILE_ASSERT(offsetof(Uniform3f, x) == 8, + OffsetOf_Uniform3f_x_not_8); +COMPILE_ASSERT(offsetof(Uniform3f, y) == 12, + OffsetOf_Uniform3f_y_not_12); +COMPILE_ASSERT(offsetof(Uniform3f, z) == 16, + OffsetOf_Uniform3f_z_not_16); + +struct Uniform3fv { + typedef Uniform3fv ValueType; + static const CommandId kCmdId = kUniform3fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform3fv) == 20, + Sizeof_Uniform3fv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform3fv, header) == 0, + OffsetOf_Uniform3fv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform3fv, location) == 4, + OffsetOf_Uniform3fv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform3fv, count) == 8, + OffsetOf_Uniform3fv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform3fv, v_shm_id) == 12, + OffsetOf_Uniform3fv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform3fv, v_shm_offset) == 16, + OffsetOf_Uniform3fv_v_shm_offset_not_16); + +struct Uniform3fvImmediate { + typedef Uniform3fvImmediate ValueType; + static const CommandId kCmdId = kUniform3fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 3 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLfloat* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12, + Sizeof_Uniform3fvImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform3fvImmediate, header) == 0, + OffsetOf_Uniform3fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform3fvImmediate, location) == 4, + OffsetOf_Uniform3fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform3fvImmediate, count) == 8, + OffsetOf_Uniform3fvImmediate_count_not_8); + +struct Uniform3i { + typedef Uniform3i ValueType; + static const CommandId kCmdId = kUniform3i; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLint _x, GLint _y, GLint _z) { + SetHeader(); + location = _location; + x = _x; + y = _y; + z = _z; + } + + void* Set(void* cmd, GLint _location, GLint _x, GLint _y, GLint _z) { + static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 x; + uint32 y; + uint32 z; +}; + +COMPILE_ASSERT(sizeof(Uniform3i) == 20, + Sizeof_Uniform3i_is_not_20); +COMPILE_ASSERT(offsetof(Uniform3i, header) == 0, + OffsetOf_Uniform3i_header_not_0); +COMPILE_ASSERT(offsetof(Uniform3i, location) == 4, + OffsetOf_Uniform3i_location_not_4); +COMPILE_ASSERT(offsetof(Uniform3i, x) == 8, + OffsetOf_Uniform3i_x_not_8); +COMPILE_ASSERT(offsetof(Uniform3i, y) == 12, + OffsetOf_Uniform3i_y_not_12); +COMPILE_ASSERT(offsetof(Uniform3i, z) == 16, + OffsetOf_Uniform3i_z_not_16); + +struct Uniform3iv { + typedef Uniform3iv ValueType; + static const CommandId kCmdId = kUniform3iv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform3iv) == 20, + Sizeof_Uniform3iv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform3iv, header) == 0, + OffsetOf_Uniform3iv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform3iv, location) == 4, + OffsetOf_Uniform3iv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform3iv, count) == 8, + OffsetOf_Uniform3iv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform3iv, v_shm_id) == 12, + OffsetOf_Uniform3iv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform3iv, v_shm_offset) == 16, + OffsetOf_Uniform3iv_v_shm_offset_not_16); + +struct Uniform3ivImmediate { + typedef Uniform3ivImmediate ValueType; + static const CommandId kCmdId = kUniform3ivImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLint) * 3 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLint* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12, + Sizeof_Uniform3ivImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform3ivImmediate, header) == 0, + OffsetOf_Uniform3ivImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4, + OffsetOf_Uniform3ivImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform3ivImmediate, count) == 8, + OffsetOf_Uniform3ivImmediate_count_not_8); + +struct Uniform4f { + typedef Uniform4f ValueType; + static const CommandId kCmdId = kUniform4f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { + SetHeader(); + location = _location; + x = _x; + y = _y; + z = _z; + w = _w; + } + + void* Set( + void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, + GLfloat _w) { + static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + float x; + float y; + float z; + float w; +}; + +COMPILE_ASSERT(sizeof(Uniform4f) == 24, + Sizeof_Uniform4f_is_not_24); +COMPILE_ASSERT(offsetof(Uniform4f, header) == 0, + OffsetOf_Uniform4f_header_not_0); +COMPILE_ASSERT(offsetof(Uniform4f, location) == 4, + OffsetOf_Uniform4f_location_not_4); +COMPILE_ASSERT(offsetof(Uniform4f, x) == 8, + OffsetOf_Uniform4f_x_not_8); +COMPILE_ASSERT(offsetof(Uniform4f, y) == 12, + OffsetOf_Uniform4f_y_not_12); +COMPILE_ASSERT(offsetof(Uniform4f, z) == 16, + OffsetOf_Uniform4f_z_not_16); +COMPILE_ASSERT(offsetof(Uniform4f, w) == 20, + OffsetOf_Uniform4f_w_not_20); + +struct Uniform4fv { + typedef Uniform4fv ValueType; + static const CommandId kCmdId = kUniform4fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform4fv) == 20, + Sizeof_Uniform4fv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform4fv, header) == 0, + OffsetOf_Uniform4fv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform4fv, location) == 4, + OffsetOf_Uniform4fv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform4fv, count) == 8, + OffsetOf_Uniform4fv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform4fv, v_shm_id) == 12, + OffsetOf_Uniform4fv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform4fv, v_shm_offset) == 16, + OffsetOf_Uniform4fv_v_shm_offset_not_16); + +struct Uniform4fvImmediate { + typedef Uniform4fvImmediate ValueType; + static const CommandId kCmdId = kUniform4fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 4 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLfloat* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12, + Sizeof_Uniform4fvImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform4fvImmediate, header) == 0, + OffsetOf_Uniform4fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform4fvImmediate, location) == 4, + OffsetOf_Uniform4fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform4fvImmediate, count) == 8, + OffsetOf_Uniform4fvImmediate_count_not_8); + +struct Uniform4i { + typedef Uniform4i ValueType; + static const CommandId kCmdId = kUniform4i; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) { + SetHeader(); + location = _location; + x = _x; + y = _y; + z = _z; + w = _w; + } + + void* Set( + void* cmd, GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) { + static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 x; + uint32 y; + uint32 z; + uint32 w; +}; + +COMPILE_ASSERT(sizeof(Uniform4i) == 24, + Sizeof_Uniform4i_is_not_24); +COMPILE_ASSERT(offsetof(Uniform4i, header) == 0, + OffsetOf_Uniform4i_header_not_0); +COMPILE_ASSERT(offsetof(Uniform4i, location) == 4, + OffsetOf_Uniform4i_location_not_4); +COMPILE_ASSERT(offsetof(Uniform4i, x) == 8, + OffsetOf_Uniform4i_x_not_8); +COMPILE_ASSERT(offsetof(Uniform4i, y) == 12, + OffsetOf_Uniform4i_y_not_12); +COMPILE_ASSERT(offsetof(Uniform4i, z) == 16, + OffsetOf_Uniform4i_z_not_16); +COMPILE_ASSERT(offsetof(Uniform4i, w) == 20, + OffsetOf_Uniform4i_w_not_20); + +struct Uniform4iv { + typedef Uniform4iv ValueType; + static const CommandId kCmdId = kUniform4iv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + SetHeader(); + location = _location; + count = _count; + v_shm_id = _v_shm_id; + v_shm_offset = _v_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id, + uint32 _v_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 v_shm_id; + uint32 v_shm_offset; +}; + +COMPILE_ASSERT(sizeof(Uniform4iv) == 20, + Sizeof_Uniform4iv_is_not_20); +COMPILE_ASSERT(offsetof(Uniform4iv, header) == 0, + OffsetOf_Uniform4iv_header_not_0); +COMPILE_ASSERT(offsetof(Uniform4iv, location) == 4, + OffsetOf_Uniform4iv_location_not_4); +COMPILE_ASSERT(offsetof(Uniform4iv, count) == 8, + OffsetOf_Uniform4iv_count_not_8); +COMPILE_ASSERT(offsetof(Uniform4iv, v_shm_id) == 12, + OffsetOf_Uniform4iv_v_shm_id_not_12); +COMPILE_ASSERT(offsetof(Uniform4iv, v_shm_offset) == 16, + OffsetOf_Uniform4iv_v_shm_offset_not_16); + +struct Uniform4ivImmediate { + typedef Uniform4ivImmediate ValueType; + static const CommandId kCmdId = kUniform4ivImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLint) * 4 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init(GLint _location, GLsizei _count, const GLint* _v) { + SetHeader(_count); + location = _location; + count = _count; + memcpy(ImmediateDataAddress(this), + _v, ComputeDataSize(_count)); + } + + void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _v); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; +}; + +COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12, + Sizeof_Uniform4ivImmediate_is_not_12); +COMPILE_ASSERT(offsetof(Uniform4ivImmediate, header) == 0, + OffsetOf_Uniform4ivImmediate_header_not_0); +COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4, + OffsetOf_Uniform4ivImmediate_location_not_4); +COMPILE_ASSERT(offsetof(Uniform4ivImmediate, count) == 8, + OffsetOf_Uniform4ivImmediate_count_not_8); + +struct UniformMatrix2fv { + typedef UniformMatrix2fv ValueType; + static const CommandId kCmdId = kUniformMatrix2fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, GLboolean _transpose, + uint32 _value_shm_id, uint32 _value_shm_offset) { + SetHeader(); + location = _location; + count = _count; + transpose = _transpose; + value_shm_id = _value_shm_id; + value_shm_offset = _value_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, + uint32 _value_shm_id, uint32 _value_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _location, _count, _transpose, _value_shm_id, _value_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 transpose; + uint32 value_shm_id; + uint32 value_shm_offset; +}; + +COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 24, + Sizeof_UniformMatrix2fv_is_not_24); +COMPILE_ASSERT(offsetof(UniformMatrix2fv, header) == 0, + OffsetOf_UniformMatrix2fv_header_not_0); +COMPILE_ASSERT(offsetof(UniformMatrix2fv, location) == 4, + OffsetOf_UniformMatrix2fv_location_not_4); +COMPILE_ASSERT(offsetof(UniformMatrix2fv, count) == 8, + OffsetOf_UniformMatrix2fv_count_not_8); +COMPILE_ASSERT(offsetof(UniformMatrix2fv, transpose) == 12, + OffsetOf_UniformMatrix2fv_transpose_not_12); +COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_id) == 16, + OffsetOf_UniformMatrix2fv_value_shm_id_not_16); +COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_offset) == 20, + OffsetOf_UniformMatrix2fv_value_shm_offset_not_20); + +struct UniformMatrix2fvImmediate { + typedef UniformMatrix2fvImmediate ValueType; + static const CommandId kCmdId = kUniformMatrix2fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 4 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init( + GLint _location, GLsizei _count, GLboolean _transpose, + const GLfloat* _value) { + SetHeader(_count); + location = _location; + count = _count; + transpose = _transpose; + memcpy(ImmediateDataAddress(this), + _value, ComputeDataSize(_count)); + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, + const GLfloat* _value) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 transpose; +}; + +COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 16, + Sizeof_UniformMatrix2fvImmediate_is_not_16); +COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0, + OffsetOf_UniformMatrix2fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4, + OffsetOf_UniformMatrix2fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8, + OffsetOf_UniformMatrix2fvImmediate_count_not_8); +COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, transpose) == 12, + OffsetOf_UniformMatrix2fvImmediate_transpose_not_12); + +struct UniformMatrix3fv { + typedef UniformMatrix3fv ValueType; + static const CommandId kCmdId = kUniformMatrix3fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, GLboolean _transpose, + uint32 _value_shm_id, uint32 _value_shm_offset) { + SetHeader(); + location = _location; + count = _count; + transpose = _transpose; + value_shm_id = _value_shm_id; + value_shm_offset = _value_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, + uint32 _value_shm_id, uint32 _value_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _location, _count, _transpose, _value_shm_id, _value_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 transpose; + uint32 value_shm_id; + uint32 value_shm_offset; +}; + +COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 24, + Sizeof_UniformMatrix3fv_is_not_24); +COMPILE_ASSERT(offsetof(UniformMatrix3fv, header) == 0, + OffsetOf_UniformMatrix3fv_header_not_0); +COMPILE_ASSERT(offsetof(UniformMatrix3fv, location) == 4, + OffsetOf_UniformMatrix3fv_location_not_4); +COMPILE_ASSERT(offsetof(UniformMatrix3fv, count) == 8, + OffsetOf_UniformMatrix3fv_count_not_8); +COMPILE_ASSERT(offsetof(UniformMatrix3fv, transpose) == 12, + OffsetOf_UniformMatrix3fv_transpose_not_12); +COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_id) == 16, + OffsetOf_UniformMatrix3fv_value_shm_id_not_16); +COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_offset) == 20, + OffsetOf_UniformMatrix3fv_value_shm_offset_not_20); + +struct UniformMatrix3fvImmediate { + typedef UniformMatrix3fvImmediate ValueType; + static const CommandId kCmdId = kUniformMatrix3fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 9 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init( + GLint _location, GLsizei _count, GLboolean _transpose, + const GLfloat* _value) { + SetHeader(_count); + location = _location; + count = _count; + transpose = _transpose; + memcpy(ImmediateDataAddress(this), + _value, ComputeDataSize(_count)); + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, + const GLfloat* _value) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 transpose; +}; + +COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 16, + Sizeof_UniformMatrix3fvImmediate_is_not_16); +COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0, + OffsetOf_UniformMatrix3fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4, + OffsetOf_UniformMatrix3fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8, + OffsetOf_UniformMatrix3fvImmediate_count_not_8); +COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, transpose) == 12, + OffsetOf_UniformMatrix3fvImmediate_transpose_not_12); + +struct UniformMatrix4fv { + typedef UniformMatrix4fv ValueType; + static const CommandId kCmdId = kUniformMatrix4fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLint _location, GLsizei _count, GLboolean _transpose, + uint32 _value_shm_id, uint32 _value_shm_offset) { + SetHeader(); + location = _location; + count = _count; + transpose = _transpose; + value_shm_id = _value_shm_id; + value_shm_offset = _value_shm_offset; + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, + uint32 _value_shm_id, uint32 _value_shm_offset) { + static_cast<ValueType*>( + cmd)->Init( + _location, _count, _transpose, _value_shm_id, _value_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 transpose; + uint32 value_shm_id; + uint32 value_shm_offset; +}; + +COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 24, + Sizeof_UniformMatrix4fv_is_not_24); +COMPILE_ASSERT(offsetof(UniformMatrix4fv, header) == 0, + OffsetOf_UniformMatrix4fv_header_not_0); +COMPILE_ASSERT(offsetof(UniformMatrix4fv, location) == 4, + OffsetOf_UniformMatrix4fv_location_not_4); +COMPILE_ASSERT(offsetof(UniformMatrix4fv, count) == 8, + OffsetOf_UniformMatrix4fv_count_not_8); +COMPILE_ASSERT(offsetof(UniformMatrix4fv, transpose) == 12, + OffsetOf_UniformMatrix4fv_transpose_not_12); +COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_id) == 16, + OffsetOf_UniformMatrix4fv_value_shm_id_not_16); +COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_offset) == 20, + OffsetOf_UniformMatrix4fv_value_shm_offset_not_20); + +struct UniformMatrix4fvImmediate { + typedef UniformMatrix4fvImmediate ValueType; + static const CommandId kCmdId = kUniformMatrix4fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize(GLsizei count) { + return static_cast<uint32>( + sizeof(GLfloat) * 16 * count); // NOLINT + } + + static uint32 ComputeSize(GLsizei count) { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize(count)); // NOLINT + } + + void SetHeader(GLsizei count) { + header.SetCmdByTotalSize<ValueType>(ComputeSize(count)); + } + + void Init( + GLint _location, GLsizei _count, GLboolean _transpose, + const GLfloat* _value) { + SetHeader(_count); + location = _location; + count = _count; + transpose = _transpose; + memcpy(ImmediateDataAddress(this), + _value, ComputeDataSize(_count)); + } + + void* Set( + void* cmd, GLint _location, GLsizei _count, GLboolean _transpose, + const GLfloat* _value) { + static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value); + const uint32 size = ComputeSize(_count); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 location; + uint32 count; + uint32 transpose; +}; + +COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 16, + Sizeof_UniformMatrix4fvImmediate_is_not_16); +COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0, + OffsetOf_UniformMatrix4fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4, + OffsetOf_UniformMatrix4fvImmediate_location_not_4); +COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8, + OffsetOf_UniformMatrix4fvImmediate_count_not_8); +COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, transpose) == 12, + OffsetOf_UniformMatrix4fvImmediate_transpose_not_12); + +struct UseProgram { + typedef UseProgram ValueType; + static const CommandId kCmdId = kUseProgram; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _program) { + SetHeader(); + program = _program; + } + + void* Set(void* cmd, GLuint _program) { + static_cast<ValueType*>(cmd)->Init(_program); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; +}; + +COMPILE_ASSERT(sizeof(UseProgram) == 8, + Sizeof_UseProgram_is_not_8); +COMPILE_ASSERT(offsetof(UseProgram, header) == 0, + OffsetOf_UseProgram_header_not_0); +COMPILE_ASSERT(offsetof(UseProgram, program) == 4, + OffsetOf_UseProgram_program_not_4); + +struct ValidateProgram { + typedef ValidateProgram ValueType; + static const CommandId kCmdId = kValidateProgram; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _program) { + SetHeader(); + program = _program; + } + + void* Set(void* cmd, GLuint _program) { + static_cast<ValueType*>(cmd)->Init(_program); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 program; +}; + +COMPILE_ASSERT(sizeof(ValidateProgram) == 8, + Sizeof_ValidateProgram_is_not_8); +COMPILE_ASSERT(offsetof(ValidateProgram, header) == 0, + OffsetOf_ValidateProgram_header_not_0); +COMPILE_ASSERT(offsetof(ValidateProgram, program) == 4, + OffsetOf_ValidateProgram_program_not_4); + +struct VertexAttrib1f { + typedef VertexAttrib1f ValueType; + static const CommandId kCmdId = kVertexAttrib1f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, GLfloat _x) { + SetHeader(); + indx = _indx; + x = _x; + } + + void* Set(void* cmd, GLuint _indx, GLfloat _x) { + static_cast<ValueType*>(cmd)->Init(_indx, _x); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + float x; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib1f) == 12, + Sizeof_VertexAttrib1f_is_not_12); +COMPILE_ASSERT(offsetof(VertexAttrib1f, header) == 0, + OffsetOf_VertexAttrib1f_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib1f, indx) == 4, + OffsetOf_VertexAttrib1f_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib1f, x) == 8, + OffsetOf_VertexAttrib1f_x_not_8); + +struct VertexAttrib1fv { + typedef VertexAttrib1fv ValueType; + static const CommandId kCmdId = kVertexAttrib1fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { + SetHeader(); + indx = _indx; + values_shm_id = _values_shm_id; + values_shm_offset = _values_shm_offset; + } + + void* Set( + void* cmd, GLuint _indx, uint32 _values_shm_id, + uint32 _values_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_indx, _values_shm_id, _values_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + uint32 values_shm_id; + uint32 values_shm_offset; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib1fv) == 16, + Sizeof_VertexAttrib1fv_is_not_16); +COMPILE_ASSERT(offsetof(VertexAttrib1fv, header) == 0, + OffsetOf_VertexAttrib1fv_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib1fv, indx) == 4, + OffsetOf_VertexAttrib1fv_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib1fv, values_shm_id) == 8, + OffsetOf_VertexAttrib1fv_values_shm_id_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib1fv, values_shm_offset) == 12, + OffsetOf_VertexAttrib1fv_values_shm_offset_not_12); + +struct VertexAttrib1fvImmediate { + typedef VertexAttrib1fvImmediate ValueType; + static const CommandId kCmdId = kVertexAttrib1fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize() { + return static_cast<uint32>( + sizeof(GLfloat) * 1); // NOLINT + } + + static uint32 ComputeSize() { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize()); // NOLINT + } + + void SetHeader() { + header.SetCmdByTotalSize<ValueType>(ComputeSize()); + } + + void Init(GLuint _indx, const GLfloat* _values) { + SetHeader(); + indx = _indx; + memcpy(ImmediateDataAddress(this), + _values, ComputeDataSize()); + } + + void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { + static_cast<ValueType*>(cmd)->Init(_indx, _values); + const uint32 size = ComputeSize(); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 indx; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib1fvImmediate) == 8, + Sizeof_VertexAttrib1fvImmediate_is_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, header) == 0, + OffsetOf_VertexAttrib1fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, indx) == 4, + OffsetOf_VertexAttrib1fvImmediate_indx_not_4); + +struct VertexAttrib2f { + typedef VertexAttrib2f ValueType; + static const CommandId kCmdId = kVertexAttrib2f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, GLfloat _x, GLfloat _y) { + SetHeader(); + indx = _indx; + x = _x; + y = _y; + } + + void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y) { + static_cast<ValueType*>(cmd)->Init(_indx, _x, _y); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + float x; + float y; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib2f) == 16, + Sizeof_VertexAttrib2f_is_not_16); +COMPILE_ASSERT(offsetof(VertexAttrib2f, header) == 0, + OffsetOf_VertexAttrib2f_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib2f, indx) == 4, + OffsetOf_VertexAttrib2f_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib2f, x) == 8, + OffsetOf_VertexAttrib2f_x_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib2f, y) == 12, + OffsetOf_VertexAttrib2f_y_not_12); + +struct VertexAttrib2fv { + typedef VertexAttrib2fv ValueType; + static const CommandId kCmdId = kVertexAttrib2fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { + SetHeader(); + indx = _indx; + values_shm_id = _values_shm_id; + values_shm_offset = _values_shm_offset; + } + + void* Set( + void* cmd, GLuint _indx, uint32 _values_shm_id, + uint32 _values_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_indx, _values_shm_id, _values_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + uint32 values_shm_id; + uint32 values_shm_offset; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib2fv) == 16, + Sizeof_VertexAttrib2fv_is_not_16); +COMPILE_ASSERT(offsetof(VertexAttrib2fv, header) == 0, + OffsetOf_VertexAttrib2fv_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib2fv, indx) == 4, + OffsetOf_VertexAttrib2fv_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib2fv, values_shm_id) == 8, + OffsetOf_VertexAttrib2fv_values_shm_id_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib2fv, values_shm_offset) == 12, + OffsetOf_VertexAttrib2fv_values_shm_offset_not_12); + +struct VertexAttrib2fvImmediate { + typedef VertexAttrib2fvImmediate ValueType; + static const CommandId kCmdId = kVertexAttrib2fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize() { + return static_cast<uint32>( + sizeof(GLfloat) * 2); // NOLINT + } + + static uint32 ComputeSize() { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize()); // NOLINT + } + + void SetHeader() { + header.SetCmdByTotalSize<ValueType>(ComputeSize()); + } + + void Init(GLuint _indx, const GLfloat* _values) { + SetHeader(); + indx = _indx; + memcpy(ImmediateDataAddress(this), + _values, ComputeDataSize()); + } + + void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { + static_cast<ValueType*>(cmd)->Init(_indx, _values); + const uint32 size = ComputeSize(); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 indx; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib2fvImmediate) == 8, + Sizeof_VertexAttrib2fvImmediate_is_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, header) == 0, + OffsetOf_VertexAttrib2fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, indx) == 4, + OffsetOf_VertexAttrib2fvImmediate_indx_not_4); + +struct VertexAttrib3f { + typedef VertexAttrib3f ValueType; + static const CommandId kCmdId = kVertexAttrib3f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) { + SetHeader(); + indx = _indx; + x = _x; + y = _y; + z = _z; + } + + void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) { + static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + float x; + float y; + float z; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib3f) == 20, + Sizeof_VertexAttrib3f_is_not_20); +COMPILE_ASSERT(offsetof(VertexAttrib3f, header) == 0, + OffsetOf_VertexAttrib3f_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib3f, indx) == 4, + OffsetOf_VertexAttrib3f_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib3f, x) == 8, + OffsetOf_VertexAttrib3f_x_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib3f, y) == 12, + OffsetOf_VertexAttrib3f_y_not_12); +COMPILE_ASSERT(offsetof(VertexAttrib3f, z) == 16, + OffsetOf_VertexAttrib3f_z_not_16); + +struct VertexAttrib3fv { + typedef VertexAttrib3fv ValueType; + static const CommandId kCmdId = kVertexAttrib3fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { + SetHeader(); + indx = _indx; + values_shm_id = _values_shm_id; + values_shm_offset = _values_shm_offset; + } + + void* Set( + void* cmd, GLuint _indx, uint32 _values_shm_id, + uint32 _values_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_indx, _values_shm_id, _values_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + uint32 values_shm_id; + uint32 values_shm_offset; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib3fv) == 16, + Sizeof_VertexAttrib3fv_is_not_16); +COMPILE_ASSERT(offsetof(VertexAttrib3fv, header) == 0, + OffsetOf_VertexAttrib3fv_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib3fv, indx) == 4, + OffsetOf_VertexAttrib3fv_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib3fv, values_shm_id) == 8, + OffsetOf_VertexAttrib3fv_values_shm_id_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib3fv, values_shm_offset) == 12, + OffsetOf_VertexAttrib3fv_values_shm_offset_not_12); + +struct VertexAttrib3fvImmediate { + typedef VertexAttrib3fvImmediate ValueType; + static const CommandId kCmdId = kVertexAttrib3fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize() { + return static_cast<uint32>( + sizeof(GLfloat) * 3); // NOLINT + } + + static uint32 ComputeSize() { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize()); // NOLINT + } + + void SetHeader() { + header.SetCmdByTotalSize<ValueType>(ComputeSize()); + } + + void Init(GLuint _indx, const GLfloat* _values) { + SetHeader(); + indx = _indx; + memcpy(ImmediateDataAddress(this), + _values, ComputeDataSize()); + } + + void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { + static_cast<ValueType*>(cmd)->Init(_indx, _values); + const uint32 size = ComputeSize(); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 indx; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib3fvImmediate) == 8, + Sizeof_VertexAttrib3fvImmediate_is_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, header) == 0, + OffsetOf_VertexAttrib3fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, indx) == 4, + OffsetOf_VertexAttrib3fvImmediate_indx_not_4); + +struct VertexAttrib4f { + typedef VertexAttrib4f ValueType; + static const CommandId kCmdId = kVertexAttrib4f; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) { + SetHeader(); + indx = _indx; + x = _x; + y = _y; + z = _z; + w = _w; + } + + void* Set( + void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, + GLfloat _w) { + static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + float x; + float y; + float z; + float w; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib4f) == 24, + Sizeof_VertexAttrib4f_is_not_24); +COMPILE_ASSERT(offsetof(VertexAttrib4f, header) == 0, + OffsetOf_VertexAttrib4f_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib4f, indx) == 4, + OffsetOf_VertexAttrib4f_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib4f, x) == 8, + OffsetOf_VertexAttrib4f_x_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib4f, y) == 12, + OffsetOf_VertexAttrib4f_y_not_12); +COMPILE_ASSERT(offsetof(VertexAttrib4f, z) == 16, + OffsetOf_VertexAttrib4f_z_not_16); +COMPILE_ASSERT(offsetof(VertexAttrib4f, w) == 20, + OffsetOf_VertexAttrib4f_w_not_20); + +struct VertexAttrib4fv { + typedef VertexAttrib4fv ValueType; + static const CommandId kCmdId = kVertexAttrib4fv; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLuint _indx, uint32 _values_shm_id, uint32 _values_shm_offset) { + SetHeader(); + indx = _indx; + values_shm_id = _values_shm_id; + values_shm_offset = _values_shm_offset; + } + + void* Set( + void* cmd, GLuint _indx, uint32 _values_shm_id, + uint32 _values_shm_offset) { + static_cast<ValueType*>( + cmd)->Init(_indx, _values_shm_id, _values_shm_offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + uint32 values_shm_id; + uint32 values_shm_offset; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib4fv) == 16, + Sizeof_VertexAttrib4fv_is_not_16); +COMPILE_ASSERT(offsetof(VertexAttrib4fv, header) == 0, + OffsetOf_VertexAttrib4fv_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib4fv, indx) == 4, + OffsetOf_VertexAttrib4fv_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttrib4fv, values_shm_id) == 8, + OffsetOf_VertexAttrib4fv_values_shm_id_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib4fv, values_shm_offset) == 12, + OffsetOf_VertexAttrib4fv_values_shm_offset_not_12); + +struct VertexAttrib4fvImmediate { + typedef VertexAttrib4fvImmediate ValueType; + static const CommandId kCmdId = kVertexAttrib4fvImmediate; + static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN; + + static uint32 ComputeDataSize() { + return static_cast<uint32>( + sizeof(GLfloat) * 4); // NOLINT + } + + static uint32 ComputeSize() { + return static_cast<uint32>( + sizeof(ValueType) + ComputeDataSize()); // NOLINT + } + + void SetHeader() { + header.SetCmdByTotalSize<ValueType>(ComputeSize()); + } + + void Init(GLuint _indx, const GLfloat* _values) { + SetHeader(); + indx = _indx; + memcpy(ImmediateDataAddress(this), + _values, ComputeDataSize()); + } + + void* Set(void* cmd, GLuint _indx, const GLfloat* _values) { + static_cast<ValueType*>(cmd)->Init(_indx, _values); + const uint32 size = ComputeSize(); + return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size); + } + + command_buffer::CommandHeader header; + uint32 indx; +}; + +COMPILE_ASSERT(sizeof(VertexAttrib4fvImmediate) == 8, + Sizeof_VertexAttrib4fvImmediate_is_not_8); +COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0, + OffsetOf_VertexAttrib4fvImmediate_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4, + OffsetOf_VertexAttrib4fvImmediate_indx_not_4); + +struct VertexAttribPointer { + typedef VertexAttribPointer ValueType; + static const CommandId kCmdId = kVertexAttribPointer; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init( + GLuint _indx, GLint _size, GLenum _type, GLboolean _normalized, + GLsizei _stride, GLuint _offset) { + SetHeader(); + indx = _indx; + size = _size; + type = _type; + normalized = _normalized; + stride = _stride; + offset = _offset; + } + + void* Set( + void* cmd, GLuint _indx, GLint _size, GLenum _type, GLboolean _normalized, + GLsizei _stride, GLuint _offset) { + static_cast<ValueType*>( + cmd)->Init(_indx, _size, _type, _normalized, _stride, _offset); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 indx; + uint32 size; + uint32 type; + uint32 normalized; + uint32 stride; + uint32 offset; +}; + +COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28, + Sizeof_VertexAttribPointer_is_not_28); +COMPILE_ASSERT(offsetof(VertexAttribPointer, header) == 0, + OffsetOf_VertexAttribPointer_header_not_0); +COMPILE_ASSERT(offsetof(VertexAttribPointer, indx) == 4, + OffsetOf_VertexAttribPointer_indx_not_4); +COMPILE_ASSERT(offsetof(VertexAttribPointer, size) == 8, + OffsetOf_VertexAttribPointer_size_not_8); +COMPILE_ASSERT(offsetof(VertexAttribPointer, type) == 12, + OffsetOf_VertexAttribPointer_type_not_12); +COMPILE_ASSERT(offsetof(VertexAttribPointer, normalized) == 16, + OffsetOf_VertexAttribPointer_normalized_not_16); +COMPILE_ASSERT(offsetof(VertexAttribPointer, stride) == 20, + OffsetOf_VertexAttribPointer_stride_not_20); +COMPILE_ASSERT(offsetof(VertexAttribPointer, offset) == 24, + OffsetOf_VertexAttribPointer_offset_not_24); + +struct Viewport { + typedef Viewport ValueType; + static const CommandId kCmdId = kViewport; + static const cmd::ArgFlags kArgFlags = cmd::kFixed; + + static uint32 ComputeSize() { + return static_cast<uint32>(sizeof(ValueType)); // NOLINT + } + + void SetHeader() { + header.SetCmd<ValueType>(); + } + + void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) { + SetHeader(); + x = _x; + y = _y; + width = _width; + height = _height; + } + + void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) { + static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height); + return NextCmdAddress<ValueType>(cmd); + } + + command_buffer::CommandHeader header; + uint32 x; + uint32 y; + uint32 width; + uint32 height; +}; + +COMPILE_ASSERT(sizeof(Viewport) == 20, + Sizeof_Viewport_is_not_20); +COMPILE_ASSERT(offsetof(Viewport, header) == 0, + OffsetOf_Viewport_header_not_0); +COMPILE_ASSERT(offsetof(Viewport, x) == 4, + OffsetOf_Viewport_x_not_4); +COMPILE_ASSERT(offsetof(Viewport, y) == 8, + OffsetOf_Viewport_y_not_8); +COMPILE_ASSERT(offsetof(Viewport, width) == 12, + OffsetOf_Viewport_width_not_12); +COMPILE_ASSERT(offsetof(Viewport, height) == 16, + OffsetOf_Viewport_height_not_16); + +} // namespace gles2 +} // namespace command_buffer + +#pragma pack(pop) + +#endif // O3D_SPUD_O3D_GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_format_test.cc b/o3d/gpu/command_buffer/common/gles2_cmd_format_test.cc new file mode 100644 index 0000000..ba4c51e --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_format_test.cc @@ -0,0 +1,17 @@ +// Copyright (c) 2006-2009 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. + +// This file contains unit tests for gles2 commmands + +#include "tests/common/win/testing_common.h" +#include "gpu/command_buffer/common/gles2_cmd_format.h" + +namespace command_buffer { +namespace gles2 { + +#include "gpu/command_buffer/common/gles2_cmd_format_test_autogen.h" + +} // namespace gles2 +} // namespace command_buffer + diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/o3d/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h new file mode 100644 index 0000000..331efec --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h @@ -0,0 +1,2750 @@ +// This file is auto-generated. DO NOT EDIT! + +// This file contains unit tests for gles2 commmands +// It is included by gles2_cmd_format_test.cc + +TEST(GLES2FormatTest, ActiveTexture) { + ActiveTexture cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(ActiveTexture::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.texture); +} + +TEST(GLES2FormatTest, AttachShader) { + AttachShader cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(AttachShader::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLuint>(12), cmd.shader); +} + +TEST(GLES2FormatTest, BindAttribLocation) { + BindAttribLocation cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLuint>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(BindAttribLocation::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLuint>(12), cmd.index); + EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.data_size); +} + +TEST(GLES2FormatTest, BindAttribLocationImmediate) { + int8 buf[256] = { 0, }; + BindAttribLocationImmediate& cmd = + *static_cast<BindAttribLocationImmediate*>(static_cast<void*>(&buf)); + static const char* const test_str = "test string"; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLuint>(12), + test_str); + EXPECT_EQ(BindAttribLocationImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + // NOLINT + RoundSizeToMultipleOfEntries(strlen(test_str)), + cmd.header.size * 4); + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLuint>(12), cmd.index); + // TODO(gman): check that string got copied. +} + +TEST(GLES2FormatTest, BindBuffer) { + BindBuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(BindBuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLuint>(12), cmd.buffer); +} + +TEST(GLES2FormatTest, BindFramebuffer) { + BindFramebuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(BindFramebuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLuint>(12), cmd.framebuffer); +} + +TEST(GLES2FormatTest, BindRenderbuffer) { + BindRenderbuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(BindRenderbuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLuint>(12), cmd.renderbuffer); +} + +TEST(GLES2FormatTest, BindTexture) { + BindTexture cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(BindTexture::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLuint>(12), cmd.texture); +} + +TEST(GLES2FormatTest, BlendColor) { + BlendColor cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLclampf>(11), + static_cast<GLclampf>(12), + static_cast<GLclampf>(13), + static_cast<GLclampf>(14)); + EXPECT_EQ(BlendColor::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLclampf>(11), cmd.red); + EXPECT_EQ(static_cast<GLclampf>(12), cmd.green); + EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue); + EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha); +} + +TEST(GLES2FormatTest, BlendEquation) { + BlendEquation cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(BlendEquation::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.mode); +} + +TEST(GLES2FormatTest, BlendEquationSeparate) { + BlendEquationSeparate cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12)); + EXPECT_EQ(BlendEquationSeparate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.modeRGB); + EXPECT_EQ(static_cast<GLenum>(12), cmd.modeAlpha); +} + +TEST(GLES2FormatTest, BlendFunc) { + BlendFunc cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12)); + EXPECT_EQ(BlendFunc::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.sfactor); + EXPECT_EQ(static_cast<GLenum>(12), cmd.dfactor); +} + +TEST(GLES2FormatTest, BlendFuncSeparate) { + BlendFuncSeparate cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLenum>(13), + static_cast<GLenum>(14)); + EXPECT_EQ(BlendFuncSeparate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.srcRGB); + EXPECT_EQ(static_cast<GLenum>(12), cmd.dstRGB); + EXPECT_EQ(static_cast<GLenum>(13), cmd.srcAlpha); + EXPECT_EQ(static_cast<GLenum>(14), cmd.dstAlpha); +} + +TEST(GLES2FormatTest, BufferData) { + BufferData cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLsizeiptr>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<GLenum>(15)); + EXPECT_EQ(BufferData::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLsizeiptr>(12), cmd.size); + EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset); + EXPECT_EQ(static_cast<GLenum>(15), cmd.usage); +} + +// TODO(gman): Implement test for BufferDataImmediate +TEST(GLES2FormatTest, BufferSubData) { + BufferSubData cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLintptr>(12), + static_cast<GLsizeiptr>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(BufferSubData::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLintptr>(12), cmd.offset); + EXPECT_EQ(static_cast<GLsizeiptr>(13), cmd.size); + EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.data_shm_offset); +} + +// TODO(gman): Implement test for BufferSubDataImmediate +TEST(GLES2FormatTest, CheckFramebufferStatus) { + CheckFramebufferStatus cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(CheckFramebufferStatus::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); +} + +TEST(GLES2FormatTest, Clear) { + Clear cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLbitfield>(11)); + EXPECT_EQ(Clear::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask); +} + +TEST(GLES2FormatTest, ClearColor) { + ClearColor cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLclampf>(11), + static_cast<GLclampf>(12), + static_cast<GLclampf>(13), + static_cast<GLclampf>(14)); + EXPECT_EQ(ClearColor::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLclampf>(11), cmd.red); + EXPECT_EQ(static_cast<GLclampf>(12), cmd.green); + EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue); + EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha); +} + +TEST(GLES2FormatTest, ClearDepthf) { + ClearDepthf cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLclampf>(11)); + EXPECT_EQ(ClearDepthf::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth); +} + +TEST(GLES2FormatTest, ClearStencil) { + ClearStencil cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11)); + EXPECT_EQ(ClearStencil::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.s); +} + +TEST(GLES2FormatTest, ColorMask) { + ColorMask cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLboolean>(11), + static_cast<GLboolean>(12), + static_cast<GLboolean>(13), + static_cast<GLboolean>(14)); + EXPECT_EQ(ColorMask::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLboolean>(11), cmd.red); + EXPECT_EQ(static_cast<GLboolean>(12), cmd.green); + EXPECT_EQ(static_cast<GLboolean>(13), cmd.blue); + EXPECT_EQ(static_cast<GLboolean>(14), cmd.alpha); +} + +TEST(GLES2FormatTest, CompileShader) { + CompileShader cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(CompileShader::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); +} + +TEST(GLES2FormatTest, CompressedTexImage2D) { + CompressedTexImage2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLenum>(13), + static_cast<GLsizei>(14), + static_cast<GLsizei>(15), + static_cast<GLint>(16), + static_cast<GLsizei>(17), + static_cast<uint32>(18), + static_cast<uint32>(19)); + EXPECT_EQ(CompressedTexImage2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLint>(12), cmd.level); + EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat); + EXPECT_EQ(static_cast<GLsizei>(14), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(15), cmd.height); + EXPECT_EQ(static_cast<GLint>(16), cmd.border); + EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize); + EXPECT_EQ(static_cast<uint32>(18), cmd.data_shm_id); + EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_offset); +} + +// TODO(gman): Implement test for CompressedTexImage2DImmediate +TEST(GLES2FormatTest, CompressedTexSubImage2D) { + CompressedTexSubImage2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLint>(13), + static_cast<GLint>(14), + static_cast<GLsizei>(15), + static_cast<GLsizei>(16), + static_cast<GLenum>(17), + static_cast<GLsizei>(18), + static_cast<uint32>(19), + static_cast<uint32>(20)); + EXPECT_EQ(CompressedTexSubImage2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLint>(12), cmd.level); + EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset); + EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset); + EXPECT_EQ(static_cast<GLsizei>(15), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(16), cmd.height); + EXPECT_EQ(static_cast<GLenum>(17), cmd.format); + EXPECT_EQ(static_cast<GLsizei>(18), cmd.imageSize); + EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id); + EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset); +} + +// TODO(gman): Implement test for CompressedTexSubImage2DImmediate +TEST(GLES2FormatTest, CopyTexImage2D) { + CopyTexImage2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLenum>(13), + static_cast<GLint>(14), + static_cast<GLint>(15), + static_cast<GLsizei>(16), + static_cast<GLsizei>(17), + static_cast<GLint>(18)); + EXPECT_EQ(CopyTexImage2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLint>(12), cmd.level); + EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat); + EXPECT_EQ(static_cast<GLint>(14), cmd.x); + EXPECT_EQ(static_cast<GLint>(15), cmd.y); + EXPECT_EQ(static_cast<GLsizei>(16), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(17), cmd.height); + EXPECT_EQ(static_cast<GLint>(18), cmd.border); +} + +TEST(GLES2FormatTest, CopyTexSubImage2D) { + CopyTexSubImage2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLint>(13), + static_cast<GLint>(14), + static_cast<GLint>(15), + static_cast<GLint>(16), + static_cast<GLsizei>(17), + static_cast<GLsizei>(18)); + EXPECT_EQ(CopyTexSubImage2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLint>(12), cmd.level); + EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset); + EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset); + EXPECT_EQ(static_cast<GLint>(15), cmd.x); + EXPECT_EQ(static_cast<GLint>(16), cmd.y); + EXPECT_EQ(static_cast<GLsizei>(17), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(18), cmd.height); +} + +TEST(GLES2FormatTest, CreateProgram) { + CreateProgram cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<uint32>(11)); + EXPECT_EQ(CreateProgram::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<uint32>(11), cmd.client_id); +} + +TEST(GLES2FormatTest, CreateShader) { + CreateShader cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<uint32>(12)); + EXPECT_EQ(CreateShader::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.type); + EXPECT_EQ(static_cast<uint32>(12), cmd.client_id); +} + +TEST(GLES2FormatTest, CullFace) { + CullFace cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(CullFace::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.mode); +} + +TEST(GLES2FormatTest, DeleteBuffers) { + DeleteBuffers cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(DeleteBuffers::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset); +} + +TEST(GLES2FormatTest, DeleteBuffersImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + DeleteBuffersImmediate& cmd = + *static_cast<DeleteBuffersImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(DeleteBuffersImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, DeleteFramebuffers) { + DeleteFramebuffers cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(DeleteFramebuffers::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset); +} + +TEST(GLES2FormatTest, DeleteFramebuffersImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + DeleteFramebuffersImmediate& cmd = + *static_cast<DeleteFramebuffersImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(DeleteFramebuffersImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, DeleteProgram) { + DeleteProgram cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(DeleteProgram::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); +} + +TEST(GLES2FormatTest, DeleteRenderbuffers) { + DeleteRenderbuffers cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(DeleteRenderbuffers::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset); +} + +TEST(GLES2FormatTest, DeleteRenderbuffersImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + DeleteRenderbuffersImmediate& cmd = + *static_cast<DeleteRenderbuffersImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(DeleteRenderbuffersImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, DeleteShader) { + DeleteShader cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(DeleteShader::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); +} + +TEST(GLES2FormatTest, DeleteTextures) { + DeleteTextures cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(DeleteTextures::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset); +} + +TEST(GLES2FormatTest, DeleteTexturesImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + DeleteTexturesImmediate& cmd = + *static_cast<DeleteTexturesImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(DeleteTexturesImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, DepthFunc) { + DepthFunc cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(DepthFunc::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.func); +} + +TEST(GLES2FormatTest, DepthMask) { + DepthMask cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLboolean>(11)); + EXPECT_EQ(DepthMask::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag); +} + +TEST(GLES2FormatTest, DepthRangef) { + DepthRangef cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLclampf>(11), + static_cast<GLclampf>(12)); + EXPECT_EQ(DepthRangef::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLclampf>(11), cmd.zNear); + EXPECT_EQ(static_cast<GLclampf>(12), cmd.zFar); +} + +TEST(GLES2FormatTest, DetachShader) { + DetachShader cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(DetachShader::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLuint>(12), cmd.shader); +} + +TEST(GLES2FormatTest, Disable) { + Disable cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(Disable::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.cap); +} + +TEST(GLES2FormatTest, DisableVertexAttribArray) { + DisableVertexAttribArray cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(DisableVertexAttribArray::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.index); +} + +TEST(GLES2FormatTest, DrawArrays) { + DrawArrays cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLsizei>(13)); + EXPECT_EQ(DrawArrays::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.mode); + EXPECT_EQ(static_cast<GLint>(12), cmd.first); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.count); +} + +TEST(GLES2FormatTest, DrawElements) { + DrawElements cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLsizei>(12), + static_cast<GLenum>(13), + static_cast<GLuint>(14)); + EXPECT_EQ(DrawElements::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.mode); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<GLenum>(13), cmd.type); + EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset); +} + +TEST(GLES2FormatTest, Enable) { + Enable cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(Enable::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.cap); +} + +TEST(GLES2FormatTest, EnableVertexAttribArray) { + EnableVertexAttribArray cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(EnableVertexAttribArray::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.index); +} + +TEST(GLES2FormatTest, Finish) { + Finish cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd); + EXPECT_EQ(Finish::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT +} + +TEST(GLES2FormatTest, Flush) { + Flush cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd); + EXPECT_EQ(Flush::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT +} + +TEST(GLES2FormatTest, FramebufferRenderbuffer) { + FramebufferRenderbuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLenum>(13), + static_cast<GLuint>(14)); + EXPECT_EQ(FramebufferRenderbuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment); + EXPECT_EQ(static_cast<GLenum>(13), cmd.renderbuffertarget); + EXPECT_EQ(static_cast<GLuint>(14), cmd.renderbuffer); +} + +TEST(GLES2FormatTest, FramebufferTexture2D) { + FramebufferTexture2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLenum>(13), + static_cast<GLuint>(14), + static_cast<GLint>(15)); + EXPECT_EQ(FramebufferTexture2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment); + EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget); + EXPECT_EQ(static_cast<GLuint>(14), cmd.texture); + EXPECT_EQ(static_cast<GLint>(15), cmd.level); +} + +TEST(GLES2FormatTest, FrontFace) { + FrontFace cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(FrontFace::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.mode); +} + +TEST(GLES2FormatTest, GenBuffers) { + GenBuffers cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GenBuffers::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset); +} + +TEST(GLES2FormatTest, GenBuffersImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + GenBuffersImmediate& cmd = + *static_cast<GenBuffersImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(GenBuffersImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, GenerateMipmap) { + GenerateMipmap cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(GenerateMipmap::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); +} + +TEST(GLES2FormatTest, GenFramebuffers) { + GenFramebuffers cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GenFramebuffers::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset); +} + +TEST(GLES2FormatTest, GenFramebuffersImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + GenFramebuffersImmediate& cmd = + *static_cast<GenFramebuffersImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(GenFramebuffersImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, GenRenderbuffers) { + GenRenderbuffers cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GenRenderbuffers::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset); +} + +TEST(GLES2FormatTest, GenRenderbuffersImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + GenRenderbuffersImmediate& cmd = + *static_cast<GenRenderbuffersImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(GenRenderbuffersImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, GenTextures) { + GenTextures cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GenTextures::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset); +} + +TEST(GLES2FormatTest, GenTexturesImmediate) { + static GLuint ids[] = { 12, 23, 34, }; + int8 buf[256] = { 0, }; + GenTexturesImmediate& cmd = + *static_cast<GenTexturesImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLsizei>(11), + ids); + EXPECT_EQ(GenTexturesImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(cmd.n * 4), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLsizei>(11), cmd.n); + // TODO(gman): Check that ids were inserted; +} + +TEST(GLES2FormatTest, GetActiveAttrib) { + GetActiveAttrib cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLuint>(12), + static_cast<GLsizei>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16), + static_cast<uint32>(17), + static_cast<uint32>(18), + static_cast<uint32>(19), + static_cast<uint32>(20), + static_cast<uint32>(21)); + EXPECT_EQ(GetActiveAttrib::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLuint>(12), cmd.index); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.bufsize); + EXPECT_EQ(static_cast<uint32>(14), cmd.length_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.length_shm_offset); + EXPECT_EQ(static_cast<uint32>(16), cmd.size_shm_id); + EXPECT_EQ(static_cast<uint32>(17), cmd.size_shm_offset); + EXPECT_EQ(static_cast<uint32>(18), cmd.type_shm_id); + EXPECT_EQ(static_cast<uint32>(19), cmd.type_shm_offset); + EXPECT_EQ(static_cast<uint32>(20), cmd.name_shm_id); + EXPECT_EQ(static_cast<uint32>(21), cmd.name_shm_offset); +} + +TEST(GLES2FormatTest, GetActiveUniform) { + GetActiveUniform cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLuint>(12), + static_cast<GLsizei>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16), + static_cast<uint32>(17), + static_cast<uint32>(18), + static_cast<uint32>(19), + static_cast<uint32>(20), + static_cast<uint32>(21)); + EXPECT_EQ(GetActiveUniform::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLuint>(12), cmd.index); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.bufsize); + EXPECT_EQ(static_cast<uint32>(14), cmd.length_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.length_shm_offset); + EXPECT_EQ(static_cast<uint32>(16), cmd.size_shm_id); + EXPECT_EQ(static_cast<uint32>(17), cmd.size_shm_offset); + EXPECT_EQ(static_cast<uint32>(18), cmd.type_shm_id); + EXPECT_EQ(static_cast<uint32>(19), cmd.type_shm_offset); + EXPECT_EQ(static_cast<uint32>(20), cmd.name_shm_id); + EXPECT_EQ(static_cast<uint32>(21), cmd.name_shm_offset); +} + +TEST(GLES2FormatTest, GetAttachedShaders) { + GetAttachedShaders cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16)); + EXPECT_EQ(GetAttachedShaders::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.maxcount); + EXPECT_EQ(static_cast<uint32>(13), cmd.count_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.count_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.shaders_shm_id); + EXPECT_EQ(static_cast<uint32>(16), cmd.shaders_shm_offset); +} + +TEST(GLES2FormatTest, GetAttribLocation) { + GetAttribLocation cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetAttribLocation::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<uint32>(12), cmd.name_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_offset); + EXPECT_EQ(static_cast<uint32>(14), cmd.data_size); +} + +TEST(GLES2FormatTest, GetAttribLocationImmediate) { + int8 buf[256] = { 0, }; + GetAttribLocationImmediate& cmd = + *static_cast<GetAttribLocationImmediate*>(static_cast<void*>(&buf)); + static const char* const test_str = "test string"; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + test_str); + EXPECT_EQ(GetAttribLocationImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + // NOLINT + RoundSizeToMultipleOfEntries(strlen(test_str)), + cmd.header.size * 4); + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + // TODO(gman): check that string got copied. +} + +TEST(GLES2FormatTest, GetBooleanv) { + GetBooleanv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GetBooleanv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.pname); + EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetBufferParameteriv) { + GetBufferParameteriv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetBufferParameteriv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetError) { + GetError cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<uint32>(11), + static_cast<uint32>(12)); + EXPECT_EQ(GetError::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<uint32>(11), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, GetFloatv) { + GetFloatv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GetFloatv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.pname); + EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetFramebufferAttachmentParameteriv) { + GetFramebufferAttachmentParameteriv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLenum>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(GetFramebufferAttachmentParameteriv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment); + EXPECT_EQ(static_cast<GLenum>(13), cmd.pname); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetIntegerv) { + GetIntegerv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(GetIntegerv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.pname); + EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetProgramiv) { + GetProgramiv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetProgramiv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetProgramInfoLog) { + GetProgramInfoLog cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16)); + EXPECT_EQ(GetProgramInfoLog::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.bufsize); + EXPECT_EQ(static_cast<uint32>(13), cmd.length_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.length_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.infolog_shm_id); + EXPECT_EQ(static_cast<uint32>(16), cmd.infolog_shm_offset); +} + +TEST(GLES2FormatTest, GetRenderbufferParameteriv) { + GetRenderbufferParameteriv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetRenderbufferParameteriv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetShaderiv) { + GetShaderiv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetShaderiv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetShaderInfoLog) { + GetShaderInfoLog cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16)); + EXPECT_EQ(GetShaderInfoLog::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.bufsize); + EXPECT_EQ(static_cast<uint32>(13), cmd.length_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.length_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.infolog_shm_id); + EXPECT_EQ(static_cast<uint32>(16), cmd.infolog_shm_offset); +} + +TEST(GLES2FormatTest, GetShaderPrecisionFormat) { + GetShaderPrecisionFormat cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16)); + EXPECT_EQ(GetShaderPrecisionFormat::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.shadertype); + EXPECT_EQ(static_cast<GLenum>(12), cmd.precisiontype); + EXPECT_EQ(static_cast<uint32>(13), cmd.range_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.range_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.precision_shm_id); + EXPECT_EQ(static_cast<uint32>(16), cmd.precision_shm_offset); +} + +TEST(GLES2FormatTest, GetShaderSource) { + GetShaderSource cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15), + static_cast<uint32>(16)); + EXPECT_EQ(GetShaderSource::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.bufsize); + EXPECT_EQ(static_cast<uint32>(13), cmd.length_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.length_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.source_shm_id); + EXPECT_EQ(static_cast<uint32>(16), cmd.source_shm_offset); +} + +TEST(GLES2FormatTest, GetString) { + GetString cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11)); + EXPECT_EQ(GetString::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.name); +} + +TEST(GLES2FormatTest, GetTexParameterfv) { + GetTexParameterfv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetTexParameterfv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetTexParameteriv) { + GetTexParameteriv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetTexParameteriv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetUniformfv) { + GetUniformfv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLint>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetUniformfv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLint>(12), cmd.location); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetUniformiv) { + GetUniformiv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLint>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetUniformiv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<GLint>(12), cmd.location); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetUniformLocation) { + GetUniformLocation cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetUniformLocation::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<uint32>(12), cmd.name_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_offset); + EXPECT_EQ(static_cast<uint32>(14), cmd.data_size); +} + +TEST(GLES2FormatTest, GetUniformLocationImmediate) { + int8 buf[256] = { 0, }; + GetUniformLocationImmediate& cmd = + *static_cast<GetUniformLocationImmediate*>(static_cast<void*>(&buf)); + static const char* const test_str = "test string"; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + test_str); + EXPECT_EQ(GetUniformLocationImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + // NOLINT + RoundSizeToMultipleOfEntries(strlen(test_str)), + cmd.header.size * 4); + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + // TODO(gman): check that string got copied. +} + +TEST(GLES2FormatTest, GetVertexAttribfv) { + GetVertexAttribfv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetVertexAttribfv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.index); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetVertexAttribiv) { + GetVertexAttribiv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetVertexAttribiv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.index); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, GetVertexAttribPointerv) { + GetVertexAttribPointerv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(GetVertexAttribPointerv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.index); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.pointer_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.pointer_shm_offset); +} + +TEST(GLES2FormatTest, Hint) { + Hint cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12)); + EXPECT_EQ(Hint::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.mode); +} + +TEST(GLES2FormatTest, IsBuffer) { + IsBuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsBuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, IsEnabled) { + IsEnabled cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsEnabled::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.cap); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, IsFramebuffer) { + IsFramebuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsFramebuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.framebuffer); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, IsProgram) { + IsProgram cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsProgram::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, IsRenderbuffer) { + IsRenderbuffer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsRenderbuffer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.renderbuffer); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, IsShader) { + IsShader cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsShader::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, IsTexture) { + IsTexture cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(IsTexture::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.texture); + EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset); +} + +TEST(GLES2FormatTest, LineWidth) { + LineWidth cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLfloat>(11)); + EXPECT_EQ(LineWidth::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLfloat>(11), cmd.width); +} + +TEST(GLES2FormatTest, LinkProgram) { + LinkProgram cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(LinkProgram::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); +} + +TEST(GLES2FormatTest, PixelStorei) { + PixelStorei cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12)); + EXPECT_EQ(PixelStorei::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.pname); + EXPECT_EQ(static_cast<GLint>(12), cmd.param); +} + +TEST(GLES2FormatTest, PolygonOffset) { + PolygonOffset cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLfloat>(11), + static_cast<GLfloat>(12)); + EXPECT_EQ(PolygonOffset::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLfloat>(11), cmd.factor); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.units); +} + +TEST(GLES2FormatTest, ReadPixels) { + ReadPixels cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12), + static_cast<GLsizei>(13), + static_cast<GLsizei>(14), + static_cast<GLenum>(15), + static_cast<GLenum>(16), + static_cast<uint32>(17), + static_cast<uint32>(18)); + EXPECT_EQ(ReadPixels::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.x); + EXPECT_EQ(static_cast<GLint>(12), cmd.y); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(14), cmd.height); + EXPECT_EQ(static_cast<GLenum>(15), cmd.format); + EXPECT_EQ(static_cast<GLenum>(16), cmd.type); + EXPECT_EQ(static_cast<uint32>(17), cmd.pixels_shm_id); + EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset); +} + +TEST(GLES2FormatTest, RenderbufferStorage) { + RenderbufferStorage cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLsizei>(13), + static_cast<GLsizei>(14)); + EXPECT_EQ(RenderbufferStorage::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(14), cmd.height); +} + +TEST(GLES2FormatTest, SampleCoverage) { + SampleCoverage cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLclampf>(11), + static_cast<GLboolean>(12)); + EXPECT_EQ(SampleCoverage::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLclampf>(11), cmd.value); + EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert); +} + +TEST(GLES2FormatTest, Scissor) { + Scissor cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12), + static_cast<GLsizei>(13), + static_cast<GLsizei>(14)); + EXPECT_EQ(Scissor::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.x); + EXPECT_EQ(static_cast<GLint>(12), cmd.y); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(14), cmd.height); +} + +TEST(GLES2FormatTest, ShaderSource) { + ShaderSource cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(ShaderSource::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.shader); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset); + EXPECT_EQ(static_cast<uint32>(15), cmd.data_size); +} + +// TODO(gman): Implement test for ShaderSourceImmediate +TEST(GLES2FormatTest, StencilFunc) { + StencilFunc cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLuint>(13)); + EXPECT_EQ(StencilFunc::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.func); + EXPECT_EQ(static_cast<GLint>(12), cmd.ref); + EXPECT_EQ(static_cast<GLuint>(13), cmd.mask); +} + +TEST(GLES2FormatTest, StencilFuncSeparate) { + StencilFuncSeparate cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLint>(13), + static_cast<GLuint>(14)); + EXPECT_EQ(StencilFuncSeparate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.face); + EXPECT_EQ(static_cast<GLenum>(12), cmd.func); + EXPECT_EQ(static_cast<GLint>(13), cmd.ref); + EXPECT_EQ(static_cast<GLuint>(14), cmd.mask); +} + +TEST(GLES2FormatTest, StencilMask) { + StencilMask cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(StencilMask::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.mask); +} + +TEST(GLES2FormatTest, StencilMaskSeparate) { + StencilMaskSeparate cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLuint>(12)); + EXPECT_EQ(StencilMaskSeparate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.face); + EXPECT_EQ(static_cast<GLuint>(12), cmd.mask); +} + +TEST(GLES2FormatTest, StencilOp) { + StencilOp cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLenum>(13)); + EXPECT_EQ(StencilOp::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.fail); + EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail); + EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass); +} + +TEST(GLES2FormatTest, StencilOpSeparate) { + StencilOpSeparate cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLenum>(13), + static_cast<GLenum>(14)); + EXPECT_EQ(StencilOpSeparate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.face); + EXPECT_EQ(static_cast<GLenum>(12), cmd.fail); + EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail); + EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass); +} + +TEST(GLES2FormatTest, TexImage2D) { + TexImage2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLint>(13), + static_cast<GLsizei>(14), + static_cast<GLsizei>(15), + static_cast<GLint>(16), + static_cast<GLenum>(17), + static_cast<GLenum>(18), + static_cast<uint32>(19), + static_cast<uint32>(20)); + EXPECT_EQ(TexImage2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLint>(12), cmd.level); + EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat); + EXPECT_EQ(static_cast<GLsizei>(14), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(15), cmd.height); + EXPECT_EQ(static_cast<GLint>(16), cmd.border); + EXPECT_EQ(static_cast<GLenum>(17), cmd.format); + EXPECT_EQ(static_cast<GLenum>(18), cmd.type); + EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id); + EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset); +} + +// TODO(gman): Implement test for TexImage2DImmediate +TEST(GLES2FormatTest, TexParameterf) { + TexParameterf cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLfloat>(13)); + EXPECT_EQ(TexParameterf::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.param); +} + +TEST(GLES2FormatTest, TexParameterfv) { + TexParameterfv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(TexParameterfv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, TexParameterfvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + }; + int8 buf[256] = { 0, }; + TexParameterfvImmediate& cmd = + *static_cast<TexParameterfvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + data); + EXPECT_EQ(TexParameterfvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, TexParameteri) { + TexParameteri cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<GLint>(13)); + EXPECT_EQ(TexParameteri::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<GLint>(13), cmd.param); +} + +TEST(GLES2FormatTest, TexParameteriv) { + TexParameteriv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(TexParameteriv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset); +} + +TEST(GLES2FormatTest, TexParameterivImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLint data[] = { + static_cast<GLint>(kSomeBaseValueToTestWith + 0), + }; + int8 buf[256] = { 0, }; + TexParameterivImmediate& cmd = + *static_cast<TexParameterivImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLenum>(12), + data); + EXPECT_EQ(TexParameterivImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLenum>(12), cmd.pname); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, TexSubImage2D) { + TexSubImage2D cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLenum>(11), + static_cast<GLint>(12), + static_cast<GLint>(13), + static_cast<GLint>(14), + static_cast<GLsizei>(15), + static_cast<GLsizei>(16), + static_cast<GLenum>(17), + static_cast<GLenum>(18), + static_cast<uint32>(19), + static_cast<uint32>(20)); + EXPECT_EQ(TexSubImage2D::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLenum>(11), cmd.target); + EXPECT_EQ(static_cast<GLint>(12), cmd.level); + EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset); + EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset); + EXPECT_EQ(static_cast<GLsizei>(15), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(16), cmd.height); + EXPECT_EQ(static_cast<GLenum>(17), cmd.format); + EXPECT_EQ(static_cast<GLenum>(18), cmd.type); + EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id); + EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset); +} + +// TODO(gman): Implement test for TexSubImage2DImmediate +TEST(GLES2FormatTest, Uniform1f) { + Uniform1f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLfloat>(12)); + EXPECT_EQ(Uniform1f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); +} + +TEST(GLES2FormatTest, Uniform1fv) { + Uniform1fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform1fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform1fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + }; + int8 buf[256] = { 0, }; + Uniform1fvImmediate& cmd = + *static_cast<Uniform1fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform1fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform1i) { + Uniform1i cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12)); + EXPECT_EQ(Uniform1i::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLint>(12), cmd.x); +} + +TEST(GLES2FormatTest, Uniform1iv) { + Uniform1iv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform1iv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform1ivImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLint data[] = { + static_cast<GLint>(kSomeBaseValueToTestWith + 0), + static_cast<GLint>(kSomeBaseValueToTestWith + 1), + }; + int8 buf[256] = { 0, }; + Uniform1ivImmediate& cmd = + *static_cast<Uniform1ivImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform1ivImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform2f) { + Uniform2f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLfloat>(12), + static_cast<GLfloat>(13)); + EXPECT_EQ(Uniform2f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.y); +} + +TEST(GLES2FormatTest, Uniform2fv) { + Uniform2fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform2fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform2fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + }; + int8 buf[256] = { 0, }; + Uniform2fvImmediate& cmd = + *static_cast<Uniform2fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform2fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform2i) { + Uniform2i cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12), + static_cast<GLint>(13)); + EXPECT_EQ(Uniform2i::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLint>(12), cmd.x); + EXPECT_EQ(static_cast<GLint>(13), cmd.y); +} + +TEST(GLES2FormatTest, Uniform2iv) { + Uniform2iv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform2iv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform2ivImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLint data[] = { + static_cast<GLint>(kSomeBaseValueToTestWith + 0), + static_cast<GLint>(kSomeBaseValueToTestWith + 1), + static_cast<GLint>(kSomeBaseValueToTestWith + 2), + static_cast<GLint>(kSomeBaseValueToTestWith + 3), + }; + int8 buf[256] = { 0, }; + Uniform2ivImmediate& cmd = + *static_cast<Uniform2ivImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform2ivImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform3f) { + Uniform3f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLfloat>(12), + static_cast<GLfloat>(13), + static_cast<GLfloat>(14)); + EXPECT_EQ(Uniform3f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.y); + EXPECT_EQ(static_cast<GLfloat>(14), cmd.z); +} + +TEST(GLES2FormatTest, Uniform3fv) { + Uniform3fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform3fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform3fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 4), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), + }; + int8 buf[256] = { 0, }; + Uniform3fvImmediate& cmd = + *static_cast<Uniform3fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform3fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform3i) { + Uniform3i cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12), + static_cast<GLint>(13), + static_cast<GLint>(14)); + EXPECT_EQ(Uniform3i::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLint>(12), cmd.x); + EXPECT_EQ(static_cast<GLint>(13), cmd.y); + EXPECT_EQ(static_cast<GLint>(14), cmd.z); +} + +TEST(GLES2FormatTest, Uniform3iv) { + Uniform3iv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform3iv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform3ivImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLint data[] = { + static_cast<GLint>(kSomeBaseValueToTestWith + 0), + static_cast<GLint>(kSomeBaseValueToTestWith + 1), + static_cast<GLint>(kSomeBaseValueToTestWith + 2), + static_cast<GLint>(kSomeBaseValueToTestWith + 3), + static_cast<GLint>(kSomeBaseValueToTestWith + 4), + static_cast<GLint>(kSomeBaseValueToTestWith + 5), + }; + int8 buf[256] = { 0, }; + Uniform3ivImmediate& cmd = + *static_cast<Uniform3ivImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform3ivImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform4f) { + Uniform4f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLfloat>(12), + static_cast<GLfloat>(13), + static_cast<GLfloat>(14), + static_cast<GLfloat>(15)); + EXPECT_EQ(Uniform4f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.y); + EXPECT_EQ(static_cast<GLfloat>(14), cmd.z); + EXPECT_EQ(static_cast<GLfloat>(15), cmd.w); +} + +TEST(GLES2FormatTest, Uniform4fv) { + Uniform4fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform4fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform4fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 4), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 6), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), + }; + int8 buf[256] = { 0, }; + Uniform4fvImmediate& cmd = + *static_cast<Uniform4fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform4fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, Uniform4i) { + Uniform4i cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12), + static_cast<GLint>(13), + static_cast<GLint>(14), + static_cast<GLint>(15)); + EXPECT_EQ(Uniform4i::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLint>(12), cmd.x); + EXPECT_EQ(static_cast<GLint>(13), cmd.y); + EXPECT_EQ(static_cast<GLint>(14), cmd.z); + EXPECT_EQ(static_cast<GLint>(15), cmd.w); +} + +TEST(GLES2FormatTest, Uniform4iv) { + Uniform4iv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<uint32>(13), + static_cast<uint32>(14)); + EXPECT_EQ(Uniform4iv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id); + EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset); +} + +TEST(GLES2FormatTest, Uniform4ivImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLint data[] = { + static_cast<GLint>(kSomeBaseValueToTestWith + 0), + static_cast<GLint>(kSomeBaseValueToTestWith + 1), + static_cast<GLint>(kSomeBaseValueToTestWith + 2), + static_cast<GLint>(kSomeBaseValueToTestWith + 3), + static_cast<GLint>(kSomeBaseValueToTestWith + 4), + static_cast<GLint>(kSomeBaseValueToTestWith + 5), + static_cast<GLint>(kSomeBaseValueToTestWith + 6), + static_cast<GLint>(kSomeBaseValueToTestWith + 7), + }; + int8 buf[256] = { 0, }; + Uniform4ivImmediate& cmd = + *static_cast<Uniform4ivImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + data); + EXPECT_EQ(Uniform4ivImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, UniformMatrix2fv) { + UniformMatrix2fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<GLboolean>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(UniformMatrix2fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose); + EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset); +} + +TEST(GLES2FormatTest, UniformMatrix2fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 4), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 6), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), + }; + int8 buf[256] = { 0, }; + UniformMatrix2fvImmediate& cmd = + *static_cast<UniformMatrix2fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + static_cast<GLboolean>(3), + data); + EXPECT_EQ(UniformMatrix2fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, UniformMatrix3fv) { + UniformMatrix3fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<GLboolean>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(UniformMatrix3fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose); + EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset); +} + +TEST(GLES2FormatTest, UniformMatrix3fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 4), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 6), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 8), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 9), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 10), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 11), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 12), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 13), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 14), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 15), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 16), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 17), + }; + int8 buf[256] = { 0, }; + UniformMatrix3fvImmediate& cmd = + *static_cast<UniformMatrix3fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + static_cast<GLboolean>(3), + data); + EXPECT_EQ(UniformMatrix3fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, UniformMatrix4fv) { + UniformMatrix4fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLsizei>(12), + static_cast<GLboolean>(13), + static_cast<uint32>(14), + static_cast<uint32>(15)); + EXPECT_EQ(UniformMatrix4fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(12), cmd.count); + EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose); + EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id); + EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset); +} + +TEST(GLES2FormatTest, UniformMatrix4fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 4), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 6), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 8), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 9), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 10), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 11), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 12), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 13), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 14), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 15), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 16), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 17), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 18), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 19), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 20), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 21), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 22), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 23), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 24), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 25), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 26), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 27), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 28), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 29), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 30), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 31), + }; + int8 buf[256] = { 0, }; + UniformMatrix4fvImmediate& cmd = + *static_cast<UniformMatrix4fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(1), + static_cast<GLsizei>(2), + static_cast<GLboolean>(3), + data); + EXPECT_EQ(UniformMatrix4fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(1), cmd.location); + EXPECT_EQ(static_cast<GLsizei>(2), cmd.count); + EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, UseProgram) { + UseProgram cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(UseProgram::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); +} + +TEST(GLES2FormatTest, ValidateProgram) { + ValidateProgram cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11)); + EXPECT_EQ(ValidateProgram::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.program); +} + +TEST(GLES2FormatTest, VertexAttrib1f) { + VertexAttrib1f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLfloat>(12)); + EXPECT_EQ(VertexAttrib1f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); +} + +TEST(GLES2FormatTest, VertexAttrib1fv) { + VertexAttrib1fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(VertexAttrib1fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset); +} + +TEST(GLES2FormatTest, VertexAttrib1fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + }; + int8 buf[256] = { 0, }; + VertexAttrib1fvImmediate& cmd = + *static_cast<VertexAttrib1fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + data); + EXPECT_EQ(VertexAttrib1fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, VertexAttrib2f) { + VertexAttrib2f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLfloat>(12), + static_cast<GLfloat>(13)); + EXPECT_EQ(VertexAttrib2f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.y); +} + +TEST(GLES2FormatTest, VertexAttrib2fv) { + VertexAttrib2fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(VertexAttrib2fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset); +} + +TEST(GLES2FormatTest, VertexAttrib2fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + }; + int8 buf[256] = { 0, }; + VertexAttrib2fvImmediate& cmd = + *static_cast<VertexAttrib2fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + data); + EXPECT_EQ(VertexAttrib2fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, VertexAttrib3f) { + VertexAttrib3f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLfloat>(12), + static_cast<GLfloat>(13), + static_cast<GLfloat>(14)); + EXPECT_EQ(VertexAttrib3f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.y); + EXPECT_EQ(static_cast<GLfloat>(14), cmd.z); +} + +TEST(GLES2FormatTest, VertexAttrib3fv) { + VertexAttrib3fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(VertexAttrib3fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset); +} + +TEST(GLES2FormatTest, VertexAttrib3fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + }; + int8 buf[256] = { 0, }; + VertexAttrib3fvImmediate& cmd = + *static_cast<VertexAttrib3fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + data); + EXPECT_EQ(VertexAttrib3fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, VertexAttrib4f) { + VertexAttrib4f cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLfloat>(12), + static_cast<GLfloat>(13), + static_cast<GLfloat>(14), + static_cast<GLfloat>(15)); + EXPECT_EQ(VertexAttrib4f::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<GLfloat>(12), cmd.x); + EXPECT_EQ(static_cast<GLfloat>(13), cmd.y); + EXPECT_EQ(static_cast<GLfloat>(14), cmd.z); + EXPECT_EQ(static_cast<GLfloat>(15), cmd.w); +} + +TEST(GLES2FormatTest, VertexAttrib4fv) { + VertexAttrib4fv cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<uint32>(12), + static_cast<uint32>(13)); + EXPECT_EQ(VertexAttrib4fv::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id); + EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset); +} + +TEST(GLES2FormatTest, VertexAttrib4fvImmediate) { + const int kSomeBaseValueToTestWith = 51; + static GLfloat data[] = { + static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), + static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), + }; + int8 buf[256] = { 0, }; + VertexAttrib4fvImmediate& cmd = + *static_cast<VertexAttrib4fvImmediate*>(static_cast<void*>(&buf)); + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + data); + EXPECT_EQ(VertexAttrib4fvImmediate::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd) + + RoundSizeToMultipleOfEntries(sizeof(data)), + cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + // TODO(gman): Check that data was inserted; +} + +TEST(GLES2FormatTest, VertexAttribPointer) { + VertexAttribPointer cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLuint>(11), + static_cast<GLint>(12), + static_cast<GLenum>(13), + static_cast<GLboolean>(14), + static_cast<GLsizei>(15), + static_cast<GLuint>(16)); + EXPECT_EQ(VertexAttribPointer::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLuint>(11), cmd.indx); + EXPECT_EQ(static_cast<GLint>(12), cmd.size); + EXPECT_EQ(static_cast<GLenum>(13), cmd.type); + EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized); + EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride); + EXPECT_EQ(static_cast<GLuint>(16), cmd.offset); +} + +TEST(GLES2FormatTest, Viewport) { + Viewport cmd = { 0, }; + void* next_cmd = cmd.Set( + &cmd, + static_cast<GLint>(11), + static_cast<GLint>(12), + static_cast<GLsizei>(13), + static_cast<GLsizei>(14)); + EXPECT_EQ(Viewport::kCmdId, cmd.header.command); + EXPECT_EQ(sizeof(cmd), cmd.header.size * 4); // NOLINT + EXPECT_EQ(static_cast<GLint>(11), cmd.x); + EXPECT_EQ(static_cast<GLint>(12), cmd.y); + EXPECT_EQ(static_cast<GLsizei>(13), cmd.width); + EXPECT_EQ(static_cast<GLsizei>(14), cmd.height); +} + diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_id_test.cc b/o3d/gpu/command_buffer/common/gles2_cmd_id_test.cc new file mode 100644 index 0000000..8bcb00b --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_id_test.cc @@ -0,0 +1,368 @@ +// Copyright (c) 2006-2008 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. +// This file contains unit tests for gles2 commmand ids + +#include "tests/common/win/testing_common.h" +#include "gpu/command_buffer/common/gles2_cmd_format.h" + +namespace command_buffer { +namespace gles2 { + +// *** These IDs MUST NOT CHANGE!!! *** +// Changing them will break all client programs. +TEST(GLES2CommandIdTest, CommandIdsMatch) { + COMPILE_ASSERT(ActiveTexture::kCmdId == 1024, + GLES2_ActiveTexture_kCmdId_mismatch); + COMPILE_ASSERT(AttachShader::kCmdId == 1025, + GLES2_AttachShader_kCmdId_mismatch); + COMPILE_ASSERT(BindAttribLocation::kCmdId == 1026, + GLES2_BindAttribLocation_kCmdId_mismatch); + COMPILE_ASSERT(BindAttribLocationImmediate::kCmdId == 1027, + GLES2_BindAttribLocationImmediate_kCmdId_mismatch); + COMPILE_ASSERT(BindBuffer::kCmdId == 1028, + GLES2_BindBuffer_kCmdId_mismatch); + COMPILE_ASSERT(BindFramebuffer::kCmdId == 1029, + GLES2_BindFramebuffer_kCmdId_mismatch); + COMPILE_ASSERT(BindRenderbuffer::kCmdId == 1030, + GLES2_BindRenderbuffer_kCmdId_mismatch); + COMPILE_ASSERT(BindTexture::kCmdId == 1031, + GLES2_BindTexture_kCmdId_mismatch); + COMPILE_ASSERT(BlendColor::kCmdId == 1032, + GLES2_BlendColor_kCmdId_mismatch); + COMPILE_ASSERT(BlendEquation::kCmdId == 1033, + GLES2_BlendEquation_kCmdId_mismatch); + COMPILE_ASSERT(BlendEquationSeparate::kCmdId == 1034, + GLES2_BlendEquationSeparate_kCmdId_mismatch); + COMPILE_ASSERT(BlendFunc::kCmdId == 1035, + GLES2_BlendFunc_kCmdId_mismatch); + COMPILE_ASSERT(BlendFuncSeparate::kCmdId == 1036, + GLES2_BlendFuncSeparate_kCmdId_mismatch); + COMPILE_ASSERT(BufferData::kCmdId == 1037, + GLES2_BufferData_kCmdId_mismatch); + COMPILE_ASSERT(BufferDataImmediate::kCmdId == 1038, + GLES2_BufferDataImmediate_kCmdId_mismatch); + COMPILE_ASSERT(BufferSubData::kCmdId == 1039, + GLES2_BufferSubData_kCmdId_mismatch); + COMPILE_ASSERT(BufferSubDataImmediate::kCmdId == 1040, + GLES2_BufferSubDataImmediate_kCmdId_mismatch); + COMPILE_ASSERT(CheckFramebufferStatus::kCmdId == 1041, + GLES2_CheckFramebufferStatus_kCmdId_mismatch); + COMPILE_ASSERT(Clear::kCmdId == 1042, + GLES2_Clear_kCmdId_mismatch); + COMPILE_ASSERT(ClearColor::kCmdId == 1043, + GLES2_ClearColor_kCmdId_mismatch); + COMPILE_ASSERT(ClearDepthf::kCmdId == 1044, + GLES2_ClearDepthf_kCmdId_mismatch); + COMPILE_ASSERT(ClearStencil::kCmdId == 1045, + GLES2_ClearStencil_kCmdId_mismatch); + COMPILE_ASSERT(ColorMask::kCmdId == 1046, + GLES2_ColorMask_kCmdId_mismatch); + COMPILE_ASSERT(CompileShader::kCmdId == 1047, + GLES2_CompileShader_kCmdId_mismatch); + COMPILE_ASSERT(CompressedTexImage2D::kCmdId == 1048, + GLES2_CompressedTexImage2D_kCmdId_mismatch); + COMPILE_ASSERT(CompressedTexImage2DImmediate::kCmdId == 1049, + GLES2_CompressedTexImage2DImmediate_kCmdId_mismatch); + COMPILE_ASSERT(CompressedTexSubImage2D::kCmdId == 1050, + GLES2_CompressedTexSubImage2D_kCmdId_mismatch); + COMPILE_ASSERT(CompressedTexSubImage2DImmediate::kCmdId == 1051, + GLES2_CompressedTexSubImage2DImmediate_kCmdId_mismatch); + COMPILE_ASSERT(CopyTexImage2D::kCmdId == 1052, + GLES2_CopyTexImage2D_kCmdId_mismatch); + COMPILE_ASSERT(CopyTexSubImage2D::kCmdId == 1053, + GLES2_CopyTexSubImage2D_kCmdId_mismatch); + COMPILE_ASSERT(CreateProgram::kCmdId == 1054, + GLES2_CreateProgram_kCmdId_mismatch); + COMPILE_ASSERT(CreateShader::kCmdId == 1055, + GLES2_CreateShader_kCmdId_mismatch); + COMPILE_ASSERT(CullFace::kCmdId == 1056, + GLES2_CullFace_kCmdId_mismatch); + COMPILE_ASSERT(DeleteBuffers::kCmdId == 1057, + GLES2_DeleteBuffers_kCmdId_mismatch); + COMPILE_ASSERT(DeleteBuffersImmediate::kCmdId == 1058, + GLES2_DeleteBuffersImmediate_kCmdId_mismatch); + COMPILE_ASSERT(DeleteFramebuffers::kCmdId == 1059, + GLES2_DeleteFramebuffers_kCmdId_mismatch); + COMPILE_ASSERT(DeleteFramebuffersImmediate::kCmdId == 1060, + GLES2_DeleteFramebuffersImmediate_kCmdId_mismatch); + COMPILE_ASSERT(DeleteProgram::kCmdId == 1061, + GLES2_DeleteProgram_kCmdId_mismatch); + COMPILE_ASSERT(DeleteRenderbuffers::kCmdId == 1062, + GLES2_DeleteRenderbuffers_kCmdId_mismatch); + COMPILE_ASSERT(DeleteRenderbuffersImmediate::kCmdId == 1063, + GLES2_DeleteRenderbuffersImmediate_kCmdId_mismatch); + COMPILE_ASSERT(DeleteShader::kCmdId == 1064, + GLES2_DeleteShader_kCmdId_mismatch); + COMPILE_ASSERT(DeleteTextures::kCmdId == 1065, + GLES2_DeleteTextures_kCmdId_mismatch); + COMPILE_ASSERT(DeleteTexturesImmediate::kCmdId == 1066, + GLES2_DeleteTexturesImmediate_kCmdId_mismatch); + COMPILE_ASSERT(DepthFunc::kCmdId == 1067, + GLES2_DepthFunc_kCmdId_mismatch); + COMPILE_ASSERT(DepthMask::kCmdId == 1068, + GLES2_DepthMask_kCmdId_mismatch); + COMPILE_ASSERT(DepthRangef::kCmdId == 1069, + GLES2_DepthRangef_kCmdId_mismatch); + COMPILE_ASSERT(DetachShader::kCmdId == 1070, + GLES2_DetachShader_kCmdId_mismatch); + COMPILE_ASSERT(Disable::kCmdId == 1071, + GLES2_Disable_kCmdId_mismatch); + COMPILE_ASSERT(DisableVertexAttribArray::kCmdId == 1072, + GLES2_DisableVertexAttribArray_kCmdId_mismatch); + COMPILE_ASSERT(DrawArrays::kCmdId == 1073, + GLES2_DrawArrays_kCmdId_mismatch); + COMPILE_ASSERT(DrawElements::kCmdId == 1074, + GLES2_DrawElements_kCmdId_mismatch); + COMPILE_ASSERT(Enable::kCmdId == 1075, + GLES2_Enable_kCmdId_mismatch); + COMPILE_ASSERT(EnableVertexAttribArray::kCmdId == 1076, + GLES2_EnableVertexAttribArray_kCmdId_mismatch); + COMPILE_ASSERT(Finish::kCmdId == 1077, + GLES2_Finish_kCmdId_mismatch); + COMPILE_ASSERT(Flush::kCmdId == 1078, + GLES2_Flush_kCmdId_mismatch); + COMPILE_ASSERT(FramebufferRenderbuffer::kCmdId == 1079, + GLES2_FramebufferRenderbuffer_kCmdId_mismatch); + COMPILE_ASSERT(FramebufferTexture2D::kCmdId == 1080, + GLES2_FramebufferTexture2D_kCmdId_mismatch); + COMPILE_ASSERT(FrontFace::kCmdId == 1081, + GLES2_FrontFace_kCmdId_mismatch); + COMPILE_ASSERT(GenBuffers::kCmdId == 1082, + GLES2_GenBuffers_kCmdId_mismatch); + COMPILE_ASSERT(GenBuffersImmediate::kCmdId == 1083, + GLES2_GenBuffersImmediate_kCmdId_mismatch); + COMPILE_ASSERT(GenerateMipmap::kCmdId == 1084, + GLES2_GenerateMipmap_kCmdId_mismatch); + COMPILE_ASSERT(GenFramebuffers::kCmdId == 1085, + GLES2_GenFramebuffers_kCmdId_mismatch); + COMPILE_ASSERT(GenFramebuffersImmediate::kCmdId == 1086, + GLES2_GenFramebuffersImmediate_kCmdId_mismatch); + COMPILE_ASSERT(GenRenderbuffers::kCmdId == 1087, + GLES2_GenRenderbuffers_kCmdId_mismatch); + COMPILE_ASSERT(GenRenderbuffersImmediate::kCmdId == 1088, + GLES2_GenRenderbuffersImmediate_kCmdId_mismatch); + COMPILE_ASSERT(GenTextures::kCmdId == 1089, + GLES2_GenTextures_kCmdId_mismatch); + COMPILE_ASSERT(GenTexturesImmediate::kCmdId == 1090, + GLES2_GenTexturesImmediate_kCmdId_mismatch); + COMPILE_ASSERT(GetActiveAttrib::kCmdId == 1091, + GLES2_GetActiveAttrib_kCmdId_mismatch); + COMPILE_ASSERT(GetActiveUniform::kCmdId == 1092, + GLES2_GetActiveUniform_kCmdId_mismatch); + COMPILE_ASSERT(GetAttachedShaders::kCmdId == 1093, + GLES2_GetAttachedShaders_kCmdId_mismatch); + COMPILE_ASSERT(GetAttribLocation::kCmdId == 1094, + GLES2_GetAttribLocation_kCmdId_mismatch); + COMPILE_ASSERT(GetAttribLocationImmediate::kCmdId == 1095, + GLES2_GetAttribLocationImmediate_kCmdId_mismatch); + COMPILE_ASSERT(GetBooleanv::kCmdId == 1096, + GLES2_GetBooleanv_kCmdId_mismatch); + COMPILE_ASSERT(GetBufferParameteriv::kCmdId == 1097, + GLES2_GetBufferParameteriv_kCmdId_mismatch); + COMPILE_ASSERT(GetError::kCmdId == 1098, + GLES2_GetError_kCmdId_mismatch); + COMPILE_ASSERT(GetFloatv::kCmdId == 1099, + GLES2_GetFloatv_kCmdId_mismatch); + COMPILE_ASSERT(GetFramebufferAttachmentParameteriv::kCmdId == 1100, + GLES2_GetFramebufferAttachmentParameteriv_kCmdId_mismatch); + COMPILE_ASSERT(GetIntegerv::kCmdId == 1101, + GLES2_GetIntegerv_kCmdId_mismatch); + COMPILE_ASSERT(GetProgramiv::kCmdId == 1102, + GLES2_GetProgramiv_kCmdId_mismatch); + COMPILE_ASSERT(GetProgramInfoLog::kCmdId == 1103, + GLES2_GetProgramInfoLog_kCmdId_mismatch); + COMPILE_ASSERT(GetRenderbufferParameteriv::kCmdId == 1104, + GLES2_GetRenderbufferParameteriv_kCmdId_mismatch); + COMPILE_ASSERT(GetShaderiv::kCmdId == 1105, + GLES2_GetShaderiv_kCmdId_mismatch); + COMPILE_ASSERT(GetShaderInfoLog::kCmdId == 1106, + GLES2_GetShaderInfoLog_kCmdId_mismatch); + COMPILE_ASSERT(GetShaderPrecisionFormat::kCmdId == 1107, + GLES2_GetShaderPrecisionFormat_kCmdId_mismatch); + COMPILE_ASSERT(GetShaderSource::kCmdId == 1108, + GLES2_GetShaderSource_kCmdId_mismatch); + COMPILE_ASSERT(GetString::kCmdId == 1109, + GLES2_GetString_kCmdId_mismatch); + COMPILE_ASSERT(GetTexParameterfv::kCmdId == 1110, + GLES2_GetTexParameterfv_kCmdId_mismatch); + COMPILE_ASSERT(GetTexParameteriv::kCmdId == 1111, + GLES2_GetTexParameteriv_kCmdId_mismatch); + COMPILE_ASSERT(GetUniformfv::kCmdId == 1112, + GLES2_GetUniformfv_kCmdId_mismatch); + COMPILE_ASSERT(GetUniformiv::kCmdId == 1113, + GLES2_GetUniformiv_kCmdId_mismatch); + COMPILE_ASSERT(GetUniformLocation::kCmdId == 1114, + GLES2_GetUniformLocation_kCmdId_mismatch); + COMPILE_ASSERT(GetUniformLocationImmediate::kCmdId == 1115, + GLES2_GetUniformLocationImmediate_kCmdId_mismatch); + COMPILE_ASSERT(GetVertexAttribfv::kCmdId == 1116, + GLES2_GetVertexAttribfv_kCmdId_mismatch); + COMPILE_ASSERT(GetVertexAttribiv::kCmdId == 1117, + GLES2_GetVertexAttribiv_kCmdId_mismatch); + COMPILE_ASSERT(GetVertexAttribPointerv::kCmdId == 1118, + GLES2_GetVertexAttribPointerv_kCmdId_mismatch); + COMPILE_ASSERT(Hint::kCmdId == 1119, + GLES2_Hint_kCmdId_mismatch); + COMPILE_ASSERT(IsBuffer::kCmdId == 1120, + GLES2_IsBuffer_kCmdId_mismatch); + COMPILE_ASSERT(IsEnabled::kCmdId == 1121, + GLES2_IsEnabled_kCmdId_mismatch); + COMPILE_ASSERT(IsFramebuffer::kCmdId == 1122, + GLES2_IsFramebuffer_kCmdId_mismatch); + COMPILE_ASSERT(IsProgram::kCmdId == 1123, + GLES2_IsProgram_kCmdId_mismatch); + COMPILE_ASSERT(IsRenderbuffer::kCmdId == 1124, + GLES2_IsRenderbuffer_kCmdId_mismatch); + COMPILE_ASSERT(IsShader::kCmdId == 1125, + GLES2_IsShader_kCmdId_mismatch); + COMPILE_ASSERT(IsTexture::kCmdId == 1126, + GLES2_IsTexture_kCmdId_mismatch); + COMPILE_ASSERT(LineWidth::kCmdId == 1127, + GLES2_LineWidth_kCmdId_mismatch); + COMPILE_ASSERT(LinkProgram::kCmdId == 1128, + GLES2_LinkProgram_kCmdId_mismatch); + COMPILE_ASSERT(PixelStorei::kCmdId == 1129, + GLES2_PixelStorei_kCmdId_mismatch); + COMPILE_ASSERT(PolygonOffset::kCmdId == 1130, + GLES2_PolygonOffset_kCmdId_mismatch); + COMPILE_ASSERT(ReadPixels::kCmdId == 1131, + GLES2_ReadPixels_kCmdId_mismatch); + COMPILE_ASSERT(RenderbufferStorage::kCmdId == 1132, + GLES2_RenderbufferStorage_kCmdId_mismatch); + COMPILE_ASSERT(SampleCoverage::kCmdId == 1133, + GLES2_SampleCoverage_kCmdId_mismatch); + COMPILE_ASSERT(Scissor::kCmdId == 1134, + GLES2_Scissor_kCmdId_mismatch); + COMPILE_ASSERT(ShaderSource::kCmdId == 1135, + GLES2_ShaderSource_kCmdId_mismatch); + COMPILE_ASSERT(ShaderSourceImmediate::kCmdId == 1136, + GLES2_ShaderSourceImmediate_kCmdId_mismatch); + COMPILE_ASSERT(StencilFunc::kCmdId == 1137, + GLES2_StencilFunc_kCmdId_mismatch); + COMPILE_ASSERT(StencilFuncSeparate::kCmdId == 1138, + GLES2_StencilFuncSeparate_kCmdId_mismatch); + COMPILE_ASSERT(StencilMask::kCmdId == 1139, + GLES2_StencilMask_kCmdId_mismatch); + COMPILE_ASSERT(StencilMaskSeparate::kCmdId == 1140, + GLES2_StencilMaskSeparate_kCmdId_mismatch); + COMPILE_ASSERT(StencilOp::kCmdId == 1141, + GLES2_StencilOp_kCmdId_mismatch); + COMPILE_ASSERT(StencilOpSeparate::kCmdId == 1142, + GLES2_StencilOpSeparate_kCmdId_mismatch); + COMPILE_ASSERT(TexImage2D::kCmdId == 1143, + GLES2_TexImage2D_kCmdId_mismatch); + COMPILE_ASSERT(TexImage2DImmediate::kCmdId == 1144, + GLES2_TexImage2DImmediate_kCmdId_mismatch); + COMPILE_ASSERT(TexParameterf::kCmdId == 1145, + GLES2_TexParameterf_kCmdId_mismatch); + COMPILE_ASSERT(TexParameterfv::kCmdId == 1146, + GLES2_TexParameterfv_kCmdId_mismatch); + COMPILE_ASSERT(TexParameterfvImmediate::kCmdId == 1147, + GLES2_TexParameterfvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(TexParameteri::kCmdId == 1148, + GLES2_TexParameteri_kCmdId_mismatch); + COMPILE_ASSERT(TexParameteriv::kCmdId == 1149, + GLES2_TexParameteriv_kCmdId_mismatch); + COMPILE_ASSERT(TexParameterivImmediate::kCmdId == 1150, + GLES2_TexParameterivImmediate_kCmdId_mismatch); + COMPILE_ASSERT(TexSubImage2D::kCmdId == 1151, + GLES2_TexSubImage2D_kCmdId_mismatch); + COMPILE_ASSERT(TexSubImage2DImmediate::kCmdId == 1152, + GLES2_TexSubImage2DImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform1f::kCmdId == 1153, + GLES2_Uniform1f_kCmdId_mismatch); + COMPILE_ASSERT(Uniform1fv::kCmdId == 1154, + GLES2_Uniform1fv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform1fvImmediate::kCmdId == 1155, + GLES2_Uniform1fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform1i::kCmdId == 1156, + GLES2_Uniform1i_kCmdId_mismatch); + COMPILE_ASSERT(Uniform1iv::kCmdId == 1157, + GLES2_Uniform1iv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform1ivImmediate::kCmdId == 1158, + GLES2_Uniform1ivImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform2f::kCmdId == 1159, + GLES2_Uniform2f_kCmdId_mismatch); + COMPILE_ASSERT(Uniform2fv::kCmdId == 1160, + GLES2_Uniform2fv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform2fvImmediate::kCmdId == 1161, + GLES2_Uniform2fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform2i::kCmdId == 1162, + GLES2_Uniform2i_kCmdId_mismatch); + COMPILE_ASSERT(Uniform2iv::kCmdId == 1163, + GLES2_Uniform2iv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform2ivImmediate::kCmdId == 1164, + GLES2_Uniform2ivImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform3f::kCmdId == 1165, + GLES2_Uniform3f_kCmdId_mismatch); + COMPILE_ASSERT(Uniform3fv::kCmdId == 1166, + GLES2_Uniform3fv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform3fvImmediate::kCmdId == 1167, + GLES2_Uniform3fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform3i::kCmdId == 1168, + GLES2_Uniform3i_kCmdId_mismatch); + COMPILE_ASSERT(Uniform3iv::kCmdId == 1169, + GLES2_Uniform3iv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform3ivImmediate::kCmdId == 1170, + GLES2_Uniform3ivImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform4f::kCmdId == 1171, + GLES2_Uniform4f_kCmdId_mismatch); + COMPILE_ASSERT(Uniform4fv::kCmdId == 1172, + GLES2_Uniform4fv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform4fvImmediate::kCmdId == 1173, + GLES2_Uniform4fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(Uniform4i::kCmdId == 1174, + GLES2_Uniform4i_kCmdId_mismatch); + COMPILE_ASSERT(Uniform4iv::kCmdId == 1175, + GLES2_Uniform4iv_kCmdId_mismatch); + COMPILE_ASSERT(Uniform4ivImmediate::kCmdId == 1176, + GLES2_Uniform4ivImmediate_kCmdId_mismatch); + COMPILE_ASSERT(UniformMatrix2fv::kCmdId == 1177, + GLES2_UniformMatrix2fv_kCmdId_mismatch); + COMPILE_ASSERT(UniformMatrix2fvImmediate::kCmdId == 1178, + GLES2_UniformMatrix2fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(UniformMatrix3fv::kCmdId == 1179, + GLES2_UniformMatrix3fv_kCmdId_mismatch); + COMPILE_ASSERT(UniformMatrix3fvImmediate::kCmdId == 1180, + GLES2_UniformMatrix3fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(UniformMatrix4fv::kCmdId == 1181, + GLES2_UniformMatrix4fv_kCmdId_mismatch); + COMPILE_ASSERT(UniformMatrix4fvImmediate::kCmdId == 1182, + GLES2_UniformMatrix4fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(UseProgram::kCmdId == 1183, + GLES2_UseProgram_kCmdId_mismatch); + COMPILE_ASSERT(ValidateProgram::kCmdId == 1184, + GLES2_ValidateProgram_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib1f::kCmdId == 1185, + GLES2_VertexAttrib1f_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib1fv::kCmdId == 1186, + GLES2_VertexAttrib1fv_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib1fvImmediate::kCmdId == 1187, + GLES2_VertexAttrib1fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib2f::kCmdId == 1188, + GLES2_VertexAttrib2f_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib2fv::kCmdId == 1189, + GLES2_VertexAttrib2fv_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib2fvImmediate::kCmdId == 1190, + GLES2_VertexAttrib2fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib3f::kCmdId == 1191, + GLES2_VertexAttrib3f_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib3fv::kCmdId == 1192, + GLES2_VertexAttrib3fv_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib3fvImmediate::kCmdId == 1193, + GLES2_VertexAttrib3fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib4f::kCmdId == 1194, + GLES2_VertexAttrib4f_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib4fv::kCmdId == 1195, + GLES2_VertexAttrib4fv_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttrib4fvImmediate::kCmdId == 1196, + GLES2_VertexAttrib4fvImmediate_kCmdId_mismatch); + COMPILE_ASSERT(VertexAttribPointer::kCmdId == 1197, + GLES2_VertexAttribPointer_kCmdId_mismatch); + COMPILE_ASSERT(Viewport::kCmdId == 1198, + GLES2_Viewport_kCmdId_mismatch); +} +} // namespace gles2 +} // namespace command_buffer + diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_utils.cc b/o3d/gpu/command_buffer/common/gles2_cmd_utils.cc new file mode 100644 index 0000000..eb5b95b --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_utils.cc @@ -0,0 +1,347 @@ +// Copyright (c) 2006-2009 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. + +// This file is here so other GLES2 related files can have a common set of +// includes where appropriate. + +#include "gpu/command_buffer/common/gles2_cmd_utils.h" + +namespace command_buffer { +namespace gles2 { + +GLsizei GLES2Util::GLGetNumValuesReturned(GLenum id) const { + switch (id) { + // -- glGetBooleanv, glGetFloatv, glGetIntergerv + case GL_ACTIVE_TEXTURE: + return 1; + case GL_ALIASED_LINE_WIDTH_RANGE: + return 2; + case GL_ALIASED_POINT_SIZE_RANGE: + return 1; + case GL_ALPHA_BITS: + return 1; + case GL_ARRAY_BUFFER_BINDING: + return 1; + case GL_BLEND: + return 1; + case GL_BLEND_COLOR: + return 4; + case GL_BLEND_DST_ALPHA: + return 1; + case GL_BLEND_DST_RGB: + return 1; + case GL_BLEND_EQUATION_ALPHA: + return 1; + case GL_BLEND_EQUATION_RGB: + return 1; + case GL_BLEND_SRC_ALPHA: + return 1; + case GL_BLEND_SRC_RGB: + return 1; + case GL_BLUE_BITS: + return 1; + case GL_COLOR_CLEAR_VALUE: + return 4; + case GL_COLOR_WRITEMASK: + return 4; + case GL_COMPRESSED_TEXTURE_FORMATS: + return num_compressed_texture_formats_; + case GL_CULL_FACE: + return 1; + case GL_CULL_FACE_MODE: + return 1; + case GL_CURRENT_PROGRAM: + return 1; + case GL_DEPTH_BITS: + return 1; + case GL_DEPTH_CLEAR_VALUE: + return 1; + case GL_DEPTH_FUNC: + return 1; + case GL_DEPTH_RANGE: + return 2; + case GL_DEPTH_TEST: + return 1; + case GL_DEPTH_WRITEMASK: + return 1; + case GL_DITHER: + return 1; + case GL_ELEMENT_ARRAY_BUFFER_BINDING: + return 1; + case GL_FRAMEBUFFER_BINDING: + return 1; + case GL_FRONT_FACE: + return 1; + case GL_GENERATE_MIPMAP_HINT: + return 1; + case GL_GREEN_BITS: + return 1; + case GL_IMPLEMENTATION_COLOR_READ_FORMAT: + return 1; + case GL_IMPLEMENTATION_COLOR_READ_TYPE: + return 1; + case GL_LINE_WIDTH: + return 1; + case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: + return 1; + case GL_MAX_CUBE_MAP_TEXTURE_SIZE: + return 1; + case GL_MAX_FRAGMENT_UNIFORM_VECTORS: + return 1; + case GL_MAX_RENDERBUFFER_SIZE: + return 1; + case GL_MAX_TEXTURE_IMAGE_UNITS: + return 1; + case GL_MAX_TEXTURE_SIZE: + return 1; + case GL_MAX_VARYING_VECTORS: + return 1; + case GL_MAX_VERTEX_ATTRIBS: + return 1; + case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: + return 1; + case GL_MAX_VERTEX_UNIFORM_VECTORS: + return 1; + case GL_MAX_VIEWPORT_DIMS: + return 2; + case GL_NUM_COMPRESSED_TEXTURE_FORMATS: + return 1; + case GL_PACK_ALIGNMENT: + return 1; + case GL_POLYGON_OFFSET_FACTOR: + return 1; + case GL_POLYGON_OFFSET_FILL: + return 1; + case GL_POLYGON_OFFSET_UNITS: + return 1; + case GL_RED_BITS: + return 1; + case GL_RENDERBUFFER_BINDING: + return 1; + case GL_SAMPLE_BUFFERS: + return 1; + case GL_SAMPLE_COVERAGE_INVERT: + return 1; + case GL_SAMPLE_COVERAGE_VALUE: + return 1; + case GL_SAMPLES: + return 1; + case GL_SCISSOR_BOX: + return 4; + case GL_SCISSOR_TEST: + return 1; + case GL_SHADER_COMPILER: + return 1; + case GL_STENCIL_BACK_FAIL: + return 1; + case GL_STENCIL_BACK_FUNC: + return 1; + case GL_STENCIL_BACK_PASS_DEPTH_FAIL: + return 1; + case GL_STENCIL_BACK_PASS_DEPTH_PASS: + return 1; + case GL_STENCIL_BACK_REF: + return 1; + case GL_STENCIL_BACK_VALUE_MASK: + return 1; + case GL_STENCIL_BACK_WRITEMASK: + return 1; + case GL_STENCIL_BITS: + return 1; + case GL_STENCIL_CLEAR_VALUE: + return 1; + case GL_STENCIL_FAIL: + return 1; + case GL_STENCIL_FUNC: + return 1; + case GL_STENCIL_PASS_DEPTH_FAIL: + return 1; + case GL_STENCIL_PASS_DEPTH_PASS: + return 1; + case GL_STENCIL_REF: + return 1; + case GL_STENCIL_TEST: + return 1; + case GL_STENCIL_VALUE_MASK: + return 1; + case GL_STENCIL_WRITEMASK: + return 1; + case GL_SUBPIXEL_BITS: + return 1; + case GL_TEXTURE_BINDING_2D: + return 1; + case GL_TEXTURE_BINDING_CUBE_MAP: + return 1; + case GL_UNPACK_ALIGNMENT: + return 1; + case GL_VIEWPORT: + return 4; + + // -- glGetBufferParameteriv + case GL_BUFFER_SIZE: + return 1; + case GL_BUFFER_USAGE: + return 1; + + // -- glGetFramebufferAttachmentParameteriv + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: + return 1; + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: + return 1; + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: + return 1; + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: + return 1; + + // -- glGetFramebufferAttachmentParameteriv + case GL_DELETE_STATUS: + return 1; + case GL_LINK_STATUS: + return 1; + case GL_VALIDATE_STATUS: + return 1; + case GL_INFO_LOG_LENGTH: + return 1; + case GL_ATTACHED_SHADERS: + return 1; + case GL_ACTIVE_ATTRIBUTES: + return 1; + case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: + return 1; + case GL_ACTIVE_UNIFORMS: + return 1; + case GL_ACTIVE_UNIFORM_MAX_LENGTH: + return 1; + + + // -- glGetRenderbufferAttachmentParameteriv + case GL_RENDERBUFFER_WIDTH: + return 1; + case GL_RENDERBUFFER_HEIGHT: + return 1; + case GL_RENDERBUFFER_INTERNAL_FORMAT: + return 1; + case GL_RENDERBUFFER_RED_SIZE: + return 1; + case GL_RENDERBUFFER_GREEN_SIZE: + return 1; + case GL_RENDERBUFFER_BLUE_SIZE: + return 1; + case GL_RENDERBUFFER_ALPHA_SIZE: + return 1; + case GL_RENDERBUFFER_DEPTH_SIZE: + return 1; + case GL_RENDERBUFFER_STENCIL_SIZE: + return 1; + + // -- glGetShaderiv + case GL_SHADER_TYPE: + return 1; + // Already defined under glGetFramebufferAttachemntParameteriv. + // case GL_DELETE_STATUS: + // return 1; + case GL_COMPILE_STATUS: + return 1; + // Already defined under glGetFramebufferAttachemntParameteriv. + // case GL_INFO_LOG_LENGTH: + // return 1; + case GL_SHADER_SOURCE_LENGTH: + return 1; + + // -- glGetTexParameterfv, glGetTexParameteriv + case GL_TEXTURE_MAG_FILTER: + return 1; + case GL_TEXTURE_MIN_FILTER: + return 1; + case GL_TEXTURE_WRAP_S: + return 1; + case GL_TEXTURE_WRAP_T: + return 1; + + // -- glGetVertexAttribfv, glGetVertexAttribiv + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: + return 1; + case GL_VERTEX_ATTRIB_ARRAY_ENABLED: + return 1; + case GL_VERTEX_ATTRIB_ARRAY_SIZE: + return 1; + case GL_VERTEX_ATTRIB_ARRAY_STRIDE: + return 1; + case GL_VERTEX_ATTRIB_ARRAY_TYPE: + return 1; + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED: + return 1; + case GL_CURRENT_VERTEX_ATTRIB: + return 4; + + // bad enum + default: + return 0; + } +} + +namespace { + +// Return the number of elements per group of a specified format. +GLint ElementsPerGroup(GLenum format, GLenum type) { + switch (type) { + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_5_5_1: + return 1; + default: + break; + } + + switch (format) { + case GL_RGB: + return 3; + case GL_LUMINANCE_ALPHA: + return 2; + case GL_RGBA: + return 4; + case GL_ALPHA: + case GL_LUMINANCE: + return 1; + default: + return 0; + } +} + +// Return the number of bytes per element, based on the element type. +GLint BytesPerElement(GLenum type) { + switch (type) { + case GL_UNSIGNED_SHORT: + case GL_SHORT: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_5_5_1: + return 2; + case GL_UNSIGNED_BYTE: + case GL_BYTE: + return 1; + default: + return 0; + } +} + +} // anonymous namespace + +// Returns the amount of data glTexImage2D or glTexSubImage2D will access. +uint32 GLES2Util::ComputeImageDataSize( + GLsizei width, GLsizei height, GLenum format, GLenum type, + GLint unpack_alignment) { + uint32 bytes_per_group = BytesPerElement(ElementsPerGroup(format, type)); + uint32 row_size = width * bytes_per_group; + if (height > 1) { + uint32 padded_row_size = ((row_size + unpack_alignment - 1) / + unpack_alignment) * unpack_alignment; + return height - 1 * padded_row_size + row_size; + } + return height * row_size; +} + +} // namespace gles2 +} // namespace command_buffer + diff --git a/o3d/gpu/command_buffer/common/gles2_cmd_utils.h b/o3d/gpu/command_buffer/common/gles2_cmd_utils.h new file mode 100644 index 0000000..0e6b2f2 --- /dev/null +++ b/o3d/gpu/command_buffer/common/gles2_cmd_utils.h @@ -0,0 +1,52 @@ +// Copyright (c) 2006-2009 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. + +// This file is here so other GLES2 related files can have a common set of +// includes where appropriate. + +#ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_UTILS_H +#define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_UTILS_H + +// The GPU Service needs to include the OS's GL headers. +#ifdef GPU_SERVICE +#include <GL/glew.h> +#if defined(OS_WIN) +#include <GL/wglew.h> +#endif +#else +#include <GLES2/gl2.h> +#endif +#include "base/basictypes.h" +#include "gpu/command_buffer/common/types.h" +#include "gpu/command_buffer/common/bitfield_helpers.h" + +namespace command_buffer { +namespace gles2 { + +// Utilties for GLES2 support. +class GLES2Util { + public: + explicit GLES2Util( + GLsizei num_compressed_texture_formats) + : num_compressed_texture_formats_(num_compressed_texture_formats) { + } + + // Gets the number of values a particular id will return when a glGet + // function is called. If 0 is returned the id is invalid. + GLsizei GLGetNumValuesReturned(GLenum id) const; + + // Computes the size of image data for TexImage2D and TexSubImage2D. + static uint32 GLES2Util::ComputeImageDataSize( + GLsizei width, GLsizei height, GLenum format, GLenum type, + GLint unpack_alignment); + + private: + GLsizei num_compressed_texture_formats_; +}; + +} // namespace gles2 +} // namespace command_buffer + +#endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_UTILS_H + diff --git a/o3d/gpu/command_buffer/service/gles2_cmd_decoder.cc b/o3d/gpu/command_buffer/service/gles2_cmd_decoder.cc new file mode 100644 index 0000000..4881dff --- /dev/null +++ b/o3d/gpu/command_buffer/service/gles2_cmd_decoder.cc @@ -0,0 +1,344 @@ +// Copyright (c) 2006-2009 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. + +#include <vector> +#include <string> +#include "gpu/command_buffer/service/gles2_cmd_decoder.h" +#include "gpu/command_buffer/common/gles2_cmd_format.h" +#include "gpu/command_buffer/service/cmd_buffer_engine.h" + +namespace command_buffer { +namespace gles2 { + +bool IdMap::AddMapping(GLuint client_id, GLuint service_id) { + std::pair<MapType::iterator, bool> result = id_map_.insert( + std::make_pair(client_id, service_id)); + return result.second; +} + +bool IdMap::RemoveMapping(GLuint client_id, GLuint service_id) { + MapType::iterator iter = id_map_.find(client_id); + if (iter != id_map_.end() && iter->second == service_id) { + id_map_.erase(iter); + return true; + } + return false; +} + +bool IdMap::GetServiceId(GLuint client_id, GLuint* service_id) { + DCHECK(service_id); + MapType::iterator iter = id_map_.find(client_id); + if (iter != id_map_.end()) { + *service_id = iter->second; + return true; + } + return false; +} + +bool IdMap::GetClientId(GLuint service_id, GLuint* client_id) { + DCHECK(client_id); + MapType::iterator end(id_map_.end()); + for (MapType::iterator iter(id_map_.begin()); + iter != end; + ++iter) { + if (iter->second == service_id) { + *client_id = iter->first; + return true; + } + } + return false; +} + +namespace { + +// Returns the address of the first byte after a struct. +template <typename T> +const void* AddressAfterStruct(const T& pod) { + return reinterpret_cast<const uint8*>(&pod) + sizeof(pod); +} + +// Returns the address of the frst byte after the struct. +template <typename RETURN_TYPE, typename COMMAND_TYPE> +RETURN_TYPE GetImmediateDataAs(const COMMAND_TYPE& pod) { + return static_cast<RETURN_TYPE>(const_cast<void*>(AddressAfterStruct(pod))); +} + +// Returns the size in bytes of the data of an Immediate command, a command with +// its data inline in the command buffer. +template <typename T> +unsigned int ImmediateDataSize(uint32 arg_count) { + return static_cast<unsigned int>( + (arg_count + 1 - ComputeNumEntries(sizeof(T))) * + sizeof(CommandBufferEntry)); // NOLINT +} + +// Checks if there is enough immediate data. +template<typename T> +bool CheckImmediateDataSize( + unsigned int arg_count, + GLuint count, + size_t size, + unsigned int elements_per_unit) { + return ImmediateDataSize<T>(arg_count) == count * size * elements_per_unit; +} + +// A struct to hold info about each command. +struct CommandInfo { + int arg_flags; // How to handle the arguments for this command + int arg_count; // How many arguments are expected for this command. +}; + +// A table of CommandInfo for all the commands. +const CommandInfo g_command_info[] = { + #define GLES2_CMD_OP(name) { \ + name::kArgFlags, \ + sizeof(name) / sizeof(CommandBufferEntry) - 1, }, /* NOLINT */ \ + + GLES2_COMMAND_LIST(GLES2_CMD_OP) + + #undef GLES2_CMD_OP +}; + +// These commands convert from c calls to local os calls. +void GLGenBuffersHelper(GLsizei n, GLuint* ids) { + glGenBuffers(n, ids); +} + +void GLGenFramebuffersHelper(GLsizei n, GLuint* ids) { + glGenFramebuffers(n, ids); +} + +void GLGenRenderbuffersHelper(GLsizei n, GLuint* ids) { + glGenRenderbuffers(n, ids); +} + +void GLGenTexturesHelper(GLsizei n, GLuint* ids) { + glGenTextures(n, ids); +} + +void GLDeleteBuffersHelper(GLsizei n, GLuint* ids) { + glDeleteBuffers(n, ids); +} + +void GLDeleteFramebuffersHelper(GLsizei n, GLuint* ids) { + glDeleteFramebuffers(n, ids); +} + +void GLDeleteRenderbuffersHelper(GLsizei n, GLuint* ids) { + glDeleteRenderbuffers(n, ids); +} + +void GLDeleteTexturesHelper(GLsizei n, GLuint* ids) { + glDeleteTextures(n, ids); +} + +} // anonymous namespace. + +GLES2Decoder::GLES2Decoder() + : util_(0), // TODO(gman): Set to actual num compress texture formats. + pack_alignment_(4), + unpack_alignment_(4), + bound_array_buffer_(0), + bound_element_array_buffer_(0) { +} + +// Decode command with its arguments, and call the corresponding GAPIInterface +// method. +// Note: args is a pointer to the command buffer. As such, it could be changed +// by a (malicious) client at any time, so if validation has to happen, it +// should operate on a copy of them. +parse_error::ParseError GLES2Decoder::DoCommand( + unsigned int command, + unsigned int arg_count, + const void* cmd_data) { + unsigned int command_index = command - kStartPoint - 1; + if (command_index < arraysize(g_command_info)) { + const CommandInfo& info = g_command_info[command_index]; + unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count); + if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) || + (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) { + switch (command) { + #define GLES2_CMD_OP(name) \ + case name::kCmdId: \ + return Handle ## name( \ + arg_count, \ + *static_cast<const name*>(cmd_data)); \ + + GLES2_COMMAND_LIST(GLES2_CMD_OP) + + #undef GLES2_CMD_OP + } + } else { + return parse_error::kParseInvalidArguments; + } + } + return DoCommonCommand(command, arg_count, cmd_data); +} + +} // namespace gles2 +} // namespace command_buffer + +// This is included so the compiler will make these inline. +#include "gpu/command_buffer/service/gles2_cmd_decoder_validate.h" + +namespace command_buffer { +namespace gles2 { + +void GLES2Decoder::CreateProgramHelper(GLuint client_id) { + // TODO(gman): verify client_id is unused. + GLuint service_id = glCreateProgram(); + if (service_id) { + id_map_.AddMapping(client_id, service_id); + } +} + +void GLES2Decoder::CreateShaderHelper(GLenum type, GLuint client_id) { + // TODO(gman): verify client_id is unused. + GLuint service_id = glCreateShader(type); + if (service_id) { + id_map_.AddMapping(client_id, service_id); + } +} + +void GLES2Decoder::DoBindBuffer(GLenum target, GLuint buffer) { + switch (target) { + case GL_ARRAY_BUFFER: + bound_array_buffer_ = buffer; + break; + case GL_ELEMENT_ARRAY_BUFFER: + bound_element_array_buffer_ = buffer; + break; + default: + break; + } + glBindBuffer(target, buffer); +} + +void GLES2Decoder::DoDeleteProgram(GLuint program) { + GLuint service_id; + if (id_map_.GetServiceId(program, &service_id)) { + glDeleteProgram(service_id); + id_map_.RemoveMapping(program, service_id); + } +} + +void GLES2Decoder::DoDeleteShader(GLuint shader) { + GLuint service_id; + if (id_map_.GetServiceId(shader, &service_id)) { + glDeleteProgram(service_id); + id_map_.RemoveMapping(shader, service_id); + } +} + +parse_error::ParseError GLES2Decoder::HandleDrawElements( + unsigned int arg_count, const gles2::DrawElements& c) { + if (bound_element_array_buffer_ != 0) { + GLenum mode = c.mode; + GLsizei count = c.count; + GLenum type = c.type; + const GLvoid* indices = reinterpret_cast<const GLvoid*>(c.index_offset); + glDrawElements(mode, count, type, indices); + } else { + // TODO(gman): set our wrapped glGetError value to GL_INVALID_VALUE + DCHECK(false); + } + return parse_error::kParseNoError; +} + +namespace { + +// Calls glShaderSource for the various versions of the ShaderSource command. +// Assumes that data / data_size points to a piece of memory that is in range +// of whatever context it came from (shared memory, immediate memory, bucket +// memory.) +parse_error::ParseError ShaderSourceHelper( + GLuint shader, GLsizei count, const char* data, uint32 data_size) { + std::vector<std::string> strings(count); + scoped_array<const char*> string_pointers(new const char* [count]); + + const uint32* ends = reinterpret_cast<const uint32*>(data); + uint32 start_offset = count * sizeof(*ends); + if (start_offset > data_size) { + return parse_error::kParseOutOfBounds; + } + for (GLsizei ii = 0; ii < count; ++ii) { + uint32 end_offset = ends[ii]; + if (end_offset > data_size || end_offset < start_offset) { + return parse_error::kParseOutOfBounds; + } + strings[ii] = std::string(data + start_offset, end_offset - start_offset); + string_pointers[ii] = strings[ii].c_str(); + } + + glShaderSource(shader, count, string_pointers.get(), NULL); + return parse_error::kParseNoError; +} + +} // anonymous namespace. + +parse_error::ParseError GLES2Decoder::HandleShaderSource( + unsigned int arg_count, const gles2::ShaderSource& c) { + GLuint shader = c.shader; + GLsizei count = c.count; + uint32 data_size = c.data_size; + const char** data = GetSharedMemoryAs<const char**>( + c.data_shm_id, c.data_shm_offset, data_size); + parse_error::ParseError result = + ValidateShaderSource(this, arg_count, shader, count, data, NULL); + if (result != parse_error::kParseNoError) { + return result; + } + return ShaderSourceHelper( + shader, count, reinterpret_cast<const char*>(data), data_size); +} + +parse_error::ParseError GLES2Decoder::HandleShaderSourceImmediate( + unsigned int arg_count, const gles2::ShaderSourceImmediate& c) { + GLuint shader = c.shader; + GLsizei count = c.count; + uint32 data_size = c.data_size; + // TODO(gman): need to check that data_size is in range for arg_count. + const char** data = GetImmediateDataAs<const char**>(c); + parse_error::ParseError result = + ValidateShaderSourceImmediate( + this, arg_count, shader, count, data, NULL); + if (result != parse_error::kParseNoError) { + return result; + } + return ShaderSourceHelper( + shader, count, reinterpret_cast<const char*>(data), data_size); +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttribPointer( + unsigned int arg_count, const gles2::VertexAttribPointer& c) { + if (bound_array_buffer_ != 0) { + GLuint indx = c.indx; + GLint size = c.size; + GLenum type = c.type; + GLboolean normalized = c.normalized; + GLsizei stride = c.stride; + GLuint offset = c.offset; + const void* ptr = reinterpret_cast<const void*>(c.offset); + parse_error::ParseError result = + ValidateVertexAttribPointer( + this, arg_count, indx, size, type, normalized, stride, ptr); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttribPointer(indx, size, type, normalized, stride, ptr); + } else { + // TODO(gman): set our wrapped glGetError value to GL_INVALID_VALUE + DCHECK(false); + } + return parse_error::kParseNoError; +} + +// Include the auto-generated part of this file. We split this because it means +// we can easily edit the non-auto generated parts right here in this file +// instead of having to edit some template or the code generator. +#include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h" + +} // namespace gles2 +} // namespace command_buffer + diff --git a/o3d/gpu/command_buffer/service/gles2_cmd_decoder.h b/o3d/gpu/command_buffer/service/gles2_cmd_decoder.h new file mode 100644 index 0000000..72afe06 --- /dev/null +++ b/o3d/gpu/command_buffer/service/gles2_cmd_decoder.h @@ -0,0 +1,162 @@ +// Copyright (c) 2006-2009 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. + +// This file contains the GLES2Decoder class. + +#ifndef O3D_COMMAND_BUFFER_SERVICE_CROSS_GLES2_CMD_DECODER_H +#define O3D_COMMAND_BUFFER_SERVICE_CROSS_GLES2_CMD_DECODER_H + +#include <map> +#include "base/scoped_ptr.h" +#include "gpu/command_buffer/common/gles2_cmd_utils.h" +#include "gpu/command_buffer/common/gles2_cmd_format.h" +#include "gpu/command_buffer/service/common_decoder.h" + +namespace command_buffer { +namespace gles2 { + +// This class maps one set of ids to another. +class IdMap { + public: + // Maps a client_id to a service_id. Return false if the client_id or + // service_id are already mapped to something else. + bool AddMapping(GLuint client_id, GLuint service_id); + + // Unmaps a pair of ids. Returns false if the pair were not previously mapped. + bool RemoveMapping(GLuint client_id, GLuint service_id); + + // Gets the corresponding service_id for the given client_id. + // Returns false if there is no corresponding service_id. + bool GetServiceId(GLuint client_id, GLuint* service_id); + + // Gets the corresponding client_id for the given service_id. + // Returns false if there is no corresponding client_id. + bool GetClientId(GLuint service_id, GLuint* client_id); + + private: + // TODO(gman): Replace with faster implementation. + typedef std::map<GLuint, GLuint> MapType; + MapType id_map_; +}; + +// This class implements the AsyncAPIInterface interface, decoding GAPI +// commands and sending them to a GAPI interface. +class GLES2Decoder : public CommonDecoder { + public: + typedef parse_error::ParseError ParseError; + + GLES2Decoder(); + virtual ~GLES2Decoder() { + } + + // Overridden from AsyncAPIInterface. + virtual ParseError DoCommand(unsigned int command, + unsigned int arg_count, + const void* args); + + // Overridden from AsyncAPIInterface. + virtual const char* GetCommandName(unsigned int command_id); + + private: + // Gets the address of shared memory. + // Parameters: + // shm_id: the id of the shared memory buffer. + // offset: the offset of the data in the shared memory buffer. + // size: size of area to get. + // Returns: + // NULL if shm_id isn't a valid shared memory buffer ID or if the offset is + // outside or if the offset + size are outside. + void* GetSharedMemory(unsigned int shm_id, unsigned int offset, + unsigned int size); + + // Typed version of GetSharedMemory + template <typename T> + T GetSharedMemoryAs(unsigned int shm_id, unsigned int offset, + unsigned int size) { + return static_cast<T>(GetSharedMemory(shm_id, offset, size)); + } + + // Template to help call glGenXXX functions. + template <void gl_gen_function(GLsizei, GLuint*)> + bool GenGLObjects(GLsizei n, const GLuint* client_ids) { + // TODO(gman): Verify client ids are unused. + scoped_array<GLuint>temp(new GLuint[n]); + gl_gen_function(n, temp.get()); + // TODO(gman): check for success before copying results. + for (GLsizei ii = 0; ii < n; ++ii) { + if (!id_map_.AddMapping(client_ids[ii], temp[ii])) { + // TODO(gman): fail. + } + } + return true; + } + + // Template to help call glDeleteXXX functions. + template <void gl_delete_function(GLsizei, GLuint*)> + bool DeleteGLObjects(GLsizei n, const GLuint* client_ids) { + scoped_array<GLuint>temp(new GLuint[n]); + // TODO(gman): check for success before copying results. + for (GLsizei ii = 0; ii < n; ++ii) { + if (id_map_.GetServiceId(client_ids[ii], &temp[ii])) { + id_map_.RemoveMapping(client_ids[ii], temp[ii]); + } else { + temp[ii] = 0; + } + } + gl_delete_function(n, temp.get()); + return true; + } + + // Wrapper for glCreateProgram + void CreateProgramHelper(GLuint client_id); + + // Wrapper for glCreateShader + void CreateShaderHelper(GLenum type, GLuint client_id); + + // Wrapper for glBindBuffer since we need to track the current targets. + void DoBindBuffer(GLenum target, GLuint buffer); + + // Wrapper for glDeleteProgram. + void DoDeleteProgram(GLuint program); + + // Wrapper for glDeleteShader. + void DoDeleteShader(GLuint shader); + + // Generate a member function prototype for each command in an automated and + // typesafe way. + #define GLES2_CMD_OP(name) \ + ParseError Handle ## name( \ + unsigned int arg_count, \ + const gles2::name& args); \ + + GLES2_COMMAND_LIST(GLES2_CMD_OP) + + #undef GLES2_CMD_OP + + // Map of client ids to GL ids. + IdMap id_map_; + GLES2Util util_; + + // pack alignment as last set by glPixelStorei + GLint pack_alignment_; + + // unpack alignment as last set by glPixelStorei + GLint unpack_alignment_; + + // The currently bound array buffer. If this is 0 it is illegal to call + // glVertexAttribPointer. + GLuint bound_array_buffer_; + + // The currently bound element array buffer. If this is 0 it is illegal + // to call glDrawElements. + GLuint bound_element_array_buffer_; + + DISALLOW_COPY_AND_ASSIGN(GLES2Decoder); +}; + +} // namespace gles2 +} // namespace command_buffer + +#endif // O3D_COMMAND_BUFFER_SERVICE_CROSS_GLES2_CMD_DECODER_H + diff --git a/o3d/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/o3d/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h new file mode 100644 index 0000000..399f6ce --- /dev/null +++ b/o3d/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h @@ -0,0 +1,2462 @@ +// This file is auto-generated. DO NOT EDIT! + +// It is included by gles2_cmd_decoder.cc + +parse_error::ParseError GLES2Decoder::HandleActiveTexture( + unsigned int arg_count, const gles2::ActiveTexture& c) { + GLenum texture = static_cast<GLenum>(c.texture); + parse_error::ParseError result = + ValidateActiveTexture(this, arg_count, texture); + if (result != parse_error::kParseNoError) { + return result; + } + glActiveTexture(texture); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleAttachShader( + unsigned int arg_count, const gles2::AttachShader& c) { + GLuint program = static_cast<GLuint>(c.program); + GLuint shader = static_cast<GLuint>(c.shader); + parse_error::ParseError result = + ValidateAttachShader(this, arg_count, program, shader); + if (result != parse_error::kParseNoError) { + return result; + } + glAttachShader(program, shader); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBindAttribLocation( + unsigned int arg_count, const gles2::BindAttribLocation& c) { + GLuint program = static_cast<GLuint>(c.program); + GLuint index = static_cast<GLuint>(c.index); + uint32 name_size = c.data_size; + const char* name = GetSharedMemoryAs<const char*>( + c.name_shm_id, c.name_shm_offset, name_size); + parse_error::ParseError result = + ValidateBindAttribLocation(this, arg_count, program, index, name); + if (result != parse_error::kParseNoError) { + return result; + } + String name_str(name, name_size); + glBindAttribLocation(program, index, name_str.c_str()); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBindAttribLocationImmediate( + unsigned int arg_count, const gles2::BindAttribLocationImmediate& c) { + GLuint program = static_cast<GLuint>(c.program); + GLuint index = static_cast<GLuint>(c.index); + uint32 name_size = c.data_size; + const char* name = GetImmediateDataAs<const char*>(c); + // TODO(gman): Make sure validate checks arg_count + // covers data_size. + parse_error::ParseError result = + ValidateBindAttribLocationImmediate( + this, arg_count, program, index, name); + if (result != parse_error::kParseNoError) { + return result; + } + String name_str(name, name_size); + glBindAttribLocation(program, index, name_str.c_str()); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBindBuffer( + unsigned int arg_count, const gles2::BindBuffer& c) { + GLenum target = static_cast<GLenum>(c.target); + GLuint buffer = static_cast<GLuint>(c.buffer); + parse_error::ParseError result = + ValidateBindBuffer(this, arg_count, target, buffer); + if (result != parse_error::kParseNoError) { + return result; + } + DoBindBuffer(target, buffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBindFramebuffer( + unsigned int arg_count, const gles2::BindFramebuffer& c) { + GLenum target = static_cast<GLenum>(c.target); + GLuint framebuffer = static_cast<GLuint>(c.framebuffer); + parse_error::ParseError result = + ValidateBindFramebuffer(this, arg_count, target, framebuffer); + if (result != parse_error::kParseNoError) { + return result; + } + glBindFramebuffer(target, framebuffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBindRenderbuffer( + unsigned int arg_count, const gles2::BindRenderbuffer& c) { + GLenum target = static_cast<GLenum>(c.target); + GLuint renderbuffer = static_cast<GLuint>(c.renderbuffer); + parse_error::ParseError result = + ValidateBindRenderbuffer(this, arg_count, target, renderbuffer); + if (result != parse_error::kParseNoError) { + return result; + } + glBindRenderbuffer(target, renderbuffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBindTexture( + unsigned int arg_count, const gles2::BindTexture& c) { + GLenum target = static_cast<GLenum>(c.target); + GLuint texture = static_cast<GLuint>(c.texture); + parse_error::ParseError result = + ValidateBindTexture(this, arg_count, target, texture); + if (result != parse_error::kParseNoError) { + return result; + } + glBindTexture(target, texture); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBlendColor( + unsigned int arg_count, const gles2::BlendColor& c) { + GLclampf red = static_cast<GLclampf>(c.red); + GLclampf green = static_cast<GLclampf>(c.green); + GLclampf blue = static_cast<GLclampf>(c.blue); + GLclampf alpha = static_cast<GLclampf>(c.alpha); + parse_error::ParseError result = + ValidateBlendColor(this, arg_count, red, green, blue, alpha); + if (result != parse_error::kParseNoError) { + return result; + } + glBlendColor(red, green, blue, alpha); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBlendEquation( + unsigned int arg_count, const gles2::BlendEquation& c) { + GLenum mode = static_cast<GLenum>(c.mode); + parse_error::ParseError result = + ValidateBlendEquation(this, arg_count, mode); + if (result != parse_error::kParseNoError) { + return result; + } + glBlendEquation(mode); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBlendEquationSeparate( + unsigned int arg_count, const gles2::BlendEquationSeparate& c) { + GLenum modeRGB = static_cast<GLenum>(c.modeRGB); + GLenum modeAlpha = static_cast<GLenum>(c.modeAlpha); + parse_error::ParseError result = + ValidateBlendEquationSeparate(this, arg_count, modeRGB, modeAlpha); + if (result != parse_error::kParseNoError) { + return result; + } + glBlendEquationSeparate(modeRGB, modeAlpha); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBlendFunc( + unsigned int arg_count, const gles2::BlendFunc& c) { + GLenum sfactor = static_cast<GLenum>(c.sfactor); + GLenum dfactor = static_cast<GLenum>(c.dfactor); + parse_error::ParseError result = + ValidateBlendFunc(this, arg_count, sfactor, dfactor); + if (result != parse_error::kParseNoError) { + return result; + } + glBlendFunc(sfactor, dfactor); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBlendFuncSeparate( + unsigned int arg_count, const gles2::BlendFuncSeparate& c) { + GLenum srcRGB = static_cast<GLenum>(c.srcRGB); + GLenum dstRGB = static_cast<GLenum>(c.dstRGB); + GLenum srcAlpha = static_cast<GLenum>(c.srcAlpha); + GLenum dstAlpha = static_cast<GLenum>(c.dstAlpha); + parse_error::ParseError result = + ValidateBlendFuncSeparate( + this, arg_count, srcRGB, dstRGB, srcAlpha, dstAlpha); + if (result != parse_error::kParseNoError) { + return result; + } + glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBufferData( + unsigned int arg_count, const gles2::BufferData& c) { + GLenum target = static_cast<GLenum>(c.target); + GLsizeiptr size = static_cast<GLsizeiptr>(c.size); + uint32 data_shm_id = static_cast<uint32>(c.data_shm_id); + uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset); + GLenum usage = static_cast<GLenum>(c.usage); + uint32 data_size = size; + const void* data = GetSharedMemoryAs<const void*>( + data_shm_id, data_shm_offset, data_size); + parse_error::ParseError result = + ValidateBufferData(this, arg_count, target, size, data, usage); + if (result != parse_error::kParseNoError) { + return result; + } + glBufferData(target, size, data, usage); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBufferDataImmediate( + unsigned int arg_count, const gles2::BufferDataImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLsizeiptr size = static_cast<GLsizeiptr>(c.size); + const void* data = GetImmediateDataAs<const void*>(c); + GLenum usage = static_cast<GLenum>(c.usage); + // Immediate version. + parse_error::ParseError result = + ValidateBufferDataImmediate(this, arg_count, target, size, data, usage); + if (result != parse_error::kParseNoError) { + return result; + } + glBufferData(target, size, data, usage); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBufferSubData( + unsigned int arg_count, const gles2::BufferSubData& c) { + GLenum target = static_cast<GLenum>(c.target); + GLintptr offset = static_cast<GLintptr>(c.offset); + GLsizeiptr size = static_cast<GLsizeiptr>(c.size); + uint32 data_shm_id = static_cast<uint32>(c.data_shm_id); + uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset); + uint32 data_size = size; + const void* data = GetSharedMemoryAs<const void*>( + data_shm_id, data_shm_offset, data_size); + parse_error::ParseError result = + ValidateBufferSubData(this, arg_count, target, offset, size, data); + if (result != parse_error::kParseNoError) { + return result; + } + glBufferSubData(target, offset, size, data); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleBufferSubDataImmediate( + unsigned int arg_count, const gles2::BufferSubDataImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLintptr offset = static_cast<GLintptr>(c.offset); + GLsizeiptr size = static_cast<GLsizeiptr>(c.size); + const void* data = GetImmediateDataAs<const void*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateBufferSubDataImmediate( + this, arg_count, target, offset, size, data); + if (result != parse_error::kParseNoError) { + return result; + } + glBufferSubData(target, offset, size, data); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCheckFramebufferStatus( + unsigned int arg_count, const gles2::CheckFramebufferStatus& c) { + GLenum target = static_cast<GLenum>(c.target); + parse_error::ParseError result = + ValidateCheckFramebufferStatus(this, arg_count, target); + if (result != parse_error::kParseNoError) { + return result; + } + glCheckFramebufferStatus(target); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleClear( + unsigned int arg_count, const gles2::Clear& c) { + GLbitfield mask = static_cast<GLbitfield>(c.mask); + parse_error::ParseError result = + ValidateClear(this, arg_count, mask); + if (result != parse_error::kParseNoError) { + return result; + } + glClear(mask); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleClearColor( + unsigned int arg_count, const gles2::ClearColor& c) { + GLclampf red = static_cast<GLclampf>(c.red); + GLclampf green = static_cast<GLclampf>(c.green); + GLclampf blue = static_cast<GLclampf>(c.blue); + GLclampf alpha = static_cast<GLclampf>(c.alpha); + parse_error::ParseError result = + ValidateClearColor(this, arg_count, red, green, blue, alpha); + if (result != parse_error::kParseNoError) { + return result; + } + glClearColor(red, green, blue, alpha); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleClearDepthf( + unsigned int arg_count, const gles2::ClearDepthf& c) { + GLclampf depth = static_cast<GLclampf>(c.depth); + parse_error::ParseError result = + ValidateClearDepthf(this, arg_count, depth); + if (result != parse_error::kParseNoError) { + return result; + } + glClearDepth(depth); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleClearStencil( + unsigned int arg_count, const gles2::ClearStencil& c) { + GLint s = static_cast<GLint>(c.s); + parse_error::ParseError result = + ValidateClearStencil(this, arg_count, s); + if (result != parse_error::kParseNoError) { + return result; + } + glClearStencil(s); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleColorMask( + unsigned int arg_count, const gles2::ColorMask& c) { + GLboolean red = static_cast<GLboolean>(c.red); + GLboolean green = static_cast<GLboolean>(c.green); + GLboolean blue = static_cast<GLboolean>(c.blue); + GLboolean alpha = static_cast<GLboolean>(c.alpha); + parse_error::ParseError result = + ValidateColorMask(this, arg_count, red, green, blue, alpha); + if (result != parse_error::kParseNoError) { + return result; + } + glColorMask(red, green, blue, alpha); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCompileShader( + unsigned int arg_count, const gles2::CompileShader& c) { + GLuint shader = static_cast<GLuint>(c.shader); + parse_error::ParseError result = + ValidateCompileShader(this, arg_count, shader); + if (result != parse_error::kParseNoError) { + return result; + } + glCompileShader(shader); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCompressedTexImage2D( + unsigned int arg_count, const gles2::CompressedTexImage2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLenum internalformat = static_cast<GLenum>(c.internalformat); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLint border = static_cast<GLint>(c.border); + GLsizei imageSize = static_cast<GLsizei>(c.imageSize); + uint32 data_shm_id = static_cast<uint32>(c.data_shm_id); + uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset); + uint32 data_size = imageSize; + const void* data = GetSharedMemoryAs<const void*>( + data_shm_id, data_shm_offset, data_size); + parse_error::ParseError result = + ValidateCompressedTexImage2D( + this, arg_count, target, level, internalformat, width, height, border, + imageSize, data); + if (result != parse_error::kParseNoError) { + return result; + } + glCompressedTexImage2D( + target, level, internalformat, width, height, border, imageSize, data); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCompressedTexImage2DImmediate( + unsigned int arg_count, const gles2::CompressedTexImage2DImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLenum internalformat = static_cast<GLenum>(c.internalformat); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLint border = static_cast<GLint>(c.border); + GLsizei imageSize = static_cast<GLsizei>(c.imageSize); + const void* data = GetImmediateDataAs<const void*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateCompressedTexImage2DImmediate( + this, arg_count, target, level, internalformat, width, height, border, + imageSize, data); + if (result != parse_error::kParseNoError) { + return result; + } + glCompressedTexImage2D( + target, level, internalformat, width, height, border, imageSize, data); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCompressedTexSubImage2D( + unsigned int arg_count, const gles2::CompressedTexSubImage2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint xoffset = static_cast<GLint>(c.xoffset); + GLint yoffset = static_cast<GLint>(c.yoffset); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLenum format = static_cast<GLenum>(c.format); + GLsizei imageSize = static_cast<GLsizei>(c.imageSize); + uint32 data_shm_id = static_cast<uint32>(c.data_shm_id); + uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset); + uint32 data_size = imageSize; + const void* data = GetSharedMemoryAs<const void*>( + data_shm_id, data_shm_offset, data_size); + parse_error::ParseError result = + ValidateCompressedTexSubImage2D( + this, arg_count, target, level, xoffset, yoffset, width, height, + format, imageSize, data); + if (result != parse_error::kParseNoError) { + return result; + } + glCompressedTexSubImage2D( + target, level, xoffset, yoffset, width, height, format, imageSize, data); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCompressedTexSubImage2DImmediate( + unsigned int arg_count, const gles2::CompressedTexSubImage2DImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint xoffset = static_cast<GLint>(c.xoffset); + GLint yoffset = static_cast<GLint>(c.yoffset); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLenum format = static_cast<GLenum>(c.format); + GLsizei imageSize = static_cast<GLsizei>(c.imageSize); + const void* data = GetImmediateDataAs<const void*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateCompressedTexSubImage2DImmediate( + this, arg_count, target, level, xoffset, yoffset, width, height, + format, imageSize, data); + if (result != parse_error::kParseNoError) { + return result; + } + glCompressedTexSubImage2D( + target, level, xoffset, yoffset, width, height, format, imageSize, data); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCopyTexImage2D( + unsigned int arg_count, const gles2::CopyTexImage2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLenum internalformat = static_cast<GLenum>(c.internalformat); + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLint border = static_cast<GLint>(c.border); + parse_error::ParseError result = + ValidateCopyTexImage2D( + this, arg_count, target, level, internalformat, x, y, width, height, + border); + if (result != parse_error::kParseNoError) { + return result; + } + glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCopyTexSubImage2D( + unsigned int arg_count, const gles2::CopyTexSubImage2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint xoffset = static_cast<GLint>(c.xoffset); + GLint yoffset = static_cast<GLint>(c.yoffset); + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + parse_error::ParseError result = + ValidateCopyTexSubImage2D( + this, arg_count, target, level, xoffset, yoffset, x, y, width, + height); + if (result != parse_error::kParseNoError) { + return result; + } + glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCreateProgram( + unsigned int arg_count, const gles2::CreateProgram& c) { + uint32 client_id = c.client_id; + parse_error::ParseError result = + ValidateCreateProgram(this, arg_count); + if (result != parse_error::kParseNoError) { + return result; + } + CreateProgramHelper(client_id); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCreateShader( + unsigned int arg_count, const gles2::CreateShader& c) { + GLenum type = static_cast<GLenum>(c.type); + uint32 client_id = c.client_id; + parse_error::ParseError result = + ValidateCreateShader(this, arg_count, type); + if (result != parse_error::kParseNoError) { + return result; + } + CreateShaderHelper(type, client_id); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleCullFace( + unsigned int arg_count, const gles2::CullFace& c) { + GLenum mode = static_cast<GLenum>(c.mode); + parse_error::ParseError result = + ValidateCullFace(this, arg_count, mode); + if (result != parse_error::kParseNoError) { + return result; + } + glCullFace(mode); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteBuffers( + unsigned int arg_count, const gles2::DeleteBuffers& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* buffers = GetSharedMemoryAs<const GLuint*>( + c.buffers_shm_id, c.buffers_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateDeleteBuffers(this, arg_count, n, buffers); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteBuffersHelper>(n, buffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteBuffersImmediate( + unsigned int arg_count, const gles2::DeleteBuffersImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* buffers = GetImmediateDataAs<const GLuint*>(c); + parse_error::ParseError result = + ValidateDeleteBuffersImmediate(this, arg_count, n, buffers); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteBuffersHelper>(n, buffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteFramebuffers( + unsigned int arg_count, const gles2::DeleteFramebuffers& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>( + c.framebuffers_shm_id, c.framebuffers_shm_offset, 0 /* TODO( + gman): size */); + parse_error::ParseError result = + ValidateDeleteFramebuffers(this, arg_count, n, framebuffers); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteFramebuffersHelper>(n, framebuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteFramebuffersImmediate( + unsigned int arg_count, const gles2::DeleteFramebuffersImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* framebuffers = GetImmediateDataAs<const GLuint*>(c); + parse_error::ParseError result = + ValidateDeleteFramebuffersImmediate(this, arg_count, n, framebuffers); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteFramebuffersHelper>(n, framebuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteProgram( + unsigned int arg_count, const gles2::DeleteProgram& c) { + GLuint program = static_cast<GLuint>(c.program); + parse_error::ParseError result = + ValidateDeleteProgram(this, arg_count, program); + if (result != parse_error::kParseNoError) { + return result; + } + DoDeleteProgram(program); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteRenderbuffers( + unsigned int arg_count, const gles2::DeleteRenderbuffers& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>( + c.renderbuffers_shm_id, c.renderbuffers_shm_offset, 0 /* TODO( + gman): size */); + parse_error::ParseError result = + ValidateDeleteRenderbuffers(this, arg_count, n, renderbuffers); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteRenderbuffersHelper>(n, renderbuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteRenderbuffersImmediate( + unsigned int arg_count, const gles2::DeleteRenderbuffersImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* renderbuffers = GetImmediateDataAs<const GLuint*>(c); + parse_error::ParseError result = + ValidateDeleteRenderbuffersImmediate(this, arg_count, n, renderbuffers); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteRenderbuffersHelper>(n, renderbuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteShader( + unsigned int arg_count, const gles2::DeleteShader& c) { + GLuint shader = static_cast<GLuint>(c.shader); + parse_error::ParseError result = + ValidateDeleteShader(this, arg_count, shader); + if (result != parse_error::kParseNoError) { + return result; + } + DoDeleteShader(shader); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteTextures( + unsigned int arg_count, const gles2::DeleteTextures& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* textures = GetSharedMemoryAs<const GLuint*>( + c.textures_shm_id, c.textures_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateDeleteTextures(this, arg_count, n, textures); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteTexturesHelper>(n, textures); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDeleteTexturesImmediate( + unsigned int arg_count, const gles2::DeleteTexturesImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + const GLuint* textures = GetImmediateDataAs<const GLuint*>(c); + parse_error::ParseError result = + ValidateDeleteTexturesImmediate(this, arg_count, n, textures); + if (result != parse_error::kParseNoError) { + return result; + } + DeleteGLObjects<GLDeleteTexturesHelper>(n, textures); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDepthFunc( + unsigned int arg_count, const gles2::DepthFunc& c) { + GLenum func = static_cast<GLenum>(c.func); + parse_error::ParseError result = + ValidateDepthFunc(this, arg_count, func); + if (result != parse_error::kParseNoError) { + return result; + } + glDepthFunc(func); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDepthMask( + unsigned int arg_count, const gles2::DepthMask& c) { + GLboolean flag = static_cast<GLboolean>(c.flag); + parse_error::ParseError result = + ValidateDepthMask(this, arg_count, flag); + if (result != parse_error::kParseNoError) { + return result; + } + glDepthMask(flag); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDepthRangef( + unsigned int arg_count, const gles2::DepthRangef& c) { + GLclampf zNear = static_cast<GLclampf>(c.zNear); + GLclampf zFar = static_cast<GLclampf>(c.zFar); + parse_error::ParseError result = + ValidateDepthRangef(this, arg_count, zNear, zFar); + if (result != parse_error::kParseNoError) { + return result; + } + glDepthRange(zNear, zFar); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDetachShader( + unsigned int arg_count, const gles2::DetachShader& c) { + GLuint program = static_cast<GLuint>(c.program); + GLuint shader = static_cast<GLuint>(c.shader); + parse_error::ParseError result = + ValidateDetachShader(this, arg_count, program, shader); + if (result != parse_error::kParseNoError) { + return result; + } + glDetachShader(program, shader); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDisable( + unsigned int arg_count, const gles2::Disable& c) { + GLenum cap = static_cast<GLenum>(c.cap); + parse_error::ParseError result = + ValidateDisable(this, arg_count, cap); + if (result != parse_error::kParseNoError) { + return result; + } + glDisable(cap); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDisableVertexAttribArray( + unsigned int arg_count, const gles2::DisableVertexAttribArray& c) { + GLuint index = static_cast<GLuint>(c.index); + parse_error::ParseError result = + ValidateDisableVertexAttribArray(this, arg_count, index); + if (result != parse_error::kParseNoError) { + return result; + } + glDisableVertexAttribArray(index); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleDrawArrays( + unsigned int arg_count, const gles2::DrawArrays& c) { + GLenum mode = static_cast<GLenum>(c.mode); + GLint first = static_cast<GLint>(c.first); + GLsizei count = static_cast<GLsizei>(c.count); + parse_error::ParseError result = + ValidateDrawArrays(this, arg_count, mode, first, count); + if (result != parse_error::kParseNoError) { + return result; + } + glDrawArrays(mode, first, count); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleEnable( + unsigned int arg_count, const gles2::Enable& c) { + GLenum cap = static_cast<GLenum>(c.cap); + parse_error::ParseError result = + ValidateEnable(this, arg_count, cap); + if (result != parse_error::kParseNoError) { + return result; + } + glEnable(cap); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleEnableVertexAttribArray( + unsigned int arg_count, const gles2::EnableVertexAttribArray& c) { + GLuint index = static_cast<GLuint>(c.index); + parse_error::ParseError result = + ValidateEnableVertexAttribArray(this, arg_count, index); + if (result != parse_error::kParseNoError) { + return result; + } + glEnableVertexAttribArray(index); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleFinish( + unsigned int arg_count, const gles2::Finish& c) { + parse_error::ParseError result = + ValidateFinish(this, arg_count); + if (result != parse_error::kParseNoError) { + return result; + } + glFinish(); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleFlush( + unsigned int arg_count, const gles2::Flush& c) { + parse_error::ParseError result = + ValidateFlush(this, arg_count); + if (result != parse_error::kParseNoError) { + return result; + } + glFlush(); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleFramebufferRenderbuffer( + unsigned int arg_count, const gles2::FramebufferRenderbuffer& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum attachment = static_cast<GLenum>(c.attachment); + GLenum renderbuffertarget = static_cast<GLenum>(c.renderbuffertarget); + GLuint renderbuffer = static_cast<GLuint>(c.renderbuffer); + parse_error::ParseError result = + ValidateFramebufferRenderbuffer( + this, arg_count, target, attachment, renderbuffertarget, + renderbuffer); + if (result != parse_error::kParseNoError) { + return result; + } + glFramebufferRenderbuffer( + target, attachment, renderbuffertarget, renderbuffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleFramebufferTexture2D( + unsigned int arg_count, const gles2::FramebufferTexture2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum attachment = static_cast<GLenum>(c.attachment); + GLenum textarget = static_cast<GLenum>(c.textarget); + GLuint texture = static_cast<GLuint>(c.texture); + GLint level = static_cast<GLint>(c.level); + parse_error::ParseError result = + ValidateFramebufferTexture2D( + this, arg_count, target, attachment, textarget, texture, level); + if (result != parse_error::kParseNoError) { + return result; + } + glFramebufferTexture2D(target, attachment, textarget, texture, level); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleFrontFace( + unsigned int arg_count, const gles2::FrontFace& c) { + GLenum mode = static_cast<GLenum>(c.mode); + parse_error::ParseError result = + ValidateFrontFace(this, arg_count, mode); + if (result != parse_error::kParseNoError) { + return result; + } + glFrontFace(mode); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenBuffers( + unsigned int arg_count, const gles2::GenBuffers& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* buffers = GetSharedMemoryAs<GLuint*>( + c.buffers_shm_id, c.buffers_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateGenBuffers(this, arg_count, n, buffers); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenBuffersHelper>(n, buffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenBuffersImmediate( + unsigned int arg_count, const gles2::GenBuffersImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* buffers = GetImmediateDataAs<GLuint*>(c); + parse_error::ParseError result = + ValidateGenBuffersImmediate(this, arg_count, n, buffers); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenBuffersHelper>(n, buffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenerateMipmap( + unsigned int arg_count, const gles2::GenerateMipmap& c) { + GLenum target = static_cast<GLenum>(c.target); + parse_error::ParseError result = + ValidateGenerateMipmap(this, arg_count, target); + if (result != parse_error::kParseNoError) { + return result; + } + glGenerateMipmap(target); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenFramebuffers( + unsigned int arg_count, const gles2::GenFramebuffers& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* framebuffers = GetSharedMemoryAs<GLuint*>( + c.framebuffers_shm_id, c.framebuffers_shm_offset, 0 /* TODO( + gman): size */); + parse_error::ParseError result = + ValidateGenFramebuffers(this, arg_count, n, framebuffers); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenFramebuffersHelper>(n, framebuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenFramebuffersImmediate( + unsigned int arg_count, const gles2::GenFramebuffersImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* framebuffers = GetImmediateDataAs<GLuint*>(c); + parse_error::ParseError result = + ValidateGenFramebuffersImmediate(this, arg_count, n, framebuffers); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenFramebuffersHelper>(n, framebuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenRenderbuffers( + unsigned int arg_count, const gles2::GenRenderbuffers& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>( + c.renderbuffers_shm_id, c.renderbuffers_shm_offset, 0 /* TODO( + gman): size */); + parse_error::ParseError result = + ValidateGenRenderbuffers(this, arg_count, n, renderbuffers); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenRenderbuffersHelper>(n, renderbuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenRenderbuffersImmediate( + unsigned int arg_count, const gles2::GenRenderbuffersImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* renderbuffers = GetImmediateDataAs<GLuint*>(c); + parse_error::ParseError result = + ValidateGenRenderbuffersImmediate(this, arg_count, n, renderbuffers); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenRenderbuffersHelper>(n, renderbuffers); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenTextures( + unsigned int arg_count, const gles2::GenTextures& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* textures = GetSharedMemoryAs<GLuint*>( + c.textures_shm_id, c.textures_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateGenTextures(this, arg_count, n, textures); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenTexturesHelper>(n, textures); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGenTexturesImmediate( + unsigned int arg_count, const gles2::GenTexturesImmediate& c) { + GLsizei n = static_cast<GLsizei>(c.n); + GLuint* textures = GetImmediateDataAs<GLuint*>(c); + parse_error::ParseError result = + ValidateGenTexturesImmediate(this, arg_count, n, textures); + if (result != parse_error::kParseNoError) { + return result; + } + GenGLObjects<GLGenTexturesHelper>(n, textures); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetAttribLocation( + unsigned int arg_count, const gles2::GetAttribLocation& c) { + GLuint program = static_cast<GLuint>(c.program); + uint32 name_size = c.data_size; + const char* name = GetSharedMemoryAs<const char*>( + c.name_shm_id, c.name_shm_offset, name_size); + parse_error::ParseError result = + ValidateGetAttribLocation(this, arg_count, program, name); + if (result != parse_error::kParseNoError) { + return result; + } + String name_str(name, name_size); + glGetAttribLocation(program, name_str.c_str()); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetAttribLocationImmediate( + unsigned int arg_count, const gles2::GetAttribLocationImmediate& c) { + GLuint program = static_cast<GLuint>(c.program); + uint32 name_size = c.data_size; + const char* name = GetImmediateDataAs<const char*>(c); + // TODO(gman): Make sure validate checks arg_count + // covers data_size. + parse_error::ParseError result = + ValidateGetAttribLocationImmediate(this, arg_count, program, name); + if (result != parse_error::kParseNoError) { + return result; + } + String name_str(name, name_size); + glGetAttribLocation(program, name_str.c_str()); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetBooleanv( + unsigned int arg_count, const gles2::GetBooleanv& c) { + GLenum pname = static_cast<GLenum>(c.pname); + GLboolean* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLboolean*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetBooleanv(this, arg_count, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetBooleanv(pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetBufferParameteriv( + unsigned int arg_count, const gles2::GetBufferParameteriv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetBufferParameteriv(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetBufferParameteriv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetError( + unsigned int arg_count, const gles2::GetError& c) { + GLenum* result_dst = GetSharedMemoryAs<GLenum*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateGetError(this, arg_count); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glGetError(); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetFloatv( + unsigned int arg_count, const gles2::GetFloatv& c) { + GLenum pname = static_cast<GLenum>(c.pname); + GLfloat* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLfloat*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetFloatv(this, arg_count, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetFloatv(pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetFramebufferAttachmentParameteriv( + + unsigned int arg_count, + const gles2::GetFramebufferAttachmentParameteriv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum attachment = static_cast<GLenum>(c.attachment); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetFramebufferAttachmentParameteriv( + this, arg_count, target, attachment, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetIntegerv( + unsigned int arg_count, const gles2::GetIntegerv& c) { + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetIntegerv(this, arg_count, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetIntegerv(pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetProgramiv( + unsigned int arg_count, const gles2::GetProgramiv& c) { + GLuint program = static_cast<GLuint>(c.program); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetProgramiv(this, arg_count, program, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetProgramiv(program, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetProgramInfoLog( + unsigned int arg_count, const gles2::GetProgramInfoLog& c) { + GLuint program = static_cast<GLuint>(c.program); + GLsizei bufsize = static_cast<GLsizei>(c.bufsize); + GLsizei* length = GetSharedMemoryAs<GLsizei*>( + c.length_shm_id, c.length_shm_offset, 0 /* TODO(gman): size */); + char* infolog = GetSharedMemoryAs<char*>( + c.infolog_shm_id, c.infolog_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateGetProgramInfoLog( + this, arg_count, program, bufsize, length, infolog); + if (result != parse_error::kParseNoError) { + return result; + } + glGetProgramInfoLog(program, bufsize, length, infolog); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetRenderbufferParameteriv( + unsigned int arg_count, const gles2::GetRenderbufferParameteriv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetRenderbufferParameteriv( + this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetRenderbufferParameteriv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetShaderiv( + unsigned int arg_count, const gles2::GetShaderiv& c) { + GLuint shader = static_cast<GLuint>(c.shader); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetShaderiv(this, arg_count, shader, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetShaderiv(shader, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetShaderInfoLog( + unsigned int arg_count, const gles2::GetShaderInfoLog& c) { + GLuint shader = static_cast<GLuint>(c.shader); + GLsizei bufsize = static_cast<GLsizei>(c.bufsize); + GLsizei* length = GetSharedMemoryAs<GLsizei*>( + c.length_shm_id, c.length_shm_offset, 0 /* TODO(gman): size */); + char* infolog = GetSharedMemoryAs<char*>( + c.infolog_shm_id, c.infolog_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateGetShaderInfoLog( + this, arg_count, shader, bufsize, length, infolog); + if (result != parse_error::kParseNoError) { + return result; + } + glGetShaderInfoLog(shader, bufsize, length, infolog); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetShaderSource( + unsigned int arg_count, const gles2::GetShaderSource& c) { + GLuint shader = static_cast<GLuint>(c.shader); + GLsizei bufsize = static_cast<GLsizei>(c.bufsize); + GLsizei* length = GetSharedMemoryAs<GLsizei*>( + c.length_shm_id, c.length_shm_offset, 0 /* TODO(gman): size */); + char* source = GetSharedMemoryAs<char*>( + c.source_shm_id, c.source_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateGetShaderSource( + this, arg_count, shader, bufsize, length, source); + if (result != parse_error::kParseNoError) { + return result; + } + glGetShaderSource(shader, bufsize, length, source); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetString( + unsigned int arg_count, const gles2::GetString& c) { + GLenum name = static_cast<GLenum>(c.name); + parse_error::ParseError result = + ValidateGetString(this, arg_count, name); + if (result != parse_error::kParseNoError) { + return result; + } + glGetString(name); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetTexParameterfv( + unsigned int arg_count, const gles2::GetTexParameterfv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + GLfloat* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLfloat*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetTexParameterfv(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetTexParameterfv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetTexParameteriv( + unsigned int arg_count, const gles2::GetTexParameteriv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetTexParameteriv(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetTexParameteriv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetUniformLocation( + unsigned int arg_count, const gles2::GetUniformLocation& c) { + GLuint program = static_cast<GLuint>(c.program); + uint32 name_size = c.data_size; + const char* name = GetSharedMemoryAs<const char*>( + c.name_shm_id, c.name_shm_offset, name_size); + parse_error::ParseError result = + ValidateGetUniformLocation(this, arg_count, program, name); + if (result != parse_error::kParseNoError) { + return result; + } + String name_str(name, name_size); + glGetUniformLocation(program, name_str.c_str()); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetUniformLocationImmediate( + unsigned int arg_count, const gles2::GetUniformLocationImmediate& c) { + GLuint program = static_cast<GLuint>(c.program); + uint32 name_size = c.data_size; + const char* name = GetImmediateDataAs<const char*>(c); + // TODO(gman): Make sure validate checks arg_count + // covers data_size. + parse_error::ParseError result = + ValidateGetUniformLocationImmediate(this, arg_count, program, name); + if (result != parse_error::kParseNoError) { + return result; + } + String name_str(name, name_size); + glGetUniformLocation(program, name_str.c_str()); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetVertexAttribfv( + unsigned int arg_count, const gles2::GetVertexAttribfv& c) { + GLuint index = static_cast<GLuint>(c.index); + GLenum pname = static_cast<GLenum>(c.pname); + GLfloat* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLfloat*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetVertexAttribfv(this, arg_count, index, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetVertexAttribfv(index, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleGetVertexAttribiv( + unsigned int arg_count, const gles2::GetVertexAttribiv& c) { + GLuint index = static_cast<GLuint>(c.index); + GLenum pname = static_cast<GLenum>(c.pname); + GLint* params; + GLsizei num_values = util_.GLGetNumValuesReturned(pname); + uint32 params_size = num_values * sizeof(*params); + params = GetSharedMemoryAs<GLint*>( + c.params_shm_id, c.params_shm_offset, params_size); + parse_error::ParseError result = + ValidateGetVertexAttribiv(this, arg_count, index, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glGetVertexAttribiv(index, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleHint( + unsigned int arg_count, const gles2::Hint& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum mode = static_cast<GLenum>(c.mode); + parse_error::ParseError result = + ValidateHint(this, arg_count, target, mode); + if (result != parse_error::kParseNoError) { + return result; + } + glHint(target, mode); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsBuffer( + unsigned int arg_count, const gles2::IsBuffer& c) { + GLuint buffer = static_cast<GLuint>(c.buffer); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsBuffer(this, arg_count, buffer); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsBuffer(buffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsEnabled( + unsigned int arg_count, const gles2::IsEnabled& c) { + GLenum cap = static_cast<GLenum>(c.cap); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsEnabled(this, arg_count, cap); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsEnabled(cap); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsFramebuffer( + unsigned int arg_count, const gles2::IsFramebuffer& c) { + GLuint framebuffer = static_cast<GLuint>(c.framebuffer); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsFramebuffer(this, arg_count, framebuffer); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsFramebuffer(framebuffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsProgram( + unsigned int arg_count, const gles2::IsProgram& c) { + GLuint program = static_cast<GLuint>(c.program); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsProgram(this, arg_count, program); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsProgram(program); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsRenderbuffer( + unsigned int arg_count, const gles2::IsRenderbuffer& c) { + GLuint renderbuffer = static_cast<GLuint>(c.renderbuffer); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsRenderbuffer(this, arg_count, renderbuffer); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsRenderbuffer(renderbuffer); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsShader( + unsigned int arg_count, const gles2::IsShader& c) { + GLuint shader = static_cast<GLuint>(c.shader); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsShader(this, arg_count, shader); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsShader(shader); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleIsTexture( + unsigned int arg_count, const gles2::IsTexture& c) { + GLuint texture = static_cast<GLuint>(c.texture); + GLboolean* result_dst = GetSharedMemoryAs<GLboolean*>( + c.result_shm_id, c.result_shm_offset, sizeof(*result_dst)); + parse_error::ParseError result = + ValidateIsTexture(this, arg_count, texture); + if (result != parse_error::kParseNoError) { + return result; + } + *result_dst = glIsTexture(texture); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleLineWidth( + unsigned int arg_count, const gles2::LineWidth& c) { + GLfloat width = static_cast<GLfloat>(c.width); + parse_error::ParseError result = + ValidateLineWidth(this, arg_count, width); + if (result != parse_error::kParseNoError) { + return result; + } + glLineWidth(width); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleLinkProgram( + unsigned int arg_count, const gles2::LinkProgram& c) { + GLuint program = static_cast<GLuint>(c.program); + parse_error::ParseError result = + ValidateLinkProgram(this, arg_count, program); + if (result != parse_error::kParseNoError) { + return result; + } + glLinkProgram(program); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandlePolygonOffset( + unsigned int arg_count, const gles2::PolygonOffset& c) { + GLfloat factor = static_cast<GLfloat>(c.factor); + GLfloat units = static_cast<GLfloat>(c.units); + parse_error::ParseError result = + ValidatePolygonOffset(this, arg_count, factor, units); + if (result != parse_error::kParseNoError) { + return result; + } + glPolygonOffset(factor, units); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleRenderbufferStorage( + unsigned int arg_count, const gles2::RenderbufferStorage& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum internalformat = static_cast<GLenum>(c.internalformat); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + parse_error::ParseError result = + ValidateRenderbufferStorage( + this, arg_count, target, internalformat, width, height); + if (result != parse_error::kParseNoError) { + return result; + } + glRenderbufferStorage(target, internalformat, width, height); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleSampleCoverage( + unsigned int arg_count, const gles2::SampleCoverage& c) { + GLclampf value = static_cast<GLclampf>(c.value); + GLboolean invert = static_cast<GLboolean>(c.invert); + parse_error::ParseError result = + ValidateSampleCoverage(this, arg_count, value, invert); + if (result != parse_error::kParseNoError) { + return result; + } + glSampleCoverage(value, invert); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleScissor( + unsigned int arg_count, const gles2::Scissor& c) { + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + parse_error::ParseError result = + ValidateScissor(this, arg_count, x, y, width, height); + if (result != parse_error::kParseNoError) { + return result; + } + glScissor(x, y, width, height); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleStencilFunc( + unsigned int arg_count, const gles2::StencilFunc& c) { + GLenum func = static_cast<GLenum>(c.func); + GLint ref = static_cast<GLint>(c.ref); + GLuint mask = static_cast<GLuint>(c.mask); + parse_error::ParseError result = + ValidateStencilFunc(this, arg_count, func, ref, mask); + if (result != parse_error::kParseNoError) { + return result; + } + glStencilFunc(func, ref, mask); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleStencilFuncSeparate( + unsigned int arg_count, const gles2::StencilFuncSeparate& c) { + GLenum face = static_cast<GLenum>(c.face); + GLenum func = static_cast<GLenum>(c.func); + GLint ref = static_cast<GLint>(c.ref); + GLuint mask = static_cast<GLuint>(c.mask); + parse_error::ParseError result = + ValidateStencilFuncSeparate(this, arg_count, face, func, ref, mask); + if (result != parse_error::kParseNoError) { + return result; + } + glStencilFuncSeparate(face, func, ref, mask); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleStencilMask( + unsigned int arg_count, const gles2::StencilMask& c) { + GLuint mask = static_cast<GLuint>(c.mask); + parse_error::ParseError result = + ValidateStencilMask(this, arg_count, mask); + if (result != parse_error::kParseNoError) { + return result; + } + glStencilMask(mask); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleStencilMaskSeparate( + unsigned int arg_count, const gles2::StencilMaskSeparate& c) { + GLenum face = static_cast<GLenum>(c.face); + GLuint mask = static_cast<GLuint>(c.mask); + parse_error::ParseError result = + ValidateStencilMaskSeparate(this, arg_count, face, mask); + if (result != parse_error::kParseNoError) { + return result; + } + glStencilMaskSeparate(face, mask); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleStencilOp( + unsigned int arg_count, const gles2::StencilOp& c) { + GLenum fail = static_cast<GLenum>(c.fail); + GLenum zfail = static_cast<GLenum>(c.zfail); + GLenum zpass = static_cast<GLenum>(c.zpass); + parse_error::ParseError result = + ValidateStencilOp(this, arg_count, fail, zfail, zpass); + if (result != parse_error::kParseNoError) { + return result; + } + glStencilOp(fail, zfail, zpass); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleStencilOpSeparate( + unsigned int arg_count, const gles2::StencilOpSeparate& c) { + GLenum face = static_cast<GLenum>(c.face); + GLenum fail = static_cast<GLenum>(c.fail); + GLenum zfail = static_cast<GLenum>(c.zfail); + GLenum zpass = static_cast<GLenum>(c.zpass); + parse_error::ParseError result = + ValidateStencilOpSeparate(this, arg_count, face, fail, zfail, zpass); + if (result != parse_error::kParseNoError) { + return result; + } + glStencilOpSeparate(face, fail, zfail, zpass); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexImage2D( + unsigned int arg_count, const gles2::TexImage2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint internalformat = static_cast<GLint>(c.internalformat); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLint border = static_cast<GLint>(c.border); + GLenum format = static_cast<GLenum>(c.format); + GLenum type = static_cast<GLenum>(c.type); + uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id); + uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset); + uint32 pixels_size = GLES2Util::ComputeImageDataSize( + width, height, format, type, unpack_alignment_); + const void* pixels = GetSharedMemoryAs<const void*>( + pixels_shm_id, pixels_shm_offset, pixels_size); + parse_error::ParseError result = + ValidateTexImage2D( + this, arg_count, target, level, internalformat, width, height, border, + format, type, pixels); + if (result != parse_error::kParseNoError) { + return result; + } + glTexImage2D( + target, level, internalformat, width, height, border, format, type, + pixels); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexImage2DImmediate( + unsigned int arg_count, const gles2::TexImage2DImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint internalformat = static_cast<GLint>(c.internalformat); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLint border = static_cast<GLint>(c.border); + GLenum format = static_cast<GLenum>(c.format); + GLenum type = static_cast<GLenum>(c.type); + const void* pixels = GetImmediateDataAs<const void*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateTexImage2DImmediate( + this, arg_count, target, level, internalformat, width, height, border, + format, type, pixels); + if (result != parse_error::kParseNoError) { + return result; + } + glTexImage2D( + target, level, internalformat, width, height, border, format, type, + pixels); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexParameterf( + unsigned int arg_count, const gles2::TexParameterf& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + GLfloat param = static_cast<GLfloat>(c.param); + parse_error::ParseError result = + ValidateTexParameterf(this, arg_count, target, pname, param); + if (result != parse_error::kParseNoError) { + return result; + } + glTexParameterf(target, pname, param); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexParameterfv( + unsigned int arg_count, const gles2::TexParameterfv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + const GLfloat* params = GetSharedMemoryAs<const GLfloat*>( + c.params_shm_id, c.params_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateTexParameterfv(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glTexParameterfv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexParameterfvImmediate( + unsigned int arg_count, const gles2::TexParameterfvImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + const GLfloat* params = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateTexParameterfvImmediate(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glTexParameterfv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexParameteri( + unsigned int arg_count, const gles2::TexParameteri& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + GLint param = static_cast<GLint>(c.param); + parse_error::ParseError result = + ValidateTexParameteri(this, arg_count, target, pname, param); + if (result != parse_error::kParseNoError) { + return result; + } + glTexParameteri(target, pname, param); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexParameteriv( + unsigned int arg_count, const gles2::TexParameteriv& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + const GLint* params = GetSharedMemoryAs<const GLint*>( + c.params_shm_id, c.params_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateTexParameteriv(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glTexParameteriv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexParameterivImmediate( + unsigned int arg_count, const gles2::TexParameterivImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLenum pname = static_cast<GLenum>(c.pname); + const GLint* params = GetImmediateDataAs<const GLint*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateTexParameterivImmediate(this, arg_count, target, pname, params); + if (result != parse_error::kParseNoError) { + return result; + } + glTexParameteriv(target, pname, params); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexSubImage2D( + unsigned int arg_count, const gles2::TexSubImage2D& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint xoffset = static_cast<GLint>(c.xoffset); + GLint yoffset = static_cast<GLint>(c.yoffset); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLenum format = static_cast<GLenum>(c.format); + GLenum type = static_cast<GLenum>(c.type); + uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id); + uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset); + uint32 pixels_size = GLES2Util::ComputeImageDataSize( + width, height, format, type, unpack_alignment_); + const void* pixels = GetSharedMemoryAs<const void*>( + pixels_shm_id, pixels_shm_offset, pixels_size); + parse_error::ParseError result = + ValidateTexSubImage2D( + this, arg_count, target, level, xoffset, yoffset, width, height, + format, type, pixels); + if (result != parse_error::kParseNoError) { + return result; + } + glTexSubImage2D( + target, level, xoffset, yoffset, width, height, format, type, pixels); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleTexSubImage2DImmediate( + unsigned int arg_count, const gles2::TexSubImage2DImmediate& c) { + GLenum target = static_cast<GLenum>(c.target); + GLint level = static_cast<GLint>(c.level); + GLint xoffset = static_cast<GLint>(c.xoffset); + GLint yoffset = static_cast<GLint>(c.yoffset); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + GLenum format = static_cast<GLenum>(c.format); + GLenum type = static_cast<GLenum>(c.type); + const void* pixels = GetImmediateDataAs<const void*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateTexSubImage2DImmediate( + this, arg_count, target, level, xoffset, yoffset, width, height, + format, type, pixels); + if (result != parse_error::kParseNoError) { + return result; + } + glTexSubImage2D( + target, level, xoffset, yoffset, width, height, format, type, pixels); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform1f( + unsigned int arg_count, const gles2::Uniform1f& c) { + GLint location = static_cast<GLint>(c.location); + GLfloat x = static_cast<GLfloat>(c.x); + parse_error::ParseError result = + ValidateUniform1f(this, arg_count, location, x); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform1f(location, x); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform1fv( + unsigned int arg_count, const gles2::Uniform1fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetSharedMemoryAs<const GLfloat*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform1fv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform1fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform1fvImmediate( + unsigned int arg_count, const gles2::Uniform1fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform1fvImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform1fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform1i( + unsigned int arg_count, const gles2::Uniform1i& c) { + GLint location = static_cast<GLint>(c.location); + GLint x = static_cast<GLint>(c.x); + parse_error::ParseError result = + ValidateUniform1i(this, arg_count, location, x); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform1i(location, x); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform1iv( + unsigned int arg_count, const gles2::Uniform1iv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetSharedMemoryAs<const GLint*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform1iv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform1iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform1ivImmediate( + unsigned int arg_count, const gles2::Uniform1ivImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetImmediateDataAs<const GLint*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform1ivImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform1iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform2f( + unsigned int arg_count, const gles2::Uniform2f& c) { + GLint location = static_cast<GLint>(c.location); + GLfloat x = static_cast<GLfloat>(c.x); + GLfloat y = static_cast<GLfloat>(c.y); + parse_error::ParseError result = + ValidateUniform2f(this, arg_count, location, x, y); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform2f(location, x, y); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform2fv( + unsigned int arg_count, const gles2::Uniform2fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetSharedMemoryAs<const GLfloat*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform2fv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform2fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform2fvImmediate( + unsigned int arg_count, const gles2::Uniform2fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform2fvImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform2fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform2i( + unsigned int arg_count, const gles2::Uniform2i& c) { + GLint location = static_cast<GLint>(c.location); + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + parse_error::ParseError result = + ValidateUniform2i(this, arg_count, location, x, y); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform2i(location, x, y); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform2iv( + unsigned int arg_count, const gles2::Uniform2iv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetSharedMemoryAs<const GLint*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform2iv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform2iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform2ivImmediate( + unsigned int arg_count, const gles2::Uniform2ivImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetImmediateDataAs<const GLint*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform2ivImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform2iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform3f( + unsigned int arg_count, const gles2::Uniform3f& c) { + GLint location = static_cast<GLint>(c.location); + GLfloat x = static_cast<GLfloat>(c.x); + GLfloat y = static_cast<GLfloat>(c.y); + GLfloat z = static_cast<GLfloat>(c.z); + parse_error::ParseError result = + ValidateUniform3f(this, arg_count, location, x, y, z); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform3f(location, x, y, z); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform3fv( + unsigned int arg_count, const gles2::Uniform3fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetSharedMemoryAs<const GLfloat*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform3fv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform3fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform3fvImmediate( + unsigned int arg_count, const gles2::Uniform3fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform3fvImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform3fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform3i( + unsigned int arg_count, const gles2::Uniform3i& c) { + GLint location = static_cast<GLint>(c.location); + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + GLint z = static_cast<GLint>(c.z); + parse_error::ParseError result = + ValidateUniform3i(this, arg_count, location, x, y, z); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform3i(location, x, y, z); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform3iv( + unsigned int arg_count, const gles2::Uniform3iv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetSharedMemoryAs<const GLint*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform3iv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform3iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform3ivImmediate( + unsigned int arg_count, const gles2::Uniform3ivImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetImmediateDataAs<const GLint*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform3ivImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform3iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform4f( + unsigned int arg_count, const gles2::Uniform4f& c) { + GLint location = static_cast<GLint>(c.location); + GLfloat x = static_cast<GLfloat>(c.x); + GLfloat y = static_cast<GLfloat>(c.y); + GLfloat z = static_cast<GLfloat>(c.z); + GLfloat w = static_cast<GLfloat>(c.w); + parse_error::ParseError result = + ValidateUniform4f(this, arg_count, location, x, y, z, w); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform4f(location, x, y, z, w); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform4fv( + unsigned int arg_count, const gles2::Uniform4fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetSharedMemoryAs<const GLfloat*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform4fv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform4fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform4fvImmediate( + unsigned int arg_count, const gles2::Uniform4fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLfloat* v = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform4fvImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform4fv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform4i( + unsigned int arg_count, const gles2::Uniform4i& c) { + GLint location = static_cast<GLint>(c.location); + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + GLint z = static_cast<GLint>(c.z); + GLint w = static_cast<GLint>(c.w); + parse_error::ParseError result = + ValidateUniform4i(this, arg_count, location, x, y, z, w); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform4i(location, x, y, z, w); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform4iv( + unsigned int arg_count, const gles2::Uniform4iv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetSharedMemoryAs<const GLint*>( + c.v_shm_id, c.v_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniform4iv(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform4iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniform4ivImmediate( + unsigned int arg_count, const gles2::Uniform4ivImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + const GLint* v = GetImmediateDataAs<const GLint*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniform4ivImmediate(this, arg_count, location, count, v); + if (result != parse_error::kParseNoError) { + return result; + } + glUniform4iv(location, count, v); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniformMatrix2fv( + unsigned int arg_count, const gles2::UniformMatrix2fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + GLboolean transpose = static_cast<GLboolean>(c.transpose); + const GLfloat* value = GetSharedMemoryAs<const GLfloat*>( + c.value_shm_id, c.value_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniformMatrix2fv( + this, arg_count, location, count, transpose, value); + if (result != parse_error::kParseNoError) { + return result; + } + glUniformMatrix2fv(location, count, transpose, value); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniformMatrix2fvImmediate( + unsigned int arg_count, const gles2::UniformMatrix2fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + GLboolean transpose = static_cast<GLboolean>(c.transpose); + const GLfloat* value = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniformMatrix2fvImmediate( + this, arg_count, location, count, transpose, value); + if (result != parse_error::kParseNoError) { + return result; + } + glUniformMatrix2fv(location, count, transpose, value); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniformMatrix3fv( + unsigned int arg_count, const gles2::UniformMatrix3fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + GLboolean transpose = static_cast<GLboolean>(c.transpose); + const GLfloat* value = GetSharedMemoryAs<const GLfloat*>( + c.value_shm_id, c.value_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniformMatrix3fv( + this, arg_count, location, count, transpose, value); + if (result != parse_error::kParseNoError) { + return result; + } + glUniformMatrix3fv(location, count, transpose, value); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniformMatrix3fvImmediate( + unsigned int arg_count, const gles2::UniformMatrix3fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + GLboolean transpose = static_cast<GLboolean>(c.transpose); + const GLfloat* value = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniformMatrix3fvImmediate( + this, arg_count, location, count, transpose, value); + if (result != parse_error::kParseNoError) { + return result; + } + glUniformMatrix3fv(location, count, transpose, value); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniformMatrix4fv( + unsigned int arg_count, const gles2::UniformMatrix4fv& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + GLboolean transpose = static_cast<GLboolean>(c.transpose); + const GLfloat* value = GetSharedMemoryAs<const GLfloat*>( + c.value_shm_id, c.value_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateUniformMatrix4fv( + this, arg_count, location, count, transpose, value); + if (result != parse_error::kParseNoError) { + return result; + } + glUniformMatrix4fv(location, count, transpose, value); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUniformMatrix4fvImmediate( + unsigned int arg_count, const gles2::UniformMatrix4fvImmediate& c) { + GLint location = static_cast<GLint>(c.location); + GLsizei count = static_cast<GLsizei>(c.count); + GLboolean transpose = static_cast<GLboolean>(c.transpose); + const GLfloat* value = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateUniformMatrix4fvImmediate( + this, arg_count, location, count, transpose, value); + if (result != parse_error::kParseNoError) { + return result; + } + glUniformMatrix4fv(location, count, transpose, value); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleUseProgram( + unsigned int arg_count, const gles2::UseProgram& c) { + GLuint program = static_cast<GLuint>(c.program); + parse_error::ParseError result = + ValidateUseProgram(this, arg_count, program); + if (result != parse_error::kParseNoError) { + return result; + } + glUseProgram(program); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleValidateProgram( + unsigned int arg_count, const gles2::ValidateProgram& c) { + GLuint program = static_cast<GLuint>(c.program); + parse_error::ParseError result = + ValidateValidateProgram(this, arg_count, program); + if (result != parse_error::kParseNoError) { + return result; + } + glValidateProgram(program); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib1f( + unsigned int arg_count, const gles2::VertexAttrib1f& c) { + GLuint indx = static_cast<GLuint>(c.indx); + GLfloat x = static_cast<GLfloat>(c.x); + parse_error::ParseError result = + ValidateVertexAttrib1f(this, arg_count, indx, x); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib1f(indx, x); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib1fv( + unsigned int arg_count, const gles2::VertexAttrib1fv& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetSharedMemoryAs<const GLfloat*>( + c.values_shm_id, c.values_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateVertexAttrib1fv(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib1fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib1fvImmediate( + unsigned int arg_count, const gles2::VertexAttrib1fvImmediate& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateVertexAttrib1fvImmediate(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib1fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib2f( + unsigned int arg_count, const gles2::VertexAttrib2f& c) { + GLuint indx = static_cast<GLuint>(c.indx); + GLfloat x = static_cast<GLfloat>(c.x); + GLfloat y = static_cast<GLfloat>(c.y); + parse_error::ParseError result = + ValidateVertexAttrib2f(this, arg_count, indx, x, y); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib2f(indx, x, y); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib2fv( + unsigned int arg_count, const gles2::VertexAttrib2fv& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetSharedMemoryAs<const GLfloat*>( + c.values_shm_id, c.values_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateVertexAttrib2fv(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib2fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib2fvImmediate( + unsigned int arg_count, const gles2::VertexAttrib2fvImmediate& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateVertexAttrib2fvImmediate(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib2fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib3f( + unsigned int arg_count, const gles2::VertexAttrib3f& c) { + GLuint indx = static_cast<GLuint>(c.indx); + GLfloat x = static_cast<GLfloat>(c.x); + GLfloat y = static_cast<GLfloat>(c.y); + GLfloat z = static_cast<GLfloat>(c.z); + parse_error::ParseError result = + ValidateVertexAttrib3f(this, arg_count, indx, x, y, z); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib3f(indx, x, y, z); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib3fv( + unsigned int arg_count, const gles2::VertexAttrib3fv& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetSharedMemoryAs<const GLfloat*>( + c.values_shm_id, c.values_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateVertexAttrib3fv(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib3fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib3fvImmediate( + unsigned int arg_count, const gles2::VertexAttrib3fvImmediate& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateVertexAttrib3fvImmediate(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib3fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib4f( + unsigned int arg_count, const gles2::VertexAttrib4f& c) { + GLuint indx = static_cast<GLuint>(c.indx); + GLfloat x = static_cast<GLfloat>(c.x); + GLfloat y = static_cast<GLfloat>(c.y); + GLfloat z = static_cast<GLfloat>(c.z); + GLfloat w = static_cast<GLfloat>(c.w); + parse_error::ParseError result = + ValidateVertexAttrib4f(this, arg_count, indx, x, y, z, w); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib4f(indx, x, y, z, w); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib4fv( + unsigned int arg_count, const gles2::VertexAttrib4fv& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetSharedMemoryAs<const GLfloat*>( + c.values_shm_id, c.values_shm_offset, 0 /* TODO(gman): size */); + parse_error::ParseError result = + ValidateVertexAttrib4fv(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib4fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleVertexAttrib4fvImmediate( + unsigned int arg_count, const gles2::VertexAttrib4fvImmediate& c) { + GLuint indx = static_cast<GLuint>(c.indx); + const GLfloat* values = GetImmediateDataAs<const GLfloat*>(c); + // Immediate version. + parse_error::ParseError result = + ValidateVertexAttrib4fvImmediate(this, arg_count, indx, values); + if (result != parse_error::kParseNoError) { + return result; + } + glVertexAttrib4fv(indx, values); + return parse_error::kParseNoError; +} + +parse_error::ParseError GLES2Decoder::HandleViewport( + unsigned int arg_count, const gles2::Viewport& c) { + GLint x = static_cast<GLint>(c.x); + GLint y = static_cast<GLint>(c.y); + GLsizei width = static_cast<GLsizei>(c.width); + GLsizei height = static_cast<GLsizei>(c.height); + parse_error::ParseError result = + ValidateViewport(this, arg_count, x, y, width, height); + if (result != parse_error::kParseNoError) { + return result; + } + glViewport(x, y, width, height); + return parse_error::kParseNoError; +} + diff --git a/o3d/gpu/command_buffer/service/gles2_cmd_decoder_validate.h b/o3d/gpu/command_buffer/service/gles2_cmd_decoder_validate.h new file mode 100644 index 0000000..6d7696b --- /dev/null +++ b/o3d/gpu/command_buffer/service/gles2_cmd_decoder_validate.h @@ -0,0 +1,1249 @@ +// Copyright (c) 2006-2008 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. + +namespace command_buffer { +namespace gles2 { + +namespace { + +parse_error::ParseError ValidateActiveTexture( + GLES2Decoder* decoder, unsigned int arg_count, GLenum texture) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateAttachShader( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + GLuint shader) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBindAttribLocation( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, GLuint index, + const char* name) { + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBindAttribLocationImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, GLuint index, + const char* name) { + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBindBuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLuint buffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBindFramebuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLuint framebuffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBindRenderbuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLuint renderbuffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBindTexture( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLuint texture) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBlendColor( + GLES2Decoder* decoder, unsigned int arg_count, GLclampf red, GLclampf green, + GLclampf blue, GLclampf alpha) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBlendEquation( + GLES2Decoder* decoder, unsigned int arg_count, GLenum mode) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBlendEquationSeparate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum modeRGB, + GLenum modeAlpha) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBlendFunc( + GLES2Decoder* decoder, unsigned int arg_count, GLenum sfactor, + GLenum dfactor) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBlendFuncSeparate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum srcRGB, GLenum dstRGB, + GLenum srcAlpha, GLenum dstAlpha) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBufferData( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLsizeiptr size, const void* data, GLenum usage) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBufferDataImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLsizeiptr size, const void* data, GLenum usage) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBufferSubData( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLintptr offset, GLsizeiptr size, const void* data) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateBufferSubDataImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLintptr offset, GLsizeiptr size, const void* data) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCheckFramebufferStatus( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateClear( + GLES2Decoder* decoder, unsigned int arg_count, GLbitfield mask) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateClearColor( + GLES2Decoder* decoder, unsigned int arg_count, GLclampf red, GLclampf green, + GLclampf blue, GLclampf alpha) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateClearDepthf( + GLES2Decoder* decoder, unsigned int arg_count, GLclampf depth) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateClearStencil( + GLES2Decoder* decoder, unsigned int arg_count, GLint s) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateColorMask( + GLES2Decoder* decoder, unsigned int arg_count, GLboolean red, + GLboolean green, GLboolean blue, GLboolean alpha) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCompileShader( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCompressedTexImage2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLenum internalformat, GLsizei width, GLsizei height, GLint border, + GLsizei imageSize, const void* data) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCompressedTexImage2DImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLenum internalformat, GLsizei width, GLsizei height, GLint border, + GLsizei imageSize, const void* data) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCompressedTexSubImage2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, + GLsizei imageSize, const void* data) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCompressedTexSubImage2DImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, + GLsizei imageSize, const void* data) { + if (data == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCopyTexImage2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, + GLint border) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCopyTexSubImage2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, + GLsizei height) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCreateProgram( + GLES2Decoder* decoder, unsigned int arg_count) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCreateShader( + GLES2Decoder* decoder, unsigned int arg_count, GLenum type) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateCullFace( + GLES2Decoder* decoder, unsigned int arg_count, GLenum mode) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteBuffers( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* buffers) { + if (buffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteBuffersImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* buffers) { + if (buffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteFramebuffers( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* framebuffers) { + if (framebuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteFramebuffersImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* framebuffers) { + if (framebuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteProgram( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteRenderbuffers( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* renderbuffers) { + if (renderbuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteRenderbuffersImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* renderbuffers) { + if (renderbuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteShader( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteTextures( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* textures) { + if (textures == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDeleteTexturesImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + const GLuint* textures) { + if (textures == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDepthFunc( + GLES2Decoder* decoder, unsigned int arg_count, GLenum func) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDepthMask( + GLES2Decoder* decoder, unsigned int arg_count, GLboolean flag) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDepthRangef( + GLES2Decoder* decoder, unsigned int arg_count, GLclampf zNear, + GLclampf zFar) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDetachShader( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + GLuint shader) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDisable( + GLES2Decoder* decoder, unsigned int arg_count, GLenum cap) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDisableVertexAttribArray( + GLES2Decoder* decoder, unsigned int arg_count, GLuint index) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDrawArrays( + GLES2Decoder* decoder, unsigned int arg_count, GLenum mode, GLint first, + GLsizei count) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateDrawElements( + GLES2Decoder* decoder, unsigned int arg_count, GLenum mode, GLsizei count, + GLenum type, const void* indices) { + if (indices == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateEnable( + GLES2Decoder* decoder, unsigned int arg_count, GLenum cap) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateEnableVertexAttribArray( + GLES2Decoder* decoder, unsigned int arg_count, GLuint index) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateFinish( + GLES2Decoder* decoder, unsigned int arg_count) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateFlush( + GLES2Decoder* decoder, unsigned int arg_count) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateFramebufferRenderbuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateFramebufferTexture2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLenum attachment, GLenum textarget, GLuint texture, GLint level) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateFrontFace( + GLES2Decoder* decoder, unsigned int arg_count, GLenum mode) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenBuffers( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* buffers) { + if (buffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenBuffersImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* buffers) { + if (buffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenerateMipmap( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenFramebuffers( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* framebuffers) { + if (framebuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenFramebuffersImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* framebuffers) { + if (framebuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenRenderbuffers( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* renderbuffers) { + if (renderbuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenRenderbuffersImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* renderbuffers) { + if (renderbuffers == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenTextures( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* textures) { + if (textures == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGenTexturesImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLsizei n, + GLuint* textures) { + if (textures == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetActiveAttrib( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, GLuint index, + GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) { + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + if (size == NULL) { + return parse_error::kParseOutOfBounds; + } + if (type == NULL) { + return parse_error::kParseOutOfBounds; + } + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetActiveUniform( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, GLuint index, + GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) { + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + if (size == NULL) { + return parse_error::kParseOutOfBounds; + } + if (type == NULL) { + return parse_error::kParseOutOfBounds; + } + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetAttachedShaders( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + GLsizei maxcount, GLsizei* count, GLuint* shaders) { + if (count == NULL) { + return parse_error::kParseOutOfBounds; + } + if (shaders == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetAttribLocation( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + const char* name) { + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetAttribLocationImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + const char* name) { + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetBooleanv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum pname, + GLboolean* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetBufferParameteriv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetError( + GLES2Decoder* decoder, unsigned int arg_count) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetFloatv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum pname, + GLfloat* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetFramebufferAttachmentParameteriv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLenum attachment, GLenum pname, GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetIntegerv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetProgramiv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetProgramInfoLog( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + GLsizei bufsize, GLsizei* length, char* infolog) { + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + if (infolog == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetRenderbufferParameteriv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetShaderiv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetShaderInfoLog( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader, + GLsizei bufsize, GLsizei* length, char* infolog) { + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + if (infolog == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetShaderPrecisionFormat( + GLES2Decoder* decoder, unsigned int arg_count, GLenum shadertype, + GLenum precisiontype, GLint* range, GLint* precision) { + if (range == NULL) { + return parse_error::kParseOutOfBounds; + } + if (precision == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetShaderSource( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader, + GLsizei bufsize, GLsizei* length, char* source) { + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + if (source == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetString( + GLES2Decoder* decoder, unsigned int arg_count, GLenum name) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetTexParameterfv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + GLfloat* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetTexParameteriv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetUniformfv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + GLint location, GLfloat* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetUniformiv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + GLint location, GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetUniformLocation( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + const char* name) { + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetUniformLocationImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program, + const char* name) { + if (name == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetVertexAttribfv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint index, GLenum pname, + GLfloat* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetVertexAttribiv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint index, GLenum pname, + GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateGetVertexAttribPointerv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint index, GLenum pname, + void** pointer) { + if (pointer == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateHint( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLenum mode) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsBuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLuint buffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsEnabled( + GLES2Decoder* decoder, unsigned int arg_count, GLenum cap) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsFramebuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLuint framebuffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsProgram( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsRenderbuffer( + GLES2Decoder* decoder, unsigned int arg_count, GLuint renderbuffer) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsShader( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateIsTexture( + GLES2Decoder* decoder, unsigned int arg_count, GLuint texture) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateLineWidth( + GLES2Decoder* decoder, unsigned int arg_count, GLfloat width) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateLinkProgram( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidatePixelStorei( + GLES2Decoder* decoder, unsigned int arg_count, GLenum pname, GLint param) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidatePolygonOffset( + GLES2Decoder* decoder, unsigned int arg_count, GLfloat factor, + GLfloat units) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateReadPixels( + GLES2Decoder* decoder, unsigned int arg_count, GLint x, GLint y, + GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) { + if (pixels == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateRenderbufferStorage( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, + GLenum internalformat, GLsizei width, GLsizei height) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateSampleCoverage( + GLES2Decoder* decoder, unsigned int arg_count, GLclampf value, + GLboolean invert) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateScissor( + GLES2Decoder* decoder, unsigned int arg_count, GLint x, GLint y, + GLsizei width, GLsizei height) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateShaderSource( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader, GLsizei count, + const char** string, const GLint* length) { + if (string == NULL) { + return parse_error::kParseOutOfBounds; + } + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateShaderSourceImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint shader, GLsizei count, + const char** string, const GLint* length) { + if (string == NULL) { + return parse_error::kParseOutOfBounds; + } + if (length == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateStencilFunc( + GLES2Decoder* decoder, unsigned int arg_count, GLenum func, GLint ref, + GLuint mask) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateStencilFuncSeparate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum face, GLenum func, + GLint ref, GLuint mask) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateStencilMask( + GLES2Decoder* decoder, unsigned int arg_count, GLuint mask) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateStencilMaskSeparate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum face, GLuint mask) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateStencilOp( + GLES2Decoder* decoder, unsigned int arg_count, GLenum fail, GLenum zfail, + GLenum zpass) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateStencilOpSeparate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum face, GLenum fail, + GLenum zfail, GLenum zpass) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexImage2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint internalformat, GLsizei width, GLsizei height, GLint border, + GLenum format, GLenum type, const void* pixels) { + if (pixels == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexImage2DImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint internalformat, GLsizei width, GLsizei height, GLint border, + GLenum format, GLenum type, const void* pixels) { + if (pixels == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexParameterf( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + GLfloat param) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexParameterfv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + const GLfloat* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexParameterfvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + const GLfloat* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<TexParameterfvImmediate>( + arg_count, 1, sizeof(GLfloat), 1)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexParameteri( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + GLint param) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexParameteriv( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + const GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexParameterivImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLenum pname, + const GLint* params) { + if (params == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<TexParameterivImmediate>( + arg_count, 1, sizeof(GLint), 1)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexSubImage2D( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, + GLenum type, const void* pixels) { + if (pixels == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateTexSubImage2DImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLenum target, GLint level, + GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, + GLenum type, const void* pixels) { + if (pixels == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform1f( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLfloat x) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform1fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform1fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform1fvImmediate>( + arg_count, count, sizeof(GLfloat), 1)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform1i( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLint x) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform1iv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform1ivImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform1ivImmediate>( + arg_count, count, sizeof(GLint), 1)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform2f( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLfloat x, + GLfloat y) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform2fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform2fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform2fvImmediate>( + arg_count, count, sizeof(GLfloat), 2)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform2i( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLint x, + GLint y) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform2iv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform2ivImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform2ivImmediate>( + arg_count, count, sizeof(GLint), 2)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform3f( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLfloat x, + GLfloat y, GLfloat z) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform3fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform3fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform3fvImmediate>( + arg_count, count, sizeof(GLfloat), 3)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform3i( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLint x, + GLint y, GLint z) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform3iv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform3ivImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform3ivImmediate>( + arg_count, count, sizeof(GLint), 3)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform4f( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLfloat x, + GLfloat y, GLfloat z, GLfloat w) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform4fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform4fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLfloat* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform4fvImmediate>( + arg_count, count, sizeof(GLfloat), 4)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform4i( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, GLint x, + GLint y, GLint z, GLint w) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform4iv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniform4ivImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, const GLint* v) { + if (v == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<Uniform4ivImmediate>( + arg_count, count, sizeof(GLint), 4)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniformMatrix2fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, GLboolean transpose, const GLfloat* value) { + if (value == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniformMatrix2fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, GLboolean transpose, const GLfloat* value) { + if (value == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<UniformMatrix2fvImmediate>( + arg_count, count, sizeof(GLfloat), 4)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniformMatrix3fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, GLboolean transpose, const GLfloat* value) { + if (value == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniformMatrix3fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, GLboolean transpose, const GLfloat* value) { + if (value == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<UniformMatrix3fvImmediate>( + arg_count, count, sizeof(GLfloat), 9)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniformMatrix4fv( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, GLboolean transpose, const GLfloat* value) { + if (value == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUniformMatrix4fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLint location, + GLsizei count, GLboolean transpose, const GLfloat* value) { + if (value == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<UniformMatrix4fvImmediate>( + arg_count, count, sizeof(GLfloat), 16)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateUseProgram( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateValidateProgram( + GLES2Decoder* decoder, unsigned int arg_count, GLuint program) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib1f( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, GLfloat x) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib1fv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib1fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<VertexAttrib1fvImmediate>( + arg_count, 1, sizeof(GLfloat), 1)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib2f( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, GLfloat x, + GLfloat y) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib2fv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib2fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<VertexAttrib2fvImmediate>( + arg_count, 1, sizeof(GLfloat), 2)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib3f( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, GLfloat x, + GLfloat y, GLfloat z) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib3fv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib3fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<VertexAttrib3fvImmediate>( + arg_count, 1, sizeof(GLfloat), 3)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib4f( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, GLfloat x, + GLfloat y, GLfloat z, GLfloat w) { + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib4fv( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttrib4fvImmediate( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, + const GLfloat* values) { + if (values == NULL) { + return parse_error::kParseOutOfBounds; + } + if (!CheckImmediateDataSize<VertexAttrib4fvImmediate>( + arg_count, 1, sizeof(GLfloat), 4)) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateVertexAttribPointer( + GLES2Decoder* decoder, unsigned int arg_count, GLuint indx, GLint size, + GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) { + if (ptr == NULL) { + return parse_error::kParseOutOfBounds; + } + return parse_error::kParseNoError; +} +parse_error::ParseError ValidateViewport( + GLES2Decoder* decoder, unsigned int arg_count, GLint x, GLint y, + GLsizei width, GLsizei height) { + return parse_error::kParseNoError; +} +} // anonymous namespace +} // namespace gles2 +} // namespace command_buffer + diff --git a/o3d/gpu/gpu.gyp b/o3d/gpu/gpu.gyp index 2079e1e..7e348da 100644 --- a/o3d/gpu/gpu.gyp +++ b/o3d/gpu/gpu.gyp @@ -14,11 +14,13 @@ 'target_name': 'command_buffer_common', 'type': 'static_library', 'include_dirs': [ + 'command_buffer/common', '..', '../..', ], 'all_dependent_settings': { 'include_dirs': [ + 'command_buffer/common', '..', '../..', ], @@ -27,6 +29,10 @@ 'command_buffer/common/bitfield_helpers.h', 'command_buffer/common/cmd_buffer_common.h', 'command_buffer/common/cmd_buffer_common.cc', + 'command_buffer/common/gles2_cmd_format.cc', + 'command_buffer/common/gles2_cmd_format.h', + 'command_buffer/common/gles2_cmd_utils.cc', + 'command_buffer/common/gles2_cmd_utils.h', 'command_buffer/common/o3d_cmd_format.h', 'command_buffer/common/o3d_cmd_format.cc', 'command_buffer/common/gapi_interface.h', @@ -38,11 +44,64 @@ ], }, { + # Library helps make GLES2 command buffers. + 'target_name': 'gles2_cmd_helper', + 'type': 'static_library', + 'dependencies': [ + 'command_buffer_common', + 'np_utils', + ], + 'sources': [ + 'command_buffer/client/gles2_cmd_helper.cc', + 'command_buffer/client/gles2_cmd_helper.h', + 'command_buffer/client/gles2_cmd_helper_autogen.h', + ], + }, + { + # Library emulates GLES2 using command_buffers. + 'target_name': 'gles2_implementation', + 'type': 'static_library', + 'dependencies': [ + 'gles2_cmd_helper', + ], + 'sources': [ + 'command_buffer/client/gles2_implementation_autogen.h', + 'command_buffer/client/gles2_implementation.cc', + 'command_buffer/client/gles2_implementation_gen.h', + 'command_buffer/client/gles2_implementation.h', + ], + }, + { + # Stub to expose gles2_implementation as a namespace rather than a class + # so GLES2 programs can work with no changes. + 'target_name': 'gles2_lib', + 'type': 'static_library', + 'dependencies': [ + 'gles2_implementation', + ], + 'sources': [ + 'command_buffer/client/gles2_lib.cc', + 'command_buffer/client/gles2_lib.h', + 'command_buffer/client/gles2_lib_autogen.h', + ], + }, + { 'target_name': 'command_buffer_common_unittests', 'type': 'none', + 'include_dirs': [ + 'command_buffer/common', + ], + 'dependencies': [ + 'gles2_lib', + 'gles2_implementation', + 'gles2_cmd_helper', + ], 'direct_dependent_settings': { 'sources': [ 'command_buffer/common/bitfield_helpers_test.cc', + 'command_buffer/common/gles2_cmd_format_test.cc', + 'command_buffer/common/gles2_cmd_format_test_autogen.h', + 'command_buffer/common/gles2_cmd_id_test.cc', ], }, }, @@ -80,6 +139,9 @@ { 'target_name': 'command_buffer_service', 'type': 'static_library', + 'defines': [ + 'GPU_SERVICE=1', + ], 'include_dirs': [ '..', '../..', @@ -168,6 +230,10 @@ 'command_buffer/service/gapi_gl.h', 'command_buffer/service/geometry_gl.cc', 'command_buffer/service/geometry_gl.h', + 'command_buffer/service/gles2_cmd_decoder.h', + 'command_buffer/service/gles2_cmd_decoder_validate.h', + 'command_buffer/service/gles2_cmd_decoder_autogen.h', + 'command_buffer/service/gles2_cmd_decoder.cc', 'command_buffer/service/gl_utils.h', 'command_buffer/service/render_surface_gl.cc', 'command_buffer/service/render_surface_gl.h', |