Bug Summary

File:var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/x86_64-unknown-linux-gnu/debug/build/swgl-6f6517a85091acb7/out/brush_mix_blend_DEBUG_OVERDRAW.h
Warning:line 2, column 8
Excessive padding in 'struct brush_mix_blend_DEBUG_OVERDRAW_common::Samplers' (32 padding bytes, where 0 is optimal). Optimal fields order: sPrimitiveHeadersI_impl, sClipMask_impl, sColor0_impl, sColor1_impl, sGpuCache_impl, sPrimitiveHeadersF_impl, sRenderTasks_impl, sTransformPalette_impl, sClipMask_slot, sColor0_slot, sColor1_slot, sGpuCache_slot, sPrimitiveHeadersF_slot, sPrimitiveHeadersI_slot, sRenderTasks_slot, sTransformPalette_slot, consider reordering the fields or adding explicit padding members

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name gl.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fapprox-func -funsafe-math-optimizations -fno-signed-zeros -mreassociate -freciprocal-math -ffp-contract=fast -fno-rounding-math -mrecip=none -complex-range=basic -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/gfx/wr/swgl -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/gfx/wr/swgl -resource-dir /usr/lib/llvm-19/lib/clang/19 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -D MOZILLA_CONFIG_H -I /var/lib/jenkins/workspace/firefox-scan-build/gfx/wr/swgl/../webrender/res -I src -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/x86_64-unknown-linux-gnu/debug/build/swgl-6f6517a85091acb7/out -U MOZILLA_CONFIG_H -D _GLIBCXX_USE_CXX11_ABI=0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -std=c++17 -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-09-22-115206-3586786-1 -x c++ src/gl.cc
1struct brush_mix_blend_DEBUG_OVERDRAW_common {
2struct Samplers {
Excessive padding in 'struct brush_mix_blend_DEBUG_OVERDRAW_common::Samplers' (32 padding bytes, where 0 is optimal). Optimal fields order: sPrimitiveHeadersI_impl, sClipMask_impl, sColor0_impl, sColor1_impl, sGpuCache_impl, sPrimitiveHeadersF_impl, sRenderTasks_impl, sTransformPalette_impl, sClipMask_slot, sColor0_slot, sColor1_slot, sGpuCache_slot, sPrimitiveHeadersF_slot, sPrimitiveHeadersI_slot, sRenderTasks_slot, sTransformPalette_slot, consider reordering the fields or adding explicit padding members
3 sampler2D_impl sClipMask_impl;
4 int sClipMask_slot;
5 sampler2D_impl sColor0_impl;
6 int sColor0_slot;
7 sampler2D_impl sColor1_impl;
8 int sColor1_slot;
9 sampler2D_impl sGpuCache_impl;
10 int sGpuCache_slot;
11 sampler2D_impl sPrimitiveHeadersF_impl;
12 int sPrimitiveHeadersF_slot;
13 isampler2D_impl sPrimitiveHeadersI_impl;
14 int sPrimitiveHeadersI_slot;
15 sampler2D_impl sRenderTasks_impl;
16 int sRenderTasks_slot;
17 sampler2D_impl sTransformPalette_impl;
18 int sTransformPalette_slot;
19 bool set_slot(int index, int value) {
20 switch (index) {
21 case 7:
22 sClipMask_slot = value;
23 return true;
24 case 8:
25 sColor0_slot = value;
26 return true;
27 case 9:
28 sColor1_slot = value;
29 return true;
30 case 2:
31 sGpuCache_slot = value;
32 return true;
33 case 4:
34 sPrimitiveHeadersF_slot = value;
35 return true;
36 case 5:
37 sPrimitiveHeadersI_slot = value;
38 return true;
39 case 1:
40 sRenderTasks_slot = value;
41 return true;
42 case 3:
43 sTransformPalette_slot = value;
44 return true;
45 }
46 return false;
47 }
48} samplers;
49struct AttribLocations {
50 int aPosition = NULL_ATTRIB16;
51 int aData = NULL_ATTRIB16;
52 void bind_loc(const char* name, int index) {
53 if (strcmp("aPosition", name) == 0) { aPosition = index; return; }
54 if (strcmp("aData", name) == 0) { aData = index; return; }
55 }
56 int get_loc(const char* name) const {
57 if (strcmp("aPosition", name) == 0) { return aPosition != NULL_ATTRIB16 ? aPosition : -1; }
58 if (strcmp("aData", name) == 0) { return aData != NULL_ATTRIB16 ? aData : -1; }
59 return -1;
60 }
61} attrib_locations;
62vec4_scalar vTransformBounds;
63vec4_scalar v_src_uv_sample_bounds;
64vec4_scalar v_backdrop_uv_sample_bounds;
65vec2_scalar v_perspective;
66ivec2_scalar v_op;
67sampler2D sClipMask;
68sampler2D sColor0;
69sampler2D sColor1;
70sampler2D sGpuCache;
71sampler2D sPrimitiveHeadersF;
72isampler2D sPrimitiveHeadersI;
73sampler2D sRenderTasks;
74sampler2D sTransformPalette;
75mat4_scalar uTransform;
76void bind_textures() {
77 sClipMask = lookup_sampler(&samplers.sClipMask_impl, samplers.sClipMask_slot);
78 sColor0 = lookup_sampler(&samplers.sColor0_impl, samplers.sColor0_slot);
79 sColor1 = lookup_sampler(&samplers.sColor1_impl, samplers.sColor1_slot);
80 sGpuCache = lookup_sampler(&samplers.sGpuCache_impl, samplers.sGpuCache_slot);
81 sPrimitiveHeadersF = lookup_sampler(&samplers.sPrimitiveHeadersF_impl, samplers.sPrimitiveHeadersF_slot);
82 sPrimitiveHeadersI = lookup_isampler(&samplers.sPrimitiveHeadersI_impl, samplers.sPrimitiveHeadersI_slot);
83 sRenderTasks = lookup_sampler(&samplers.sRenderTasks_impl, samplers.sRenderTasks_slot);
84 sTransformPalette = lookup_sampler(&samplers.sTransformPalette_impl, samplers.sTransformPalette_slot);
85}
86};
87struct brush_mix_blend_DEBUG_OVERDRAW_vert : VertexShaderImpl, brush_mix_blend_DEBUG_OVERDRAW_common {
88private:
89typedef brush_mix_blend_DEBUG_OVERDRAW_vert Self;
90// mat4_scalar uTransform;
91vec2 aPosition;
92// sampler2D sColor0;
93// sampler2D sColor1;
94// sampler2D sColor2;
95struct RectWithSize_scalar {
96vec2_scalar p0;
97vec2_scalar size;
98RectWithSize_scalar() = default;
99RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
100};
101struct RectWithSize {
102vec2 p0;
103vec2 size;
104RectWithSize() = default;
105RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
106RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
107}
108IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
109}
110friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
111if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
112}};
113struct RectWithEndpoint_scalar {
114vec2_scalar p0;
115vec2_scalar p1;
116RectWithEndpoint_scalar() = default;
117RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
118};
119struct RectWithEndpoint {
120vec2 p0;
121vec2 p1;
122RectWithEndpoint() = default;
123RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
124RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
125}
126IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
127}
128friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
129if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
130}};
131// sampler2D sRenderTasks;
132struct RenderTaskData_scalar {
133RectWithEndpoint_scalar task_rect;
134vec4_scalar user_data;
135RenderTaskData_scalar() = default;
136RenderTaskData_scalar(RectWithEndpoint_scalar task_rect, vec4_scalar user_data) : task_rect(task_rect), user_data(user_data){}
137};
138struct RenderTaskData {
139RectWithEndpoint task_rect;
140vec4 user_data;
141RenderTaskData() = default;
142RenderTaskData(RectWithEndpoint task_rect, vec4 user_data) : task_rect(task_rect), user_data(user_data){}
143RenderTaskData(RectWithEndpoint_scalar task_rect, vec4_scalar user_data):task_rect(task_rect),user_data(user_data){
144}
145IMPLICIT RenderTaskData(RenderTaskData_scalar s):task_rect(s.task_rect),user_data(s.user_data){
146}
147friend RenderTaskData if_then_else(I32 c, RenderTaskData t, RenderTaskData e) { return RenderTaskData(
148if_then_else(c, t.task_rect, e.task_rect), if_then_else(c, t.user_data, e.user_data));
149}};
150struct PictureTask_scalar {
151RectWithEndpoint_scalar task_rect;
152float device_pixel_scale;
153vec2_scalar content_origin;
154PictureTask_scalar() = default;
155PictureTask_scalar(RectWithEndpoint_scalar task_rect, float device_pixel_scale, vec2_scalar content_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), content_origin(content_origin){}
156};
157struct PictureTask {
158RectWithEndpoint task_rect;
159Float device_pixel_scale;
160vec2 content_origin;
161PictureTask() = default;
162PictureTask(RectWithEndpoint task_rect, Float device_pixel_scale, vec2 content_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), content_origin(content_origin){}
163PictureTask(RectWithEndpoint_scalar task_rect, float device_pixel_scale, vec2_scalar content_origin):task_rect(task_rect),device_pixel_scale(device_pixel_scale),content_origin(content_origin){
164}
165IMPLICIT PictureTask(PictureTask_scalar s):task_rect(s.task_rect),device_pixel_scale(s.device_pixel_scale),content_origin(s.content_origin){
166}
167friend PictureTask if_then_else(I32 c, PictureTask t, PictureTask e) { return PictureTask(
168if_then_else(c, t.task_rect, e.task_rect), if_then_else(c, t.device_pixel_scale, e.device_pixel_scale), if_then_else(c, t.content_origin, e.content_origin));
169}};
170struct ClipArea_scalar {
171RectWithEndpoint_scalar task_rect;
172float device_pixel_scale;
173vec2_scalar screen_origin;
174ClipArea_scalar() = default;
175ClipArea_scalar(RectWithEndpoint_scalar task_rect, float device_pixel_scale, vec2_scalar screen_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), screen_origin(screen_origin){}
176};
177struct ClipArea {
178RectWithEndpoint task_rect;
179Float device_pixel_scale;
180vec2 screen_origin;
181ClipArea() = default;
182ClipArea(RectWithEndpoint task_rect, Float device_pixel_scale, vec2 screen_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), screen_origin(screen_origin){}
183ClipArea(RectWithEndpoint_scalar task_rect, float device_pixel_scale, vec2_scalar screen_origin):task_rect(task_rect),device_pixel_scale(device_pixel_scale),screen_origin(screen_origin){
184}
185IMPLICIT ClipArea(ClipArea_scalar s):task_rect(s.task_rect),device_pixel_scale(s.device_pixel_scale),screen_origin(s.screen_origin){
186}
187friend ClipArea if_then_else(I32 c, ClipArea t, ClipArea e) { return ClipArea(
188if_then_else(c, t.task_rect, e.task_rect), if_then_else(c, t.device_pixel_scale, e.device_pixel_scale), if_then_else(c, t.screen_origin, e.screen_origin));
189}};
190// sampler2D sGpuCache;
191struct ImageSource_scalar {
192RectWithEndpoint_scalar uv_rect;
193vec4_scalar user_data;
194ImageSource_scalar() = default;
195ImageSource_scalar(RectWithEndpoint_scalar uv_rect, vec4_scalar user_data) : uv_rect(uv_rect), user_data(user_data){}
196};
197struct ImageSource {
198RectWithEndpoint uv_rect;
199vec4 user_data;
200ImageSource() = default;
201ImageSource(RectWithEndpoint uv_rect, vec4 user_data) : uv_rect(uv_rect), user_data(user_data){}
202ImageSource(RectWithEndpoint_scalar uv_rect, vec4_scalar user_data):uv_rect(uv_rect),user_data(user_data){
203}
204IMPLICIT ImageSource(ImageSource_scalar s):uv_rect(s.uv_rect),user_data(s.user_data){
205}
206friend ImageSource if_then_else(I32 c, ImageSource t, ImageSource e) { return ImageSource(
207if_then_else(c, t.uv_rect, e.uv_rect), if_then_else(c, t.user_data, e.user_data));
208}};
209struct ImageSourceExtra_scalar {
210vec4_scalar st_tl;
211vec4_scalar st_tr;
212vec4_scalar st_bl;
213vec4_scalar st_br;
214ImageSourceExtra_scalar() = default;
215ImageSourceExtra_scalar(vec4_scalar st_tl, vec4_scalar st_tr, vec4_scalar st_bl, vec4_scalar st_br) : st_tl(st_tl), st_tr(st_tr), st_bl(st_bl), st_br(st_br){}
216};
217struct ImageSourceExtra {
218vec4 st_tl;
219vec4 st_tr;
220vec4 st_bl;
221vec4 st_br;
222ImageSourceExtra() = default;
223ImageSourceExtra(vec4 st_tl, vec4 st_tr, vec4 st_bl, vec4 st_br) : st_tl(st_tl), st_tr(st_tr), st_bl(st_bl), st_br(st_br){}
224ImageSourceExtra(vec4_scalar st_tl, vec4_scalar st_tr, vec4_scalar st_bl, vec4_scalar st_br):st_tl(st_tl),st_tr(st_tr),st_bl(st_bl),st_br(st_br){
225}
226IMPLICIT ImageSourceExtra(ImageSourceExtra_scalar s):st_tl(s.st_tl),st_tr(s.st_tr),st_bl(s.st_bl),st_br(s.st_br){
227}
228friend ImageSourceExtra if_then_else(I32 c, ImageSourceExtra t, ImageSourceExtra e) { return ImageSourceExtra(
229if_then_else(c, t.st_tl, e.st_tl), if_then_else(c, t.st_tr, e.st_tr), if_then_else(c, t.st_bl, e.st_bl), if_then_else(c, t.st_br, e.st_br));
230}};
231// vec4_scalar vTransformBounds;
232// sampler2D sTransformPalette;
233struct Transform_scalar {
234mat4_scalar m;
235mat4_scalar inv_m;
236bool is_axis_aligned;
237Transform_scalar() = default;
238Transform_scalar(mat4_scalar m, mat4_scalar inv_m, bool is_axis_aligned) : m(m), inv_m(inv_m), is_axis_aligned(is_axis_aligned){}
239};
240struct Transform {
241mat4 m;
242mat4 inv_m;
243Bool is_axis_aligned;
244Transform() = default;
245Transform(mat4 m, mat4 inv_m, Bool is_axis_aligned) : m(m), inv_m(inv_m), is_axis_aligned(is_axis_aligned){}
246Transform(mat4_scalar m, mat4_scalar inv_m, bool is_axis_aligned):m(m),inv_m(inv_m),is_axis_aligned(is_axis_aligned){
247}
248IMPLICIT Transform(Transform_scalar s):m(s.m),inv_m(s.inv_m),is_axis_aligned(s.is_axis_aligned){
249}
250friend Transform if_then_else(I32 c, Transform t, Transform e) { return Transform(
251if_then_else(c, t.m, e.m), if_then_else(c, t.inv_m, e.inv_m), if_then_else(c, t.is_axis_aligned, e.is_axis_aligned));
252}};
253// sampler2D sClipMask;
254// sampler2D sPrimitiveHeadersF;
255// isampler2D sPrimitiveHeadersI;
256ivec4_scalar aData;
257struct Instance_scalar {
258int32_t prim_header_address;
259int32_t clip_address;
260int32_t segment_index;
261int32_t flags;
262int32_t resource_address;
263int32_t brush_kind;
264Instance_scalar() = default;
265Instance_scalar(int32_t prim_header_address, int32_t clip_address, int32_t segment_index, int32_t flags, int32_t resource_address, int32_t brush_kind) : prim_header_address(prim_header_address), clip_address(clip_address), segment_index(segment_index), flags(flags), resource_address(resource_address), brush_kind(brush_kind){}
266};
267struct Instance {
268I32 prim_header_address;
269I32 clip_address;
270I32 segment_index;
271I32 flags;
272I32 resource_address;
273I32 brush_kind;
274Instance() = default;
275Instance(I32 prim_header_address, I32 clip_address, I32 segment_index, I32 flags, I32 resource_address, I32 brush_kind) : prim_header_address(prim_header_address), clip_address(clip_address), segment_index(segment_index), flags(flags), resource_address(resource_address), brush_kind(brush_kind){}
276Instance(int32_t prim_header_address, int32_t clip_address, int32_t segment_index, int32_t flags, int32_t resource_address, int32_t brush_kind):prim_header_address(prim_header_address),clip_address(clip_address),segment_index(segment_index),flags(flags),resource_address(resource_address),brush_kind(brush_kind){
277}
278IMPLICIT Instance(Instance_scalar s):prim_header_address(s.prim_header_address),clip_address(s.clip_address),segment_index(s.segment_index),flags(s.flags),resource_address(s.resource_address),brush_kind(s.brush_kind){
279}
280friend Instance if_then_else(I32 c, Instance t, Instance e) { return Instance(
281if_then_else(c, t.prim_header_address, e.prim_header_address), if_then_else(c, t.clip_address, e.clip_address), if_then_else(c, t.segment_index, e.segment_index), if_then_else(c, t.flags, e.flags), if_then_else(c, t.resource_address, e.resource_address), if_then_else(c, t.brush_kind, e.brush_kind));
282}};
283struct PrimitiveHeader_scalar {
284RectWithEndpoint_scalar local_rect;
285RectWithEndpoint_scalar local_clip_rect;
286float z;
287int32_t specific_prim_address;
288int32_t transform_id;
289int32_t picture_task_address;
290ivec4_scalar user_data;
291PrimitiveHeader_scalar() = default;
292PrimitiveHeader_scalar(RectWithEndpoint_scalar local_rect, RectWithEndpoint_scalar local_clip_rect, float z, int32_t specific_prim_address, int32_t transform_id, int32_t picture_task_address, ivec4_scalar user_data) : local_rect(local_rect), local_clip_rect(local_clip_rect), z(z), specific_prim_address(specific_prim_address), transform_id(transform_id), picture_task_address(picture_task_address), user_data(user_data){}
293};
294struct PrimitiveHeader {
295RectWithEndpoint local_rect;
296RectWithEndpoint local_clip_rect;
297Float z;
298I32 specific_prim_address;
299I32 transform_id;
300I32 picture_task_address;
301ivec4 user_data;
302PrimitiveHeader() = default;
303PrimitiveHeader(RectWithEndpoint local_rect, RectWithEndpoint local_clip_rect, Float z, I32 specific_prim_address, I32 transform_id, I32 picture_task_address, ivec4 user_data) : local_rect(local_rect), local_clip_rect(local_clip_rect), z(z), specific_prim_address(specific_prim_address), transform_id(transform_id), picture_task_address(picture_task_address), user_data(user_data){}
304PrimitiveHeader(RectWithEndpoint_scalar local_rect, RectWithEndpoint_scalar local_clip_rect, float z, int32_t specific_prim_address, int32_t transform_id, int32_t picture_task_address, ivec4_scalar user_data):local_rect(local_rect),local_clip_rect(local_clip_rect),z(z),specific_prim_address(specific_prim_address),transform_id(transform_id),picture_task_address(picture_task_address),user_data(user_data){
305}
306IMPLICIT PrimitiveHeader(PrimitiveHeader_scalar s):local_rect(s.local_rect),local_clip_rect(s.local_clip_rect),z(s.z),specific_prim_address(s.specific_prim_address),transform_id(s.transform_id),picture_task_address(s.picture_task_address),user_data(s.user_data){
307}
308friend PrimitiveHeader if_then_else(I32 c, PrimitiveHeader t, PrimitiveHeader e) { return PrimitiveHeader(
309if_then_else(c, t.local_rect, e.local_rect), if_then_else(c, t.local_clip_rect, e.local_clip_rect), if_then_else(c, t.z, e.z), if_then_else(c, t.specific_prim_address, e.specific_prim_address), if_then_else(c, t.transform_id, e.transform_id), if_then_else(c, t.picture_task_address, e.picture_task_address), if_then_else(c, t.user_data, e.user_data));
310}};
311struct VertexInfo_scalar {
312vec2_scalar local_pos;
313vec4_scalar world_pos;
314VertexInfo_scalar() = default;
315VertexInfo_scalar(vec2_scalar local_pos, vec4_scalar world_pos) : local_pos(local_pos), world_pos(world_pos){}
316};
317struct VertexInfo {
318vec2 local_pos;
319vec4 world_pos;
320VertexInfo() = default;
321VertexInfo(vec2 local_pos, vec4 world_pos) : local_pos(local_pos), world_pos(world_pos){}
322VertexInfo(vec2_scalar local_pos, vec4_scalar world_pos):local_pos(local_pos),world_pos(world_pos){
323}
324IMPLICIT VertexInfo(VertexInfo_scalar s):local_pos(s.local_pos),world_pos(s.world_pos){
325}
326friend VertexInfo if_then_else(I32 c, VertexInfo t, VertexInfo e) { return VertexInfo(
327if_then_else(c, t.local_pos, e.local_pos), if_then_else(c, t.world_pos, e.world_pos));
328}};
329vec2 v_src_uv;
330// vec4_scalar v_src_uv_sample_bounds;
331vec2 v_backdrop_uv;
332// vec4_scalar v_backdrop_uv_sample_bounds;
333// vec2_scalar v_perspective;
334// ivec2_scalar v_op;
335Instance_scalar decode_instance_attributes() {
336 Instance_scalar instance;
337 (instance).prim_header_address = (aData).x;
338 (instance).clip_address = (aData).y;
339 (instance).segment_index = ((aData).z)&(65535);
340 (instance).flags = ((aData).z)>>(16);
341 (instance).resource_address = ((aData).w)&(16777215);
342 (instance).brush_kind = ((aData).w)>>(24);
343 return instance;
344}
345PrimitiveHeader_scalar fetch_prim_header(int32_t index) {
346 PrimitiveHeader_scalar ph;
347 ivec2_scalar uv_f = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
348 auto sPrimitiveHeadersF_uv_f_fetch = texelFetchPtr(sPrimitiveHeadersF, uv_f, 0, 1, 0, 0);
349 vec4_scalar local_rect = texelFetchUnchecked(sPrimitiveHeadersF, sPrimitiveHeadersF_uv_f_fetch, 0, 0);
350 vec4_scalar local_clip_rect = texelFetchUnchecked(sPrimitiveHeadersF, sPrimitiveHeadersF_uv_f_fetch, 1, 0);
351 (ph).local_rect = RectWithEndpoint_scalar((local_rect).sel(X,Y), (local_rect).sel(Z,W));
352 (ph).local_clip_rect = RectWithEndpoint_scalar((local_clip_rect).sel(X,Y), (local_clip_rect).sel(Z,W));
353 ivec2_scalar uv_i = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
354 auto sPrimitiveHeadersI_uv_i_fetch = texelFetchPtr(sPrimitiveHeadersI, uv_i, 0, 1, 0, 0);
355 ivec4_scalar data0 = texelFetchUnchecked(sPrimitiveHeadersI, sPrimitiveHeadersI_uv_i_fetch, 0, 0);
356 ivec4_scalar data1 = texelFetchUnchecked(sPrimitiveHeadersI, sPrimitiveHeadersI_uv_i_fetch, 1, 0);
357 (ph).z = make_float((data0).x);
358 (ph).specific_prim_address = (data0).y;
359 (ph).transform_id = (data0).z;
360 (ph).picture_task_address = (data0).w;
361 (ph).user_data = data1;
362 return ph;
363}
364Transform_scalar fetch_transform(int32_t id) {
365 Transform_scalar transform;
366 (transform).is_axis_aligned = ((id)>>(23))==(0);
367 int32_t index = (id)&(8388607);
368 ivec2_scalar uv = make_ivec2(make_int((8u)*((make_uint(index))%((1024u)/(8u)))), make_int((make_uint(index))/((1024u)/(8u))));
369 ivec2_scalar uv0 = make_ivec2(((uv).x)+(0), (uv).y);
370 auto sTransformPalette_uv0_fetch = texelFetchPtr(sTransformPalette, uv0, 0, 7, 0, 0);
371 (transform).m[0] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 0, 0);
372 (transform).m[1] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 1, 0);
373 (transform).m[2] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 2, 0);
374 (transform).m[3] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 3, 0);
375 (transform).inv_m[0] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 4, 0);
376 (transform).inv_m[1] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 5, 0);
377 (transform).inv_m[2] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 6, 0);
378 (transform).inv_m[3] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 7, 0);
379 return transform;
380}
381RenderTaskData_scalar fetch_render_task_data(int32_t index) {
382 ivec2_scalar uv = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
383 auto sRenderTasks_uv_fetch = texelFetchPtr(sRenderTasks, uv, 0, 1, 0, 0);
384 vec4_scalar texel0 = texelFetchUnchecked(sRenderTasks, sRenderTasks_uv_fetch, 0, 0);
385 vec4_scalar texel1 = texelFetchUnchecked(sRenderTasks, sRenderTasks_uv_fetch, 1, 0);
386 RectWithEndpoint_scalar task_rect = RectWithEndpoint_scalar((texel0).sel(X,Y), (texel0).sel(Z,W));
387 RenderTaskData_scalar data = RenderTaskData_scalar(task_rect, texel1);
388 return data;
389}
390PictureTask_scalar fetch_picture_task(int32_t address) {
391 RenderTaskData_scalar task_data = fetch_render_task_data(address);
392 PictureTask_scalar task = PictureTask_scalar((task_data).task_rect, ((task_data).user_data).x, ((task_data).user_data).sel(Y,Z));
393 return task;
394}
395ClipArea_scalar fetch_clip_area(int32_t index) {
396 RenderTaskData_scalar task_data;
397 if ((index)>=(2147483647)) {
398 {
399 task_data = RenderTaskData_scalar(RectWithEndpoint_scalar(make_vec2(0.f), make_vec2(0.f)), make_vec4(0.f));
400 }
401 } else {
402 task_data = fetch_render_task_data(index);
403 }
404 return ClipArea_scalar((task_data).task_rect, ((task_data).user_data).x, ((task_data).user_data).sel(Y,Z));
405}
406ivec2_scalar get_gpu_cache_uv(int32_t address) {
407 return make_ivec2((make_uint(address))%(1024u), (make_uint(address))/(1024u));
408}
409Array<vec4_scalar,2> fetch_from_gpu_cache_2(int32_t address) {
410 ivec2_scalar uv = get_gpu_cache_uv(address);
411 auto sGpuCache_uv_fetch = texelFetchPtr(sGpuCache, uv, 0, 1, 0, 0);
412 return Array<vec4_scalar,2>{{texelFetchUnchecked(sGpuCache, sGpuCache_uv_fetch, 0, 0), texelFetchUnchecked(sGpuCache, sGpuCache_uv_fetch, 1, 0)}};
413}
414RectWithEndpoint_scalar clip_and_init_antialiasing(RectWithEndpoint_scalar segment_rect, RectWithEndpoint_scalar prim_rect, RectWithEndpoint_scalar clip_rect, int32_t edge_flags, float z, Transform_scalar transform, PictureTask_scalar task) {
415 bvec4_scalar clipped = make_bvec4(greaterThan((clip_rect).p0, (segment_rect).p0), lessThan((clip_rect).p1, (segment_rect).p1));
416 swgl_antiAlias((edge_flags)|(((clipped).x ? 1 : 0)|(((clipped).y ? 2 : 0)|(((clipped).z ? 4 : 0)|((clipped).w ? 8 : 0)))))do { swgl_AAEdgeMask = calcAAEdgeMask((edge_flags)|(((clipped
).x ? 1 : 0)|(((clipped).y ? 2 : 0)|(((clipped).z ? 4 : 0)|((
clipped).w ? 8 : 0))))); if (swgl_AAEdgeMask) { swgl_ClipFlags
|= SWGL_CLIP_FLAG_AA; } } while (0)
;
417 (segment_rect).p0 = clamp((segment_rect).p0, (clip_rect).p0, (clip_rect).p1);
418 (segment_rect).p1 = clamp((segment_rect).p1, (clip_rect).p0, (clip_rect).p1);
419 return segment_rect;
420}
421vec2 rect_clamp(RectWithEndpoint_scalar rect, vec2 pt) {
422 return clamp(pt, (rect).p0, (rect).p1);
423}
424VertexInfo write_vertex(vec2 local_pos, RectWithEndpoint_scalar local_clip_rect, float z, Transform_scalar transform, PictureTask_scalar task) {
425 vec2 clamped_local_pos = rect_clamp(local_clip_rect, local_pos);
426 vec4 world_pos = ((transform).m)*(make_vec4(clamped_local_pos, 0.f, 1.f));
427 vec2 device_pos = ((world_pos).sel(X,Y))*((task).device_pixel_scale);
428 vec2_scalar final_offset = (-((task).content_origin))+(((task).task_rect).p0);
429 gl_Position = (uTransform)*(make_vec4((device_pos)+((final_offset)*((world_pos).w)), (z)*((world_pos).w), (world_pos).w));
430 VertexInfo vi = VertexInfo(clamped_local_pos, world_pos);
431 return vi;
432}
433vec2_scalar rect_size(RectWithEndpoint_scalar rect) {
434 return ((rect).p1)-((rect).p0);
435}
436void write_clip(vec4 world_pos, ClipArea_scalar area, PictureTask_scalar task) {
437 swgl_clipMask(sClipMask, ((((task).task_rect).p0)-((task).content_origin))-((((area).task_rect).p0)-((area).screen_origin)), ((area).task_rect).p0, rect_size((area).task_rect))do { if (rect_size((area).task_rect) != vec2_scalar(0.0f, 0.0f
)) { swgl_ClipFlags |= SWGL_CLIP_FLAG_MASK; swgl_ClipMask = sClipMask
; swgl_ClipMaskOffset = make_ivec2(((((task).task_rect).p0)-(
(task).content_origin))-((((area).task_rect).p0)-((area).screen_origin
))); swgl_ClipMaskBounds = IntRect(make_ivec2(((area).task_rect
).p0), make_ivec2(rect_size((area).task_rect))); } } while (0
)
;
438}
439ImageSource_scalar fetch_image_source(int32_t address) {
440 Array<vec4_scalar,2> data = fetch_from_gpu_cache_2(address);
441 RectWithEndpoint_scalar uv_rect = RectWithEndpoint_scalar((data[0]).sel(X,Y), (data[0]).sel(Z,W));
442 return ImageSource_scalar(uv_rect, data[1]);
443}
444Array<vec4_scalar,4> fetch_from_gpu_cache_4(int32_t address) {
445 ivec2_scalar uv = get_gpu_cache_uv(address);
446 auto sGpuCache_uv_fetch = texelFetchPtr(sGpuCache, uv, 0, 3, 0, 0);
447 return Array<vec4_scalar,4>{{texelFetchUnchecked(sGpuCache, sGpuCache_uv_fetch, 0, 0), texelFetchUnchecked(sGpuCache, sGpuCache_uv_fetch, 1, 0), texelFetchUnchecked(sGpuCache, sGpuCache_uv_fetch, 2, 0), texelFetchUnchecked(sGpuCache, sGpuCache_uv_fetch, 3, 0)}};
448}
449ImageSourceExtra_scalar fetch_image_source_extra(int32_t address) {
450 Array<vec4_scalar,4> data = fetch_from_gpu_cache_4((address)+(2));
451 return ImageSourceExtra_scalar(data[0], data[1], data[2], data[3]);
452}
453vec2 get_image_quad_uv(int32_t address, vec2 f) {
454 ImageSourceExtra_scalar extra_data = fetch_image_source_extra(address);
455 vec4 x = mix((extra_data).st_tl, (extra_data).st_tr, (f).x);
456 vec4 y = mix((extra_data).st_bl, (extra_data).st_br, (f).x);
457 vec4 z = mix(x, y, (f).y);
458 return ((z).sel(X,Y))/((z).w);
459}
460void get_uv(int32_t res_address, vec2 f, ivec2_scalar texture_size, float perspective_f, vec2& out_uv, vec4_scalar& out_uv_sample_bounds) {
461 ImageSource_scalar res = fetch_image_source(res_address);
462 vec2_scalar uv0 = ((res).uv_rect).p0;
463 vec2_scalar uv1 = ((res).uv_rect).p1;
464 vec2_scalar inv_texture_size = (make_vec2(1.f))/(make_vec2(texture_size));
465 f = get_image_quad_uv(res_address, f);
466 vec2 uv = mix(uv0, uv1, f);
467 out_uv = ((uv)*(inv_texture_size))*(perspective_f);
468 out_uv_sample_bounds = (make_vec4((uv0)+(make_vec2(0.5f)), (uv1)-(make_vec2(0.5f))))*((inv_texture_size).sel(X,Y,X,Y));
469}
470void get_uv(int32_t res_address, vec2 f, ivec2_scalar texture_size, Float perspective_f, vec2& out_uv, vec4_scalar& out_uv_sample_bounds) {
471 ImageSource_scalar res = fetch_image_source(res_address);
472 vec2_scalar uv0 = ((res).uv_rect).p0;
473 vec2_scalar uv1 = ((res).uv_rect).p1;
474 vec2_scalar inv_texture_size = (make_vec2(1.f))/(make_vec2(texture_size));
475 f = get_image_quad_uv(res_address, f);
476 vec2 uv = mix(uv0, uv1, f);
477 out_uv = ((uv)*(inv_texture_size))*(perspective_f);
478 out_uv_sample_bounds = (make_vec4((uv0)+(make_vec2(0.5f)), (uv1)-(make_vec2(0.5f))))*((inv_texture_size).sel(X,Y,X,Y));
479}
480void brush_vs(VertexInfo vi, int32_t prim_address, RectWithEndpoint_scalar local_rect, RectWithEndpoint_scalar segment_rect, ivec4_scalar prim_user_data, int32_t specific_resource_address, mat4_scalar transform, PictureTask_scalar pic_task, int32_t brush_flags, vec4_scalar unused) {
481 vec2 f = (((vi).local_pos)-((local_rect).p0))/(rect_size(local_rect));
482 float perspective_interpolate = ((brush_flags)&(1))!=(0) ? 1.f : 0.f;
483 Float perspective_f = mix(((vi).world_pos).w, 1.f, perspective_interpolate);
484 (v_perspective).x = perspective_interpolate;
485 (v_op).x = (prim_user_data).x;
486 get_uv((prim_user_data).y, f, (textureSize(sColor0, 0)).sel(X,Y), 1.f, v_backdrop_uv, v_backdrop_uv_sample_bounds);
487 get_uv((prim_user_data).z, f, (textureSize(sColor1, 0)).sel(X,Y), perspective_f, v_src_uv, v_src_uv_sample_bounds);
488}
489void brush_shader_main_vs(Instance_scalar instance, PrimitiveHeader_scalar ph, Transform_scalar transform, PictureTask_scalar pic_task, ClipArea_scalar clip_area) {
490 int32_t edge_flags = (((instance).flags)>>(12))&(15);
491 int32_t brush_flags = ((instance).flags)&(4095);
492 vec4_scalar segment_data;
493 RectWithEndpoint_scalar segment_rect;
494 if (((instance).segment_index)==(65535)) {
495 {
496 segment_rect = (ph).local_rect;
497 segment_data = make_vec4(0.f);
498 }
499 } else {
500 int32_t segment_address = (((ph).specific_prim_address)+(3))+(((instance).segment_index)*(2));
501 Array<vec4_scalar,2> segment_info = fetch_from_gpu_cache_2(segment_address);
502 segment_rect = RectWithEndpoint_scalar((segment_info[0]).sel(X,Y), (segment_info[0]).sel(Z,W));
503 (segment_rect).p0 += ((ph).local_rect).p0;
504 (segment_rect).p1 += ((ph).local_rect).p0;
505 segment_data = segment_info[1];
506 }
507 RectWithEndpoint_scalar adjusted_segment_rect = segment_rect;
508 bool antialiased = (!((transform).is_axis_aligned))||(((brush_flags)&(1024))!=(0));
509 if (antialiased) {
510 {
511 adjusted_segment_rect = clip_and_init_antialiasing(segment_rect, (ph).local_rect, (ph).local_clip_rect, edge_flags, (ph).z, transform, pic_task);
512 ((ph).local_clip_rect).p0 = make_vec2(-(10000000000000000.f));
513 ((ph).local_clip_rect).p1 = make_vec2(10000000000000000.f);
514 }
515 } else {
516 }
517 vec2 local_pos = mix((adjusted_segment_rect).p0, (adjusted_segment_rect).p1, (aPosition).sel(X,Y));
518 VertexInfo vi = write_vertex(local_pos, (ph).local_clip_rect, (ph).z, transform, pic_task);
519 write_clip((vi).world_pos, clip_area, pic_task);
520 brush_vs(vi, (ph).specific_prim_address, (ph).local_rect, segment_rect, (ph).user_data, (instance).resource_address, (transform).m, pic_task, brush_flags, segment_data);
521}
522ALWAYS_INLINE__attribute__((always_inline)) inline void main(void) {
523 Instance_scalar instance = decode_instance_attributes();
524 PrimitiveHeader_scalar ph = fetch_prim_header((instance).prim_header_address);
525 Transform_scalar transform = fetch_transform((ph).transform_id);
526 PictureTask_scalar task = fetch_picture_task((ph).picture_task_address);
527 ClipArea_scalar clip_area = fetch_clip_area((instance).clip_address);
528 brush_shader_main_vs(instance, ph, transform, task, clip_area);
529}
530static void set_uniform_1i(VertexShaderImpl* impl, int index, int value) {
531 Self* self = (Self*)impl;
532 if (self->samplers.set_slot(index, value)) return;
533 switch (index) {
534 case 7:
535 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sClipMask
536 break;
537 case 8:
538 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sColor0
539 break;
540 case 9:
541 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sColor1
542 break;
543 case 2:
544 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sGpuCache
545 break;
546 case 4:
547 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sPrimitiveHeadersF
548 break;
549 case 5:
550 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sPrimitiveHeadersI
551 break;
552 case 1:
553 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sRenderTasks
554 break;
555 case 3:
556 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sTransformPalette
557 break;
558 case 6:
559 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // uTransform
560 break;
561 }
562}
563static void set_uniform_4fv(VertexShaderImpl* impl, int index, const float *value) {
564 Self* self = (Self*)impl;
565 switch (index) {
566 case 7:
567 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sClipMask
568 break;
569 case 8:
570 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sColor0
571 break;
572 case 9:
573 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sColor1
574 break;
575 case 2:
576 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sGpuCache
577 break;
578 case 4:
579 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sPrimitiveHeadersF
580 break;
581 case 5:
582 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sPrimitiveHeadersI
583 break;
584 case 1:
585 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sRenderTasks
586 break;
587 case 3:
588 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sTransformPalette
589 break;
590 case 6:
591 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // uTransform
592 break;
593 }
594}
595static void set_uniform_matrix4fv(VertexShaderImpl* impl, int index, const float *value) {
596 Self* self = (Self*)impl;
597 switch (index) {
598 case 7:
599 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sClipMask
600 break;
601 case 8:
602 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sColor0
603 break;
604 case 9:
605 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sColor1
606 break;
607 case 2:
608 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sGpuCache
609 break;
610 case 4:
611 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sPrimitiveHeadersF
612 break;
613 case 5:
614 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sPrimitiveHeadersI
615 break;
616 case 1:
617 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sRenderTasks
618 break;
619 case 3:
620 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
; // sTransformPalette
621 break;
622 case 6:
623 self->uTransform = mat4_scalar::load_from_ptr(value);
624 break;
625 }
626}
627static void load_attribs(VertexShaderImpl* impl, VertexAttrib *attribs, uint32_t start, int instance, int count) {Self* self = (Self*)impl;
628 load_attrib(self->aPosition, attribs[self->attrib_locations.aPosition], start, instance, count);
629 load_flat_attrib(self->aData, attribs[self->attrib_locations.aData], start, instance, count);
630}
631public:
632struct InterpOutputs {
633vec2_scalar v_src_uv;
634vec2_scalar v_backdrop_uv;
635};
636private:
637ALWAYS_INLINE__attribute__((always_inline)) inline void store_interp_outputs(char* dest_ptr, size_t stride) {
638 for(int n = 0; n < 4; n++) {
639 auto* dest = reinterpret_cast<InterpOutputs*>(dest_ptr);
640 dest->v_src_uv = get_nth(v_src_uv, n);
641 dest->v_backdrop_uv = get_nth(v_backdrop_uv, n);
642 dest_ptr += stride;
643 }
644}
645static void run(VertexShaderImpl* impl, char* interps, size_t interp_stride) {
646 Self* self = (Self*)impl;
647 self->main();
648 self->store_interp_outputs(interps, interp_stride);
649}
650static void init_batch(VertexShaderImpl* impl) {
651 Self* self = (Self*)impl; self->bind_textures(); }
652public:
653brush_mix_blend_DEBUG_OVERDRAW_vert() {
654 set_uniform_1i_func = &set_uniform_1i;
655 set_uniform_4fv_func = &set_uniform_4fv;
656 set_uniform_matrix4fv_func = &set_uniform_matrix4fv;
657 init_batch_func = &init_batch;
658 load_attribs_func = &load_attribs;
659 run_primitive_func = &run;
660}
661};
662
663
664struct brush_mix_blend_DEBUG_OVERDRAW_frag : FragmentShaderImpl, brush_mix_blend_DEBUG_OVERDRAW_vert {
665private:
666typedef brush_mix_blend_DEBUG_OVERDRAW_frag Self;
667#define oFragColorgl_FragColor gl_FragColor
668// vec4 oFragColor;
669// sampler2D sColor0;
670// sampler2D sColor1;
671// sampler2D sColor2;
672struct RectWithSize_scalar {
673vec2_scalar p0;
674vec2_scalar size;
675RectWithSize_scalar() = default;
676RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
677};
678struct RectWithSize {
679vec2 p0;
680vec2 size;
681RectWithSize() = default;
682RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
683RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
684}
685IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
686}
687friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
688if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
689}};
690struct RectWithEndpoint_scalar {
691vec2_scalar p0;
692vec2_scalar p1;
693RectWithEndpoint_scalar() = default;
694RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
695};
696struct RectWithEndpoint {
697vec2 p0;
698vec2 p1;
699RectWithEndpoint() = default;
700RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
701RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
702}
703IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
704}
705friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
706if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
707}};
708// sampler2D sGpuCache;
709// vec4_scalar vTransformBounds;
710// sampler2D sClipMask;
711struct Fragment_scalar {
712vec4_scalar color;
713Fragment_scalar() = default;
714explicit Fragment_scalar(vec4_scalar color) : color(color){}
715};
716struct Fragment {
717vec4 color;
718Fragment() = default;
719explicit Fragment(vec4 color) : color(color){}
720explicit Fragment(vec4_scalar color):color(color){
721}
722IMPLICIT Fragment(Fragment_scalar s):color(s.color){
723}
724friend Fragment if_then_else(I32 c, Fragment t, Fragment e) { return Fragment(
725if_then_else(c, t.color, e.color));
726}};
727vec2 v_src_uv;
728// vec4_scalar v_src_uv_sample_bounds;
729vec2 v_backdrop_uv;
730// vec4_scalar v_backdrop_uv_sample_bounds;
731// vec2_scalar v_perspective;
732// ivec2_scalar v_op;
733int32_t static constexpr MixBlendMode_Multiply = 1;
734int32_t static constexpr MixBlendMode_Screen = 2;
735int32_t static constexpr MixBlendMode_Overlay = 3;
736int32_t static constexpr MixBlendMode_Darken = 4;
737int32_t static constexpr MixBlendMode_Lighten = 5;
738int32_t static constexpr MixBlendMode_ColorDodge = 6;
739int32_t static constexpr MixBlendMode_ColorBurn = 7;
740int32_t static constexpr MixBlendMode_HardLight = 8;
741int32_t static constexpr MixBlendMode_SoftLight = 9;
742int32_t static constexpr MixBlendMode_Difference = 10;
743int32_t static constexpr MixBlendMode_Exclusion = 11;
744int32_t static constexpr MixBlendMode_Hue = 12;
745int32_t static constexpr MixBlendMode_Saturation = 13;
746int32_t static constexpr MixBlendMode_Color = 14;
747int32_t static constexpr MixBlendMode_Luminosity = 15;
748int32_t static constexpr MixBlendMode_PlusLighter = 16;
749ALWAYS_INLINE__attribute__((always_inline)) inline void main(void) {
750 oFragColorgl_FragColor = make_vec4(0.11f, 0.077f, 0.027f, 0.125f);
751}
752typedef brush_mix_blend_DEBUG_OVERDRAW_vert::InterpOutputs InterpInputs;
753InterpInputs interp_step;
754static void read_interp_inputs(FragmentShaderImpl* impl, const void* init_, const void* step_) {Self* self = (Self*)impl;const InterpInputs* init = (const InterpInputs*)init_;const InterpInputs* step = (const InterpInputs*)step_;
755}
756ALWAYS_INLINE__attribute__((always_inline)) inline void step_interp_inputs(int steps = 4) {
757}
758static void run(FragmentShaderImpl* impl) {
759 Self* self = (Self*)impl;
760 self->main();
761 self->step_interp_inputs();
762}
763static void skip(FragmentShaderImpl* impl, int steps) {
764 Self* self = (Self*)impl;
765 self->step_interp_inputs(steps);
766}
767public:
768brush_mix_blend_DEBUG_OVERDRAW_frag() {
769 init_span_func = &read_interp_inputs;
770 run_func = &run;
771 skip_func = &skip;
772 init_span_w_func = &read_interp_inputs;
773 run_w_func = &run;
774 skip_w_func = &skip;
775}
776};
777
778struct brush_mix_blend_DEBUG_OVERDRAW_program : ProgramImpl, brush_mix_blend_DEBUG_OVERDRAW_frag {
779int get_uniform(const char *name) const override {
780 if (strcmp("sClipMask", name) == 0) { return 7; }
781 if (strcmp("sColor0", name) == 0) { return 8; }
782 if (strcmp("sColor1", name) == 0) { return 9; }
783 if (strcmp("sGpuCache", name) == 0) { return 2; }
784 if (strcmp("sPrimitiveHeadersF", name) == 0) { return 4; }
785 if (strcmp("sPrimitiveHeadersI", name) == 0) { return 5; }
786 if (strcmp("sRenderTasks", name) == 0) { return 1; }
787 if (strcmp("sTransformPalette", name) == 0) { return 3; }
788 if (strcmp("uTransform", name) == 0) { return 6; }
789 return -1;
790}
791void bind_attrib(const char* name, int index) override {
792 attrib_locations.bind_loc(name, index);
793}
794int get_attrib(const char* name) const override {
795 return attrib_locations.get_loc(name);
796}
797size_t interpolants_size() const override { return sizeof(InterpOutputs); }
798VertexShaderImpl* get_vertex_shader() override {
799 return this;
800}
801FragmentShaderImpl* get_fragment_shader() override {
802 return this;
803}
804const char* get_name() const override { return "brush_mix_blend_DEBUG_OVERDRAW"; }
805static ProgramImpl* loader() { return new brush_mix_blend_DEBUG_OVERDRAW_program; }
806};
807
808int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Multiply;
809int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Screen;
810int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Overlay;
811int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Darken;
812int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Lighten;
813int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_ColorDodge;
814int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_ColorBurn;
815int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_HardLight;
816int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_SoftLight;
817int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Difference;
818int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Exclusion;
819int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Hue;
820int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Saturation;
821int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Color;
822int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_Luminosity;
823int32_t constexpr brush_mix_blend_DEBUG_OVERDRAW_frag::MixBlendMode_PlusLighter;