Bug Summary

File:root/firefox-clang/obj-x86_64-pc-linux-gnu/x86_64-unknown-linux-gnu/debug/build/swgl-632c403fa1e5c7af/out/cs_path_tile_PATH_SSAA4.h
Warning:line 253, column 14
Value stored to 'texel1' during its initialization 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-632c403fa1e5c7af/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/16/../../../../include/c++/16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/x86_64-linux-gnu/c++/16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/c++/16/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/16/../../../../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-11-12-001017-1011516-1 -x c++ src/gl.cc
1struct cs_path_tile_PATH_SSAA4_common {
2struct Samplers {
3 sampler2D_impl sGpuBufferF_impl;
4 int sGpuBufferF_slot;
5 isampler2D_impl sGpuBufferI_impl;
6 int sGpuBufferI_slot;
7 sampler2D_impl sPathEdges_impl;
8 int sPathEdges_slot;
9 sampler2D_impl sRenderTasks_impl;
10 int sRenderTasks_slot;
11 bool set_slot(int index, int value) {
12 switch (index) {
13 case 2:
14 sGpuBufferF_slot = value;
15 return true;
16 case 3:
17 sGpuBufferI_slot = value;
18 return true;
19 case 5:
20 sPathEdges_slot = value;
21 return true;
22 case 1:
23 sRenderTasks_slot = value;
24 return true;
25 }
26 return false;
27 }
28} samplers;
29struct AttribLocations {
30 int aPosition = NULL_ATTRIB16;
31 int aData = NULL_ATTRIB16;
32 void bind_loc(const char* name, int index) {
33 if (strcmp("aPosition", name) == 0) { aPosition = index; return; }
34 if (strcmp("aData", name) == 0) { aData = index; return; }
35 }
36 int get_loc(const char* name) const {
37 if (strcmp("aPosition", name) == 0) { return aPosition != NULL_ATTRIB16 ? aPosition : -1; }
38 if (strcmp("aData", name) == 0) { return aData != NULL_ATTRIB16 ? aData : -1; }
39 return -1;
40 }
41} attrib_locations;
42ivec4_scalar vTileData;
43sampler2D sGpuBufferF;
44isampler2D sGpuBufferI;
45sampler2D sPathEdges;
46sampler2D sRenderTasks;
47mat4_scalar uTransform;
48void bind_textures() {
49 sGpuBufferF = lookup_sampler(&samplers.sGpuBufferF_impl, samplers.sGpuBufferF_slot);
50 sGpuBufferI = lookup_isampler(&samplers.sGpuBufferI_impl, samplers.sGpuBufferI_slot);
51 sPathEdges = lookup_sampler(&samplers.sPathEdges_impl, samplers.sPathEdges_slot);
52 sRenderTasks = lookup_sampler(&samplers.sRenderTasks_impl, samplers.sRenderTasks_slot);
53}
54};
55struct cs_path_tile_PATH_SSAA4_vert : VertexShaderImpl, cs_path_tile_PATH_SSAA4_common {
56private:
57typedef cs_path_tile_PATH_SSAA4_vert Self;
58// mat4_scalar uTransform;
59vec2 aPosition;
60struct RectWithSize_scalar {
61vec2_scalar p0;
62vec2_scalar size;
63RectWithSize_scalar() = default;
64RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
65};
66struct RectWithSize {
67vec2 p0;
68vec2 size;
69RectWithSize() = default;
70RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
71RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
72}
73IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
74}
75friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
76if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
77}};
78struct RectWithEndpoint_scalar {
79vec2_scalar p0;
80vec2_scalar p1;
81RectWithEndpoint_scalar() = default;
82RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
83};
84struct RectWithEndpoint {
85vec2 p0;
86vec2 p1;
87RectWithEndpoint() = default;
88RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
89RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
90}
91IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
92}
93friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
94if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
95}};
96// sampler2D sRenderTasks;
97struct RenderTaskData_scalar {
98RectWithEndpoint_scalar task_rect;
99vec4_scalar user_data;
100RenderTaskData_scalar() = default;
101RenderTaskData_scalar(RectWithEndpoint_scalar task_rect, vec4_scalar user_data) : task_rect(task_rect), user_data(user_data){}
102};
103struct RenderTaskData {
104RectWithEndpoint task_rect;
105vec4 user_data;
106RenderTaskData() = default;
107RenderTaskData(RectWithEndpoint task_rect, vec4 user_data) : task_rect(task_rect), user_data(user_data){}
108RenderTaskData(RectWithEndpoint_scalar task_rect, vec4_scalar user_data):task_rect(task_rect),user_data(user_data){
109}
110IMPLICIT RenderTaskData(RenderTaskData_scalar s):task_rect(s.task_rect),user_data(s.user_data){
111}
112friend RenderTaskData if_then_else(I32 c, RenderTaskData t, RenderTaskData e) { return RenderTaskData(
113if_then_else(c, t.task_rect, e.task_rect), if_then_else(c, t.user_data, e.user_data));
114}};
115struct PictureTask_scalar {
116RectWithEndpoint_scalar task_rect;
117float device_pixel_scale;
118vec2_scalar content_origin;
119PictureTask_scalar() = default;
120PictureTask_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){}
121};
122struct PictureTask {
123RectWithEndpoint task_rect;
124Float device_pixel_scale;
125vec2 content_origin;
126PictureTask() = default;
127PictureTask(RectWithEndpoint task_rect, Float device_pixel_scale, vec2 content_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), content_origin(content_origin){}
128PictureTask(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){
129}
130IMPLICIT PictureTask(PictureTask_scalar s):task_rect(s.task_rect),device_pixel_scale(s.device_pixel_scale),content_origin(s.content_origin){
131}
132friend PictureTask if_then_else(I32 c, PictureTask t, PictureTask e) { return PictureTask(
133if_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));
134}};
135struct ClipArea_scalar {
136RectWithEndpoint_scalar task_rect;
137float device_pixel_scale;
138vec2_scalar screen_origin;
139ClipArea_scalar() = default;
140ClipArea_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){}
141};
142struct ClipArea {
143RectWithEndpoint task_rect;
144Float device_pixel_scale;
145vec2 screen_origin;
146ClipArea() = default;
147ClipArea(RectWithEndpoint task_rect, Float device_pixel_scale, vec2 screen_origin) : task_rect(task_rect), device_pixel_scale(device_pixel_scale), screen_origin(screen_origin){}
148ClipArea(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){
149}
150IMPLICIT ClipArea(ClipArea_scalar s):task_rect(s.task_rect),device_pixel_scale(s.device_pixel_scale),screen_origin(s.screen_origin){
151}
152friend ClipArea if_then_else(I32 c, ClipArea t, ClipArea e) { return ClipArea(
153if_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));
154}};
155// sampler2D sGpuBufferF;
156// isampler2D sGpuBufferI;
157// sampler2D sPathEdges;
158struct PathTile_scalar {
159vec4_scalar rect;
160ivec2_scalar edges;
161int32_t backdrop;
162int32_t path_address;
163PathTile_scalar() = default;
164PathTile_scalar(vec4_scalar rect, ivec2_scalar edges, int32_t backdrop, int32_t path_address) : rect(rect), edges(edges), backdrop(backdrop), path_address(path_address){}
165};
166struct PathTile {
167vec4 rect;
168ivec2 edges;
169I32 backdrop;
170I32 path_address;
171PathTile() = default;
172PathTile(vec4 rect, ivec2 edges, I32 backdrop, I32 path_address) : rect(rect), edges(edges), backdrop(backdrop), path_address(path_address){}
173PathTile(vec4_scalar rect, ivec2_scalar edges, int32_t backdrop, int32_t path_address):rect(rect),edges(edges),backdrop(backdrop),path_address(path_address){
174}
175IMPLICIT PathTile(PathTile_scalar s):rect(s.rect),edges(s.edges),backdrop(s.backdrop),path_address(s.path_address){
176}
177friend PathTile if_then_else(I32 c, PathTile t, PathTile e) { return PathTile(
178if_then_else(c, t.rect, e.rect), if_then_else(c, t.edges, e.edges), if_then_else(c, t.backdrop, e.backdrop), if_then_else(c, t.path_address, e.path_address));
179}};
180struct PathInfo_scalar {
181int32_t render_task_address;
182int32_t fill_rule;
183float opacity;
184PathInfo_scalar() = default;
185PathInfo_scalar(int32_t render_task_address, int32_t fill_rule, float opacity) : render_task_address(render_task_address), fill_rule(fill_rule), opacity(opacity){}
186};
187struct PathInfo {
188I32 render_task_address;
189I32 fill_rule;
190Float opacity;
191PathInfo() = default;
192PathInfo(I32 render_task_address, I32 fill_rule, Float opacity) : render_task_address(render_task_address), fill_rule(fill_rule), opacity(opacity){}
193PathInfo(int32_t render_task_address, int32_t fill_rule, float opacity):render_task_address(render_task_address),fill_rule(fill_rule),opacity(opacity){
194}
195IMPLICIT PathInfo(PathInfo_scalar s):render_task_address(s.render_task_address),fill_rule(s.fill_rule),opacity(s.opacity){
196}
197friend PathInfo if_then_else(I32 c, PathInfo t, PathInfo e) { return PathInfo(
198if_then_else(c, t.render_task_address, e.render_task_address), if_then_else(c, t.fill_rule, e.fill_rule), if_then_else(c, t.opacity, e.opacity));
199}};
200struct PathPrimInfo_scalar {
201int32_t z_id;
202vec4_scalar color;
203vec4_scalar scissor;
204PathPrimInfo_scalar() = default;
205PathPrimInfo_scalar(int32_t z_id, vec4_scalar color, vec4_scalar scissor) : z_id(z_id), color(color), scissor(scissor){}
206};
207struct PathPrimInfo {
208I32 z_id;
209vec4 color;
210vec4 scissor;
211PathPrimInfo() = default;
212PathPrimInfo(I32 z_id, vec4 color, vec4 scissor) : z_id(z_id), color(color), scissor(scissor){}
213PathPrimInfo(int32_t z_id, vec4_scalar color, vec4_scalar scissor):z_id(z_id),color(color),scissor(scissor){
214}
215IMPLICIT PathPrimInfo(PathPrimInfo_scalar s):z_id(s.z_id),color(s.color),scissor(s.scissor){
216}
217friend PathPrimInfo if_then_else(I32 c, PathPrimInfo t, PathPrimInfo e) { return PathPrimInfo(
218if_then_else(c, t.z_id, e.z_id), if_then_else(c, t.color, e.color), if_then_else(c, t.scissor, e.scissor));
219}};
220vec2 vUv;
221// ivec4_scalar vTileData;
222ivec4_scalar aData;
223PathTile_scalar decode_path_tile(ivec4_scalar data) {
224 PathTile_scalar tile;
225 vec2_scalar offset = make_vec2(make_float((((data).x)>>(10))&(1023)), make_float(((data).x)&(1023)));
226 float extend_x = make_float((((data).x)>>(20))&(1023));
227 (tile).rect = (make_vec4((offset).x, (offset).y, (((offset).x)+(1.f))+(extend_x), ((offset).y)+(1.f)))*(16.f);
228 int32_t edge_count = (((data).z)>>(16))&(65535);
229 (tile).edges = make_ivec2((data).y, ((data).y)+(edge_count));
230 (tile).backdrop = (((data).z)&(65535))-(128);
231 (tile).path_address = (data).w;
232 return tile;
233}
234ivec2_scalar get_gpu_buffer_uv(int32_t address) {
235 return make_ivec2((make_uint(address))%(1024u), (make_uint(address))/(1024u));
236}
237ivec4_scalar fetch_from_gpu_buffer_1i(int32_t address) {
238 ivec2_scalar uv = get_gpu_buffer_uv(address);
239 return texelFetch(sGpuBufferI, uv, 0);
240}
241PathInfo_scalar fetch_path_info(int32_t address) {
242 ivec4_scalar data = fetch_from_gpu_buffer_1i(address);
243 PathInfo_scalar path;
244 (path).render_task_address = (data).x;
245 (path).fill_rule = (data).y;
246 (path).opacity = (make_float((data).z))/(65535.f);
247 return path;
248}
249RectWithEndpoint_scalar fetch_render_task_rect(int32_t index) {
250 ivec2_scalar uv = make_ivec2(make_int((2u)*((make_uint(index))%((1024u)/(2u)))), make_int((make_uint(index))/((1024u)/(2u))));
251 auto sRenderTasks_uv_fetch = texelFetchPtr(sRenderTasks, uv, 0, 1, 0, 0);
252 vec4_scalar texel0 = texelFetchUnchecked(sRenderTasks, sRenderTasks_uv_fetch, 0, 0);
253 vec4_scalar texel1 = texelFetchUnchecked(sRenderTasks, sRenderTasks_uv_fetch, 1, 0);
Value stored to 'texel1' during its initialization is never read
254 RectWithEndpoint_scalar task_rect = RectWithEndpoint_scalar((texel0).sel(X,Y), (texel0).sel(Z,W));
255 return task_rect;
256}
257ALWAYS_INLINE__attribute__((always_inline)) inline void main(void) {
258 PathTile_scalar tile = decode_path_tile(aData);
259 PathInfo_scalar path = fetch_path_info((tile).path_address);
260 RectWithEndpoint_scalar task_rect = fetch_render_task_rect((path).render_task_address);
261 vec2_scalar task_size = ((task_rect).p1)-((task_rect).p0);
262 vec2_scalar p0 = min(((tile).rect).sel(X,Y), task_size);
263 vec2_scalar p1 = min(((tile).rect).sel(Z,W), task_size);
264 vec2 pos = mix(p0, p1, (aPosition).sel(X,Y));
265 vUv = (pos)-(((tile).rect).sel(X,Y));
266 vTileData = make_ivec4((tile).edges, (tile).backdrop, (path).fill_rule);
267 gl_Position = (uTransform)*(make_vec4(((task_rect).p0)+(pos), 0.f, 1.f));
268}
269static void set_uniform_1i(VertexShaderImpl* impl, int index, int value) {
270 Self* self = (Self*)impl;
271 if (self->samplers.set_slot(index, value)) return;
272 switch (index) {
273 case 2:
274 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferF
275 break;
276 case 3:
277 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferI
278 break;
279 case 5:
280 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPathEdges
281 break;
282 case 1:
283 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sRenderTasks
284 break;
285 case 4:
286 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // uTransform
287 break;
288 }
289}
290static void set_uniform_4fv(VertexShaderImpl* impl, int index, const float *value) {
291 Self* self = (Self*)impl;
292 switch (index) {
293 case 2:
294 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferF
295 break;
296 case 3:
297 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferI
298 break;
299 case 5:
300 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPathEdges
301 break;
302 case 1:
303 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sRenderTasks
304 break;
305 case 4:
306 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // uTransform
307 break;
308 }
309}
310static void set_uniform_matrix4fv(VertexShaderImpl* impl, int index, const float *value) {
311 Self* self = (Self*)impl;
312 switch (index) {
313 case 2:
314 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferF
315 break;
316 case 3:
317 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sGpuBufferI
318 break;
319 case 5:
320 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sPathEdges
321 break;
322 case 1:
323 assert(0)(static_cast <bool> (0) ? void (0) : __assert_fail ("0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); // sRenderTasks
324 break;
325 case 4:
326 self->uTransform = mat4_scalar::load_from_ptr(value);
327 break;
328 }
329}
330static void load_attribs(VertexShaderImpl* impl, VertexAttrib *attribs, uint32_t start, int instance, int count) {Self* self = (Self*)impl;
331 load_attrib(self->aPosition, attribs[self->attrib_locations.aPosition], start, instance, count);
332 load_flat_attrib(self->aData, attribs[self->attrib_locations.aData], start, instance, count);
333}
334public:
335struct InterpOutputs {
336vec2_scalar vUv;
337};
338private:
339ALWAYS_INLINE__attribute__((always_inline)) inline void store_interp_outputs(char* dest_ptr, size_t stride) {
340 for(int n = 0; n < 4; n++) {
341 auto* dest = reinterpret_cast<InterpOutputs*>(dest_ptr);
342 dest->vUv = get_nth(vUv, n);
343 dest_ptr += stride;
344 }
345}
346static void run(VertexShaderImpl* impl, char* interps, size_t interp_stride) {
347 Self* self = (Self*)impl;
348 self->main();
349 self->store_interp_outputs(interps, interp_stride);
350}
351static void init_batch(VertexShaderImpl* impl) {
352 Self* self = (Self*)impl; self->bind_textures(); }
353public:
354cs_path_tile_PATH_SSAA4_vert() {
355 set_uniform_1i_func = &set_uniform_1i;
356 set_uniform_4fv_func = &set_uniform_4fv;
357 set_uniform_matrix4fv_func = &set_uniform_matrix4fv;
358 init_batch_func = &init_batch;
359 load_attribs_func = &load_attribs;
360 run_primitive_func = &run;
361}
362};
363
364
365struct cs_path_tile_PATH_SSAA4_frag : FragmentShaderImpl, cs_path_tile_PATH_SSAA4_vert {
366private:
367typedef cs_path_tile_PATH_SSAA4_frag Self;
368#define oFragColorgl_FragColor gl_FragColor
369// vec4 oFragColor;
370struct RectWithSize_scalar {
371vec2_scalar p0;
372vec2_scalar size;
373RectWithSize_scalar() = default;
374RectWithSize_scalar(vec2_scalar p0, vec2_scalar size) : p0(p0), size(size){}
375};
376struct RectWithSize {
377vec2 p0;
378vec2 size;
379RectWithSize() = default;
380RectWithSize(vec2 p0, vec2 size) : p0(p0), size(size){}
381RectWithSize(vec2_scalar p0, vec2_scalar size):p0(p0),size(size){
382}
383IMPLICIT RectWithSize(RectWithSize_scalar s):p0(s.p0),size(s.size){
384}
385friend RectWithSize if_then_else(I32 c, RectWithSize t, RectWithSize e) { return RectWithSize(
386if_then_else(c, t.p0, e.p0), if_then_else(c, t.size, e.size));
387}};
388struct RectWithEndpoint_scalar {
389vec2_scalar p0;
390vec2_scalar p1;
391RectWithEndpoint_scalar() = default;
392RectWithEndpoint_scalar(vec2_scalar p0, vec2_scalar p1) : p0(p0), p1(p1){}
393};
394struct RectWithEndpoint {
395vec2 p0;
396vec2 p1;
397RectWithEndpoint() = default;
398RectWithEndpoint(vec2 p0, vec2 p1) : p0(p0), p1(p1){}
399RectWithEndpoint(vec2_scalar p0, vec2_scalar p1):p0(p0),p1(p1){
400}
401IMPLICIT RectWithEndpoint(RectWithEndpoint_scalar s):p0(s.p0),p1(s.p1){
402}
403friend RectWithEndpoint if_then_else(I32 c, RectWithEndpoint t, RectWithEndpoint e) { return RectWithEndpoint(
404if_then_else(c, t.p0, e.p0), if_then_else(c, t.p1, e.p1));
405}};
406// sampler2D sGpuBufferF;
407// isampler2D sGpuBufferI;
408// sampler2D sPathEdges;
409vec2 vUv;
410// ivec4_scalar vTileData;
411Float ssaa_sample(vec2_scalar offset, vec2 edge, Float cross_at_origin, Float y_min, Float y_max, float winding) {
412 Bool in_y_range = ((y_min)<=((offset).y))&&((y_max)>=((offset).y));
413 Float cross = ((cross_at_origin)+(((edge).x)*((offset).y)))-(((edge).y)*((offset).x));
414 return if_then_else((in_y_range)&&((cross)>=(0.f)), winding, 0.f);
415}
416Float path_even_odd(Float winding_number) {
417 return (1.f)-(abs__glsl_abs((mod(abs__glsl_abs(winding_number), 2.f))-(1.f)));
418}
419Float path_non_zero(Float winding_number) {
420 return min(abs__glsl_abs(winding_number), 1.f);
421}
422Float path_tile_coverage(vec2 uv, ivec2_scalar edges, int32_t backdrop, int32_t fill_rule) {
423 vec4 wn = make_vec4(make_float(backdrop));
424 int32_t end = min((edges).y, ((edges).x)+(512));
425 for ( int32_t edge_idx = (edges).x;
426(edge_idx)<(end); edge_idx++) {
427 ivec2_scalar edge_uv = make_ivec2(make_int((make_uint(edge_idx))%(1024u)), make_int((make_uint(edge_idx))/(1024u)));
428 vec4_scalar edge = (texelFetch(sPathEdges, edge_uv, 0))*((255.f)/(15.f));
429 vec2_scalar p0 = (edge).sel(X,Y);
430 vec2_scalar p1 = (edge).sel(Z,W);
431 if (((p0).y)==((p1).y)) {
432 {
433 continue;
434 }
435 }
436 bool downwards = ((p1).y)>((p0).y);
437 float s = downwards ? 1.f : -(1.f);
438 vec2 upper = (downwards ? p0 : p1)-(uv);
439 vec2 lower = (downwards ? p1 : p0)-(uv);
440 Float y_min = -((lower).y);
441 Float y_max = -((upper).y);
442 auto _c2_ = ((y_min)<=((3.f)/(8.f)))&&((y_max)>=((-(3.f))/(8.f)));
443 {
444 vec2_scalar const a = make_vec2((1.f)/(8.f), (-(3.f))/(8.f));
445 vec2_scalar const b = make_vec2((-(3.f))/(8.f), (-(1.f))/(8.f));
446 vec2_scalar const c = make_vec2((3.f)/(8.f), (1.f)/(8.f));
447 vec2_scalar const d = make_vec2((-(1.f))/(8.f), (3.f)/(8.f));
448 vec2 v = (lower)-(upper);
449 Float cross_at_origin = (((v).x)*((upper).y))-(((upper).x)*((v).y));
450 (wn).x = if_then_else(_c2_,(wn).x+ssaa_sample(a, v, cross_at_origin, y_min, y_max, s),(wn).x);
451 (wn).y = if_then_else(_c2_,(wn).y+ssaa_sample(b, v, cross_at_origin, y_min, y_max, s),(wn).y);
452 (wn).z = if_then_else(_c2_,(wn).z+ssaa_sample(c, v, cross_at_origin, y_min, y_max, s),(wn).z);
453 (wn).w = if_then_else(_c2_,(wn).w+ssaa_sample(d, v, cross_at_origin, y_min, y_max, s),(wn).w);
454 }
455 }
456 Float mask;
457 if (((fill_rule)&(1))==(0)) {
458 {
459 mask = (((path_even_odd((wn).x))+(path_even_odd((wn).y)))+(path_even_odd((wn).z)))+(path_even_odd((wn).w));
460 }
461 } else {
462 mask = (((path_non_zero((wn).x))+(path_non_zero((wn).y)))+(path_non_zero((wn).z)))+(path_non_zero((wn).w));
463 }
464 mask *= 0.25f;
465 if (((fill_rule)&(2))!=(0)) {
466 {
467 mask = (1.f)-(mask);
468 }
469 }
470 return mask;
471}
472ALWAYS_INLINE__attribute__((always_inline)) inline void main(void) {
473 Float mask = path_tile_coverage(vUv, (vTileData).sel(X,Y), (vTileData).z, (vTileData).w);
474 oFragColorgl_FragColor = make_vec4(make_vec3((1.f)-(mask)), mask);
475}
476void swgl_drawSpanRGBA8() {
477 swgl_commitPathTileRGBA8(sPathEdges, vUv, vTileData, 4)do { int drawn = 0; if (4 == 8) { drawn = blend_key ? blendPathTile
<8, true>(sPathEdges, vUv, vTileData, swgl_OutRGBA8, swgl_SpanLength
) : blendPathTile<8, false>(sPathEdges, vUv, vTileData,
swgl_OutRGBA8, swgl_SpanLength); } else { drawn = blend_key ?
blendPathTile<4, true>(sPathEdges, vUv, vTileData, swgl_OutRGBA8
, swgl_SpanLength) : blendPathTile<4, false>(sPathEdges
, vUv, vTileData, swgl_OutRGBA8, swgl_SpanLength); } swgl_OutRGBA8
+= drawn; swgl_SpanLength -= drawn; } while (0);
478}
479void swgl_drawSpanR8() {
480 swgl_commitPathTileR8(sPathEdges, vUv, vTileData, 4)do { int drawn = 0; if (4 == 8) { drawn = blend_key ? blendPathTile
<8, true>(sPathEdges, vUv, vTileData, swgl_OutR8, swgl_SpanLength
) : blendPathTile<8, false>(sPathEdges, vUv, vTileData,
swgl_OutR8, swgl_SpanLength); } else { drawn = blend_key ? blendPathTile
<4, true>(sPathEdges, vUv, vTileData, swgl_OutR8, swgl_SpanLength
) : blendPathTile<4, false>(sPathEdges, vUv, vTileData,
swgl_OutR8, swgl_SpanLength); } swgl_OutR8 += drawn; swgl_SpanLength
-= drawn; } while (0);
481}
482typedef cs_path_tile_PATH_SSAA4_vert::InterpOutputs InterpInputs;
483InterpInputs interp_step;
484struct InterpPerspective {
485vec2 vUv;
486};
487InterpPerspective interp_perspective;
488static 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_;
489 self->vUv = init_interp(init->vUv, step->vUv);
490 self->interp_step.vUv = step->vUv * 4.0f;
491}
492static 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_;
493 Float w = 1.0f / self->gl_FragCoord.w;
494 self->interp_perspective.vUv = init_interp(init->vUv, step->vUv);
495 self->vUv = self->interp_perspective.vUv * w;
496 self->interp_step.vUv = step->vUv * 4.0f;
497}
498ALWAYS_INLINE__attribute__((always_inline)) inline void step_interp_inputs(int steps = 4) {
499 float chunks = steps * 0.25f;
500 vUv += interp_step.vUv * chunks;
501}
502ALWAYS_INLINE__attribute__((always_inline)) inline void step_perspective_inputs(int steps = 4) {
503 step_perspective(steps);
504 float chunks = steps * 0.25f;
505 Float w = 1.0f / gl_FragCoord.w;
506 interp_perspective.vUv += interp_step.vUv * chunks;
507 vUv = w * interp_perspective.vUv;
508}
509static void run(FragmentShaderImpl* impl) {
510 Self* self = (Self*)impl;
511 self->main();
512 self->step_interp_inputs();
513}
514static void skip(FragmentShaderImpl* impl, int steps) {
515 Self* self = (Self*)impl;
516 self->step_interp_inputs(steps);
517}
518static void run_perspective(FragmentShaderImpl* impl) {
519 Self* self = (Self*)impl;
520 self->main();
521 self->step_perspective_inputs();
522}
523static void skip_perspective(FragmentShaderImpl* impl, int steps) {
524 Self* self = (Self*)impl;
525 self->step_perspective_inputs(steps);
526}
527static int draw_span_RGBA8(FragmentShaderImpl* impl) {
528 Self* self = (Self*)impl; DISPATCH_DRAW_SPAN(self, RGBA8)do { int total = self->swgl_SpanLength; self->swgl_drawSpanRGBA8
(); int drawn = total - self->swgl_SpanLength; if (drawn) self
->step_interp_inputs(drawn); return drawn; } while (0); }
529static int draw_span_R8(FragmentShaderImpl* impl) {
530 Self* self = (Self*)impl; DISPATCH_DRAW_SPAN(self, R8)do { int total = self->swgl_SpanLength; self->swgl_drawSpanR8
(); int drawn = total - self->swgl_SpanLength; if (drawn) self
->step_interp_inputs(drawn); return drawn; } while (0); }
531public:
532cs_path_tile_PATH_SSAA4_frag() {
533 init_span_func = &read_interp_inputs;
534 run_func = &run;
535 skip_func = &skip;
536 draw_span_RGBA8_func = &draw_span_RGBA8;
537 draw_span_R8_func = &draw_span_R8;
538 enable_perspective();
539 init_span_w_func = &read_perspective_inputs;
540 run_w_func = &run_perspective;
541 skip_w_func = &skip_perspective;
542}
543};
544
545struct cs_path_tile_PATH_SSAA4_program : ProgramImpl, cs_path_tile_PATH_SSAA4_frag {
546int get_uniform(const char *name) const override {
547 if (strcmp("sGpuBufferF", name) == 0) { return 2; }
548 if (strcmp("sGpuBufferI", name) == 0) { return 3; }
549 if (strcmp("sPathEdges", name) == 0) { return 5; }
550 if (strcmp("sRenderTasks", name) == 0) { return 1; }
551 if (strcmp("uTransform", name) == 0) { return 4; }
552 return -1;
553}
554void bind_attrib(const char* name, int index) override {
555 attrib_locations.bind_loc(name, index);
556}
557int get_attrib(const char* name) const override {
558 return attrib_locations.get_loc(name);
559}
560size_t interpolants_size() const override { return sizeof(InterpOutputs); }
561VertexShaderImpl* get_vertex_shader() override {
562 return this;
563}
564FragmentShaderImpl* get_fragment_shader() override {
565 return this;
566}
567const char* get_name() const override { return "cs_path_tile_PATH_SSAA4"; }
568static ProgramImpl* loader() { return new cs_path_tile_PATH_SSAA4_program; }
569};
570