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