Bug Summary

File:root/firefox-clang/obj-x86_64-pc-linux-gnu/x86_64-unknown-linux-gnu/debug/build/swgl-250521f66641ef82/out/brush_mix_blend_ALPHA_PASS.h
Warning:line 831, column 3
Value stored to 'ret_mask' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -O2 -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=off -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=/root/firefox-clang/gfx/wr/swgl -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/root/firefox-clang/gfx/wr/swgl -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /root/firefox-clang/gfx/wr/swgl/../webrender/res -I src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/x86_64-unknown-linux-gnu/debug/build/swgl-250521f66641ef82/out -D _GLIBCXX_USE_CXX11_ABI=0 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -D _GLIBCXX_ASSERTIONS=1 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../include/c++/15 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../include/x86_64-linux-gnu/c++/15 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../include/c++/15/backward -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -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-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 -Wno-character-conversion -std=gnu++20 -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 -fno-implicit-modules -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-07-16-093543-1626485-1 -x c++ src/gl.cc
1struct brush_mix_blend_ALPHA_PASS_common {
2struct Samplers {
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 sGpuBufferF_impl;
10 int sGpuBufferF_slot;
11 isampler2D_impl sGpuBufferI_impl;
12 int sGpuBufferI_slot;
13 sampler2D_impl sPrimitiveHeadersF_impl;
14 int sPrimitiveHeadersF_slot;
15 isampler2D_impl sPrimitiveHeadersI_impl;
16 int sPrimitiveHeadersI_slot;
17 sampler2D_impl sRenderTasks_impl;
18 int sRenderTasks_slot;
19 sampler2D_impl sTransformPalette_impl;
20 int sTransformPalette_slot;
21 bool set_slot(int index, int value) {
22 switch (index) {
23 case 8:
24 sClipMask_slot = value;
25 return true;
26 case 9:
27 sColor0_slot = value;
28 return true;
29 case 10:
30 sColor1_slot = value;
31 return true;
32 case 3:
33 sGpuBufferF_slot = value;
34 return true;
35 case 4:
36 sGpuBufferI_slot = value;
37 return true;
38 case 5:
39 sPrimitiveHeadersF_slot = value;
40 return true;
41 case 6:
42 sPrimitiveHeadersI_slot = value;
43 return true;
44 case 1:
45 sRenderTasks_slot = value;
46 return true;
47 case 2:
48 sTransformPalette_slot = value;
49 return true;
50 }
51 return false;
52 }
53} samplers;
54struct AttribLocations {
55 int aPosition = NULL_ATTRIB16;
56 int aData = NULL_ATTRIB16;
57 void bind_loc(const char* name, int index) {
58 if (strcmp("aPosition", name) == 0) { aPosition = index; return; }
59 if (strcmp("aData", name) == 0) { aData = index; return; }
60 }
61 int get_loc(const char* name) const {
62 if (strcmp("aPosition", name) == 0) { return aPosition != NULL_ATTRIB16 ? aPosition : -1; }
63 if (strcmp("aData", name) == 0) { return aData != NULL_ATTRIB16 ? aData : -1; }
64 return -1;
65 }
66} attrib_locations;
67vec4_scalar vTransformBounds;
68vec4_scalar v_src_uv_sample_bounds;
69vec4_scalar v_backdrop_uv_sample_bounds;
70vec2_scalar v_perspective;
71ivec2_scalar v_op;
72sampler2D sClipMask;
73sampler2D sColor0;
74sampler2D sColor1;
75sampler2D sGpuBufferF;
76isampler2D sGpuBufferI;
77sampler2D sPrimitiveHeadersF;
78isampler2D sPrimitiveHeadersI;
79sampler2D sRenderTasks;
80sampler2D sTransformPalette;
81mat4_scalar uTransform;
82void bind_textures() {
83 sClipMask = lookup_sampler(&samplers.sClipMask_impl, samplers.sClipMask_slot);
84 sColor0 = lookup_sampler(&samplers.sColor0_impl, samplers.sColor0_slot);
85 sColor1 = lookup_sampler(&samplers.sColor1_impl, samplers.sColor1_slot);
86 sGpuBufferF = lookup_sampler(&samplers.sGpuBufferF_impl, samplers.sGpuBufferF_slot);
87 sGpuBufferI = lookup_isampler(&samplers.sGpuBufferI_impl, samplers.sGpuBufferI_slot);
88 sPrimitiveHeadersF = lookup_sampler(&samplers.sPrimitiveHeadersF_impl, samplers.sPrimitiveHeadersF_slot);
89 sPrimitiveHeadersI = lookup_isampler(&samplers.sPrimitiveHeadersI_impl, samplers.sPrimitiveHeadersI_slot);
90 sRenderTasks = lookup_sampler(&samplers.sRenderTasks_impl, samplers.sRenderTasks_slot);
91 sTransformPalette = lookup_sampler(&samplers.sTransformPalette_impl, samplers.sTransformPalette_slot);
92}
93};
94struct brush_mix_blend_ALPHA_PASS_vert : VertexShaderImpl, brush_mix_blend_ALPHA_PASS_common {
95private:
96typedef brush_mix_blend_ALPHA_PASS_vert Self;
97// mat4_scalar uTransform;
98vec2 aPosition;
99// sampler2D sColor0;
100// sampler2D sColor1;
101// sampler2D sColor2;
102struct RectWithSize_scalar {
103vec2_scalar p0;
104vec2_scalar size;
105RectWithSize_scalar() = default;
106RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
107};
108struct RectWithSize {
109vec2 p0;
110vec2 size;
111RectWithSize() = default;
112RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
113RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
114}
115IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
116}
117friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
118if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
119}};
120struct RectWithEndpoint_scalar {
121vec2_scalar p0;
122vec2_scalar p1;
123RectWithEndpoint_scalar() = default;
124RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
125};
126struct RectWithEndpoint {
127vec2 p0;
128vec2 p1;
129RectWithEndpoint() = default;
130RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
131RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
132}
133IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
134}
135friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
136if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
137}};
138// sampler2D sRenderTasks;
139struct RenderTaskData_scalar {
140RectWithEndpoint_scalar task_rect;
141vec4_scalar user_data;
142RenderTaskData_scalar() = default;
143RenderTaskData_scalar(RectWithEndpoint_scalar task_rect, vec4_scalar user_data) : task_rect(task_rect), user_data(user_data){}
144};
145struct RenderTaskData {
146RectWithEndpoint task_rect;
147vec4 user_data;
148RenderTaskData() = default;
149RenderTaskData(RectWithEndpoint task_rect, vec4 user_data) : task_rect(task_rect), user_data(user_data){}
150RenderTaskData(RectWithEndpoint_scalar task_rect, vec4_scalar user_data):task_rect(task_rect),user_data(user_data){
151}
152IMPLICIT RenderTaskData(RenderTaskData_scalar s):task_rect(s.task_rect),user_data(s.user_data){
153}
154friend RenderTaskData if_then_else(I32 c, RenderTaskData t, RenderTaskData e) { return RenderTaskData(
155if_then_else(c, t.task_rect, e.task_rect), if_then_else(c, t.user_data, e.user_data));
156}};
157struct PictureTask_scalar {
158RectWithEndpoint_scalar task_rect;
159float device_pixel_scale;
160vec2_scalar content_origin;
161PictureTask_scalar() = default;
162PictureTask_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){}
163};
164struct PictureTask {
165RectWithEndpoint task_rect;
166Float device_pixel_scale;
167vec2 content_origin;
168PictureTask() = default;
169PictureTask(RectWithEndpoint task_rect, Float device_pixel_scale, vec2 content_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), content_origin(content_origin){}
170PictureTask(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){
171}
172IMPLICIT PictureTask(PictureTask_scalar s):task_rect(s.task_rect),device_pixel_scale(s.device_pixel_scale),content_origin(s.content_origin){
173}
174friend PictureTask if_then_else(I32 c, PictureTask t, PictureTask e) { return PictureTask(
175if_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));
176}};
177struct ClipArea_scalar {
178RectWithEndpoint_scalar task_rect;
179float device_pixel_scale;
180vec2_scalar screen_origin;
181ClipArea_scalar() = default;
182ClipArea_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){}
183};
184struct ClipArea {
185RectWithEndpoint task_rect;
186Float device_pixel_scale;
187vec2 screen_origin;
188ClipArea() = default;
189ClipArea(RectWithEndpoint task_rect, Float device_pixel_scale, vec2 screen_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), screen_origin(screen_origin){}
190ClipArea(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){
191}
192IMPLICIT ClipArea(ClipArea_scalar s):task_rect(s.task_rect),device_pixel_scale(s.device_pixel_scale),screen_origin(s.screen_origin){
193}
194friend ClipArea if_then_else(I32 c, ClipArea t, ClipArea e) { return ClipArea(
195if_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));
196}};
197// vec4_scalar vTransformBounds;
198// sampler2D sTransformPalette;
199struct Transform_scalar {
200mat4_scalar m;
201mat4_scalar inv_m;
202bool is_axis_aligned;
203Transform_scalar() = default;
204Transform_scalar(mat4_scalar m, mat4_scalar inv_m, bool is_axis_aligned) : m(m), inv_m(inv_m), is_axis_aligned(is_axis_aligned){}
205};
206struct Transform {
207mat4 m;
208mat4 inv_m;
209Bool is_axis_aligned;
210Transform() = default;
211Transform(mat4 m, mat4 inv_m, Bool is_axis_aligned) : m(m), inv_m(inv_m), is_axis_aligned(is_axis_aligned){}
212Transform(mat4_scalar m, mat4_scalar inv_m, bool is_axis_aligned):m(m),inv_m(inv_m),is_axis_aligned(is_axis_aligned){
213}
214IMPLICIT Transform(Transform_scalar s):m(s.m),inv_m(s.inv_m),is_axis_aligned(s.is_axis_aligned){
215}
216friend Transform if_then_else(I32 c, Transform t, Transform e) { return Transform(
217if_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));
218}};
219// sampler2D sGpuBufferF;
220// isampler2D sGpuBufferI;
221struct ImageSource_scalar {
222RectWithEndpoint_scalar uv_rect;
223vec4_scalar user_data;
224ImageSource_scalar() = default;
225ImageSource_scalar(RectWithEndpoint_scalar uv_rect, vec4_scalar user_data) : uv_rect(uv_rect), user_data(user_data){}
226};
227struct ImageSource {
228RectWithEndpoint uv_rect;
229vec4 user_data;
230ImageSource() = default;
231ImageSource(RectWithEndpoint uv_rect, vec4 user_data) : uv_rect(uv_rect), user_data(user_data){}
232ImageSource(RectWithEndpoint_scalar uv_rect, vec4_scalar user_data):uv_rect(uv_rect),user_data(user_data){
233}
234IMPLICIT ImageSource(ImageSource_scalar s):uv_rect(s.uv_rect),user_data(s.user_data){
235}
236friend ImageSource if_then_else(I32 c, ImageSource t, ImageSource e) { return ImageSource(
237if_then_else(c, t.uv_rect, e.uv_rect), if_then_else(c, t.user_data, e.user_data));
238}};
239struct ImageSourceExtra_scalar {
240vec4_scalar st_tl;
241vec4_scalar st_tr;
242vec4_scalar st_bl;
243vec4_scalar st_br;
244ImageSourceExtra_scalar() = default;
245ImageSourceExtra_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){}
246};
247struct ImageSourceExtra {
248vec4 st_tl;
249vec4 st_tr;
250vec4 st_bl;
251vec4 st_br;
252ImageSourceExtra() = default;
253ImageSourceExtra(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){}
254ImageSourceExtra(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){
255}
256IMPLICIT ImageSourceExtra(ImageSourceExtra_scalar s):st_tl(s.st_tl),st_tr(s.st_tr),st_bl(s.st_bl),st_br(s.st_br){
257}
258friend ImageSourceExtra if_then_else(I32 c, ImageSourceExtra t, ImageSourceExtra e) { return ImageSourceExtra(
259if_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));
260}};
261// sampler2D sClipMask;
262// sampler2D sPrimitiveHeadersF;
263// isampler2D sPrimitiveHeadersI;
264ivec4_scalar aData;
265struct Instance_scalar {
266int32_t prim_header_address;
267int32_t clip_address;
268int32_t segment_index;
269int32_t flags;
270int32_t resource_address;
271int32_t brush_kind;
272Instance_scalar() = default;
273Instance_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){}
274};
275struct Instance {
276I32 prim_header_address;
277I32 clip_address;
278I32 segment_index;
279I32 flags;
280I32 resource_address;
281I32 brush_kind;
282Instance() = default;
283Instance(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){}
284Instance(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){
285}
286IMPLICIT 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){
287}
288friend Instance if_then_else(I32 c, Instance t, Instance e) { return Instance(
289if_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));
290}};
291struct PrimitiveHeader_scalar {
292RectWithEndpoint_scalar local_rect;
293RectWithEndpoint_scalar local_clip_rect;
294float z;
295int32_t specific_prim_address;
296int32_t transform_id;
297int32_t picture_task_address;
298ivec4_scalar user_data;
299PrimitiveHeader_scalar() = default;
300PrimitiveHeader_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){}
301};
302struct PrimitiveHeader {
303RectWithEndpoint local_rect;
304RectWithEndpoint local_clip_rect;
305Float z;
306I32 specific_prim_address;
307I32 transform_id;
308I32 picture_task_address;
309ivec4 user_data;
310PrimitiveHeader() = default;
311PrimitiveHeader(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){}
312PrimitiveHeader(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){
313}
314IMPLICIT 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){
315}
316friend PrimitiveHeader if_then_else(I32 c, PrimitiveHeader t, PrimitiveHeader e) { return PrimitiveHeader(
317if_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));
318}};
319struct VertexInfo_scalar {
320vec2_scalar local_pos;
321vec4_scalar world_pos;
322VertexInfo_scalar() = default;
323VertexInfo_scalar(vec2_scalar local_pos, vec4_scalar world_pos) : local_pos(local_pos), world_pos(world_pos){}
324};
325struct VertexInfo {
326vec2 local_pos;
327vec4 world_pos;
328VertexInfo() = default;
329VertexInfo(vec2 local_pos, vec4 world_pos) : local_pos(local_pos), world_pos(world_pos){}
330VertexInfo(vec2_scalar local_pos, vec4_scalar world_pos):local_pos(local_pos),world_pos(world_pos){
331}
332IMPLICIT VertexInfo(VertexInfo_scalar s):local_pos(s.local_pos),world_pos(s.world_pos){
333}
334friend VertexInfo if_then_else(I32 c, VertexInfo t, VertexInfo e) { return VertexInfo(
335if_then_else(c, t.local_pos, e.local_pos), if_then_else(c, t.world_pos, e.world_pos));
336}};
337vec2 v_src_uv;
338// vec4_scalar v_src_uv_sample_bounds;
339vec2 v_backdrop_uv;
340// vec4_scalar v_backdrop_uv_sample_bounds;
341// vec2_scalar v_perspective;
342// ivec2_scalar v_op;
343Instance_scalar decode_instance_attributes() {
344 Instance_scalar instance;
345 (instance).prim_header_address = (aData).x;
346 (instance).clip_address = (aData).y;
347 (instance).segment_index = ((aData).z)&(65535);
348 (instance).flags = ((aData).z)>>(16);
349 (instance).resource_address = ((aData).w)&(16777215);
350 (instance).brush_kind = ((aData).w)>>(24);
351 return instance;
352}
353PrimitiveHeader_scalar fetch_prim_header(int32_t index) {
354 PrimitiveHeader_scalar ph;
355 ivec2_scalar uv_f = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
356 auto sPrimitiveHeadersF_uv_f_fetch = texelFetchPtr(sPrimitiveHeadersF, uv_f, 0, 1, 0, 0);
357 vec4_scalar local_rect = texelFetchUnchecked(sPrimitiveHeadersF, sPrimitiveHeadersF_uv_f_fetch, 0, 0);
358 vec4_scalar local_clip_rect = texelFetchUnchecked(sPrimitiveHeadersF, sPrimitiveHeadersF_uv_f_fetch, 1, 0);
359 (ph).local_rect = RectWithEndpoint_scalar((local_rect).sel(X,Y), (local_rect).sel(Z,W));
360 (ph).local_clip_rect = RectWithEndpoint_scalar((local_clip_rect).sel(X,Y), (local_clip_rect).sel(Z,W));
361 ivec2_scalar uv_i = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
362 auto sPrimitiveHeadersI_uv_i_fetch = texelFetchPtr(sPrimitiveHeadersI, uv_i, 0, 1, 0, 0);
363 ivec4_scalar data0 = texelFetchUnchecked(sPrimitiveHeadersI, sPrimitiveHeadersI_uv_i_fetch, 0, 0);
364 ivec4_scalar data1 = texelFetchUnchecked(sPrimitiveHeadersI, sPrimitiveHeadersI_uv_i_fetch, 1, 0);
365 (ph).z = make_float((data0).x);
366 (ph).specific_prim_address = (data0).y;
367 (ph).transform_id = (data0).z;
368 (ph).picture_task_address = (data0).w;
369 (ph).user_data = data1;
370 return ph;
371}
372Transform_scalar fetch_transform(int32_t id) {
373 Transform_scalar transform;
374 (transform).is_axis_aligned = ((id)>>(23))==(0);
375 int32_t index = (id)&(4194303);
376 ivec2_scalar uv = make_ivec2(make_int((8u)*((make_uint(index))%((1024u)/(8u)))), make_int((make_uint(index))/((1024u)/(8u))));
377 ivec2_scalar uv0 = make_ivec2(((uv).x)+(0), (uv).y);
378 auto sTransformPalette_uv0_fetch = texelFetchPtr(sTransformPalette, uv0, 0, 7, 0, 0);
379 (transform).m[0] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 0, 0);
380 (transform).m[1] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 1, 0);
381 (transform).m[2] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 2, 0);
382 (transform).m[3] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 3, 0);
383 (transform).inv_m[0] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 4, 0);
384 (transform).inv_m[1] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 5, 0);
385 (transform).inv_m[2] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 6, 0);
386 (transform).inv_m[3] = texelFetchUnchecked(sTransformPalette, sTransformPalette_uv0_fetch, 7, 0);
387 return transform;
388}
389RenderTaskData_scalar fetch_render_task_data(int32_t index) {
390 ivec2_scalar uv = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
391 auto sRenderTasks_uv_fetch = texelFetchPtr(sRenderTasks, uv, 0, 1, 0, 0);
392 vec4_scalar texel0 = texelFetchUnchecked(sRenderTasks, sRenderTasks_uv_fetch, 0, 0);
393 vec4_scalar texel1 = texelFetchUnchecked(sRenderTasks, sRenderTasks_uv_fetch, 1, 0);
394 RectWithEndpoint_scalar task_rect = RectWithEndpoint_scalar((texel0).sel(X,Y), (texel0).sel(Z,W));
395 RenderTaskData_scalar data = RenderTaskData_scalar(task_rect, texel1);
396 return data;
397}
398PictureTask_scalar fetch_picture_task(int32_t address) {
399 RenderTaskData_scalar task_data = fetch_render_task_data(address);
400 PictureTask_scalar task = PictureTask_scalar((task_data).task_rect, ((task_data).user_data).x, ((task_data).user_data).sel(Y,Z));
401 return task;
402}
403ClipArea_scalar fetch_clip_area(int32_t index) {
404 RenderTaskData_scalar task_data;
405 if ((index)>=(2147483647)) {
406 {
407 task_data = RenderTaskData_scalar(RectWithEndpoint_scalar(make_vec2(0.f), make_vec2(0.f)), make_vec4(0.f));
408 }
409 } else {
410 task_data = fetch_render_task_data(index);
411 }
412 return ClipArea_scalar((task_data).task_rect, ((task_data).user_data).x, ((task_data).user_data).sel(Y,Z));
413}
414ivec2_scalar get_gpu_buffer_uv(int32_t address) {
415 return make_ivec2((make_uint(address))%(1024u), (make_uint(address))/(1024u));
416}
417Array<vec4_scalar,2> fetch_from_gpu_buffer_2f_direct(ivec2_scalar uv) {
418 auto sGpuBufferF_uv_fetch = texelFetchPtr(sGpuBufferF, uv, 0, 1, 0, 0);
419 return Array<vec4_scalar,2>{{texelFetchUnchecked(sGpuBufferF, sGpuBufferF_uv_fetch, 0, 0), texelFetchUnchecked(sGpuBufferF, sGpuBufferF_uv_fetch, 1, 0)}};
420}
421Array<vec4_scalar,2> fetch_from_gpu_buffer_2f(int32_t address) {
422 ivec2_scalar uv = get_gpu_buffer_uv(address);
423 return fetch_from_gpu_buffer_2f_direct(uv);
424}
425RectWithEndpoint_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) {
426 bvec4_scalar clipped = make_bvec4(greaterThan((clip_rect).p0, (segment_rect).p0), lessThan((clip_rect).p1, (segment_rect).p1));
427 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);
428 (segment_rect).p0 = clamp((segment_rect).p0, (clip_rect).p0, (clip_rect).p1);
429 (segment_rect).p1 = clamp((segment_rect).p1, (clip_rect).p0, (clip_rect).p1);
430 return segment_rect;
431}
432vec2 rect_clamp(RectWithEndpoint_scalar rect, vec2 pt) {
433 return clamp(pt, (rect).p0, (rect).p1);
434}
435VertexInfo write_vertex(vec2 local_pos, RectWithEndpoint_scalar local_clip_rect, float z, Transform_scalar transform, PictureTask_scalar task) {
436 vec2 clamped_local_pos = rect_clamp(local_clip_rect, local_pos);
437 vec4 world_pos = ((transform).m)*(make_vec4(clamped_local_pos, 0.f, 1.f));
438 vec2 device_pos = ((world_pos).sel(X,Y))*((task).device_pixel_scale);
439 vec2_scalar final_offset = (-((task).content_origin))+(((task).task_rect).p0);
440 gl_Position = (uTransform)*(make_vec4((device_pos)+((final_offset)*((world_pos).w)), (z)*((world_pos).w), (world_pos).w));
441 VertexInfo vi = VertexInfo(clamped_local_pos, world_pos);
442 return vi;
443}
444vec2_scalar rect_size(RectWithEndpoint_scalar rect) {
445 return ((rect).p1)-((rect).p0);
446}
447void write_clip(vec4 world_pos, ClipArea_scalar area, PictureTask_scalar task) {
448 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
);
449}
450ImageSource_scalar fetch_image_source(int32_t address) {
451 Array<vec4_scalar,2> data = fetch_from_gpu_buffer_2f(address);
452 RectWithEndpoint_scalar uv_rect = RectWithEndpoint_scalar((data[0]).sel(X,Y), (data[0]).sel(Z,W));
453 return ImageSource_scalar(uv_rect, data[1]);
454}
455Array<vec4_scalar,4> fetch_from_gpu_buffer_4f_direct(ivec2_scalar uv) {
456 auto sGpuBufferF_uv_fetch = texelFetchPtr(sGpuBufferF, uv, 0, 3, 0, 0);
457 return Array<vec4_scalar,4>{{texelFetchUnchecked(sGpuBufferF, sGpuBufferF_uv_fetch, 0, 0), texelFetchUnchecked(sGpuBufferF, sGpuBufferF_uv_fetch, 1, 0), texelFetchUnchecked(sGpuBufferF, sGpuBufferF_uv_fetch, 2, 0), texelFetchUnchecked(sGpuBufferF, sGpuBufferF_uv_fetch, 3, 0)}};
458}
459Array<vec4_scalar,4> fetch_from_gpu_buffer_4f(int32_t address) {
460 ivec2_scalar uv = get_gpu_buffer_uv(address);
461 return fetch_from_gpu_buffer_4f_direct(uv);
462}
463ImageSourceExtra_scalar fetch_image_source_extra(int32_t address) {
464 Array<vec4_scalar,4> data = fetch_from_gpu_buffer_4f((address)+(2));
465 return ImageSourceExtra_scalar(data[0], data[1], data[2], data[3]);
466}
467vec2 get_image_quad_uv(int32_t address, vec2 f) {
468 ImageSourceExtra_scalar extra_data = fetch_image_source_extra(address);
469 vec4 x = mix((extra_data).st_tl, (extra_data).st_tr, (f).x);
470 vec4 y = mix((extra_data).st_bl, (extra_data).st_br, (f).x);
471 vec4 z = mix(x, y, (f).y);
472 return ((z).sel(X,Y))/((z).w);
473}
474void get_uv(int32_t res_address, vec2 f, ivec2_scalar texture_size, float perspective_f, vec2& out_uv, vec4_scalar& out_uv_sample_bounds) {
475 ImageSource_scalar res = fetch_image_source(res_address);
476 vec2_scalar uv0 = ((res).uv_rect).p0;
477 vec2_scalar uv1 = ((res).uv_rect).p1;
478 vec2_scalar inv_texture_size = (make_vec2(1.f))/(make_vec2(texture_size));
479 f = get_image_quad_uv(res_address, f);
480 vec2 uv = mix(uv0, uv1, f);
481 out_uv = ((uv)*(inv_texture_size))*(perspective_f);
482 out_uv_sample_bounds = (make_vec4((uv0)+(make_vec2(0.5f)), (uv1)-(make_vec2(0.5f))))*((inv_texture_size).sel(X,Y,X,Y));
483}
484void get_uv(int32_t res_address, vec2 f, ivec2_scalar texture_size, Float perspective_f, vec2& out_uv, vec4_scalar& out_uv_sample_bounds) {
485 ImageSource_scalar res = fetch_image_source(res_address);
486 vec2_scalar uv0 = ((res).uv_rect).p0;
487 vec2_scalar uv1 = ((res).uv_rect).p1;
488 vec2_scalar inv_texture_size = (make_vec2(1.f))/(make_vec2(texture_size));
489 f = get_image_quad_uv(res_address, f);
490 vec2 uv = mix(uv0, uv1, f);
491 out_uv = ((uv)*(inv_texture_size))*(perspective_f);
492 out_uv_sample_bounds = (make_vec4((uv0)+(make_vec2(0.5f)), (uv1)-(make_vec2(0.5f))))*((inv_texture_size).sel(X,Y,X,Y));
493}
494void 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) {
495 vec2 f = (((vi).local_pos)-((local_rect).p0))/(rect_size(local_rect));
496 float perspective_interpolate = ((brush_flags)&(1))!=(0) ? 1.f : 0.f;
497 Float perspective_f = mix(((vi).world_pos).w, 1.f, perspective_interpolate);
498 (v_perspective).x = perspective_interpolate;
499 (v_op).x = (prim_user_data).x;
500 get_uv((prim_user_data).y, f, (textureSize(sColor0, 0)).sel(X,Y), 1.f, v_backdrop_uv, v_backdrop_uv_sample_bounds);
501 get_uv((prim_user_data).z, f, (textureSize(sColor1, 0)).sel(X,Y), perspective_f, v_src_uv, v_src_uv_sample_bounds);
502}
503void brush_shader_main_vs(Instance_scalar instance, PrimitiveHeader_scalar ph, Transform_scalar transform, PictureTask_scalar pic_task, ClipArea_scalar clip_area) {
504 int32_t edge_flags = (((instance).flags)>>(12))&(15);
505 int32_t brush_flags = ((instance).flags)&(4095);
506 vec4_scalar segment_data;
507 RectWithEndpoint_scalar segment_rect;
508 if (((instance).segment_index)==(65535)) {
509 {
510 segment_rect = (ph).local_rect;
511 segment_data = make_vec4(0.f);
512 }
513 } else {
514 int32_t segment_address = (((ph).specific_prim_address)+(3))+(((instance).segment_index)*(2));
515 Array<vec4_scalar,2> segment_info = fetch_from_gpu_buffer_2f(segment_address);
516 segment_rect = RectWithEndpoint_scalar((segment_info[0]).sel(X,Y), (segment_info[0]).sel(Z,W));
517 (segment_rect).p0 += ((ph).local_rect).p0;
518 (segment_rect).p1 += ((ph).local_rect).p0;
519 segment_data = segment_info[1];
520 }
521 RectWithEndpoint_scalar adjusted_segment_rect = segment_rect;
522 bool antialiased = (!((transform).is_axis_aligned))||(((brush_flags)&(1024))!=(0));
523 if (antialiased) {
524 {
525 adjusted_segment_rect = clip_and_init_antialiasing(segment_rect, (ph).local_rect, (ph).local_clip_rect, edge_flags, (ph).z, transform, pic_task);
526 ((ph).local_clip_rect).p0 = make_vec2(-(10000000000000000.f));
527 ((ph).local_clip_rect).p1 = make_vec2(10000000000000000.f);
528 }
529 } else {
530 }
531 vec2 local_pos = mix((adjusted_segment_rect).p0, (adjusted_segment_rect).p1, (aPosition).sel(X,Y));
532 VertexInfo vi = write_vertex(local_pos, (ph).local_clip_rect, (ph).z, transform, pic_task);
533 write_clip((vi).world_pos, clip_area, pic_task);
534 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);
535}
536ALWAYS_INLINE__attribute__((always_inline)) inline void main(void) {
537 Instance_scalar instance = decode_instance_attributes();
538 PrimitiveHeader_scalar ph = fetch_prim_header((instance).prim_header_address);
539 Transform_scalar transform = fetch_transform((ph).transform_id);
540 PictureTask_scalar task = fetch_picture_task((ph).picture_task_address);
541 ClipArea_scalar clip_area = fetch_clip_area((instance).clip_address);
542 brush_shader_main_vs(instance, ph, transform, task, clip_area);
543}
544static void set_uniform_1i(VertexShaderImpl* impl, int index, int value) {
545 Self* self = (Self*)impl;
546 if (self->samplers.set_slot(index, value)) return;
547 switch (index) {
548 case 8:
549 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sClipMask
550 break;
551 case 9:
552 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sColor0
553 break;
554 case 10:
555 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sColor1
556 break;
557 case 3:
558 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferF
559 break;
560 case 4:
561 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferI
562 break;
563 case 5:
564 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPrimitiveHeadersF
565 break;
566 case 6:
567 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPrimitiveHeadersI
568 break;
569 case 1:
570 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sRenderTasks
571 break;
572 case 2:
573 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sTransformPalette
574 break;
575 case 7:
576 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // uTransform
577 break;
578 }
579}
580static void set_uniform_4fv(VertexShaderImpl* impl, int index, const float *value) {
581 Self* self = (Self*)impl;
582 switch (index) {
583 case 8:
584 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sClipMask
585 break;
586 case 9:
587 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sColor0
588 break;
589 case 10:
590 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sColor1
591 break;
592 case 3:
593 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferF
594 break;
595 case 4:
596 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferI
597 break;
598 case 5:
599 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPrimitiveHeadersF
600 break;
601 case 6:
602 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPrimitiveHeadersI
603 break;
604 case 1:
605 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sRenderTasks
606 break;
607 case 2:
608 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sTransformPalette
609 break;
610 case 7:
611 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // uTransform
612 break;
613 }
614}
615static void set_uniform_matrix4fv(VertexShaderImpl* impl, int index, const float *value) {
616 Self* self = (Self*)impl;
617 switch (index) {
618 case 8:
619 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sClipMask
620 break;
621 case 9:
622 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sColor0
623 break;
624 case 10:
625 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sColor1
626 break;
627 case 3:
628 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferF
629 break;
630 case 4:
631 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferI
632 break;
633 case 5:
634 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPrimitiveHeadersF
635 break;
636 case 6:
637 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPrimitiveHeadersI
638 break;
639 case 1:
640 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sRenderTasks
641 break;
642 case 2:
643 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sTransformPalette
644 break;
645 case 7:
646 self->uTransform = mat4_scalar::load_from_ptr(value);
647 break;
648 }
649}
650static void load_attribs(VertexShaderImpl* impl, VertexAttrib *attribs, uint32_t start, int instance, int count) {Self* self = (Self*)impl;
651 load_attrib(self->aPosition, attribs[self->attrib_locations.aPosition], start, instance, count);
652 load_flat_attrib(self->aData, attribs[self->attrib_locations.aData], start, instance, count);
653}
654public:
655struct InterpOutputs {
656vec2_scalar v_src_uv;
657vec2_scalar v_backdrop_uv;
658};
659private:
660ALWAYS_INLINE__attribute__((always_inline)) inline void store_interp_outputs(char* dest_ptr, size_t stride) {
661 for(int n = 0; n < 4; n++) {
662 auto* dest = reinterpret_cast<InterpOutputs*>(dest_ptr);
663 dest->v_src_uv = get_nth(v_src_uv, n);
664 dest->v_backdrop_uv = get_nth(v_backdrop_uv, n);
665 dest_ptr += stride;
666 }
667}
668static void run(VertexShaderImpl* impl, char* interps, size_t interp_stride) {
669 Self* self = (Self*)impl;
670 self->main();
671 self->store_interp_outputs(interps, interp_stride);
672}
673static void init_batch(VertexShaderImpl* impl) {
674 Self* self = (Self*)impl; self->bind_textures(); }
675public:
676brush_mix_blend_ALPHA_PASS_vert() {
677 set_uniform_1i_func = &set_uniform_1i;
678 set_uniform_4fv_func = &set_uniform_4fv;
679 set_uniform_matrix4fv_func = &set_uniform_matrix4fv;
680 init_batch_func = &init_batch;
681 load_attribs_func = &load_attribs;
682 run_primitive_func = &run;
683}
684};
685
686
687struct brush_mix_blend_ALPHA_PASS_frag : FragmentShaderImpl, brush_mix_blend_ALPHA_PASS_vert {
688private:
689typedef brush_mix_blend_ALPHA_PASS_frag Self;
690#define oFragColorgl_FragColor gl_FragColor
691// vec4 oFragColor;
692// sampler2D sColor0;
693// sampler2D sColor1;
694// sampler2D sColor2;
695struct RectWithSize_scalar {
696vec2_scalar p0;
697vec2_scalar size;
698RectWithSize_scalar() = default;
699RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
700};
701struct RectWithSize {
702vec2 p0;
703vec2 size;
704RectWithSize() = default;
705RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
706RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
707}
708IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
709}
710friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
711if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
712}};
713struct RectWithEndpoint_scalar {
714vec2_scalar p0;
715vec2_scalar p1;
716RectWithEndpoint_scalar() = default;
717RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
718};
719struct RectWithEndpoint {
720vec2 p0;
721vec2 p1;
722RectWithEndpoint() = default;
723RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
724RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
725}
726IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
727}
728friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
729if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
730}};
731// vec4_scalar vTransformBounds;
732// sampler2D sGpuBufferF;
733// isampler2D sGpuBufferI;
734// sampler2D sClipMask;
735struct Fragment_scalar {
736vec4_scalar color;
737Fragment_scalar() = default;
738explicit Fragment_scalar(vec4_scalar color) : color(color){}
739};
740struct Fragment {
741vec4 color;
742Fragment() = default;
743explicit Fragment(vec4 color) : color(color){}
744explicit Fragment(vec4_scalar color):color(color){
745}
746IMPLICIT Fragment(Fragment_scalar s):color(s.color){
747}
748friend Fragment if_then_else(I32 c, Fragment t, Fragment e) { return Fragment(
749if_then_else(c, t.color, e.color));
750}};
751vec2 v_src_uv;
752// vec4_scalar v_src_uv_sample_bounds;
753vec2 v_backdrop_uv;
754// vec4_scalar v_backdrop_uv_sample_bounds;
755// vec2_scalar v_perspective;
756// ivec2_scalar v_op;
757int32_t static constexpr MixBlendMode_Multiply = 1;
758int32_t static constexpr MixBlendMode_Screen = 2;
759int32_t static constexpr MixBlendMode_Overlay = 3;
760int32_t static constexpr MixBlendMode_Darken = 4;
761int32_t static constexpr MixBlendMode_Lighten = 5;
762int32_t static constexpr MixBlendMode_ColorDodge = 6;
763int32_t static constexpr MixBlendMode_ColorBurn = 7;
764int32_t static constexpr MixBlendMode_HardLight = 8;
765int32_t static constexpr MixBlendMode_SoftLight = 9;
766int32_t static constexpr MixBlendMode_Difference = 10;
767int32_t static constexpr MixBlendMode_Exclusion = 11;
768int32_t static constexpr MixBlendMode_Hue = 12;
769int32_t static constexpr MixBlendMode_Saturation = 13;
770int32_t static constexpr MixBlendMode_Color = 14;
771int32_t static constexpr MixBlendMode_Luminosity = 15;
772int32_t static constexpr MixBlendMode_PlusLighter = 16;
773vec3 Multiply(vec3 Cb, vec3 Cs) {
774 return (Cb)*(Cs);
775}
776vec3 Screen(vec3 Cb, vec3 Cs) {
777 return ((Cb)+(Cs))-((Cb)*(Cs));
778}
779vec3 HardLight(vec3 Cb, vec3 Cs) {
780 vec3 m = Multiply(Cb, (2.f)*(Cs));
781 vec3 s = Screen(Cb, ((2.f)*(Cs))-(1.f));
782 vec3_scalar edge = make_vec3(0.5f, 0.5f, 0.5f);
783 return mix(m, s, step(edge, Cs));
784}
785Float ColorDodge(Float Cb, Float Cs) {
786 I32 ret_mask = ~0;
787 Float ret;
788 auto _c8_ = (Cb)==(0.f);
789 ret = 0.f;
790 ret_mask = ~I32(_c8_);
791 auto _c9_ = (Cs)==(1.f);
792 auto _c10_ = (~(_c8_))&(_c9_);
793 ret = if_then_else(ret_mask & I32(_c10_), 1.f, ret);
794 ret_mask &= ~I32(_c10_);
795 _c9_ = (~(_c8_))&(~(_c9_));
796 ret = if_then_else(ret_mask & I32(_c9_), min(1.f, (Cb)/((1.f)-(Cs))), ret);
797 ret_mask &= ~I32(_c9_);
798 return ret;
799}
800Float ColorBurn(Float Cb, Float Cs) {
801 I32 ret_mask = ~0;
802 Float ret;
803 auto _c14_ = (Cb)==(1.f);
804 ret = 1.f;
805 ret_mask = ~I32(_c14_);
806 auto _c15_ = (Cs)==(0.f);
807 auto _c16_ = (~(_c14_))&(_c15_);
808 ret = if_then_else(ret_mask & I32(_c16_), 0.f, ret);
809 ret_mask &= ~I32(_c16_);
810 _c15_ = (~(_c14_))&(~(_c15_));
811 ret = if_then_else(ret_mask & I32(_c15_), (1.f)-(min(1.f, ((1.f)-(Cb))/(Cs))), ret);
812 ret_mask &= ~I32(_c15_);
813 return ret;
814}
815Float SoftLight(Float Cb, Float Cs) {
816 I32 ret_mask = ~0;
817 Float ret;
818 auto _c20_ = (Cs)<=(0.5f);
819 {
820 ret = (Cb)-((((1.f)-((2.f)*(Cs)))*(Cb))*((1.f)-(Cb)));
821 ret_mask = ~I32(_c20_);
822 }
823 {
824 Float D;
825 auto _c21_ = (Cb)<=(0.25f);
826 auto _c22_ = (~(_c20_))&(_c21_);
827 D = if_then_else(_c22_,(((((16.f)*(Cb))-(12.f))*(Cb))+(4.f))*(Cb),D);
828 _c21_ = (~(_c20_))&(~(_c21_));
829 D = if_then_else(_c21_,sqrt__glsl_sqrt(Cb),D);
830 ret = if_then_else(ret_mask & I32(~(_c20_)), (Cb)+((((2.f)*(Cs))-(1.f))*((D)-(Cb))), ret);
831 ret_mask &= ~I32(~(_c20_));
Value stored to 'ret_mask' is never read
832 }
833 return ret;
834}
835vec3 Difference(vec3 Cb, vec3 Cs) {
836 return abs__glsl_abs((Cb)-(Cs));
837}
838Float Lum(vec3 c) {
839 vec3_scalar f = make_vec3(0.3f, 0.59f, 0.11f);
840 return dot(c, f);
841}
842vec3 ClipColor(vec3 C) {
843 Float L = Lum(C);
844 Float n = min((C).x, min((C).y, (C).z));
845 Float x = max((C).x, max((C).y, (C).z));
846 auto _c25_ = ((n)<(0.f))&&((L)!=(n));
847 C = if_then_else(_c25_,(L)+((((C)-(L))*(L))/((L)-(n))),C);
848 auto _c26_ = ((x)>(1.f))&&((x)!=(L));
849 C = if_then_else(_c26_,(L)+((((C)-(L))*((1.f)-(L)))/((x)-(L))),C);
850 return C;
851}
852vec3 SetLum(vec3 C, Float l) {
853 Float d = (l)-(Lum(C));
854 return ClipColor((C)+(d));
855}
856void SetSatInner(Float& Cmin, Float& Cmid, Float& Cmax, Float s, I32 _cond_mask_) {
857 auto _c47_ = (Cmax)>(Cmin);
858 auto _c48_ = (_cond_mask_)&(_c47_);
859 {
860 Cmid = if_then_else(_c48_,(((Cmid)-(Cmin))*(s))/((Cmax)-(Cmin)),Cmid);
861 Cmax = if_then_else(_c48_,s,Cmax);
862 }
863 _c47_ = (_cond_mask_)&(~(_c47_));
864 {
865 Cmid = if_then_else(_c47_,0.f,Cmid);
866 Cmax = if_then_else(_c47_,0.f,Cmax);
867 }
868 Cmin = if_then_else(_cond_mask_,0.f,Cmin);
869}
870vec3 SetSat(vec3 C, Float s) {
871 auto _c36_ = ((C).x)<=((C).y);
872 {
873 auto _c37_ = ((C).y)<=((C).z);
874 auto _c38_ = (_c36_)&(_c37_);
875 {
876 SetSatInner((C).x, (C).y, (C).z, s, _c38_);
877 }
878 _c37_ = (_c36_)&(~(_c37_));
879 {
880 auto _c39_ = ((C).x)<=((C).z);
881 auto _c40_ = (_c37_)&(_c39_);
882 {
883 SetSatInner((C).x, (C).z, (C).y, s, _c40_);
884 }
885 _c39_ = (_c37_)&(~(_c39_));
886 {
887 SetSatInner((C).z, (C).x, (C).y, s, _c39_);
888 }
889 }
890 }
891 {
892 auto _c41_ = ((C).x)<=((C).z);
893 auto _c42_ = (~(_c36_))&(_c41_);
894 {
895 SetSatInner((C).y, (C).x, (C).z, s, _c42_);
896 }
897 _c41_ = (~(_c36_))&(~(_c41_));
898 {
899 auto _c43_ = ((C).y)<=((C).z);
900 auto _c44_ = (_c41_)&(_c43_);
901 {
902 SetSatInner((C).y, (C).z, (C).x, s, _c44_);
903 }
904 _c43_ = (_c41_)&(~(_c43_));
905 {
906 SetSatInner((C).z, (C).y, (C).x, s, _c43_);
907 }
908 }
909 }
910 return C;
911}
912Float Sat(vec3 c) {
913 return (max((c).x, max((c).y, (c).z)))-(min((c).x, min((c).y, (c).z)));
914}
915vec3 Hue(vec3 Cb, vec3 Cs) {
916 return SetLum(SetSat(Cs, Sat(Cb)), Lum(Cb));
917}
918vec3 Saturation(vec3 Cb, vec3 Cs) {
919 return SetLum(SetSat(Cb, Sat(Cs)), Lum(Cb));
920}
921vec3 Color(vec3 Cb, vec3 Cs) {
922 return SetLum(Cs, Lum(Cb));
923}
924vec3 Luminosity(vec3 Cb, vec3 Cs) {
925 return SetLum(Cb, Lum(Cs));
926}
927Fragment brush_fs() {
928 Float perspective_divisor = mix((gl_FragCoord).w, 1.f, (v_perspective).x);
929 vec2 src_uv = (v_src_uv)*(perspective_divisor);
930 src_uv = clamp(src_uv, (v_src_uv_sample_bounds).sel(X,Y), (v_src_uv_sample_bounds).sel(Z,W));
931 vec2 backdrop_uv = clamp(v_backdrop_uv, (v_backdrop_uv_sample_bounds).sel(X,Y), (v_backdrop_uv_sample_bounds).sel(Z,W));
932 vec4 Cb = texture(sColor0, backdrop_uv);
933 vec4 Cs = texture(sColor1, src_uv);
934 auto _c3_ = ((Cb).w)!=(0.f);
935 {
936 (Cb).lsel(R,G,B) = if_then_else(_c3_,(Cb).sel(R,G,B)/(Cb).w,(Cb).sel(R,G,B));
937 }
938 auto _c4_ = ((Cs).w)!=(0.f);
939 {
940 (Cs).lsel(R,G,B) = if_then_else(_c4_,(Cs).sel(R,G,B)/(Cs).w,(Cs).sel(R,G,B));
941 }
942 vec4 result = make_vec4(1.f, 1.f, 0.f, 1.f);
943 switch (((v_op).x)&(255)) {
944 case MixBlendMode_Multiply:
945 (result).lsel(R,G,B) = Multiply((Cb).sel(R,G,B), (Cs).sel(R,G,B));
946 break;
947 case MixBlendMode_Overlay:
948 (result).lsel(R,G,B) = HardLight((Cs).sel(R,G,B), (Cb).sel(R,G,B));
949 break;
950 case MixBlendMode_Darken:
951 (result).lsel(R,G,B) = min((Cs).sel(R,G,B), (Cb).sel(R,G,B));
952 break;
953 case MixBlendMode_Lighten:
954 (result).lsel(R,G,B) = max((Cs).sel(R,G,B), (Cb).sel(R,G,B));
955 break;
956 case MixBlendMode_ColorDodge:
957 (result).x = ColorDodge((Cb).x, (Cs).x);
958 (result).y = ColorDodge((Cb).y, (Cs).y);
959 (result).z = ColorDodge((Cb).z, (Cs).z);
960 break;
961 case MixBlendMode_ColorBurn:
962 (result).x = ColorBurn((Cb).x, (Cs).x);
963 (result).y = ColorBurn((Cb).y, (Cs).y);
964 (result).z = ColorBurn((Cb).z, (Cs).z);
965 break;
966 case MixBlendMode_HardLight:
967 (result).lsel(R,G,B) = HardLight((Cb).sel(R,G,B), (Cs).sel(R,G,B));
968 break;
969 case MixBlendMode_SoftLight:
970 (result).x = SoftLight((Cb).x, (Cs).x);
971 (result).y = SoftLight((Cb).y, (Cs).y);
972 (result).z = SoftLight((Cb).z, (Cs).z);
973 break;
974 case MixBlendMode_Difference:
975 (result).lsel(R,G,B) = Difference((Cb).sel(R,G,B), (Cs).sel(R,G,B));
976 break;
977 case MixBlendMode_Hue:
978 (result).lsel(R,G,B) = Hue((Cb).sel(R,G,B), (Cs).sel(R,G,B));
979 break;
980 case MixBlendMode_Saturation:
981 (result).lsel(R,G,B) = Saturation((Cb).sel(R,G,B), (Cs).sel(R,G,B));
982 break;
983 case MixBlendMode_Color:
984 (result).lsel(R,G,B) = Color((Cb).sel(R,G,B), (Cs).sel(R,G,B));
985 break;
986 case MixBlendMode_Luminosity:
987 (result).lsel(R,G,B) = Luminosity((Cb).sel(R,G,B), (Cs).sel(R,G,B));
988 break;
989 case MixBlendMode_Screen:
990 case MixBlendMode_Exclusion:
991 case MixBlendMode_PlusLighter:
992 break;
993 default:
994 break;
995 }
996 (result).lsel(R,G,B) = (((1.f)-((Cb).w))*((Cs).sel(R,G,B)))+(((Cb).w)*((result).sel(R,G,B)));
997 (result).w = (Cs).w;
998 (result).lsel(R,G,B) *= (result).w;
999 return Fragment(result);
1000}
1001float do_clip() {
1002 return 1.f;
1003}
1004void write_output(vec4 color) {
1005 oFragColorgl_FragColor = color;
1006}
1007ALWAYS_INLINE__attribute__((always_inline)) inline void main(void) {
1008 Fragment frag = brush_fs();
1009 float clip_alpha = do_clip();
1010 (frag).color *= clip_alpha;
1011 write_output((frag).color);
1012}
1013typedef brush_mix_blend_ALPHA_PASS_vert::InterpOutputs InterpInputs;
1014InterpInputs interp_step;
1015struct InterpPerspective {
1016vec2 v_src_uv;
1017vec2 v_backdrop_uv;
1018};
1019InterpPerspective interp_perspective;
1020static 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_;
1021 self->v_src_uv = init_interp(init->v_src_uv, step->v_src_uv);
1022 self->interp_step.v_src_uv = step->v_src_uv * 4.0f;
1023 self->v_backdrop_uv = init_interp(init->v_backdrop_uv, step->v_backdrop_uv);
1024 self->interp_step.v_backdrop_uv = step->v_backdrop_uv * 4.0f;
1025}
1026static void read_perspective_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_;
1027 Float w = 1.0f / self->gl_FragCoord.w;
1028 self->interp_perspective.v_src_uv = init_interp(init->v_src_uv, step->v_src_uv);
1029 self->v_src_uv = self->interp_perspective.v_src_uv * w;
1030 self->interp_step.v_src_uv = step->v_src_uv * 4.0f;
1031 self->interp_perspective.v_backdrop_uv = init_interp(init->v_backdrop_uv, step->v_backdrop_uv);
1032 self->v_backdrop_uv = self->interp_perspective.v_backdrop_uv * w;
1033 self->interp_step.v_backdrop_uv = step->v_backdrop_uv * 4.0f;
1034}
1035ALWAYS_INLINE__attribute__((always_inline)) inline void step_interp_inputs(int steps = 4) {
1036 float chunks = steps * 0.25f;
1037 v_src_uv += interp_step.v_src_uv * chunks;
1038 v_backdrop_uv += interp_step.v_backdrop_uv * chunks;
1039}
1040ALWAYS_INLINE__attribute__((always_inline)) inline void step_perspective_inputs(int steps = 4) {
1041 step_perspective(steps);
1042 float chunks = steps * 0.25f;
1043 Float w = 1.0f / gl_FragCoord.w;
1044 interp_perspective.v_src_uv += interp_step.v_src_uv * chunks;
1045 v_src_uv = w * interp_perspective.v_src_uv;
1046 interp_perspective.v_backdrop_uv += interp_step.v_backdrop_uv * chunks;
1047 v_backdrop_uv = w * interp_perspective.v_backdrop_uv;
1048}
1049static void run(FragmentShaderImpl* impl) {
1050 Self* self = (Self*)impl;
1051 self->main();
1052 self->step_interp_inputs();
1053}
1054static void skip(FragmentShaderImpl* impl, int steps) {
1055 Self* self = (Self*)impl;
1056 self->step_interp_inputs(steps);
1057}
1058static void run_perspective(FragmentShaderImpl* impl) {
1059 Self* self = (Self*)impl;
1060 self->main();
1061 self->step_perspective_inputs();
1062}
1063static void skip_perspective(FragmentShaderImpl* impl, int steps) {
1064 Self* self = (Self*)impl;
1065 self->step_perspective_inputs(steps);
1066}
1067public:
1068brush_mix_blend_ALPHA_PASS_frag() {
1069 init_span_func = &read_interp_inputs;
1070 run_func = &run;
1071 skip_func = &skip;
1072 enable_perspective();
1073 init_span_w_func = &read_perspective_inputs;
1074 run_w_func = &run_perspective;
1075 skip_w_func = &skip_perspective;
1076}
1077};
1078
1079struct brush_mix_blend_ALPHA_PASS_program : ProgramImpl, brush_mix_blend_ALPHA_PASS_frag {
1080int get_uniform(const char *name) const override {
1081 if (strcmp("sClipMask", name) == 0) { return 8; }
1082 if (strcmp("sColor0", name) == 0) { return 9; }
1083 if (strcmp("sColor1", name) == 0) { return 10; }
1084 if (strcmp("sGpuBufferF", name) == 0) { return 3; }
1085 if (strcmp("sGpuBufferI", name) == 0) { return 4; }
1086 if (strcmp("sPrimitiveHeadersF", name) == 0) { return 5; }
1087 if (strcmp("sPrimitiveHeadersI", name) == 0) { return 6; }
1088 if (strcmp("sRenderTasks", name) == 0) { return 1; }
1089 if (strcmp("sTransformPalette", name) == 0) { return 2; }
1090 if (strcmp("uTransform", name) == 0) { return 7; }
1091 return -1;
1092}
1093void bind_attrib(const char* name, int index) override {
1094 attrib_locations.bind_loc(name, index);
1095}
1096int get_attrib(const char* name) const override {
1097 return attrib_locations.get_loc(name);
1098}
1099size_t interpolants_size() const override { return sizeof(InterpOutputs); }
1100VertexShaderImpl* get_vertex_shader() override {
1101 return this;
1102}
1103FragmentShaderImpl* get_fragment_shader() override {
1104 return this;
1105}
1106const char* get_name() const override { return "brush_mix_blend_ALPHA_PASS"; }
1107static ProgramImpl* loader() { return new brush_mix_blend_ALPHA_PASS_program; }
1108};
1109
1110int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Multiply;
1111int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Screen;
1112int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Overlay;
1113int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Darken;
1114int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Lighten;
1115int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_ColorDodge;
1116int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_ColorBurn;
1117int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_HardLight;
1118int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_SoftLight;
1119int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Difference;
1120int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Exclusion;
1121int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Hue;
1122int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Saturation;
1123int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Color;
1124int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_Luminosity;
1125int32_t constexpr brush_mix_blend_ALPHA_PASS_frag::MixBlendMode_PlusLighter;