| OLD | NEW |
|---|
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 // This file is auto-generated from | 5 // This file is auto-generated from |
| 6 // gpu/command_buffer/build_gles2_cmd_buffer.py | 6 // gpu/command_buffer/build_gles2_cmd_buffer.py |
| 7 // It's formatted by clang-format using chromium coding style: | 7 // It's formatted by clang-format using chromium coding style: |
| 8 // clang-format -i -style=chromium filename | 8 // clang-format -i -style=chromium filename |
| 9 // DO NOT EDIT! | 9 // DO NOT EDIT! |
| 10 | 10 |
| (...skipping 10864 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 10875 uint32 matrixMode; | 10875 uint32 matrixMode; |
| 10876 }; | 10876 }; |
| 10877 | 10877 |
| 10878 COMPILE_ASSERT(sizeof(MatrixLoadIdentityCHROMIUM) == 8, | 10878 COMPILE_ASSERT(sizeof(MatrixLoadIdentityCHROMIUM) == 8, |
| 10879 Sizeof_MatrixLoadIdentityCHROMIUM_is_not_8); | 10879 Sizeof_MatrixLoadIdentityCHROMIUM_is_not_8); |
| 10880 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0, | 10880 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0, |
| 10881 OffsetOf_MatrixLoadIdentityCHROMIUM_header_not_0); | 10881 OffsetOf_MatrixLoadIdentityCHROMIUM_header_not_0); |
| 10882 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4, | 10882 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4, |
| 10883 OffsetOf_MatrixLoadIdentityCHROMIUM_matrixMode_not_4); | 10883 OffsetOf_MatrixLoadIdentityCHROMIUM_matrixMode_not_4); |
| 10884 | 10884 |
| 10885 struct GenPathsCHROMIUM { |
| 10886 typedef GenPathsCHROMIUM ValueType; |
| 10887 static const CommandId kCmdId = kGenPathsCHROMIUM; |
| 10888 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 10889 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 10890 |
| 10891 static uint32 ComputeSize() { |
| 10892 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 10893 } |
| 10894 |
| 10895 void SetHeader() { header.SetCmd<ValueType>(); } |
| 10896 |
| 10897 void Init(GLsizei _range, |
| 10898 uint32 _client_ids_shm_id, |
| 10899 uint32 _client_ids_shm_offset) { |
| 10900 SetHeader(); |
| 10901 range = _range; |
| 10902 client_ids_shm_id = _client_ids_shm_id; |
| 10903 client_ids_shm_offset = _client_ids_shm_offset; |
| 10904 } |
| 10905 |
| 10906 void* Set(void* cmd, |
| 10907 GLsizei _range, |
| 10908 uint32 _client_ids_shm_id, |
| 10909 uint32 _client_ids_shm_offset) { |
| 10910 static_cast<ValueType*>(cmd) |
| 10911 ->Init(_range, _client_ids_shm_id, _client_ids_shm_offset); |
| 10912 return NextCmdAddress<ValueType>(cmd); |
| 10913 } |
| 10914 |
| 10915 gpu::CommandHeader header; |
| 10916 int32 range; |
| 10917 uint32 client_ids_shm_id; |
| 10918 uint32 client_ids_shm_offset; |
| 10919 }; |
| 10920 |
| 10921 COMPILE_ASSERT(sizeof(GenPathsCHROMIUM) == 16, |
| 10922 Sizeof_GenPathsCHROMIUM_is_not_16); |
| 10923 COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, header) == 0, |
| 10924 OffsetOf_GenPathsCHROMIUM_header_not_0); |
| 10925 COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, range) == 4, |
| 10926 OffsetOf_GenPathsCHROMIUM_range_not_4); |
| 10927 COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, client_ids_shm_id) == 8, |
| 10928 OffsetOf_GenPathsCHROMIUM_client_ids_shm_id_not_8); |
| 10929 COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, client_ids_shm_offset) == 12, |
| 10930 OffsetOf_GenPathsCHROMIUM_client_ids_shm_offset_not_12); |
| 10931 |
| 10932 struct DeletePathsCHROMIUM { |
| 10933 typedef DeletePathsCHROMIUM ValueType; |
| 10934 static const CommandId kCmdId = kDeletePathsCHROMIUM; |
| 10935 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 10936 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 10937 |
| 10938 static uint32 ComputeSize() { |
| 10939 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 10940 } |
| 10941 |
| 10942 void SetHeader() { header.SetCmd<ValueType>(); } |
| 10943 |
| 10944 void Init(GLuint _path, GLsizei _range) { |
| 10945 SetHeader(); |
| 10946 path = _path; |
| 10947 range = _range; |
| 10948 } |
| 10949 |
| 10950 void* Set(void* cmd, GLuint _path, GLsizei _range) { |
| 10951 static_cast<ValueType*>(cmd)->Init(_path, _range); |
| 10952 return NextCmdAddress<ValueType>(cmd); |
| 10953 } |
| 10954 |
| 10955 gpu::CommandHeader header; |
| 10956 uint32 path; |
| 10957 int32 range; |
| 10958 }; |
| 10959 |
| 10960 COMPILE_ASSERT(sizeof(DeletePathsCHROMIUM) == 12, |
| 10961 Sizeof_DeletePathsCHROMIUM_is_not_12); |
| 10962 COMPILE_ASSERT(offsetof(DeletePathsCHROMIUM, header) == 0, |
| 10963 OffsetOf_DeletePathsCHROMIUM_header_not_0); |
| 10964 COMPILE_ASSERT(offsetof(DeletePathsCHROMIUM, path) == 4, |
| 10965 OffsetOf_DeletePathsCHROMIUM_path_not_4); |
| 10966 COMPILE_ASSERT(offsetof(DeletePathsCHROMIUM, range) == 8, |
| 10967 OffsetOf_DeletePathsCHROMIUM_range_not_8); |
| 10968 |
| 10969 struct PathCommandsCHROMIUM { |
| 10970 typedef PathCommandsCHROMIUM ValueType; |
| 10971 static const CommandId kCmdId = kPathCommandsCHROMIUM; |
| 10972 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 10973 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 10974 |
| 10975 static uint32 ComputeSize() { |
| 10976 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 10977 } |
| 10978 |
| 10979 void SetHeader() { header.SetCmd<ValueType>(); } |
| 10980 |
| 10981 void Init(GLuint _path, |
| 10982 GLsizei _numCommands, |
| 10983 uint32 _commands_shm_id, |
| 10984 uint32 _commands_shm_offset, |
| 10985 GLsizei _numCoords, |
| 10986 GLenum _coordType, |
| 10987 uint32 _coords_shm_id, |
| 10988 uint32 _coords_shm_offset) { |
| 10989 SetHeader(); |
| 10990 path = _path; |
| 10991 numCommands = _numCommands; |
| 10992 commands_shm_id = _commands_shm_id; |
| 10993 commands_shm_offset = _commands_shm_offset; |
| 10994 numCoords = _numCoords; |
| 10995 coordType = _coordType; |
| 10996 coords_shm_id = _coords_shm_id; |
| 10997 coords_shm_offset = _coords_shm_offset; |
| 10998 } |
| 10999 |
| 11000 void* Set(void* cmd, |
| 11001 GLuint _path, |
| 11002 GLsizei _numCommands, |
| 11003 uint32 _commands_shm_id, |
| 11004 uint32 _commands_shm_offset, |
| 11005 GLsizei _numCoords, |
| 11006 GLenum _coordType, |
| 11007 uint32 _coords_shm_id, |
| 11008 uint32 _coords_shm_offset) { |
| 11009 static_cast<ValueType*>(cmd)->Init(_path, |
| 11010 _numCommands, |
| 11011 _commands_shm_id, |
| 11012 _commands_shm_offset, |
| 11013 _numCoords, |
| 11014 _coordType, |
| 11015 _coords_shm_id, |
| 11016 _coords_shm_offset); |
| 11017 return NextCmdAddress<ValueType>(cmd); |
| 11018 } |
| 11019 |
| 11020 gpu::CommandHeader header; |
| 11021 uint32 path; |
| 11022 int32 numCommands; |
| 11023 uint32 commands_shm_id; |
| 11024 uint32 commands_shm_offset; |
| 11025 int32 numCoords; |
| 11026 uint32 coordType; |
| 11027 uint32 coords_shm_id; |
| 11028 uint32 coords_shm_offset; |
| 11029 }; |
| 11030 |
| 11031 COMPILE_ASSERT(sizeof(PathCommandsCHROMIUM) == 36, |
| 11032 Sizeof_PathCommandsCHROMIUM_is_not_36); |
| 11033 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, header) == 0, |
| 11034 OffsetOf_PathCommandsCHROMIUM_header_not_0); |
| 11035 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, path) == 4, |
| 11036 OffsetOf_PathCommandsCHROMIUM_path_not_4); |
| 11037 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, numCommands) == 8, |
| 11038 OffsetOf_PathCommandsCHROMIUM_numCommands_not_8); |
| 11039 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, commands_shm_id) == 12, |
| 11040 OffsetOf_PathCommandsCHROMIUM_commands_shm_id_not_12); |
| 11041 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, commands_shm_offset) == 16, |
| 11042 OffsetOf_PathCommandsCHROMIUM_commands_shm_offset_not_16); |
| 11043 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, numCoords) == 20, |
| 11044 OffsetOf_PathCommandsCHROMIUM_numCoords_not_20); |
| 11045 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, coordType) == 24, |
| 11046 OffsetOf_PathCommandsCHROMIUM_coordType_not_24); |
| 11047 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, coords_shm_id) == 28, |
| 11048 OffsetOf_PathCommandsCHROMIUM_coords_shm_id_not_28); |
| 11049 COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, coords_shm_offset) == 32, |
| 11050 OffsetOf_PathCommandsCHROMIUM_coords_shm_offset_not_32); |
| 11051 |
| 11052 struct PathParameterfCHROMIUM { |
| 11053 typedef PathParameterfCHROMIUM ValueType; |
| 11054 static const CommandId kCmdId = kPathParameterfCHROMIUM; |
| 11055 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11056 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11057 |
| 11058 static uint32 ComputeSize() { |
| 11059 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11060 } |
| 11061 |
| 11062 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11063 |
| 11064 void Init(GLuint _path, GLenum _pname, GLfloat _value) { |
| 11065 SetHeader(); |
| 11066 path = _path; |
| 11067 pname = _pname; |
| 11068 value = _value; |
| 11069 } |
| 11070 |
| 11071 void* Set(void* cmd, GLuint _path, GLenum _pname, GLfloat _value) { |
| 11072 static_cast<ValueType*>(cmd)->Init(_path, _pname, _value); |
| 11073 return NextCmdAddress<ValueType>(cmd); |
| 11074 } |
| 11075 |
| 11076 gpu::CommandHeader header; |
| 11077 uint32 path; |
| 11078 uint32 pname; |
| 11079 float value; |
| 11080 }; |
| 11081 |
| 11082 COMPILE_ASSERT(sizeof(PathParameterfCHROMIUM) == 16, |
| 11083 Sizeof_PathParameterfCHROMIUM_is_not_16); |
| 11084 COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, header) == 0, |
| 11085 OffsetOf_PathParameterfCHROMIUM_header_not_0); |
| 11086 COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, path) == 4, |
| 11087 OffsetOf_PathParameterfCHROMIUM_path_not_4); |
| 11088 COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, pname) == 8, |
| 11089 OffsetOf_PathParameterfCHROMIUM_pname_not_8); |
| 11090 COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, value) == 12, |
| 11091 OffsetOf_PathParameterfCHROMIUM_value_not_12); |
| 11092 |
| 11093 struct PathParameteriCHROMIUM { |
| 11094 typedef PathParameteriCHROMIUM ValueType; |
| 11095 static const CommandId kCmdId = kPathParameteriCHROMIUM; |
| 11096 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11097 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11098 |
| 11099 static uint32 ComputeSize() { |
| 11100 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11101 } |
| 11102 |
| 11103 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11104 |
| 11105 void Init(GLuint _path, GLenum _pname, GLint _value) { |
| 11106 SetHeader(); |
| 11107 path = _path; |
| 11108 pname = _pname; |
| 11109 value = _value; |
| 11110 } |
| 11111 |
| 11112 void* Set(void* cmd, GLuint _path, GLenum _pname, GLint _value) { |
| 11113 static_cast<ValueType*>(cmd)->Init(_path, _pname, _value); |
| 11114 return NextCmdAddress<ValueType>(cmd); |
| 11115 } |
| 11116 |
| 11117 gpu::CommandHeader header; |
| 11118 uint32 path; |
| 11119 uint32 pname; |
| 11120 int32 value; |
| 11121 }; |
| 11122 |
| 11123 COMPILE_ASSERT(sizeof(PathParameteriCHROMIUM) == 16, |
| 11124 Sizeof_PathParameteriCHROMIUM_is_not_16); |
| 11125 COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, header) == 0, |
| 11126 OffsetOf_PathParameteriCHROMIUM_header_not_0); |
| 11127 COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, path) == 4, |
| 11128 OffsetOf_PathParameteriCHROMIUM_path_not_4); |
| 11129 COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, pname) == 8, |
| 11130 OffsetOf_PathParameteriCHROMIUM_pname_not_8); |
| 11131 COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, value) == 12, |
| 11132 OffsetOf_PathParameteriCHROMIUM_value_not_12); |
| 11133 |
| 11134 struct PathStencilFuncCHROMIUM { |
| 11135 typedef PathStencilFuncCHROMIUM ValueType; |
| 11136 static const CommandId kCmdId = kPathStencilFuncCHROMIUM; |
| 11137 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11138 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11139 |
| 11140 static uint32 ComputeSize() { |
| 11141 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11142 } |
| 11143 |
| 11144 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11145 |
| 11146 void Init(GLenum _func, GLint _ref, GLuint _mask) { |
| 11147 SetHeader(); |
| 11148 func = _func; |
| 11149 ref = _ref; |
| 11150 mask = _mask; |
| 11151 } |
| 11152 |
| 11153 void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) { |
| 11154 static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask); |
| 11155 return NextCmdAddress<ValueType>(cmd); |
| 11156 } |
| 11157 |
| 11158 gpu::CommandHeader header; |
| 11159 uint32 func; |
| 11160 int32 ref; |
| 11161 uint32 mask; |
| 11162 }; |
| 11163 |
| 11164 COMPILE_ASSERT(sizeof(PathStencilFuncCHROMIUM) == 16, |
| 11165 Sizeof_PathStencilFuncCHROMIUM_is_not_16); |
| 11166 COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, header) == 0, |
| 11167 OffsetOf_PathStencilFuncCHROMIUM_header_not_0); |
| 11168 COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, func) == 4, |
| 11169 OffsetOf_PathStencilFuncCHROMIUM_func_not_4); |
| 11170 COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, ref) == 8, |
| 11171 OffsetOf_PathStencilFuncCHROMIUM_ref_not_8); |
| 11172 COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, mask) == 12, |
| 11173 OffsetOf_PathStencilFuncCHROMIUM_mask_not_12); |
| 11174 |
| 11175 struct StencilFillPathCHROMIUM { |
| 11176 typedef StencilFillPathCHROMIUM ValueType; |
| 11177 static const CommandId kCmdId = kStencilFillPathCHROMIUM; |
| 11178 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11179 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11180 |
| 11181 static uint32 ComputeSize() { |
| 11182 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11183 } |
| 11184 |
| 11185 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11186 |
| 11187 void Init(GLuint _path, GLenum _fillMode, GLuint _mask) { |
| 11188 SetHeader(); |
| 11189 path = _path; |
| 11190 fillMode = _fillMode; |
| 11191 mask = _mask; |
| 11192 } |
| 11193 |
| 11194 void* Set(void* cmd, GLuint _path, GLenum _fillMode, GLuint _mask) { |
| 11195 static_cast<ValueType*>(cmd)->Init(_path, _fillMode, _mask); |
| 11196 return NextCmdAddress<ValueType>(cmd); |
| 11197 } |
| 11198 |
| 11199 gpu::CommandHeader header; |
| 11200 uint32 path; |
| 11201 uint32 fillMode; |
| 11202 uint32 mask; |
| 11203 }; |
| 11204 |
| 11205 COMPILE_ASSERT(sizeof(StencilFillPathCHROMIUM) == 16, |
| 11206 Sizeof_StencilFillPathCHROMIUM_is_not_16); |
| 11207 COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, header) == 0, |
| 11208 OffsetOf_StencilFillPathCHROMIUM_header_not_0); |
| 11209 COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, path) == 4, |
| 11210 OffsetOf_StencilFillPathCHROMIUM_path_not_4); |
| 11211 COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, fillMode) == 8, |
| 11212 OffsetOf_StencilFillPathCHROMIUM_fillMode_not_8); |
| 11213 COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, mask) == 12, |
| 11214 OffsetOf_StencilFillPathCHROMIUM_mask_not_12); |
| 11215 |
| 11216 struct StencilFillPathInstancedCHROMIUM { |
| 11217 typedef StencilFillPathInstancedCHROMIUM ValueType; |
| 11218 static const CommandId kCmdId = kStencilFillPathInstancedCHROMIUM; |
| 11219 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11220 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11221 |
| 11222 static uint32 ComputeSize() { |
| 11223 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11224 } |
| 11225 |
| 11226 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11227 |
| 11228 void Init(GLsizei _numPaths, |
| 11229 GLenum _pathNameType, |
| 11230 uint32 _paths_shm_id, |
| 11231 uint32 _paths_shm_offset, |
| 11232 GLuint _pathBase, |
| 11233 GLenum _fillMode, |
| 11234 GLuint _mask, |
| 11235 GLenum _transformType, |
| 11236 uint32 _transformValues_shm_id, |
| 11237 uint32 _transformValues_shm_offset) { |
| 11238 SetHeader(); |
| 11239 numPaths = _numPaths; |
| 11240 pathNameType = _pathNameType; |
| 11241 paths_shm_id = _paths_shm_id; |
| 11242 paths_shm_offset = _paths_shm_offset; |
| 11243 pathBase = _pathBase; |
| 11244 fillMode = _fillMode; |
| 11245 mask = _mask; |
| 11246 transformType = _transformType; |
| 11247 transformValues_shm_id = _transformValues_shm_id; |
| 11248 transformValues_shm_offset = _transformValues_shm_offset; |
| 11249 } |
| 11250 |
| 11251 void* Set(void* cmd, |
| 11252 GLsizei _numPaths, |
| 11253 GLenum _pathNameType, |
| 11254 uint32 _paths_shm_id, |
| 11255 uint32 _paths_shm_offset, |
| 11256 GLuint _pathBase, |
| 11257 GLenum _fillMode, |
| 11258 GLuint _mask, |
| 11259 GLenum _transformType, |
| 11260 uint32 _transformValues_shm_id, |
| 11261 uint32 _transformValues_shm_offset) { |
| 11262 static_cast<ValueType*>(cmd)->Init(_numPaths, |
| 11263 _pathNameType, |
| 11264 _paths_shm_id, |
| 11265 _paths_shm_offset, |
| 11266 _pathBase, |
| 11267 _fillMode, |
| 11268 _mask, |
| 11269 _transformType, |
| 11270 _transformValues_shm_id, |
| 11271 _transformValues_shm_offset); |
| 11272 return NextCmdAddress<ValueType>(cmd); |
| 11273 } |
| 11274 |
| 11275 gpu::CommandHeader header; |
| 11276 int32 numPaths; |
| 11277 uint32 pathNameType; |
| 11278 uint32 paths_shm_id; |
| 11279 uint32 paths_shm_offset; |
| 11280 uint32 pathBase; |
| 11281 uint32 fillMode; |
| 11282 uint32 mask; |
| 11283 uint32 transformType; |
| 11284 uint32 transformValues_shm_id; |
| 11285 uint32 transformValues_shm_offset; |
| 11286 }; |
| 11287 |
| 11288 COMPILE_ASSERT(sizeof(StencilFillPathInstancedCHROMIUM) == 44, |
| 11289 Sizeof_StencilFillPathInstancedCHROMIUM_is_not_44); |
| 11290 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, header) == 0, |
| 11291 OffsetOf_StencilFillPathInstancedCHROMIUM_header_not_0); |
| 11292 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, numPaths) == 4, |
| 11293 OffsetOf_StencilFillPathInstancedCHROMIUM_numPaths_not_4); |
| 11294 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, pathNameType) == 8, |
| 11295 OffsetOf_StencilFillPathInstancedCHROMIUM_pathNameType_not_8); |
| 11296 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, paths_shm_id) == 12, |
| 11297 OffsetOf_StencilFillPathInstancedCHROMIUM_paths_shm_id_not_12); |
| 11298 COMPILE_ASSERT( |
| 11299 offsetof(StencilFillPathInstancedCHROMIUM, paths_shm_offset) == 16, |
| 11300 OffsetOf_StencilFillPathInstancedCHROMIUM_paths_shm_offset_not_16); |
| 11301 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, pathBase) == 20, |
| 11302 OffsetOf_StencilFillPathInstancedCHROMIUM_pathBase_not_20); |
| 11303 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, fillMode) == 24, |
| 11304 OffsetOf_StencilFillPathInstancedCHROMIUM_fillMode_not_24); |
| 11305 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, mask) == 28, |
| 11306 OffsetOf_StencilFillPathInstancedCHROMIUM_mask_not_28); |
| 11307 COMPILE_ASSERT(offsetof(StencilFillPathInstancedCHROMIUM, transformType) == 32, |
| 11308 OffsetOf_StencilFillPathInstancedCHROMIUM_transformType_not_32); |
| 11309 COMPILE_ASSERT( |
| 11310 offsetof(StencilFillPathInstancedCHROMIUM, transformValues_shm_id) == 36, |
| 11311 OffsetOf_StencilFillPathInstancedCHROMIUM_transformValues_shm_id_not_36); |
| 11312 COMPILE_ASSERT( |
| 11313 offsetof(StencilFillPathInstancedCHROMIUM, transformValues_shm_offset) == |
| 11314 40, |
| 11315 OffsetOf_StencilFillPathInstancedCHROMIUM_transformValues_shm_offset_not_40)
; |
| 11316 |
| 11317 struct StencilStrokePathCHROMIUM { |
| 11318 typedef StencilStrokePathCHROMIUM ValueType; |
| 11319 static const CommandId kCmdId = kStencilStrokePathCHROMIUM; |
| 11320 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11321 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11322 |
| 11323 static uint32 ComputeSize() { |
| 11324 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11325 } |
| 11326 |
| 11327 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11328 |
| 11329 void Init(GLuint _path, GLint _reference, GLuint _mask) { |
| 11330 SetHeader(); |
| 11331 path = _path; |
| 11332 reference = _reference; |
| 11333 mask = _mask; |
| 11334 } |
| 11335 |
| 11336 void* Set(void* cmd, GLuint _path, GLint _reference, GLuint _mask) { |
| 11337 static_cast<ValueType*>(cmd)->Init(_path, _reference, _mask); |
| 11338 return NextCmdAddress<ValueType>(cmd); |
| 11339 } |
| 11340 |
| 11341 gpu::CommandHeader header; |
| 11342 uint32 path; |
| 11343 int32 reference; |
| 11344 uint32 mask; |
| 11345 }; |
| 11346 |
| 11347 COMPILE_ASSERT(sizeof(StencilStrokePathCHROMIUM) == 16, |
| 11348 Sizeof_StencilStrokePathCHROMIUM_is_not_16); |
| 11349 COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, header) == 0, |
| 11350 OffsetOf_StencilStrokePathCHROMIUM_header_not_0); |
| 11351 COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, path) == 4, |
| 11352 OffsetOf_StencilStrokePathCHROMIUM_path_not_4); |
| 11353 COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, reference) == 8, |
| 11354 OffsetOf_StencilStrokePathCHROMIUM_reference_not_8); |
| 11355 COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, mask) == 12, |
| 11356 OffsetOf_StencilStrokePathCHROMIUM_mask_not_12); |
| 11357 |
| 11358 struct StencilStrokePathInstancedCHROMIUM { |
| 11359 typedef StencilStrokePathInstancedCHROMIUM ValueType; |
| 11360 static const CommandId kCmdId = kStencilStrokePathInstancedCHROMIUM; |
| 11361 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11362 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11363 |
| 11364 static uint32 ComputeSize() { |
| 11365 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11366 } |
| 11367 |
| 11368 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11369 |
| 11370 void Init(GLsizei _numPaths, |
| 11371 GLenum _pathNameType, |
| 11372 uint32 _paths_shm_id, |
| 11373 uint32 _paths_shm_offset, |
| 11374 GLuint _pathBase, |
| 11375 GLint _ref, |
| 11376 GLuint _mask, |
| 11377 GLenum _transformType, |
| 11378 uint32 _transformValues_shm_id, |
| 11379 uint32 _transformValues_shm_offset) { |
| 11380 SetHeader(); |
| 11381 numPaths = _numPaths; |
| 11382 pathNameType = _pathNameType; |
| 11383 paths_shm_id = _paths_shm_id; |
| 11384 paths_shm_offset = _paths_shm_offset; |
| 11385 pathBase = _pathBase; |
| 11386 ref = _ref; |
| 11387 mask = _mask; |
| 11388 transformType = _transformType; |
| 11389 transformValues_shm_id = _transformValues_shm_id; |
| 11390 transformValues_shm_offset = _transformValues_shm_offset; |
| 11391 } |
| 11392 |
| 11393 void* Set(void* cmd, |
| 11394 GLsizei _numPaths, |
| 11395 GLenum _pathNameType, |
| 11396 uint32 _paths_shm_id, |
| 11397 uint32 _paths_shm_offset, |
| 11398 GLuint _pathBase, |
| 11399 GLint _ref, |
| 11400 GLuint _mask, |
| 11401 GLenum _transformType, |
| 11402 uint32 _transformValues_shm_id, |
| 11403 uint32 _transformValues_shm_offset) { |
| 11404 static_cast<ValueType*>(cmd)->Init(_numPaths, |
| 11405 _pathNameType, |
| 11406 _paths_shm_id, |
| 11407 _paths_shm_offset, |
| 11408 _pathBase, |
| 11409 _ref, |
| 11410 _mask, |
| 11411 _transformType, |
| 11412 _transformValues_shm_id, |
| 11413 _transformValues_shm_offset); |
| 11414 return NextCmdAddress<ValueType>(cmd); |
| 11415 } |
| 11416 |
| 11417 gpu::CommandHeader header; |
| 11418 int32 numPaths; |
| 11419 uint32 pathNameType; |
| 11420 uint32 paths_shm_id; |
| 11421 uint32 paths_shm_offset; |
| 11422 uint32 pathBase; |
| 11423 int32 ref; |
| 11424 uint32 mask; |
| 11425 uint32 transformType; |
| 11426 uint32 transformValues_shm_id; |
| 11427 uint32 transformValues_shm_offset; |
| 11428 }; |
| 11429 |
| 11430 COMPILE_ASSERT(sizeof(StencilStrokePathInstancedCHROMIUM) == 44, |
| 11431 Sizeof_StencilStrokePathInstancedCHROMIUM_is_not_44); |
| 11432 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, header) == 0, |
| 11433 OffsetOf_StencilStrokePathInstancedCHROMIUM_header_not_0); |
| 11434 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, numPaths) == 4, |
| 11435 OffsetOf_StencilStrokePathInstancedCHROMIUM_numPaths_not_4); |
| 11436 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, pathNameType) == 8, |
| 11437 OffsetOf_StencilStrokePathInstancedCHROMIUM_pathNameType_not_8); |
| 11438 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, paths_shm_id) == 12, |
| 11439 OffsetOf_StencilStrokePathInstancedCHROMIUM_paths_shm_id_not_12); |
| 11440 COMPILE_ASSERT( |
| 11441 offsetof(StencilStrokePathInstancedCHROMIUM, paths_shm_offset) == 16, |
| 11442 OffsetOf_StencilStrokePathInstancedCHROMIUM_paths_shm_offset_not_16); |
| 11443 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, pathBase) == 20, |
| 11444 OffsetOf_StencilStrokePathInstancedCHROMIUM_pathBase_not_20); |
| 11445 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, ref) == 24, |
| 11446 OffsetOf_StencilStrokePathInstancedCHROMIUM_ref_not_24); |
| 11447 COMPILE_ASSERT(offsetof(StencilStrokePathInstancedCHROMIUM, mask) == 28, |
| 11448 OffsetOf_StencilStrokePathInstancedCHROMIUM_mask_not_28); |
| 11449 COMPILE_ASSERT( |
| 11450 offsetof(StencilStrokePathInstancedCHROMIUM, transformType) == 32, |
| 11451 OffsetOf_StencilStrokePathInstancedCHROMIUM_transformType_not_32); |
| 11452 COMPILE_ASSERT( |
| 11453 offsetof(StencilStrokePathInstancedCHROMIUM, transformValues_shm_id) == 36, |
| 11454 OffsetOf_StencilStrokePathInstancedCHROMIUM_transformValues_shm_id_not_36); |
| 11455 COMPILE_ASSERT( |
| 11456 offsetof(StencilStrokePathInstancedCHROMIUM, transformValues_shm_offset) == |
| 11457 40, |
| 11458 OffsetOf_StencilStrokePathInstancedCHROMIUM_transformValues_shm_offset_not_4
0); |
| 11459 |
| 11460 struct PathTexGenCHROMIUM { |
| 11461 typedef PathTexGenCHROMIUM ValueType; |
| 11462 static const CommandId kCmdId = kPathTexGenCHROMIUM; |
| 11463 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11464 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11465 |
| 11466 static uint32 ComputeSize() { |
| 11467 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11468 } |
| 11469 |
| 11470 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11471 |
| 11472 void Init(GLenum _texCoordSet, |
| 11473 GLenum _genMode, |
| 11474 GLint _components, |
| 11475 uint32 _coeffs_shm_id, |
| 11476 uint32 _coeffs_shm_offset) { |
| 11477 SetHeader(); |
| 11478 texCoordSet = _texCoordSet; |
| 11479 genMode = _genMode; |
| 11480 components = _components; |
| 11481 coeffs_shm_id = _coeffs_shm_id; |
| 11482 coeffs_shm_offset = _coeffs_shm_offset; |
| 11483 } |
| 11484 |
| 11485 void* Set(void* cmd, |
| 11486 GLenum _texCoordSet, |
| 11487 GLenum _genMode, |
| 11488 GLint _components, |
| 11489 uint32 _coeffs_shm_id, |
| 11490 uint32 _coeffs_shm_offset) { |
| 11491 static_cast<ValueType*>(cmd)->Init(_texCoordSet, |
| 11492 _genMode, |
| 11493 _components, |
| 11494 _coeffs_shm_id, |
| 11495 _coeffs_shm_offset); |
| 11496 return NextCmdAddress<ValueType>(cmd); |
| 11497 } |
| 11498 |
| 11499 gpu::CommandHeader header; |
| 11500 uint32 texCoordSet; |
| 11501 uint32 genMode; |
| 11502 int32 components; |
| 11503 uint32 coeffs_shm_id; |
| 11504 uint32 coeffs_shm_offset; |
| 11505 }; |
| 11506 |
| 11507 COMPILE_ASSERT(sizeof(PathTexGenCHROMIUM) == 24, |
| 11508 Sizeof_PathTexGenCHROMIUM_is_not_24); |
| 11509 COMPILE_ASSERT(offsetof(PathTexGenCHROMIUM, header) == 0, |
| 11510 OffsetOf_PathTexGenCHROMIUM_header_not_0); |
| 11511 COMPILE_ASSERT(offsetof(PathTexGenCHROMIUM, texCoordSet) == 4, |
| 11512 OffsetOf_PathTexGenCHROMIUM_texCoordSet_not_4); |
| 11513 COMPILE_ASSERT(offsetof(PathTexGenCHROMIUM, genMode) == 8, |
| 11514 OffsetOf_PathTexGenCHROMIUM_genMode_not_8); |
| 11515 COMPILE_ASSERT(offsetof(PathTexGenCHROMIUM, components) == 12, |
| 11516 OffsetOf_PathTexGenCHROMIUM_components_not_12); |
| 11517 COMPILE_ASSERT(offsetof(PathTexGenCHROMIUM, coeffs_shm_id) == 16, |
| 11518 OffsetOf_PathTexGenCHROMIUM_coeffs_shm_id_not_16); |
| 11519 COMPILE_ASSERT(offsetof(PathTexGenCHROMIUM, coeffs_shm_offset) == 20, |
| 11520 OffsetOf_PathTexGenCHROMIUM_coeffs_shm_offset_not_20); |
| 11521 |
| 11522 struct CoverFillPathCHROMIUM { |
| 11523 typedef CoverFillPathCHROMIUM ValueType; |
| 11524 static const CommandId kCmdId = kCoverFillPathCHROMIUM; |
| 11525 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11526 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11527 |
| 11528 static uint32 ComputeSize() { |
| 11529 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11530 } |
| 11531 |
| 11532 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11533 |
| 11534 void Init(GLuint _path, GLenum _coverMode) { |
| 11535 SetHeader(); |
| 11536 path = _path; |
| 11537 coverMode = _coverMode; |
| 11538 } |
| 11539 |
| 11540 void* Set(void* cmd, GLuint _path, GLenum _coverMode) { |
| 11541 static_cast<ValueType*>(cmd)->Init(_path, _coverMode); |
| 11542 return NextCmdAddress<ValueType>(cmd); |
| 11543 } |
| 11544 |
| 11545 gpu::CommandHeader header; |
| 11546 uint32 path; |
| 11547 uint32 coverMode; |
| 11548 }; |
| 11549 |
| 11550 COMPILE_ASSERT(sizeof(CoverFillPathCHROMIUM) == 12, |
| 11551 Sizeof_CoverFillPathCHROMIUM_is_not_12); |
| 11552 COMPILE_ASSERT(offsetof(CoverFillPathCHROMIUM, header) == 0, |
| 11553 OffsetOf_CoverFillPathCHROMIUM_header_not_0); |
| 11554 COMPILE_ASSERT(offsetof(CoverFillPathCHROMIUM, path) == 4, |
| 11555 OffsetOf_CoverFillPathCHROMIUM_path_not_4); |
| 11556 COMPILE_ASSERT(offsetof(CoverFillPathCHROMIUM, coverMode) == 8, |
| 11557 OffsetOf_CoverFillPathCHROMIUM_coverMode_not_8); |
| 11558 |
| 11559 struct CoverFillPathInstancedCHROMIUM { |
| 11560 typedef CoverFillPathInstancedCHROMIUM ValueType; |
| 11561 static const CommandId kCmdId = kCoverFillPathInstancedCHROMIUM; |
| 11562 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11563 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11564 |
| 11565 static uint32 ComputeSize() { |
| 11566 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11567 } |
| 11568 |
| 11569 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11570 |
| 11571 void Init(GLsizei _numPaths, |
| 11572 GLenum _pathNameType, |
| 11573 uint32 _paths_shm_id, |
| 11574 uint32 _paths_shm_offset, |
| 11575 GLuint _pathBase, |
| 11576 GLenum _coverMode, |
| 11577 GLenum _transformType, |
| 11578 uint32 _transformValues_shm_id, |
| 11579 uint32 _transformValues_shm_offset) { |
| 11580 SetHeader(); |
| 11581 numPaths = _numPaths; |
| 11582 pathNameType = _pathNameType; |
| 11583 paths_shm_id = _paths_shm_id; |
| 11584 paths_shm_offset = _paths_shm_offset; |
| 11585 pathBase = _pathBase; |
| 11586 coverMode = _coverMode; |
| 11587 transformType = _transformType; |
| 11588 transformValues_shm_id = _transformValues_shm_id; |
| 11589 transformValues_shm_offset = _transformValues_shm_offset; |
| 11590 } |
| 11591 |
| 11592 void* Set(void* cmd, |
| 11593 GLsizei _numPaths, |
| 11594 GLenum _pathNameType, |
| 11595 uint32 _paths_shm_id, |
| 11596 uint32 _paths_shm_offset, |
| 11597 GLuint _pathBase, |
| 11598 GLenum _coverMode, |
| 11599 GLenum _transformType, |
| 11600 uint32 _transformValues_shm_id, |
| 11601 uint32 _transformValues_shm_offset) { |
| 11602 static_cast<ValueType*>(cmd)->Init(_numPaths, |
| 11603 _pathNameType, |
| 11604 _paths_shm_id, |
| 11605 _paths_shm_offset, |
| 11606 _pathBase, |
| 11607 _coverMode, |
| 11608 _transformType, |
| 11609 _transformValues_shm_id, |
| 11610 _transformValues_shm_offset); |
| 11611 return NextCmdAddress<ValueType>(cmd); |
| 11612 } |
| 11613 |
| 11614 gpu::CommandHeader header; |
| 11615 int32 numPaths; |
| 11616 uint32 pathNameType; |
| 11617 uint32 paths_shm_id; |
| 11618 uint32 paths_shm_offset; |
| 11619 uint32 pathBase; |
| 11620 uint32 coverMode; |
| 11621 uint32 transformType; |
| 11622 uint32 transformValues_shm_id; |
| 11623 uint32 transformValues_shm_offset; |
| 11624 }; |
| 11625 |
| 11626 COMPILE_ASSERT(sizeof(CoverFillPathInstancedCHROMIUM) == 40, |
| 11627 Sizeof_CoverFillPathInstancedCHROMIUM_is_not_40); |
| 11628 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, header) == 0, |
| 11629 OffsetOf_CoverFillPathInstancedCHROMIUM_header_not_0); |
| 11630 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, numPaths) == 4, |
| 11631 OffsetOf_CoverFillPathInstancedCHROMIUM_numPaths_not_4); |
| 11632 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, pathNameType) == 8, |
| 11633 OffsetOf_CoverFillPathInstancedCHROMIUM_pathNameType_not_8); |
| 11634 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, paths_shm_id) == 12, |
| 11635 OffsetOf_CoverFillPathInstancedCHROMIUM_paths_shm_id_not_12); |
| 11636 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, paths_shm_offset) == 16, |
| 11637 OffsetOf_CoverFillPathInstancedCHROMIUM_paths_shm_offset_not_16); |
| 11638 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, pathBase) == 20, |
| 11639 OffsetOf_CoverFillPathInstancedCHROMIUM_pathBase_not_20); |
| 11640 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, coverMode) == 24, |
| 11641 OffsetOf_CoverFillPathInstancedCHROMIUM_coverMode_not_24); |
| 11642 COMPILE_ASSERT(offsetof(CoverFillPathInstancedCHROMIUM, transformType) == 28, |
| 11643 OffsetOf_CoverFillPathInstancedCHROMIUM_transformType_not_28); |
| 11644 COMPILE_ASSERT( |
| 11645 offsetof(CoverFillPathInstancedCHROMIUM, transformValues_shm_id) == 32, |
| 11646 OffsetOf_CoverFillPathInstancedCHROMIUM_transformValues_shm_id_not_32); |
| 11647 COMPILE_ASSERT( |
| 11648 offsetof(CoverFillPathInstancedCHROMIUM, transformValues_shm_offset) == 36, |
| 11649 OffsetOf_CoverFillPathInstancedCHROMIUM_transformValues_shm_offset_not_36); |
| 11650 |
| 11651 struct CoverStrokePathCHROMIUM { |
| 11652 typedef CoverStrokePathCHROMIUM ValueType; |
| 11653 static const CommandId kCmdId = kCoverStrokePathCHROMIUM; |
| 11654 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11655 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11656 |
| 11657 static uint32 ComputeSize() { |
| 11658 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11659 } |
| 11660 |
| 11661 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11662 |
| 11663 void Init(GLuint _path, GLenum _coverMode) { |
| 11664 SetHeader(); |
| 11665 path = _path; |
| 11666 coverMode = _coverMode; |
| 11667 } |
| 11668 |
| 11669 void* Set(void* cmd, GLuint _path, GLenum _coverMode) { |
| 11670 static_cast<ValueType*>(cmd)->Init(_path, _coverMode); |
| 11671 return NextCmdAddress<ValueType>(cmd); |
| 11672 } |
| 11673 |
| 11674 gpu::CommandHeader header; |
| 11675 uint32 path; |
| 11676 uint32 coverMode; |
| 11677 }; |
| 11678 |
| 11679 COMPILE_ASSERT(sizeof(CoverStrokePathCHROMIUM) == 12, |
| 11680 Sizeof_CoverStrokePathCHROMIUM_is_not_12); |
| 11681 COMPILE_ASSERT(offsetof(CoverStrokePathCHROMIUM, header) == 0, |
| 11682 OffsetOf_CoverStrokePathCHROMIUM_header_not_0); |
| 11683 COMPILE_ASSERT(offsetof(CoverStrokePathCHROMIUM, path) == 4, |
| 11684 OffsetOf_CoverStrokePathCHROMIUM_path_not_4); |
| 11685 COMPILE_ASSERT(offsetof(CoverStrokePathCHROMIUM, coverMode) == 8, |
| 11686 OffsetOf_CoverStrokePathCHROMIUM_coverMode_not_8); |
| 11687 |
| 11688 struct CoverStrokePathInstancedCHROMIUM { |
| 11689 typedef CoverStrokePathInstancedCHROMIUM ValueType; |
| 11690 static const CommandId kCmdId = kCoverStrokePathInstancedCHROMIUM; |
| 11691 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 11692 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 11693 |
| 11694 static uint32 ComputeSize() { |
| 11695 return static_cast<uint32>(sizeof(ValueType)); // NOLINT |
| 11696 } |
| 11697 |
| 11698 void SetHeader() { header.SetCmd<ValueType>(); } |
| 11699 |
| 11700 void Init(GLsizei _numPaths, |
| 11701 GLenum _pathNameType, |
| 11702 uint32 _paths_shm_id, |
| 11703 uint32 _paths_shm_offset, |
| 11704 GLuint _pathBase, |
| 11705 GLenum _coverMode, |
| 11706 GLenum _transformType, |
| 11707 uint32 _transformValues_shm_id, |
| 11708 uint32 _transformValues_shm_offset) { |
| 11709 SetHeader(); |
| 11710 numPaths = _numPaths; |
| 11711 pathNameType = _pathNameType; |
| 11712 paths_shm_id = _paths_shm_id; |
| 11713 paths_shm_offset = _paths_shm_offset; |
| 11714 pathBase = _pathBase; |
| 11715 coverMode = _coverMode; |
| 11716 transformType = _transformType; |
| 11717 transformValues_shm_id = _transformValues_shm_id; |
| 11718 transformValues_shm_offset = _transformValues_shm_offset; |
| 11719 } |
| 11720 |
| 11721 void* Set(void* cmd, |
| 11722 GLsizei _numPaths, |
| 11723 GLenum _pathNameType, |
| 11724 uint32 _paths_shm_id, |
| 11725 uint32 _paths_shm_offset, |
| 11726 GLuint _pathBase, |
| 11727 GLenum _coverMode, |
| 11728 GLenum _transformType, |
| 11729 uint32 _transformValues_shm_id, |
| 11730 uint32 _transformValues_shm_offset) { |
| 11731 static_cast<ValueType*>(cmd)->Init(_numPaths, |
| 11732 _pathNameType, |
| 11733 _paths_shm_id, |
| 11734 _paths_shm_offset, |
| 11735 _pathBase, |
| 11736 _coverMode, |
| 11737 _transformType, |
| 11738 _transformValues_shm_id, |
| 11739 _transformValues_shm_offset); |
| 11740 return NextCmdAddress<ValueType>(cmd); |
| 11741 } |
| 11742 |
| 11743 gpu::CommandHeader header; |
| 11744 int32 numPaths; |
| 11745 uint32 pathNameType; |
| 11746 uint32 paths_shm_id; |
| 11747 uint32 paths_shm_offset; |
| 11748 uint32 pathBase; |
| 11749 uint32 coverMode; |
| 11750 uint32 transformType; |
| 11751 uint32 transformValues_shm_id; |
| 11752 uint32 transformValues_shm_offset; |
| 11753 }; |
| 11754 |
| 11755 COMPILE_ASSERT(sizeof(CoverStrokePathInstancedCHROMIUM) == 40, |
| 11756 Sizeof_CoverStrokePathInstancedCHROMIUM_is_not_40); |
| 11757 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, header) == 0, |
| 11758 OffsetOf_CoverStrokePathInstancedCHROMIUM_header_not_0); |
| 11759 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, numPaths) == 4, |
| 11760 OffsetOf_CoverStrokePathInstancedCHROMIUM_numPaths_not_4); |
| 11761 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, pathNameType) == 8, |
| 11762 OffsetOf_CoverStrokePathInstancedCHROMIUM_pathNameType_not_8); |
| 11763 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, paths_shm_id) == 12, |
| 11764 OffsetOf_CoverStrokePathInstancedCHROMIUM_paths_shm_id_not_12); |
| 11765 COMPILE_ASSERT( |
| 11766 offsetof(CoverStrokePathInstancedCHROMIUM, paths_shm_offset) == 16, |
| 11767 OffsetOf_CoverStrokePathInstancedCHROMIUM_paths_shm_offset_not_16); |
| 11768 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, pathBase) == 20, |
| 11769 OffsetOf_CoverStrokePathInstancedCHROMIUM_pathBase_not_20); |
| 11770 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, coverMode) == 24, |
| 11771 OffsetOf_CoverStrokePathInstancedCHROMIUM_coverMode_not_24); |
| 11772 COMPILE_ASSERT(offsetof(CoverStrokePathInstancedCHROMIUM, transformType) == 28, |
| 11773 OffsetOf_CoverStrokePathInstancedCHROMIUM_transformType_not_28); |
| 11774 COMPILE_ASSERT( |
| 11775 offsetof(CoverStrokePathInstancedCHROMIUM, transformValues_shm_id) == 32, |
| 11776 OffsetOf_CoverStrokePathInstancedCHROMIUM_transformValues_shm_id_not_32); |
| 11777 COMPILE_ASSERT( |
| 11778 offsetof(CoverStrokePathInstancedCHROMIUM, transformValues_shm_offset) == |
| 11779 36, |
| 11780 OffsetOf_CoverStrokePathInstancedCHROMIUM_transformValues_shm_offset_not_36)
; |
| 11781 |
| 10885 #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ | 11782 #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 169403005:
command_buffer: Implement path rendering functions for CHROMIUM_path_rendering (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@nv-pr-02-texgen