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 13762 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
13773 uint32_t matrixMode; | 13773 uint32_t matrixMode; |
13774 }; | 13774 }; |
13775 | 13775 |
13776 static_assert(sizeof(MatrixLoadIdentityCHROMIUM) == 8, | 13776 static_assert(sizeof(MatrixLoadIdentityCHROMIUM) == 8, |
13777 "size of MatrixLoadIdentityCHROMIUM should be 8"); | 13777 "size of MatrixLoadIdentityCHROMIUM should be 8"); |
13778 static_assert(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0, | 13778 static_assert(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0, |
13779 "offset of MatrixLoadIdentityCHROMIUM header should be 0"); | 13779 "offset of MatrixLoadIdentityCHROMIUM header should be 0"); |
13780 static_assert(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4, | 13780 static_assert(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4, |
13781 "offset of MatrixLoadIdentityCHROMIUM matrixMode should be 4"); | 13781 "offset of MatrixLoadIdentityCHROMIUM matrixMode should be 4"); |
13782 | 13782 |
| 13783 struct GenPathsCHROMIUM { |
| 13784 typedef GenPathsCHROMIUM ValueType; |
| 13785 static const CommandId kCmdId = kGenPathsCHROMIUM; |
| 13786 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 13787 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 13788 |
| 13789 static uint32_t ComputeSize() { |
| 13790 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 13791 } |
| 13792 |
| 13793 void SetHeader() { header.SetCmd<ValueType>(); } |
| 13794 |
| 13795 void Init(GLuint _first_client_id, GLsizei _range) { |
| 13796 SetHeader(); |
| 13797 first_client_id = _first_client_id; |
| 13798 range = _range; |
| 13799 } |
| 13800 |
| 13801 void* Set(void* cmd, GLuint _first_client_id, GLsizei _range) { |
| 13802 static_cast<ValueType*>(cmd)->Init(_first_client_id, _range); |
| 13803 return NextCmdAddress<ValueType>(cmd); |
| 13804 } |
| 13805 |
| 13806 gpu::CommandHeader header; |
| 13807 uint32_t first_client_id; |
| 13808 int32_t range; |
| 13809 }; |
| 13810 |
| 13811 static_assert(sizeof(GenPathsCHROMIUM) == 12, |
| 13812 "size of GenPathsCHROMIUM should be 12"); |
| 13813 static_assert(offsetof(GenPathsCHROMIUM, header) == 0, |
| 13814 "offset of GenPathsCHROMIUM header should be 0"); |
| 13815 static_assert(offsetof(GenPathsCHROMIUM, first_client_id) == 4, |
| 13816 "offset of GenPathsCHROMIUM first_client_id should be 4"); |
| 13817 static_assert(offsetof(GenPathsCHROMIUM, range) == 8, |
| 13818 "offset of GenPathsCHROMIUM range should be 8"); |
| 13819 |
| 13820 struct DeletePathsCHROMIUM { |
| 13821 typedef DeletePathsCHROMIUM ValueType; |
| 13822 static const CommandId kCmdId = kDeletePathsCHROMIUM; |
| 13823 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 13824 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 13825 |
| 13826 static uint32_t ComputeSize() { |
| 13827 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 13828 } |
| 13829 |
| 13830 void SetHeader() { header.SetCmd<ValueType>(); } |
| 13831 |
| 13832 void Init(GLuint _first_client_id, GLsizei _range) { |
| 13833 SetHeader(); |
| 13834 first_client_id = _first_client_id; |
| 13835 range = _range; |
| 13836 } |
| 13837 |
| 13838 void* Set(void* cmd, GLuint _first_client_id, GLsizei _range) { |
| 13839 static_cast<ValueType*>(cmd)->Init(_first_client_id, _range); |
| 13840 return NextCmdAddress<ValueType>(cmd); |
| 13841 } |
| 13842 |
| 13843 gpu::CommandHeader header; |
| 13844 uint32_t first_client_id; |
| 13845 int32_t range; |
| 13846 }; |
| 13847 |
| 13848 static_assert(sizeof(DeletePathsCHROMIUM) == 12, |
| 13849 "size of DeletePathsCHROMIUM should be 12"); |
| 13850 static_assert(offsetof(DeletePathsCHROMIUM, header) == 0, |
| 13851 "offset of DeletePathsCHROMIUM header should be 0"); |
| 13852 static_assert(offsetof(DeletePathsCHROMIUM, first_client_id) == 4, |
| 13853 "offset of DeletePathsCHROMIUM first_client_id should be 4"); |
| 13854 static_assert(offsetof(DeletePathsCHROMIUM, range) == 8, |
| 13855 "offset of DeletePathsCHROMIUM range should be 8"); |
| 13856 |
| 13857 struct IsPathCHROMIUM { |
| 13858 typedef IsPathCHROMIUM ValueType; |
| 13859 static const CommandId kCmdId = kIsPathCHROMIUM; |
| 13860 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 13861 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 13862 |
| 13863 typedef uint32_t Result; |
| 13864 |
| 13865 static uint32_t ComputeSize() { |
| 13866 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 13867 } |
| 13868 |
| 13869 void SetHeader() { header.SetCmd<ValueType>(); } |
| 13870 |
| 13871 void Init(GLuint _path, |
| 13872 uint32_t _result_shm_id, |
| 13873 uint32_t _result_shm_offset) { |
| 13874 SetHeader(); |
| 13875 path = _path; |
| 13876 result_shm_id = _result_shm_id; |
| 13877 result_shm_offset = _result_shm_offset; |
| 13878 } |
| 13879 |
| 13880 void* Set(void* cmd, |
| 13881 GLuint _path, |
| 13882 uint32_t _result_shm_id, |
| 13883 uint32_t _result_shm_offset) { |
| 13884 static_cast<ValueType*>(cmd) |
| 13885 ->Init(_path, _result_shm_id, _result_shm_offset); |
| 13886 return NextCmdAddress<ValueType>(cmd); |
| 13887 } |
| 13888 |
| 13889 gpu::CommandHeader header; |
| 13890 uint32_t path; |
| 13891 uint32_t result_shm_id; |
| 13892 uint32_t result_shm_offset; |
| 13893 }; |
| 13894 |
| 13895 static_assert(sizeof(IsPathCHROMIUM) == 16, |
| 13896 "size of IsPathCHROMIUM should be 16"); |
| 13897 static_assert(offsetof(IsPathCHROMIUM, header) == 0, |
| 13898 "offset of IsPathCHROMIUM header should be 0"); |
| 13899 static_assert(offsetof(IsPathCHROMIUM, path) == 4, |
| 13900 "offset of IsPathCHROMIUM path should be 4"); |
| 13901 static_assert(offsetof(IsPathCHROMIUM, result_shm_id) == 8, |
| 13902 "offset of IsPathCHROMIUM result_shm_id should be 8"); |
| 13903 static_assert(offsetof(IsPathCHROMIUM, result_shm_offset) == 12, |
| 13904 "offset of IsPathCHROMIUM result_shm_offset should be 12"); |
| 13905 |
| 13906 struct PathCommandsCHROMIUM { |
| 13907 typedef PathCommandsCHROMIUM ValueType; |
| 13908 static const CommandId kCmdId = kPathCommandsCHROMIUM; |
| 13909 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 13910 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 13911 |
| 13912 static uint32_t ComputeSize() { |
| 13913 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 13914 } |
| 13915 |
| 13916 void SetHeader() { header.SetCmd<ValueType>(); } |
| 13917 |
| 13918 void Init(GLuint _path, |
| 13919 GLsizei _numCommands, |
| 13920 uint32_t _commands_shm_id, |
| 13921 uint32_t _commands_shm_offset, |
| 13922 GLsizei _numCoords, |
| 13923 GLenum _coordType, |
| 13924 uint32_t _coords_shm_id, |
| 13925 uint32_t _coords_shm_offset) { |
| 13926 SetHeader(); |
| 13927 path = _path; |
| 13928 numCommands = _numCommands; |
| 13929 commands_shm_id = _commands_shm_id; |
| 13930 commands_shm_offset = _commands_shm_offset; |
| 13931 numCoords = _numCoords; |
| 13932 coordType = _coordType; |
| 13933 coords_shm_id = _coords_shm_id; |
| 13934 coords_shm_offset = _coords_shm_offset; |
| 13935 } |
| 13936 |
| 13937 void* Set(void* cmd, |
| 13938 GLuint _path, |
| 13939 GLsizei _numCommands, |
| 13940 uint32_t _commands_shm_id, |
| 13941 uint32_t _commands_shm_offset, |
| 13942 GLsizei _numCoords, |
| 13943 GLenum _coordType, |
| 13944 uint32_t _coords_shm_id, |
| 13945 uint32_t _coords_shm_offset) { |
| 13946 static_cast<ValueType*>(cmd) |
| 13947 ->Init(_path, _numCommands, _commands_shm_id, _commands_shm_offset, |
| 13948 _numCoords, _coordType, _coords_shm_id, _coords_shm_offset); |
| 13949 return NextCmdAddress<ValueType>(cmd); |
| 13950 } |
| 13951 |
| 13952 gpu::CommandHeader header; |
| 13953 uint32_t path; |
| 13954 int32_t numCommands; |
| 13955 uint32_t commands_shm_id; |
| 13956 uint32_t commands_shm_offset; |
| 13957 int32_t numCoords; |
| 13958 uint32_t coordType; |
| 13959 uint32_t coords_shm_id; |
| 13960 uint32_t coords_shm_offset; |
| 13961 }; |
| 13962 |
| 13963 static_assert(sizeof(PathCommandsCHROMIUM) == 36, |
| 13964 "size of PathCommandsCHROMIUM should be 36"); |
| 13965 static_assert(offsetof(PathCommandsCHROMIUM, header) == 0, |
| 13966 "offset of PathCommandsCHROMIUM header should be 0"); |
| 13967 static_assert(offsetof(PathCommandsCHROMIUM, path) == 4, |
| 13968 "offset of PathCommandsCHROMIUM path should be 4"); |
| 13969 static_assert(offsetof(PathCommandsCHROMIUM, numCommands) == 8, |
| 13970 "offset of PathCommandsCHROMIUM numCommands should be 8"); |
| 13971 static_assert(offsetof(PathCommandsCHROMIUM, commands_shm_id) == 12, |
| 13972 "offset of PathCommandsCHROMIUM commands_shm_id should be 12"); |
| 13973 static_assert( |
| 13974 offsetof(PathCommandsCHROMIUM, commands_shm_offset) == 16, |
| 13975 "offset of PathCommandsCHROMIUM commands_shm_offset should be 16"); |
| 13976 static_assert(offsetof(PathCommandsCHROMIUM, numCoords) == 20, |
| 13977 "offset of PathCommandsCHROMIUM numCoords should be 20"); |
| 13978 static_assert(offsetof(PathCommandsCHROMIUM, coordType) == 24, |
| 13979 "offset of PathCommandsCHROMIUM coordType should be 24"); |
| 13980 static_assert(offsetof(PathCommandsCHROMIUM, coords_shm_id) == 28, |
| 13981 "offset of PathCommandsCHROMIUM coords_shm_id should be 28"); |
| 13982 static_assert(offsetof(PathCommandsCHROMIUM, coords_shm_offset) == 32, |
| 13983 "offset of PathCommandsCHROMIUM coords_shm_offset should be 32"); |
| 13984 |
| 13985 struct PathParameterfCHROMIUM { |
| 13986 typedef PathParameterfCHROMIUM ValueType; |
| 13987 static const CommandId kCmdId = kPathParameterfCHROMIUM; |
| 13988 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 13989 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 13990 |
| 13991 static uint32_t ComputeSize() { |
| 13992 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 13993 } |
| 13994 |
| 13995 void SetHeader() { header.SetCmd<ValueType>(); } |
| 13996 |
| 13997 void Init(GLuint _path, GLenum _pname, GLfloat _value) { |
| 13998 SetHeader(); |
| 13999 path = _path; |
| 14000 pname = _pname; |
| 14001 value = _value; |
| 14002 } |
| 14003 |
| 14004 void* Set(void* cmd, GLuint _path, GLenum _pname, GLfloat _value) { |
| 14005 static_cast<ValueType*>(cmd)->Init(_path, _pname, _value); |
| 14006 return NextCmdAddress<ValueType>(cmd); |
| 14007 } |
| 14008 |
| 14009 gpu::CommandHeader header; |
| 14010 uint32_t path; |
| 14011 uint32_t pname; |
| 14012 float value; |
| 14013 }; |
| 14014 |
| 14015 static_assert(sizeof(PathParameterfCHROMIUM) == 16, |
| 14016 "size of PathParameterfCHROMIUM should be 16"); |
| 14017 static_assert(offsetof(PathParameterfCHROMIUM, header) == 0, |
| 14018 "offset of PathParameterfCHROMIUM header should be 0"); |
| 14019 static_assert(offsetof(PathParameterfCHROMIUM, path) == 4, |
| 14020 "offset of PathParameterfCHROMIUM path should be 4"); |
| 14021 static_assert(offsetof(PathParameterfCHROMIUM, pname) == 8, |
| 14022 "offset of PathParameterfCHROMIUM pname should be 8"); |
| 14023 static_assert(offsetof(PathParameterfCHROMIUM, value) == 12, |
| 14024 "offset of PathParameterfCHROMIUM value should be 12"); |
| 14025 |
| 14026 struct PathParameteriCHROMIUM { |
| 14027 typedef PathParameteriCHROMIUM ValueType; |
| 14028 static const CommandId kCmdId = kPathParameteriCHROMIUM; |
| 14029 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14030 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14031 |
| 14032 static uint32_t ComputeSize() { |
| 14033 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14034 } |
| 14035 |
| 14036 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14037 |
| 14038 void Init(GLuint _path, GLenum _pname, GLint _value) { |
| 14039 SetHeader(); |
| 14040 path = _path; |
| 14041 pname = _pname; |
| 14042 value = _value; |
| 14043 } |
| 14044 |
| 14045 void* Set(void* cmd, GLuint _path, GLenum _pname, GLint _value) { |
| 14046 static_cast<ValueType*>(cmd)->Init(_path, _pname, _value); |
| 14047 return NextCmdAddress<ValueType>(cmd); |
| 14048 } |
| 14049 |
| 14050 gpu::CommandHeader header; |
| 14051 uint32_t path; |
| 14052 uint32_t pname; |
| 14053 int32_t value; |
| 14054 }; |
| 14055 |
| 14056 static_assert(sizeof(PathParameteriCHROMIUM) == 16, |
| 14057 "size of PathParameteriCHROMIUM should be 16"); |
| 14058 static_assert(offsetof(PathParameteriCHROMIUM, header) == 0, |
| 14059 "offset of PathParameteriCHROMIUM header should be 0"); |
| 14060 static_assert(offsetof(PathParameteriCHROMIUM, path) == 4, |
| 14061 "offset of PathParameteriCHROMIUM path should be 4"); |
| 14062 static_assert(offsetof(PathParameteriCHROMIUM, pname) == 8, |
| 14063 "offset of PathParameteriCHROMIUM pname should be 8"); |
| 14064 static_assert(offsetof(PathParameteriCHROMIUM, value) == 12, |
| 14065 "offset of PathParameteriCHROMIUM value should be 12"); |
| 14066 |
| 14067 struct PathStencilFuncCHROMIUM { |
| 14068 typedef PathStencilFuncCHROMIUM ValueType; |
| 14069 static const CommandId kCmdId = kPathStencilFuncCHROMIUM; |
| 14070 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14071 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14072 |
| 14073 static uint32_t ComputeSize() { |
| 14074 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14075 } |
| 14076 |
| 14077 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14078 |
| 14079 void Init(GLenum _func, GLint _ref, GLuint _mask) { |
| 14080 SetHeader(); |
| 14081 func = _func; |
| 14082 ref = _ref; |
| 14083 mask = _mask; |
| 14084 } |
| 14085 |
| 14086 void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) { |
| 14087 static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask); |
| 14088 return NextCmdAddress<ValueType>(cmd); |
| 14089 } |
| 14090 |
| 14091 gpu::CommandHeader header; |
| 14092 uint32_t func; |
| 14093 int32_t ref; |
| 14094 uint32_t mask; |
| 14095 }; |
| 14096 |
| 14097 static_assert(sizeof(PathStencilFuncCHROMIUM) == 16, |
| 14098 "size of PathStencilFuncCHROMIUM should be 16"); |
| 14099 static_assert(offsetof(PathStencilFuncCHROMIUM, header) == 0, |
| 14100 "offset of PathStencilFuncCHROMIUM header should be 0"); |
| 14101 static_assert(offsetof(PathStencilFuncCHROMIUM, func) == 4, |
| 14102 "offset of PathStencilFuncCHROMIUM func should be 4"); |
| 14103 static_assert(offsetof(PathStencilFuncCHROMIUM, ref) == 8, |
| 14104 "offset of PathStencilFuncCHROMIUM ref should be 8"); |
| 14105 static_assert(offsetof(PathStencilFuncCHROMIUM, mask) == 12, |
| 14106 "offset of PathStencilFuncCHROMIUM mask should be 12"); |
| 14107 |
| 14108 struct StencilFillPathCHROMIUM { |
| 14109 typedef StencilFillPathCHROMIUM ValueType; |
| 14110 static const CommandId kCmdId = kStencilFillPathCHROMIUM; |
| 14111 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14112 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14113 |
| 14114 static uint32_t ComputeSize() { |
| 14115 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14116 } |
| 14117 |
| 14118 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14119 |
| 14120 void Init(GLuint _path, GLenum _fillMode, GLuint _mask) { |
| 14121 SetHeader(); |
| 14122 path = _path; |
| 14123 fillMode = _fillMode; |
| 14124 mask = _mask; |
| 14125 } |
| 14126 |
| 14127 void* Set(void* cmd, GLuint _path, GLenum _fillMode, GLuint _mask) { |
| 14128 static_cast<ValueType*>(cmd)->Init(_path, _fillMode, _mask); |
| 14129 return NextCmdAddress<ValueType>(cmd); |
| 14130 } |
| 14131 |
| 14132 gpu::CommandHeader header; |
| 14133 uint32_t path; |
| 14134 uint32_t fillMode; |
| 14135 uint32_t mask; |
| 14136 }; |
| 14137 |
| 14138 static_assert(sizeof(StencilFillPathCHROMIUM) == 16, |
| 14139 "size of StencilFillPathCHROMIUM should be 16"); |
| 14140 static_assert(offsetof(StencilFillPathCHROMIUM, header) == 0, |
| 14141 "offset of StencilFillPathCHROMIUM header should be 0"); |
| 14142 static_assert(offsetof(StencilFillPathCHROMIUM, path) == 4, |
| 14143 "offset of StencilFillPathCHROMIUM path should be 4"); |
| 14144 static_assert(offsetof(StencilFillPathCHROMIUM, fillMode) == 8, |
| 14145 "offset of StencilFillPathCHROMIUM fillMode should be 8"); |
| 14146 static_assert(offsetof(StencilFillPathCHROMIUM, mask) == 12, |
| 14147 "offset of StencilFillPathCHROMIUM mask should be 12"); |
| 14148 |
| 14149 struct StencilStrokePathCHROMIUM { |
| 14150 typedef StencilStrokePathCHROMIUM ValueType; |
| 14151 static const CommandId kCmdId = kStencilStrokePathCHROMIUM; |
| 14152 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14153 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14154 |
| 14155 static uint32_t ComputeSize() { |
| 14156 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14157 } |
| 14158 |
| 14159 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14160 |
| 14161 void Init(GLuint _path, GLint _reference, GLuint _mask) { |
| 14162 SetHeader(); |
| 14163 path = _path; |
| 14164 reference = _reference; |
| 14165 mask = _mask; |
| 14166 } |
| 14167 |
| 14168 void* Set(void* cmd, GLuint _path, GLint _reference, GLuint _mask) { |
| 14169 static_cast<ValueType*>(cmd)->Init(_path, _reference, _mask); |
| 14170 return NextCmdAddress<ValueType>(cmd); |
| 14171 } |
| 14172 |
| 14173 gpu::CommandHeader header; |
| 14174 uint32_t path; |
| 14175 int32_t reference; |
| 14176 uint32_t mask; |
| 14177 }; |
| 14178 |
| 14179 static_assert(sizeof(StencilStrokePathCHROMIUM) == 16, |
| 14180 "size of StencilStrokePathCHROMIUM should be 16"); |
| 14181 static_assert(offsetof(StencilStrokePathCHROMIUM, header) == 0, |
| 14182 "offset of StencilStrokePathCHROMIUM header should be 0"); |
| 14183 static_assert(offsetof(StencilStrokePathCHROMIUM, path) == 4, |
| 14184 "offset of StencilStrokePathCHROMIUM path should be 4"); |
| 14185 static_assert(offsetof(StencilStrokePathCHROMIUM, reference) == 8, |
| 14186 "offset of StencilStrokePathCHROMIUM reference should be 8"); |
| 14187 static_assert(offsetof(StencilStrokePathCHROMIUM, mask) == 12, |
| 14188 "offset of StencilStrokePathCHROMIUM mask should be 12"); |
| 14189 |
| 14190 struct CoverFillPathCHROMIUM { |
| 14191 typedef CoverFillPathCHROMIUM ValueType; |
| 14192 static const CommandId kCmdId = kCoverFillPathCHROMIUM; |
| 14193 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14194 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14195 |
| 14196 static uint32_t ComputeSize() { |
| 14197 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14198 } |
| 14199 |
| 14200 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14201 |
| 14202 void Init(GLuint _path, GLenum _coverMode) { |
| 14203 SetHeader(); |
| 14204 path = _path; |
| 14205 coverMode = _coverMode; |
| 14206 } |
| 14207 |
| 14208 void* Set(void* cmd, GLuint _path, GLenum _coverMode) { |
| 14209 static_cast<ValueType*>(cmd)->Init(_path, _coverMode); |
| 14210 return NextCmdAddress<ValueType>(cmd); |
| 14211 } |
| 14212 |
| 14213 gpu::CommandHeader header; |
| 14214 uint32_t path; |
| 14215 uint32_t coverMode; |
| 14216 }; |
| 14217 |
| 14218 static_assert(sizeof(CoverFillPathCHROMIUM) == 12, |
| 14219 "size of CoverFillPathCHROMIUM should be 12"); |
| 14220 static_assert(offsetof(CoverFillPathCHROMIUM, header) == 0, |
| 14221 "offset of CoverFillPathCHROMIUM header should be 0"); |
| 14222 static_assert(offsetof(CoverFillPathCHROMIUM, path) == 4, |
| 14223 "offset of CoverFillPathCHROMIUM path should be 4"); |
| 14224 static_assert(offsetof(CoverFillPathCHROMIUM, coverMode) == 8, |
| 14225 "offset of CoverFillPathCHROMIUM coverMode should be 8"); |
| 14226 |
| 14227 struct CoverStrokePathCHROMIUM { |
| 14228 typedef CoverStrokePathCHROMIUM ValueType; |
| 14229 static const CommandId kCmdId = kCoverStrokePathCHROMIUM; |
| 14230 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14231 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14232 |
| 14233 static uint32_t ComputeSize() { |
| 14234 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14235 } |
| 14236 |
| 14237 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14238 |
| 14239 void Init(GLuint _path, GLenum _coverMode) { |
| 14240 SetHeader(); |
| 14241 path = _path; |
| 14242 coverMode = _coverMode; |
| 14243 } |
| 14244 |
| 14245 void* Set(void* cmd, GLuint _path, GLenum _coverMode) { |
| 14246 static_cast<ValueType*>(cmd)->Init(_path, _coverMode); |
| 14247 return NextCmdAddress<ValueType>(cmd); |
| 14248 } |
| 14249 |
| 14250 gpu::CommandHeader header; |
| 14251 uint32_t path; |
| 14252 uint32_t coverMode; |
| 14253 }; |
| 14254 |
| 14255 static_assert(sizeof(CoverStrokePathCHROMIUM) == 12, |
| 14256 "size of CoverStrokePathCHROMIUM should be 12"); |
| 14257 static_assert(offsetof(CoverStrokePathCHROMIUM, header) == 0, |
| 14258 "offset of CoverStrokePathCHROMIUM header should be 0"); |
| 14259 static_assert(offsetof(CoverStrokePathCHROMIUM, path) == 4, |
| 14260 "offset of CoverStrokePathCHROMIUM path should be 4"); |
| 14261 static_assert(offsetof(CoverStrokePathCHROMIUM, coverMode) == 8, |
| 14262 "offset of CoverStrokePathCHROMIUM coverMode should be 8"); |
| 14263 |
| 14264 struct StencilThenCoverFillPathCHROMIUM { |
| 14265 typedef StencilThenCoverFillPathCHROMIUM ValueType; |
| 14266 static const CommandId kCmdId = kStencilThenCoverFillPathCHROMIUM; |
| 14267 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14268 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14269 |
| 14270 static uint32_t ComputeSize() { |
| 14271 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14272 } |
| 14273 |
| 14274 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14275 |
| 14276 void Init(GLuint _path, GLenum _fillMode, GLuint _mask, GLenum _coverMode) { |
| 14277 SetHeader(); |
| 14278 path = _path; |
| 14279 fillMode = _fillMode; |
| 14280 mask = _mask; |
| 14281 coverMode = _coverMode; |
| 14282 } |
| 14283 |
| 14284 void* Set(void* cmd, |
| 14285 GLuint _path, |
| 14286 GLenum _fillMode, |
| 14287 GLuint _mask, |
| 14288 GLenum _coverMode) { |
| 14289 static_cast<ValueType*>(cmd)->Init(_path, _fillMode, _mask, _coverMode); |
| 14290 return NextCmdAddress<ValueType>(cmd); |
| 14291 } |
| 14292 |
| 14293 gpu::CommandHeader header; |
| 14294 uint32_t path; |
| 14295 uint32_t fillMode; |
| 14296 uint32_t mask; |
| 14297 uint32_t coverMode; |
| 14298 }; |
| 14299 |
| 14300 static_assert(sizeof(StencilThenCoverFillPathCHROMIUM) == 20, |
| 14301 "size of StencilThenCoverFillPathCHROMIUM should be 20"); |
| 14302 static_assert(offsetof(StencilThenCoverFillPathCHROMIUM, header) == 0, |
| 14303 "offset of StencilThenCoverFillPathCHROMIUM header should be 0"); |
| 14304 static_assert(offsetof(StencilThenCoverFillPathCHROMIUM, path) == 4, |
| 14305 "offset of StencilThenCoverFillPathCHROMIUM path should be 4"); |
| 14306 static_assert( |
| 14307 offsetof(StencilThenCoverFillPathCHROMIUM, fillMode) == 8, |
| 14308 "offset of StencilThenCoverFillPathCHROMIUM fillMode should be 8"); |
| 14309 static_assert(offsetof(StencilThenCoverFillPathCHROMIUM, mask) == 12, |
| 14310 "offset of StencilThenCoverFillPathCHROMIUM mask should be 12"); |
| 14311 static_assert( |
| 14312 offsetof(StencilThenCoverFillPathCHROMIUM, coverMode) == 16, |
| 14313 "offset of StencilThenCoverFillPathCHROMIUM coverMode should be 16"); |
| 14314 |
| 14315 struct StencilThenCoverStrokePathCHROMIUM { |
| 14316 typedef StencilThenCoverStrokePathCHROMIUM ValueType; |
| 14317 static const CommandId kCmdId = kStencilThenCoverStrokePathCHROMIUM; |
| 14318 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
| 14319 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
| 14320 |
| 14321 static uint32_t ComputeSize() { |
| 14322 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
| 14323 } |
| 14324 |
| 14325 void SetHeader() { header.SetCmd<ValueType>(); } |
| 14326 |
| 14327 void Init(GLuint _path, GLint _reference, GLuint _mask, GLenum _coverMode) { |
| 14328 SetHeader(); |
| 14329 path = _path; |
| 14330 reference = _reference; |
| 14331 mask = _mask; |
| 14332 coverMode = _coverMode; |
| 14333 } |
| 14334 |
| 14335 void* Set(void* cmd, |
| 14336 GLuint _path, |
| 14337 GLint _reference, |
| 14338 GLuint _mask, |
| 14339 GLenum _coverMode) { |
| 14340 static_cast<ValueType*>(cmd)->Init(_path, _reference, _mask, _coverMode); |
| 14341 return NextCmdAddress<ValueType>(cmd); |
| 14342 } |
| 14343 |
| 14344 gpu::CommandHeader header; |
| 14345 uint32_t path; |
| 14346 int32_t reference; |
| 14347 uint32_t mask; |
| 14348 uint32_t coverMode; |
| 14349 }; |
| 14350 |
| 14351 static_assert(sizeof(StencilThenCoverStrokePathCHROMIUM) == 20, |
| 14352 "size of StencilThenCoverStrokePathCHROMIUM should be 20"); |
| 14353 static_assert( |
| 14354 offsetof(StencilThenCoverStrokePathCHROMIUM, header) == 0, |
| 14355 "offset of StencilThenCoverStrokePathCHROMIUM header should be 0"); |
| 14356 static_assert(offsetof(StencilThenCoverStrokePathCHROMIUM, path) == 4, |
| 14357 "offset of StencilThenCoverStrokePathCHROMIUM path should be 4"); |
| 14358 static_assert( |
| 14359 offsetof(StencilThenCoverStrokePathCHROMIUM, reference) == 8, |
| 14360 "offset of StencilThenCoverStrokePathCHROMIUM reference should be 8"); |
| 14361 static_assert(offsetof(StencilThenCoverStrokePathCHROMIUM, mask) == 12, |
| 14362 "offset of StencilThenCoverStrokePathCHROMIUM mask should be 12"); |
| 14363 static_assert( |
| 14364 offsetof(StencilThenCoverStrokePathCHROMIUM, coverMode) == 16, |
| 14365 "offset of StencilThenCoverStrokePathCHROMIUM coverMode should be 16"); |
| 14366 |
13783 struct BlendBarrierKHR { | 14367 struct BlendBarrierKHR { |
13784 typedef BlendBarrierKHR ValueType; | 14368 typedef BlendBarrierKHR ValueType; |
13785 static const CommandId kCmdId = kBlendBarrierKHR; | 14369 static const CommandId kCmdId = kBlendBarrierKHR; |
13786 static const cmd::ArgFlags kArgFlags = cmd::kFixed; | 14370 static const cmd::ArgFlags kArgFlags = cmd::kFixed; |
13787 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); | 14371 static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3); |
13788 | 14372 |
13789 static uint32_t ComputeSize() { | 14373 static uint32_t ComputeSize() { |
13790 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT | 14374 return static_cast<uint32_t>(sizeof(ValueType)); // NOLINT |
13791 } | 14375 } |
13792 | 14376 |
13793 void SetHeader() { header.SetCmd<ValueType>(); } | 14377 void SetHeader() { header.SetCmd<ValueType>(); } |
13794 | 14378 |
13795 void Init() { SetHeader(); } | 14379 void Init() { SetHeader(); } |
13796 | 14380 |
13797 void* Set(void* cmd) { | 14381 void* Set(void* cmd) { |
13798 static_cast<ValueType*>(cmd)->Init(); | 14382 static_cast<ValueType*>(cmd)->Init(); |
13799 return NextCmdAddress<ValueType>(cmd); | 14383 return NextCmdAddress<ValueType>(cmd); |
13800 } | 14384 } |
13801 | 14385 |
13802 gpu::CommandHeader header; | 14386 gpu::CommandHeader header; |
13803 }; | 14387 }; |
13804 | 14388 |
13805 static_assert(sizeof(BlendBarrierKHR) == 4, | 14389 static_assert(sizeof(BlendBarrierKHR) == 4, |
13806 "size of BlendBarrierKHR should be 4"); | 14390 "size of BlendBarrierKHR should be 4"); |
13807 static_assert(offsetof(BlendBarrierKHR, header) == 0, | 14391 static_assert(offsetof(BlendBarrierKHR, header) == 0, |
13808 "offset of BlendBarrierKHR header should be 0"); | 14392 "offset of BlendBarrierKHR header should be 0"); |
13809 | 14393 |
13810 #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ | 14394 #endif // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_ |
OLD | NEW |