1use crate::{
6 dr::{self, Builder},
7 spirv,
8};
9impl Builder {
10 #[allow(clippy::too_many_arguments)]
11 pub fn gl_round(
12 &mut self,
13 result_type: spirv::Word,
14 x: spirv::Word,
15 ) -> Result<spirv::Word, dr::Error> {
16 self.gl_round_id(result_type, None, x)
17 }
18 #[allow(clippy::too_many_arguments)]
19 pub fn gl_round_id(
20 &mut self,
21 result_type: spirv::Word,
22 result_id: Option<spirv::Word>,
23 x: spirv::Word,
24 ) -> Result<spirv::Word, dr::Error> {
25 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
26 #[allow(unused_mut)]
27 let mut args = vec![dr::Operand::IdRef(x)];
28 self.ext_inst(
29 result_type,
30 result_id,
31 extension_set,
32 crate::spirv::GLOp::Round as spirv::Word,
33 args,
34 )
35 }
36 #[allow(clippy::too_many_arguments)]
37 pub fn gl_round_even(
38 &mut self,
39 result_type: spirv::Word,
40 x: spirv::Word,
41 ) -> Result<spirv::Word, dr::Error> {
42 self.gl_round_even_id(result_type, None, x)
43 }
44 #[allow(clippy::too_many_arguments)]
45 pub fn gl_round_even_id(
46 &mut self,
47 result_type: spirv::Word,
48 result_id: Option<spirv::Word>,
49 x: spirv::Word,
50 ) -> Result<spirv::Word, dr::Error> {
51 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
52 #[allow(unused_mut)]
53 let mut args = vec![dr::Operand::IdRef(x)];
54 self.ext_inst(
55 result_type,
56 result_id,
57 extension_set,
58 crate::spirv::GLOp::RoundEven as spirv::Word,
59 args,
60 )
61 }
62 #[allow(clippy::too_many_arguments)]
63 pub fn gl_trunc(
64 &mut self,
65 result_type: spirv::Word,
66 x: spirv::Word,
67 ) -> Result<spirv::Word, dr::Error> {
68 self.gl_trunc_id(result_type, None, x)
69 }
70 #[allow(clippy::too_many_arguments)]
71 pub fn gl_trunc_id(
72 &mut self,
73 result_type: spirv::Word,
74 result_id: Option<spirv::Word>,
75 x: spirv::Word,
76 ) -> Result<spirv::Word, dr::Error> {
77 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
78 #[allow(unused_mut)]
79 let mut args = vec![dr::Operand::IdRef(x)];
80 self.ext_inst(
81 result_type,
82 result_id,
83 extension_set,
84 crate::spirv::GLOp::Trunc as spirv::Word,
85 args,
86 )
87 }
88 #[allow(clippy::too_many_arguments)]
89 pub fn gl_f_abs(
90 &mut self,
91 result_type: spirv::Word,
92 x: spirv::Word,
93 ) -> Result<spirv::Word, dr::Error> {
94 self.gl_f_abs_id(result_type, None, x)
95 }
96 #[allow(clippy::too_many_arguments)]
97 pub fn gl_f_abs_id(
98 &mut self,
99 result_type: spirv::Word,
100 result_id: Option<spirv::Word>,
101 x: spirv::Word,
102 ) -> Result<spirv::Word, dr::Error> {
103 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
104 #[allow(unused_mut)]
105 let mut args = vec![dr::Operand::IdRef(x)];
106 self.ext_inst(
107 result_type,
108 result_id,
109 extension_set,
110 crate::spirv::GLOp::FAbs as spirv::Word,
111 args,
112 )
113 }
114 #[allow(clippy::too_many_arguments)]
115 pub fn gl_s_abs(
116 &mut self,
117 result_type: spirv::Word,
118 x: spirv::Word,
119 ) -> Result<spirv::Word, dr::Error> {
120 self.gl_s_abs_id(result_type, None, x)
121 }
122 #[allow(clippy::too_many_arguments)]
123 pub fn gl_s_abs_id(
124 &mut self,
125 result_type: spirv::Word,
126 result_id: Option<spirv::Word>,
127 x: spirv::Word,
128 ) -> Result<spirv::Word, dr::Error> {
129 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
130 #[allow(unused_mut)]
131 let mut args = vec![dr::Operand::IdRef(x)];
132 self.ext_inst(
133 result_type,
134 result_id,
135 extension_set,
136 crate::spirv::GLOp::SAbs as spirv::Word,
137 args,
138 )
139 }
140 #[allow(clippy::too_many_arguments)]
141 pub fn gl_f_sign(
142 &mut self,
143 result_type: spirv::Word,
144 x: spirv::Word,
145 ) -> Result<spirv::Word, dr::Error> {
146 self.gl_f_sign_id(result_type, None, x)
147 }
148 #[allow(clippy::too_many_arguments)]
149 pub fn gl_f_sign_id(
150 &mut self,
151 result_type: spirv::Word,
152 result_id: Option<spirv::Word>,
153 x: spirv::Word,
154 ) -> Result<spirv::Word, dr::Error> {
155 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
156 #[allow(unused_mut)]
157 let mut args = vec![dr::Operand::IdRef(x)];
158 self.ext_inst(
159 result_type,
160 result_id,
161 extension_set,
162 crate::spirv::GLOp::FSign as spirv::Word,
163 args,
164 )
165 }
166 #[allow(clippy::too_many_arguments)]
167 pub fn gl_s_sign(
168 &mut self,
169 result_type: spirv::Word,
170 x: spirv::Word,
171 ) -> Result<spirv::Word, dr::Error> {
172 self.gl_s_sign_id(result_type, None, x)
173 }
174 #[allow(clippy::too_many_arguments)]
175 pub fn gl_s_sign_id(
176 &mut self,
177 result_type: spirv::Word,
178 result_id: Option<spirv::Word>,
179 x: spirv::Word,
180 ) -> Result<spirv::Word, dr::Error> {
181 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
182 #[allow(unused_mut)]
183 let mut args = vec![dr::Operand::IdRef(x)];
184 self.ext_inst(
185 result_type,
186 result_id,
187 extension_set,
188 crate::spirv::GLOp::SSign as spirv::Word,
189 args,
190 )
191 }
192 #[allow(clippy::too_many_arguments)]
193 pub fn gl_floor(
194 &mut self,
195 result_type: spirv::Word,
196 x: spirv::Word,
197 ) -> Result<spirv::Word, dr::Error> {
198 self.gl_floor_id(result_type, None, x)
199 }
200 #[allow(clippy::too_many_arguments)]
201 pub fn gl_floor_id(
202 &mut self,
203 result_type: spirv::Word,
204 result_id: Option<spirv::Word>,
205 x: spirv::Word,
206 ) -> Result<spirv::Word, dr::Error> {
207 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
208 #[allow(unused_mut)]
209 let mut args = vec![dr::Operand::IdRef(x)];
210 self.ext_inst(
211 result_type,
212 result_id,
213 extension_set,
214 crate::spirv::GLOp::Floor as spirv::Word,
215 args,
216 )
217 }
218 #[allow(clippy::too_many_arguments)]
219 pub fn gl_ceil(
220 &mut self,
221 result_type: spirv::Word,
222 x: spirv::Word,
223 ) -> Result<spirv::Word, dr::Error> {
224 self.gl_ceil_id(result_type, None, x)
225 }
226 #[allow(clippy::too_many_arguments)]
227 pub fn gl_ceil_id(
228 &mut self,
229 result_type: spirv::Word,
230 result_id: Option<spirv::Word>,
231 x: spirv::Word,
232 ) -> Result<spirv::Word, dr::Error> {
233 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
234 #[allow(unused_mut)]
235 let mut args = vec![dr::Operand::IdRef(x)];
236 self.ext_inst(
237 result_type,
238 result_id,
239 extension_set,
240 crate::spirv::GLOp::Ceil as spirv::Word,
241 args,
242 )
243 }
244 #[allow(clippy::too_many_arguments)]
245 pub fn gl_fract(
246 &mut self,
247 result_type: spirv::Word,
248 x: spirv::Word,
249 ) -> Result<spirv::Word, dr::Error> {
250 self.gl_fract_id(result_type, None, x)
251 }
252 #[allow(clippy::too_many_arguments)]
253 pub fn gl_fract_id(
254 &mut self,
255 result_type: spirv::Word,
256 result_id: Option<spirv::Word>,
257 x: spirv::Word,
258 ) -> Result<spirv::Word, dr::Error> {
259 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
260 #[allow(unused_mut)]
261 let mut args = vec![dr::Operand::IdRef(x)];
262 self.ext_inst(
263 result_type,
264 result_id,
265 extension_set,
266 crate::spirv::GLOp::Fract as spirv::Word,
267 args,
268 )
269 }
270 #[allow(clippy::too_many_arguments)]
271 pub fn gl_radians(
272 &mut self,
273 result_type: spirv::Word,
274 degrees: spirv::Word,
275 ) -> Result<spirv::Word, dr::Error> {
276 self.gl_radians_id(result_type, None, degrees)
277 }
278 #[allow(clippy::too_many_arguments)]
279 pub fn gl_radians_id(
280 &mut self,
281 result_type: spirv::Word,
282 result_id: Option<spirv::Word>,
283 degrees: spirv::Word,
284 ) -> Result<spirv::Word, dr::Error> {
285 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
286 #[allow(unused_mut)]
287 let mut args = vec![dr::Operand::IdRef(degrees)];
288 self.ext_inst(
289 result_type,
290 result_id,
291 extension_set,
292 crate::spirv::GLOp::Radians as spirv::Word,
293 args,
294 )
295 }
296 #[allow(clippy::too_many_arguments)]
297 pub fn gl_degrees(
298 &mut self,
299 result_type: spirv::Word,
300 radians: spirv::Word,
301 ) -> Result<spirv::Word, dr::Error> {
302 self.gl_degrees_id(result_type, None, radians)
303 }
304 #[allow(clippy::too_many_arguments)]
305 pub fn gl_degrees_id(
306 &mut self,
307 result_type: spirv::Word,
308 result_id: Option<spirv::Word>,
309 radians: spirv::Word,
310 ) -> Result<spirv::Word, dr::Error> {
311 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
312 #[allow(unused_mut)]
313 let mut args = vec![dr::Operand::IdRef(radians)];
314 self.ext_inst(
315 result_type,
316 result_id,
317 extension_set,
318 crate::spirv::GLOp::Degrees as spirv::Word,
319 args,
320 )
321 }
322 #[allow(clippy::too_many_arguments)]
323 pub fn gl_sin(
324 &mut self,
325 result_type: spirv::Word,
326 x: spirv::Word,
327 ) -> Result<spirv::Word, dr::Error> {
328 self.gl_sin_id(result_type, None, x)
329 }
330 #[allow(clippy::too_many_arguments)]
331 pub fn gl_sin_id(
332 &mut self,
333 result_type: spirv::Word,
334 result_id: Option<spirv::Word>,
335 x: spirv::Word,
336 ) -> Result<spirv::Word, dr::Error> {
337 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
338 #[allow(unused_mut)]
339 let mut args = vec![dr::Operand::IdRef(x)];
340 self.ext_inst(
341 result_type,
342 result_id,
343 extension_set,
344 crate::spirv::GLOp::Sin as spirv::Word,
345 args,
346 )
347 }
348 #[allow(clippy::too_many_arguments)]
349 pub fn gl_cos(
350 &mut self,
351 result_type: spirv::Word,
352 x: spirv::Word,
353 ) -> Result<spirv::Word, dr::Error> {
354 self.gl_cos_id(result_type, None, x)
355 }
356 #[allow(clippy::too_many_arguments)]
357 pub fn gl_cos_id(
358 &mut self,
359 result_type: spirv::Word,
360 result_id: Option<spirv::Word>,
361 x: spirv::Word,
362 ) -> Result<spirv::Word, dr::Error> {
363 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
364 #[allow(unused_mut)]
365 let mut args = vec![dr::Operand::IdRef(x)];
366 self.ext_inst(
367 result_type,
368 result_id,
369 extension_set,
370 crate::spirv::GLOp::Cos as spirv::Word,
371 args,
372 )
373 }
374 #[allow(clippy::too_many_arguments)]
375 pub fn gl_tan(
376 &mut self,
377 result_type: spirv::Word,
378 x: spirv::Word,
379 ) -> Result<spirv::Word, dr::Error> {
380 self.gl_tan_id(result_type, None, x)
381 }
382 #[allow(clippy::too_many_arguments)]
383 pub fn gl_tan_id(
384 &mut self,
385 result_type: spirv::Word,
386 result_id: Option<spirv::Word>,
387 x: spirv::Word,
388 ) -> Result<spirv::Word, dr::Error> {
389 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
390 #[allow(unused_mut)]
391 let mut args = vec![dr::Operand::IdRef(x)];
392 self.ext_inst(
393 result_type,
394 result_id,
395 extension_set,
396 crate::spirv::GLOp::Tan as spirv::Word,
397 args,
398 )
399 }
400 #[allow(clippy::too_many_arguments)]
401 pub fn gl_asin(
402 &mut self,
403 result_type: spirv::Word,
404 x: spirv::Word,
405 ) -> Result<spirv::Word, dr::Error> {
406 self.gl_asin_id(result_type, None, x)
407 }
408 #[allow(clippy::too_many_arguments)]
409 pub fn gl_asin_id(
410 &mut self,
411 result_type: spirv::Word,
412 result_id: Option<spirv::Word>,
413 x: spirv::Word,
414 ) -> Result<spirv::Word, dr::Error> {
415 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
416 #[allow(unused_mut)]
417 let mut args = vec![dr::Operand::IdRef(x)];
418 self.ext_inst(
419 result_type,
420 result_id,
421 extension_set,
422 crate::spirv::GLOp::Asin as spirv::Word,
423 args,
424 )
425 }
426 #[allow(clippy::too_many_arguments)]
427 pub fn gl_acos(
428 &mut self,
429 result_type: spirv::Word,
430 x: spirv::Word,
431 ) -> Result<spirv::Word, dr::Error> {
432 self.gl_acos_id(result_type, None, x)
433 }
434 #[allow(clippy::too_many_arguments)]
435 pub fn gl_acos_id(
436 &mut self,
437 result_type: spirv::Word,
438 result_id: Option<spirv::Word>,
439 x: spirv::Word,
440 ) -> Result<spirv::Word, dr::Error> {
441 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
442 #[allow(unused_mut)]
443 let mut args = vec![dr::Operand::IdRef(x)];
444 self.ext_inst(
445 result_type,
446 result_id,
447 extension_set,
448 crate::spirv::GLOp::Acos as spirv::Word,
449 args,
450 )
451 }
452 #[allow(clippy::too_many_arguments)]
453 pub fn gl_atan(
454 &mut self,
455 result_type: spirv::Word,
456 y_over_x: spirv::Word,
457 ) -> Result<spirv::Word, dr::Error> {
458 self.gl_atan_id(result_type, None, y_over_x)
459 }
460 #[allow(clippy::too_many_arguments)]
461 pub fn gl_atan_id(
462 &mut self,
463 result_type: spirv::Word,
464 result_id: Option<spirv::Word>,
465 y_over_x: spirv::Word,
466 ) -> Result<spirv::Word, dr::Error> {
467 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
468 #[allow(unused_mut)]
469 let mut args = vec![dr::Operand::IdRef(y_over_x)];
470 self.ext_inst(
471 result_type,
472 result_id,
473 extension_set,
474 crate::spirv::GLOp::Atan as spirv::Word,
475 args,
476 )
477 }
478 #[allow(clippy::too_many_arguments)]
479 pub fn gl_sinh(
480 &mut self,
481 result_type: spirv::Word,
482 x: spirv::Word,
483 ) -> Result<spirv::Word, dr::Error> {
484 self.gl_sinh_id(result_type, None, x)
485 }
486 #[allow(clippy::too_many_arguments)]
487 pub fn gl_sinh_id(
488 &mut self,
489 result_type: spirv::Word,
490 result_id: Option<spirv::Word>,
491 x: spirv::Word,
492 ) -> Result<spirv::Word, dr::Error> {
493 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
494 #[allow(unused_mut)]
495 let mut args = vec![dr::Operand::IdRef(x)];
496 self.ext_inst(
497 result_type,
498 result_id,
499 extension_set,
500 crate::spirv::GLOp::Sinh as spirv::Word,
501 args,
502 )
503 }
504 #[allow(clippy::too_many_arguments)]
505 pub fn gl_cosh(
506 &mut self,
507 result_type: spirv::Word,
508 x: spirv::Word,
509 ) -> Result<spirv::Word, dr::Error> {
510 self.gl_cosh_id(result_type, None, x)
511 }
512 #[allow(clippy::too_many_arguments)]
513 pub fn gl_cosh_id(
514 &mut self,
515 result_type: spirv::Word,
516 result_id: Option<spirv::Word>,
517 x: spirv::Word,
518 ) -> Result<spirv::Word, dr::Error> {
519 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
520 #[allow(unused_mut)]
521 let mut args = vec![dr::Operand::IdRef(x)];
522 self.ext_inst(
523 result_type,
524 result_id,
525 extension_set,
526 crate::spirv::GLOp::Cosh as spirv::Word,
527 args,
528 )
529 }
530 #[allow(clippy::too_many_arguments)]
531 pub fn gl_tanh(
532 &mut self,
533 result_type: spirv::Word,
534 x: spirv::Word,
535 ) -> Result<spirv::Word, dr::Error> {
536 self.gl_tanh_id(result_type, None, x)
537 }
538 #[allow(clippy::too_many_arguments)]
539 pub fn gl_tanh_id(
540 &mut self,
541 result_type: spirv::Word,
542 result_id: Option<spirv::Word>,
543 x: spirv::Word,
544 ) -> Result<spirv::Word, dr::Error> {
545 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
546 #[allow(unused_mut)]
547 let mut args = vec![dr::Operand::IdRef(x)];
548 self.ext_inst(
549 result_type,
550 result_id,
551 extension_set,
552 crate::spirv::GLOp::Tanh as spirv::Word,
553 args,
554 )
555 }
556 #[allow(clippy::too_many_arguments)]
557 pub fn gl_asinh(
558 &mut self,
559 result_type: spirv::Word,
560 x: spirv::Word,
561 ) -> Result<spirv::Word, dr::Error> {
562 self.gl_asinh_id(result_type, None, x)
563 }
564 #[allow(clippy::too_many_arguments)]
565 pub fn gl_asinh_id(
566 &mut self,
567 result_type: spirv::Word,
568 result_id: Option<spirv::Word>,
569 x: spirv::Word,
570 ) -> Result<spirv::Word, dr::Error> {
571 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
572 #[allow(unused_mut)]
573 let mut args = vec![dr::Operand::IdRef(x)];
574 self.ext_inst(
575 result_type,
576 result_id,
577 extension_set,
578 crate::spirv::GLOp::Asinh as spirv::Word,
579 args,
580 )
581 }
582 #[allow(clippy::too_many_arguments)]
583 pub fn gl_acosh(
584 &mut self,
585 result_type: spirv::Word,
586 x: spirv::Word,
587 ) -> Result<spirv::Word, dr::Error> {
588 self.gl_acosh_id(result_type, None, x)
589 }
590 #[allow(clippy::too_many_arguments)]
591 pub fn gl_acosh_id(
592 &mut self,
593 result_type: spirv::Word,
594 result_id: Option<spirv::Word>,
595 x: spirv::Word,
596 ) -> Result<spirv::Word, dr::Error> {
597 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
598 #[allow(unused_mut)]
599 let mut args = vec![dr::Operand::IdRef(x)];
600 self.ext_inst(
601 result_type,
602 result_id,
603 extension_set,
604 crate::spirv::GLOp::Acosh as spirv::Word,
605 args,
606 )
607 }
608 #[allow(clippy::too_many_arguments)]
609 pub fn gl_atanh(
610 &mut self,
611 result_type: spirv::Word,
612 x: spirv::Word,
613 ) -> Result<spirv::Word, dr::Error> {
614 self.gl_atanh_id(result_type, None, x)
615 }
616 #[allow(clippy::too_many_arguments)]
617 pub fn gl_atanh_id(
618 &mut self,
619 result_type: spirv::Word,
620 result_id: Option<spirv::Word>,
621 x: spirv::Word,
622 ) -> Result<spirv::Word, dr::Error> {
623 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
624 #[allow(unused_mut)]
625 let mut args = vec![dr::Operand::IdRef(x)];
626 self.ext_inst(
627 result_type,
628 result_id,
629 extension_set,
630 crate::spirv::GLOp::Atanh as spirv::Word,
631 args,
632 )
633 }
634 #[allow(clippy::too_many_arguments)]
635 pub fn gl_atan2(
636 &mut self,
637 result_type: spirv::Word,
638 y: spirv::Word,
639 x: spirv::Word,
640 ) -> Result<spirv::Word, dr::Error> {
641 self.gl_atan2_id(result_type, None, y, x)
642 }
643 #[allow(clippy::too_many_arguments)]
644 pub fn gl_atan2_id(
645 &mut self,
646 result_type: spirv::Word,
647 result_id: Option<spirv::Word>,
648 y: spirv::Word,
649 x: spirv::Word,
650 ) -> Result<spirv::Word, dr::Error> {
651 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
652 #[allow(unused_mut)]
653 let mut args = vec![dr::Operand::IdRef(y), dr::Operand::IdRef(x)];
654 self.ext_inst(
655 result_type,
656 result_id,
657 extension_set,
658 crate::spirv::GLOp::Atan2 as spirv::Word,
659 args,
660 )
661 }
662 #[allow(clippy::too_many_arguments)]
663 pub fn gl_pow(
664 &mut self,
665 result_type: spirv::Word,
666 x: spirv::Word,
667 y: spirv::Word,
668 ) -> Result<spirv::Word, dr::Error> {
669 self.gl_pow_id(result_type, None, x, y)
670 }
671 #[allow(clippy::too_many_arguments)]
672 pub fn gl_pow_id(
673 &mut self,
674 result_type: spirv::Word,
675 result_id: Option<spirv::Word>,
676 x: spirv::Word,
677 y: spirv::Word,
678 ) -> Result<spirv::Word, dr::Error> {
679 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
680 #[allow(unused_mut)]
681 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
682 self.ext_inst(
683 result_type,
684 result_id,
685 extension_set,
686 crate::spirv::GLOp::Pow as spirv::Word,
687 args,
688 )
689 }
690 #[allow(clippy::too_many_arguments)]
691 pub fn gl_exp(
692 &mut self,
693 result_type: spirv::Word,
694 x: spirv::Word,
695 ) -> Result<spirv::Word, dr::Error> {
696 self.gl_exp_id(result_type, None, x)
697 }
698 #[allow(clippy::too_many_arguments)]
699 pub fn gl_exp_id(
700 &mut self,
701 result_type: spirv::Word,
702 result_id: Option<spirv::Word>,
703 x: spirv::Word,
704 ) -> Result<spirv::Word, dr::Error> {
705 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
706 #[allow(unused_mut)]
707 let mut args = vec![dr::Operand::IdRef(x)];
708 self.ext_inst(
709 result_type,
710 result_id,
711 extension_set,
712 crate::spirv::GLOp::Exp as spirv::Word,
713 args,
714 )
715 }
716 #[allow(clippy::too_many_arguments)]
717 pub fn gl_log(
718 &mut self,
719 result_type: spirv::Word,
720 x: spirv::Word,
721 ) -> Result<spirv::Word, dr::Error> {
722 self.gl_log_id(result_type, None, x)
723 }
724 #[allow(clippy::too_many_arguments)]
725 pub fn gl_log_id(
726 &mut self,
727 result_type: spirv::Word,
728 result_id: Option<spirv::Word>,
729 x: spirv::Word,
730 ) -> Result<spirv::Word, dr::Error> {
731 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
732 #[allow(unused_mut)]
733 let mut args = vec![dr::Operand::IdRef(x)];
734 self.ext_inst(
735 result_type,
736 result_id,
737 extension_set,
738 crate::spirv::GLOp::Log as spirv::Word,
739 args,
740 )
741 }
742 #[allow(clippy::too_many_arguments)]
743 pub fn gl_exp2(
744 &mut self,
745 result_type: spirv::Word,
746 x: spirv::Word,
747 ) -> Result<spirv::Word, dr::Error> {
748 self.gl_exp2_id(result_type, None, x)
749 }
750 #[allow(clippy::too_many_arguments)]
751 pub fn gl_exp2_id(
752 &mut self,
753 result_type: spirv::Word,
754 result_id: Option<spirv::Word>,
755 x: spirv::Word,
756 ) -> Result<spirv::Word, dr::Error> {
757 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
758 #[allow(unused_mut)]
759 let mut args = vec![dr::Operand::IdRef(x)];
760 self.ext_inst(
761 result_type,
762 result_id,
763 extension_set,
764 crate::spirv::GLOp::Exp2 as spirv::Word,
765 args,
766 )
767 }
768 #[allow(clippy::too_many_arguments)]
769 pub fn gl_log2(
770 &mut self,
771 result_type: spirv::Word,
772 x: spirv::Word,
773 ) -> Result<spirv::Word, dr::Error> {
774 self.gl_log2_id(result_type, None, x)
775 }
776 #[allow(clippy::too_many_arguments)]
777 pub fn gl_log2_id(
778 &mut self,
779 result_type: spirv::Word,
780 result_id: Option<spirv::Word>,
781 x: spirv::Word,
782 ) -> Result<spirv::Word, dr::Error> {
783 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
784 #[allow(unused_mut)]
785 let mut args = vec![dr::Operand::IdRef(x)];
786 self.ext_inst(
787 result_type,
788 result_id,
789 extension_set,
790 crate::spirv::GLOp::Log2 as spirv::Word,
791 args,
792 )
793 }
794 #[allow(clippy::too_many_arguments)]
795 pub fn gl_sqrt(
796 &mut self,
797 result_type: spirv::Word,
798 x: spirv::Word,
799 ) -> Result<spirv::Word, dr::Error> {
800 self.gl_sqrt_id(result_type, None, x)
801 }
802 #[allow(clippy::too_many_arguments)]
803 pub fn gl_sqrt_id(
804 &mut self,
805 result_type: spirv::Word,
806 result_id: Option<spirv::Word>,
807 x: spirv::Word,
808 ) -> Result<spirv::Word, dr::Error> {
809 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
810 #[allow(unused_mut)]
811 let mut args = vec![dr::Operand::IdRef(x)];
812 self.ext_inst(
813 result_type,
814 result_id,
815 extension_set,
816 crate::spirv::GLOp::Sqrt as spirv::Word,
817 args,
818 )
819 }
820 #[allow(clippy::too_many_arguments)]
821 pub fn gl_inverse_sqrt(
822 &mut self,
823 result_type: spirv::Word,
824 x: spirv::Word,
825 ) -> Result<spirv::Word, dr::Error> {
826 self.gl_inverse_sqrt_id(result_type, None, x)
827 }
828 #[allow(clippy::too_many_arguments)]
829 pub fn gl_inverse_sqrt_id(
830 &mut self,
831 result_type: spirv::Word,
832 result_id: Option<spirv::Word>,
833 x: spirv::Word,
834 ) -> Result<spirv::Word, dr::Error> {
835 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
836 #[allow(unused_mut)]
837 let mut args = vec![dr::Operand::IdRef(x)];
838 self.ext_inst(
839 result_type,
840 result_id,
841 extension_set,
842 crate::spirv::GLOp::InverseSqrt as spirv::Word,
843 args,
844 )
845 }
846 #[allow(clippy::too_many_arguments)]
847 pub fn gl_determinant(
848 &mut self,
849 result_type: spirv::Word,
850 x: spirv::Word,
851 ) -> Result<spirv::Word, dr::Error> {
852 self.gl_determinant_id(result_type, None, x)
853 }
854 #[allow(clippy::too_many_arguments)]
855 pub fn gl_determinant_id(
856 &mut self,
857 result_type: spirv::Word,
858 result_id: Option<spirv::Word>,
859 x: spirv::Word,
860 ) -> Result<spirv::Word, dr::Error> {
861 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
862 #[allow(unused_mut)]
863 let mut args = vec![dr::Operand::IdRef(x)];
864 self.ext_inst(
865 result_type,
866 result_id,
867 extension_set,
868 crate::spirv::GLOp::Determinant as spirv::Word,
869 args,
870 )
871 }
872 #[allow(clippy::too_many_arguments)]
873 pub fn gl_matrix_inverse(
874 &mut self,
875 result_type: spirv::Word,
876 x: spirv::Word,
877 ) -> Result<spirv::Word, dr::Error> {
878 self.gl_matrix_inverse_id(result_type, None, x)
879 }
880 #[allow(clippy::too_many_arguments)]
881 pub fn gl_matrix_inverse_id(
882 &mut self,
883 result_type: spirv::Word,
884 result_id: Option<spirv::Word>,
885 x: spirv::Word,
886 ) -> Result<spirv::Word, dr::Error> {
887 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
888 #[allow(unused_mut)]
889 let mut args = vec![dr::Operand::IdRef(x)];
890 self.ext_inst(
891 result_type,
892 result_id,
893 extension_set,
894 crate::spirv::GLOp::MatrixInverse as spirv::Word,
895 args,
896 )
897 }
898 #[allow(clippy::too_many_arguments)]
899 pub fn gl_modf(
900 &mut self,
901 result_type: spirv::Word,
902 x: spirv::Word,
903 i: spirv::Word,
904 ) -> Result<spirv::Word, dr::Error> {
905 self.gl_modf_id(result_type, None, x, i)
906 }
907 #[allow(clippy::too_many_arguments)]
908 pub fn gl_modf_id(
909 &mut self,
910 result_type: spirv::Word,
911 result_id: Option<spirv::Word>,
912 x: spirv::Word,
913 i: spirv::Word,
914 ) -> Result<spirv::Word, dr::Error> {
915 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
916 #[allow(unused_mut)]
917 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(i)];
918 self.ext_inst(
919 result_type,
920 result_id,
921 extension_set,
922 crate::spirv::GLOp::Modf as spirv::Word,
923 args,
924 )
925 }
926 #[allow(clippy::too_many_arguments)]
927 pub fn gl_modf_struct(
928 &mut self,
929 result_type: spirv::Word,
930 x: spirv::Word,
931 ) -> Result<spirv::Word, dr::Error> {
932 self.gl_modf_struct_id(result_type, None, x)
933 }
934 #[allow(clippy::too_many_arguments)]
935 pub fn gl_modf_struct_id(
936 &mut self,
937 result_type: spirv::Word,
938 result_id: Option<spirv::Word>,
939 x: spirv::Word,
940 ) -> Result<spirv::Word, dr::Error> {
941 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
942 #[allow(unused_mut)]
943 let mut args = vec![dr::Operand::IdRef(x)];
944 self.ext_inst(
945 result_type,
946 result_id,
947 extension_set,
948 crate::spirv::GLOp::ModfStruct as spirv::Word,
949 args,
950 )
951 }
952 #[allow(clippy::too_many_arguments)]
953 pub fn gl_f_min(
954 &mut self,
955 result_type: spirv::Word,
956 x: spirv::Word,
957 y: spirv::Word,
958 ) -> Result<spirv::Word, dr::Error> {
959 self.gl_f_min_id(result_type, None, x, y)
960 }
961 #[allow(clippy::too_many_arguments)]
962 pub fn gl_f_min_id(
963 &mut self,
964 result_type: spirv::Word,
965 result_id: Option<spirv::Word>,
966 x: spirv::Word,
967 y: spirv::Word,
968 ) -> Result<spirv::Word, dr::Error> {
969 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
970 #[allow(unused_mut)]
971 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
972 self.ext_inst(
973 result_type,
974 result_id,
975 extension_set,
976 crate::spirv::GLOp::FMin as spirv::Word,
977 args,
978 )
979 }
980 #[allow(clippy::too_many_arguments)]
981 pub fn gl_u_min(
982 &mut self,
983 result_type: spirv::Word,
984 x: spirv::Word,
985 y: spirv::Word,
986 ) -> Result<spirv::Word, dr::Error> {
987 self.gl_u_min_id(result_type, None, x, y)
988 }
989 #[allow(clippy::too_many_arguments)]
990 pub fn gl_u_min_id(
991 &mut self,
992 result_type: spirv::Word,
993 result_id: Option<spirv::Word>,
994 x: spirv::Word,
995 y: spirv::Word,
996 ) -> Result<spirv::Word, dr::Error> {
997 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
998 #[allow(unused_mut)]
999 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1000 self.ext_inst(
1001 result_type,
1002 result_id,
1003 extension_set,
1004 crate::spirv::GLOp::UMin as spirv::Word,
1005 args,
1006 )
1007 }
1008 #[allow(clippy::too_many_arguments)]
1009 pub fn gl_s_min(
1010 &mut self,
1011 result_type: spirv::Word,
1012 x: spirv::Word,
1013 y: spirv::Word,
1014 ) -> Result<spirv::Word, dr::Error> {
1015 self.gl_s_min_id(result_type, None, x, y)
1016 }
1017 #[allow(clippy::too_many_arguments)]
1018 pub fn gl_s_min_id(
1019 &mut self,
1020 result_type: spirv::Word,
1021 result_id: Option<spirv::Word>,
1022 x: spirv::Word,
1023 y: spirv::Word,
1024 ) -> Result<spirv::Word, dr::Error> {
1025 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1026 #[allow(unused_mut)]
1027 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1028 self.ext_inst(
1029 result_type,
1030 result_id,
1031 extension_set,
1032 crate::spirv::GLOp::SMin as spirv::Word,
1033 args,
1034 )
1035 }
1036 #[allow(clippy::too_many_arguments)]
1037 pub fn gl_f_max(
1038 &mut self,
1039 result_type: spirv::Word,
1040 x: spirv::Word,
1041 y: spirv::Word,
1042 ) -> Result<spirv::Word, dr::Error> {
1043 self.gl_f_max_id(result_type, None, x, y)
1044 }
1045 #[allow(clippy::too_many_arguments)]
1046 pub fn gl_f_max_id(
1047 &mut self,
1048 result_type: spirv::Word,
1049 result_id: Option<spirv::Word>,
1050 x: spirv::Word,
1051 y: spirv::Word,
1052 ) -> Result<spirv::Word, dr::Error> {
1053 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1054 #[allow(unused_mut)]
1055 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1056 self.ext_inst(
1057 result_type,
1058 result_id,
1059 extension_set,
1060 crate::spirv::GLOp::FMax as spirv::Word,
1061 args,
1062 )
1063 }
1064 #[allow(clippy::too_many_arguments)]
1065 pub fn gl_u_max(
1066 &mut self,
1067 result_type: spirv::Word,
1068 x: spirv::Word,
1069 y: spirv::Word,
1070 ) -> Result<spirv::Word, dr::Error> {
1071 self.gl_u_max_id(result_type, None, x, y)
1072 }
1073 #[allow(clippy::too_many_arguments)]
1074 pub fn gl_u_max_id(
1075 &mut self,
1076 result_type: spirv::Word,
1077 result_id: Option<spirv::Word>,
1078 x: spirv::Word,
1079 y: spirv::Word,
1080 ) -> Result<spirv::Word, dr::Error> {
1081 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1082 #[allow(unused_mut)]
1083 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1084 self.ext_inst(
1085 result_type,
1086 result_id,
1087 extension_set,
1088 crate::spirv::GLOp::UMax as spirv::Word,
1089 args,
1090 )
1091 }
1092 #[allow(clippy::too_many_arguments)]
1093 pub fn gl_s_max(
1094 &mut self,
1095 result_type: spirv::Word,
1096 x: spirv::Word,
1097 y: spirv::Word,
1098 ) -> Result<spirv::Word, dr::Error> {
1099 self.gl_s_max_id(result_type, None, x, y)
1100 }
1101 #[allow(clippy::too_many_arguments)]
1102 pub fn gl_s_max_id(
1103 &mut self,
1104 result_type: spirv::Word,
1105 result_id: Option<spirv::Word>,
1106 x: spirv::Word,
1107 y: spirv::Word,
1108 ) -> Result<spirv::Word, dr::Error> {
1109 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1110 #[allow(unused_mut)]
1111 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1112 self.ext_inst(
1113 result_type,
1114 result_id,
1115 extension_set,
1116 crate::spirv::GLOp::SMax as spirv::Word,
1117 args,
1118 )
1119 }
1120 #[allow(clippy::too_many_arguments)]
1121 pub fn gl_f_clamp(
1122 &mut self,
1123 result_type: spirv::Word,
1124 x: spirv::Word,
1125 min_val: spirv::Word,
1126 max_val: spirv::Word,
1127 ) -> Result<spirv::Word, dr::Error> {
1128 self.gl_f_clamp_id(result_type, None, x, min_val, max_val)
1129 }
1130 #[allow(clippy::too_many_arguments)]
1131 pub fn gl_f_clamp_id(
1132 &mut self,
1133 result_type: spirv::Word,
1134 result_id: Option<spirv::Word>,
1135 x: spirv::Word,
1136 min_val: spirv::Word,
1137 max_val: spirv::Word,
1138 ) -> Result<spirv::Word, dr::Error> {
1139 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1140 #[allow(unused_mut)]
1141 let mut args = vec![
1142 dr::Operand::IdRef(x),
1143 dr::Operand::IdRef(min_val),
1144 dr::Operand::IdRef(max_val),
1145 ];
1146 self.ext_inst(
1147 result_type,
1148 result_id,
1149 extension_set,
1150 crate::spirv::GLOp::FClamp as spirv::Word,
1151 args,
1152 )
1153 }
1154 #[allow(clippy::too_many_arguments)]
1155 pub fn gl_u_clamp(
1156 &mut self,
1157 result_type: spirv::Word,
1158 x: spirv::Word,
1159 min_val: spirv::Word,
1160 max_val: spirv::Word,
1161 ) -> Result<spirv::Word, dr::Error> {
1162 self.gl_u_clamp_id(result_type, None, x, min_val, max_val)
1163 }
1164 #[allow(clippy::too_many_arguments)]
1165 pub fn gl_u_clamp_id(
1166 &mut self,
1167 result_type: spirv::Word,
1168 result_id: Option<spirv::Word>,
1169 x: spirv::Word,
1170 min_val: spirv::Word,
1171 max_val: spirv::Word,
1172 ) -> Result<spirv::Word, dr::Error> {
1173 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1174 #[allow(unused_mut)]
1175 let mut args = vec![
1176 dr::Operand::IdRef(x),
1177 dr::Operand::IdRef(min_val),
1178 dr::Operand::IdRef(max_val),
1179 ];
1180 self.ext_inst(
1181 result_type,
1182 result_id,
1183 extension_set,
1184 crate::spirv::GLOp::UClamp as spirv::Word,
1185 args,
1186 )
1187 }
1188 #[allow(clippy::too_many_arguments)]
1189 pub fn gl_s_clamp(
1190 &mut self,
1191 result_type: spirv::Word,
1192 x: spirv::Word,
1193 min_val: spirv::Word,
1194 max_val: spirv::Word,
1195 ) -> Result<spirv::Word, dr::Error> {
1196 self.gl_s_clamp_id(result_type, None, x, min_val, max_val)
1197 }
1198 #[allow(clippy::too_many_arguments)]
1199 pub fn gl_s_clamp_id(
1200 &mut self,
1201 result_type: spirv::Word,
1202 result_id: Option<spirv::Word>,
1203 x: spirv::Word,
1204 min_val: spirv::Word,
1205 max_val: spirv::Word,
1206 ) -> Result<spirv::Word, dr::Error> {
1207 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1208 #[allow(unused_mut)]
1209 let mut args = vec![
1210 dr::Operand::IdRef(x),
1211 dr::Operand::IdRef(min_val),
1212 dr::Operand::IdRef(max_val),
1213 ];
1214 self.ext_inst(
1215 result_type,
1216 result_id,
1217 extension_set,
1218 crate::spirv::GLOp::SClamp as spirv::Word,
1219 args,
1220 )
1221 }
1222 #[allow(clippy::too_many_arguments)]
1223 pub fn gl_f_mix(
1224 &mut self,
1225 result_type: spirv::Word,
1226 x: spirv::Word,
1227 y: spirv::Word,
1228 a: spirv::Word,
1229 ) -> Result<spirv::Word, dr::Error> {
1230 self.gl_f_mix_id(result_type, None, x, y, a)
1231 }
1232 #[allow(clippy::too_many_arguments)]
1233 pub fn gl_f_mix_id(
1234 &mut self,
1235 result_type: spirv::Word,
1236 result_id: Option<spirv::Word>,
1237 x: spirv::Word,
1238 y: spirv::Word,
1239 a: spirv::Word,
1240 ) -> Result<spirv::Word, dr::Error> {
1241 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1242 #[allow(unused_mut)]
1243 let mut args = vec![
1244 dr::Operand::IdRef(x),
1245 dr::Operand::IdRef(y),
1246 dr::Operand::IdRef(a),
1247 ];
1248 self.ext_inst(
1249 result_type,
1250 result_id,
1251 extension_set,
1252 crate::spirv::GLOp::FMix as spirv::Word,
1253 args,
1254 )
1255 }
1256 #[allow(clippy::too_many_arguments)]
1257 pub fn gl_i_mix(
1258 &mut self,
1259 result_type: spirv::Word,
1260 x: spirv::Word,
1261 y: spirv::Word,
1262 a: spirv::Word,
1263 ) -> Result<spirv::Word, dr::Error> {
1264 self.gl_i_mix_id(result_type, None, x, y, a)
1265 }
1266 #[allow(clippy::too_many_arguments)]
1267 pub fn gl_i_mix_id(
1268 &mut self,
1269 result_type: spirv::Word,
1270 result_id: Option<spirv::Word>,
1271 x: spirv::Word,
1272 y: spirv::Word,
1273 a: spirv::Word,
1274 ) -> Result<spirv::Word, dr::Error> {
1275 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1276 #[allow(unused_mut)]
1277 let mut args = vec![
1278 dr::Operand::IdRef(x),
1279 dr::Operand::IdRef(y),
1280 dr::Operand::IdRef(a),
1281 ];
1282 self.ext_inst(
1283 result_type,
1284 result_id,
1285 extension_set,
1286 crate::spirv::GLOp::IMix as spirv::Word,
1287 args,
1288 )
1289 }
1290 #[allow(clippy::too_many_arguments)]
1291 pub fn gl_step(
1292 &mut self,
1293 result_type: spirv::Word,
1294 edge: spirv::Word,
1295 x: spirv::Word,
1296 ) -> Result<spirv::Word, dr::Error> {
1297 self.gl_step_id(result_type, None, edge, x)
1298 }
1299 #[allow(clippy::too_many_arguments)]
1300 pub fn gl_step_id(
1301 &mut self,
1302 result_type: spirv::Word,
1303 result_id: Option<spirv::Word>,
1304 edge: spirv::Word,
1305 x: spirv::Word,
1306 ) -> Result<spirv::Word, dr::Error> {
1307 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1308 #[allow(unused_mut)]
1309 let mut args = vec![dr::Operand::IdRef(edge), dr::Operand::IdRef(x)];
1310 self.ext_inst(
1311 result_type,
1312 result_id,
1313 extension_set,
1314 crate::spirv::GLOp::Step as spirv::Word,
1315 args,
1316 )
1317 }
1318 #[allow(clippy::too_many_arguments)]
1319 pub fn gl_smooth_step(
1320 &mut self,
1321 result_type: spirv::Word,
1322 edge0: spirv::Word,
1323 edge1: spirv::Word,
1324 x: spirv::Word,
1325 ) -> Result<spirv::Word, dr::Error> {
1326 self.gl_smooth_step_id(result_type, None, edge0, edge1, x)
1327 }
1328 #[allow(clippy::too_many_arguments)]
1329 pub fn gl_smooth_step_id(
1330 &mut self,
1331 result_type: spirv::Word,
1332 result_id: Option<spirv::Word>,
1333 edge0: spirv::Word,
1334 edge1: spirv::Word,
1335 x: spirv::Word,
1336 ) -> Result<spirv::Word, dr::Error> {
1337 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1338 #[allow(unused_mut)]
1339 let mut args = vec![
1340 dr::Operand::IdRef(edge0),
1341 dr::Operand::IdRef(edge1),
1342 dr::Operand::IdRef(x),
1343 ];
1344 self.ext_inst(
1345 result_type,
1346 result_id,
1347 extension_set,
1348 crate::spirv::GLOp::SmoothStep as spirv::Word,
1349 args,
1350 )
1351 }
1352 #[allow(clippy::too_many_arguments)]
1353 pub fn gl_fma(
1354 &mut self,
1355 result_type: spirv::Word,
1356 a: spirv::Word,
1357 b: spirv::Word,
1358 c: spirv::Word,
1359 ) -> Result<spirv::Word, dr::Error> {
1360 self.gl_fma_id(result_type, None, a, b, c)
1361 }
1362 #[allow(clippy::too_many_arguments)]
1363 pub fn gl_fma_id(
1364 &mut self,
1365 result_type: spirv::Word,
1366 result_id: Option<spirv::Word>,
1367 a: spirv::Word,
1368 b: spirv::Word,
1369 c: spirv::Word,
1370 ) -> Result<spirv::Word, dr::Error> {
1371 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1372 #[allow(unused_mut)]
1373 let mut args = vec![
1374 dr::Operand::IdRef(a),
1375 dr::Operand::IdRef(b),
1376 dr::Operand::IdRef(c),
1377 ];
1378 self.ext_inst(
1379 result_type,
1380 result_id,
1381 extension_set,
1382 crate::spirv::GLOp::Fma as spirv::Word,
1383 args,
1384 )
1385 }
1386 #[allow(clippy::too_many_arguments)]
1387 pub fn gl_frexp(
1388 &mut self,
1389 result_type: spirv::Word,
1390 x: spirv::Word,
1391 exp: spirv::Word,
1392 ) -> Result<spirv::Word, dr::Error> {
1393 self.gl_frexp_id(result_type, None, x, exp)
1394 }
1395 #[allow(clippy::too_many_arguments)]
1396 pub fn gl_frexp_id(
1397 &mut self,
1398 result_type: spirv::Word,
1399 result_id: Option<spirv::Word>,
1400 x: spirv::Word,
1401 exp: spirv::Word,
1402 ) -> Result<spirv::Word, dr::Error> {
1403 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1404 #[allow(unused_mut)]
1405 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(exp)];
1406 self.ext_inst(
1407 result_type,
1408 result_id,
1409 extension_set,
1410 crate::spirv::GLOp::Frexp as spirv::Word,
1411 args,
1412 )
1413 }
1414 #[allow(clippy::too_many_arguments)]
1415 pub fn gl_frexp_struct(
1416 &mut self,
1417 result_type: spirv::Word,
1418 x: spirv::Word,
1419 ) -> Result<spirv::Word, dr::Error> {
1420 self.gl_frexp_struct_id(result_type, None, x)
1421 }
1422 #[allow(clippy::too_many_arguments)]
1423 pub fn gl_frexp_struct_id(
1424 &mut self,
1425 result_type: spirv::Word,
1426 result_id: Option<spirv::Word>,
1427 x: spirv::Word,
1428 ) -> Result<spirv::Word, dr::Error> {
1429 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1430 #[allow(unused_mut)]
1431 let mut args = vec![dr::Operand::IdRef(x)];
1432 self.ext_inst(
1433 result_type,
1434 result_id,
1435 extension_set,
1436 crate::spirv::GLOp::FrexpStruct as spirv::Word,
1437 args,
1438 )
1439 }
1440 #[allow(clippy::too_many_arguments)]
1441 pub fn gl_ldexp(
1442 &mut self,
1443 result_type: spirv::Word,
1444 x: spirv::Word,
1445 exp: spirv::Word,
1446 ) -> Result<spirv::Word, dr::Error> {
1447 self.gl_ldexp_id(result_type, None, x, exp)
1448 }
1449 #[allow(clippy::too_many_arguments)]
1450 pub fn gl_ldexp_id(
1451 &mut self,
1452 result_type: spirv::Word,
1453 result_id: Option<spirv::Word>,
1454 x: spirv::Word,
1455 exp: spirv::Word,
1456 ) -> Result<spirv::Word, dr::Error> {
1457 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1458 #[allow(unused_mut)]
1459 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(exp)];
1460 self.ext_inst(
1461 result_type,
1462 result_id,
1463 extension_set,
1464 crate::spirv::GLOp::Ldexp as spirv::Word,
1465 args,
1466 )
1467 }
1468 #[allow(clippy::too_many_arguments)]
1469 pub fn gl_pack_snorm4x8(
1470 &mut self,
1471 result_type: spirv::Word,
1472 v: spirv::Word,
1473 ) -> Result<spirv::Word, dr::Error> {
1474 self.gl_pack_snorm4x8_id(result_type, None, v)
1475 }
1476 #[allow(clippy::too_many_arguments)]
1477 pub fn gl_pack_snorm4x8_id(
1478 &mut self,
1479 result_type: spirv::Word,
1480 result_id: Option<spirv::Word>,
1481 v: spirv::Word,
1482 ) -> Result<spirv::Word, dr::Error> {
1483 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1484 #[allow(unused_mut)]
1485 let mut args = vec![dr::Operand::IdRef(v)];
1486 self.ext_inst(
1487 result_type,
1488 result_id,
1489 extension_set,
1490 crate::spirv::GLOp::PackSnorm4x8 as spirv::Word,
1491 args,
1492 )
1493 }
1494 #[allow(clippy::too_many_arguments)]
1495 pub fn gl_pack_unorm4x8(
1496 &mut self,
1497 result_type: spirv::Word,
1498 v: spirv::Word,
1499 ) -> Result<spirv::Word, dr::Error> {
1500 self.gl_pack_unorm4x8_id(result_type, None, v)
1501 }
1502 #[allow(clippy::too_many_arguments)]
1503 pub fn gl_pack_unorm4x8_id(
1504 &mut self,
1505 result_type: spirv::Word,
1506 result_id: Option<spirv::Word>,
1507 v: spirv::Word,
1508 ) -> Result<spirv::Word, dr::Error> {
1509 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1510 #[allow(unused_mut)]
1511 let mut args = vec![dr::Operand::IdRef(v)];
1512 self.ext_inst(
1513 result_type,
1514 result_id,
1515 extension_set,
1516 crate::spirv::GLOp::PackUnorm4x8 as spirv::Word,
1517 args,
1518 )
1519 }
1520 #[allow(clippy::too_many_arguments)]
1521 pub fn gl_pack_snorm2x16(
1522 &mut self,
1523 result_type: spirv::Word,
1524 v: spirv::Word,
1525 ) -> Result<spirv::Word, dr::Error> {
1526 self.gl_pack_snorm2x16_id(result_type, None, v)
1527 }
1528 #[allow(clippy::too_many_arguments)]
1529 pub fn gl_pack_snorm2x16_id(
1530 &mut self,
1531 result_type: spirv::Word,
1532 result_id: Option<spirv::Word>,
1533 v: spirv::Word,
1534 ) -> Result<spirv::Word, dr::Error> {
1535 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1536 #[allow(unused_mut)]
1537 let mut args = vec![dr::Operand::IdRef(v)];
1538 self.ext_inst(
1539 result_type,
1540 result_id,
1541 extension_set,
1542 crate::spirv::GLOp::PackSnorm2x16 as spirv::Word,
1543 args,
1544 )
1545 }
1546 #[allow(clippy::too_many_arguments)]
1547 pub fn gl_pack_unorm2x16(
1548 &mut self,
1549 result_type: spirv::Word,
1550 v: spirv::Word,
1551 ) -> Result<spirv::Word, dr::Error> {
1552 self.gl_pack_unorm2x16_id(result_type, None, v)
1553 }
1554 #[allow(clippy::too_many_arguments)]
1555 pub fn gl_pack_unorm2x16_id(
1556 &mut self,
1557 result_type: spirv::Word,
1558 result_id: Option<spirv::Word>,
1559 v: spirv::Word,
1560 ) -> Result<spirv::Word, dr::Error> {
1561 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1562 #[allow(unused_mut)]
1563 let mut args = vec![dr::Operand::IdRef(v)];
1564 self.ext_inst(
1565 result_type,
1566 result_id,
1567 extension_set,
1568 crate::spirv::GLOp::PackUnorm2x16 as spirv::Word,
1569 args,
1570 )
1571 }
1572 #[allow(clippy::too_many_arguments)]
1573 pub fn gl_pack_half2x16(
1574 &mut self,
1575 result_type: spirv::Word,
1576 v: spirv::Word,
1577 ) -> Result<spirv::Word, dr::Error> {
1578 self.gl_pack_half2x16_id(result_type, None, v)
1579 }
1580 #[allow(clippy::too_many_arguments)]
1581 pub fn gl_pack_half2x16_id(
1582 &mut self,
1583 result_type: spirv::Word,
1584 result_id: Option<spirv::Word>,
1585 v: spirv::Word,
1586 ) -> Result<spirv::Word, dr::Error> {
1587 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1588 #[allow(unused_mut)]
1589 let mut args = vec![dr::Operand::IdRef(v)];
1590 self.ext_inst(
1591 result_type,
1592 result_id,
1593 extension_set,
1594 crate::spirv::GLOp::PackHalf2x16 as spirv::Word,
1595 args,
1596 )
1597 }
1598 #[allow(clippy::too_many_arguments)]
1599 pub fn gl_pack_double2x32(
1600 &mut self,
1601 result_type: spirv::Word,
1602 v: spirv::Word,
1603 ) -> Result<spirv::Word, dr::Error> {
1604 self.gl_pack_double2x32_id(result_type, None, v)
1605 }
1606 #[allow(clippy::too_many_arguments)]
1607 pub fn gl_pack_double2x32_id(
1608 &mut self,
1609 result_type: spirv::Word,
1610 result_id: Option<spirv::Word>,
1611 v: spirv::Word,
1612 ) -> Result<spirv::Word, dr::Error> {
1613 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1614 #[allow(unused_mut)]
1615 let mut args = vec![dr::Operand::IdRef(v)];
1616 self.ext_inst(
1617 result_type,
1618 result_id,
1619 extension_set,
1620 crate::spirv::GLOp::PackDouble2x32 as spirv::Word,
1621 args,
1622 )
1623 }
1624 #[allow(clippy::too_many_arguments)]
1625 pub fn gl_unpack_snorm2x16(
1626 &mut self,
1627 result_type: spirv::Word,
1628 p: spirv::Word,
1629 ) -> Result<spirv::Word, dr::Error> {
1630 self.gl_unpack_snorm2x16_id(result_type, None, p)
1631 }
1632 #[allow(clippy::too_many_arguments)]
1633 pub fn gl_unpack_snorm2x16_id(
1634 &mut self,
1635 result_type: spirv::Word,
1636 result_id: Option<spirv::Word>,
1637 p: spirv::Word,
1638 ) -> Result<spirv::Word, dr::Error> {
1639 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1640 #[allow(unused_mut)]
1641 let mut args = vec![dr::Operand::IdRef(p)];
1642 self.ext_inst(
1643 result_type,
1644 result_id,
1645 extension_set,
1646 crate::spirv::GLOp::UnpackSnorm2x16 as spirv::Word,
1647 args,
1648 )
1649 }
1650 #[allow(clippy::too_many_arguments)]
1651 pub fn gl_unpack_unorm2x16(
1652 &mut self,
1653 result_type: spirv::Word,
1654 p: spirv::Word,
1655 ) -> Result<spirv::Word, dr::Error> {
1656 self.gl_unpack_unorm2x16_id(result_type, None, p)
1657 }
1658 #[allow(clippy::too_many_arguments)]
1659 pub fn gl_unpack_unorm2x16_id(
1660 &mut self,
1661 result_type: spirv::Word,
1662 result_id: Option<spirv::Word>,
1663 p: spirv::Word,
1664 ) -> Result<spirv::Word, dr::Error> {
1665 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1666 #[allow(unused_mut)]
1667 let mut args = vec![dr::Operand::IdRef(p)];
1668 self.ext_inst(
1669 result_type,
1670 result_id,
1671 extension_set,
1672 crate::spirv::GLOp::UnpackUnorm2x16 as spirv::Word,
1673 args,
1674 )
1675 }
1676 #[allow(clippy::too_many_arguments)]
1677 pub fn gl_unpack_half2x16(
1678 &mut self,
1679 result_type: spirv::Word,
1680 v: spirv::Word,
1681 ) -> Result<spirv::Word, dr::Error> {
1682 self.gl_unpack_half2x16_id(result_type, None, v)
1683 }
1684 #[allow(clippy::too_many_arguments)]
1685 pub fn gl_unpack_half2x16_id(
1686 &mut self,
1687 result_type: spirv::Word,
1688 result_id: Option<spirv::Word>,
1689 v: spirv::Word,
1690 ) -> Result<spirv::Word, dr::Error> {
1691 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1692 #[allow(unused_mut)]
1693 let mut args = vec![dr::Operand::IdRef(v)];
1694 self.ext_inst(
1695 result_type,
1696 result_id,
1697 extension_set,
1698 crate::spirv::GLOp::UnpackHalf2x16 as spirv::Word,
1699 args,
1700 )
1701 }
1702 #[allow(clippy::too_many_arguments)]
1703 pub fn gl_unpack_snorm4x8(
1704 &mut self,
1705 result_type: spirv::Word,
1706 p: spirv::Word,
1707 ) -> Result<spirv::Word, dr::Error> {
1708 self.gl_unpack_snorm4x8_id(result_type, None, p)
1709 }
1710 #[allow(clippy::too_many_arguments)]
1711 pub fn gl_unpack_snorm4x8_id(
1712 &mut self,
1713 result_type: spirv::Word,
1714 result_id: Option<spirv::Word>,
1715 p: spirv::Word,
1716 ) -> Result<spirv::Word, dr::Error> {
1717 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1718 #[allow(unused_mut)]
1719 let mut args = vec![dr::Operand::IdRef(p)];
1720 self.ext_inst(
1721 result_type,
1722 result_id,
1723 extension_set,
1724 crate::spirv::GLOp::UnpackSnorm4x8 as spirv::Word,
1725 args,
1726 )
1727 }
1728 #[allow(clippy::too_many_arguments)]
1729 pub fn gl_unpack_unorm4x8(
1730 &mut self,
1731 result_type: spirv::Word,
1732 p: spirv::Word,
1733 ) -> Result<spirv::Word, dr::Error> {
1734 self.gl_unpack_unorm4x8_id(result_type, None, p)
1735 }
1736 #[allow(clippy::too_many_arguments)]
1737 pub fn gl_unpack_unorm4x8_id(
1738 &mut self,
1739 result_type: spirv::Word,
1740 result_id: Option<spirv::Word>,
1741 p: spirv::Word,
1742 ) -> Result<spirv::Word, dr::Error> {
1743 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1744 #[allow(unused_mut)]
1745 let mut args = vec![dr::Operand::IdRef(p)];
1746 self.ext_inst(
1747 result_type,
1748 result_id,
1749 extension_set,
1750 crate::spirv::GLOp::UnpackUnorm4x8 as spirv::Word,
1751 args,
1752 )
1753 }
1754 #[allow(clippy::too_many_arguments)]
1755 pub fn gl_unpack_double2x32(
1756 &mut self,
1757 result_type: spirv::Word,
1758 v: spirv::Word,
1759 ) -> Result<spirv::Word, dr::Error> {
1760 self.gl_unpack_double2x32_id(result_type, None, v)
1761 }
1762 #[allow(clippy::too_many_arguments)]
1763 pub fn gl_unpack_double2x32_id(
1764 &mut self,
1765 result_type: spirv::Word,
1766 result_id: Option<spirv::Word>,
1767 v: spirv::Word,
1768 ) -> Result<spirv::Word, dr::Error> {
1769 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1770 #[allow(unused_mut)]
1771 let mut args = vec![dr::Operand::IdRef(v)];
1772 self.ext_inst(
1773 result_type,
1774 result_id,
1775 extension_set,
1776 crate::spirv::GLOp::UnpackDouble2x32 as spirv::Word,
1777 args,
1778 )
1779 }
1780 #[allow(clippy::too_many_arguments)]
1781 pub fn gl_length(
1782 &mut self,
1783 result_type: spirv::Word,
1784 x: spirv::Word,
1785 ) -> Result<spirv::Word, dr::Error> {
1786 self.gl_length_id(result_type, None, x)
1787 }
1788 #[allow(clippy::too_many_arguments)]
1789 pub fn gl_length_id(
1790 &mut self,
1791 result_type: spirv::Word,
1792 result_id: Option<spirv::Word>,
1793 x: spirv::Word,
1794 ) -> Result<spirv::Word, dr::Error> {
1795 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1796 #[allow(unused_mut)]
1797 let mut args = vec![dr::Operand::IdRef(x)];
1798 self.ext_inst(
1799 result_type,
1800 result_id,
1801 extension_set,
1802 crate::spirv::GLOp::Length as spirv::Word,
1803 args,
1804 )
1805 }
1806 #[allow(clippy::too_many_arguments)]
1807 pub fn gl_distance(
1808 &mut self,
1809 result_type: spirv::Word,
1810 p0: spirv::Word,
1811 p1: spirv::Word,
1812 ) -> Result<spirv::Word, dr::Error> {
1813 self.gl_distance_id(result_type, None, p0, p1)
1814 }
1815 #[allow(clippy::too_many_arguments)]
1816 pub fn gl_distance_id(
1817 &mut self,
1818 result_type: spirv::Word,
1819 result_id: Option<spirv::Word>,
1820 p0: spirv::Word,
1821 p1: spirv::Word,
1822 ) -> Result<spirv::Word, dr::Error> {
1823 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1824 #[allow(unused_mut)]
1825 let mut args = vec![dr::Operand::IdRef(p0), dr::Operand::IdRef(p1)];
1826 self.ext_inst(
1827 result_type,
1828 result_id,
1829 extension_set,
1830 crate::spirv::GLOp::Distance as spirv::Word,
1831 args,
1832 )
1833 }
1834 #[allow(clippy::too_many_arguments)]
1835 pub fn gl_cross(
1836 &mut self,
1837 result_type: spirv::Word,
1838 x: spirv::Word,
1839 y: spirv::Word,
1840 ) -> Result<spirv::Word, dr::Error> {
1841 self.gl_cross_id(result_type, None, x, y)
1842 }
1843 #[allow(clippy::too_many_arguments)]
1844 pub fn gl_cross_id(
1845 &mut self,
1846 result_type: spirv::Word,
1847 result_id: Option<spirv::Word>,
1848 x: spirv::Word,
1849 y: spirv::Word,
1850 ) -> Result<spirv::Word, dr::Error> {
1851 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1852 #[allow(unused_mut)]
1853 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
1854 self.ext_inst(
1855 result_type,
1856 result_id,
1857 extension_set,
1858 crate::spirv::GLOp::Cross as spirv::Word,
1859 args,
1860 )
1861 }
1862 #[allow(clippy::too_many_arguments)]
1863 pub fn gl_normalize(
1864 &mut self,
1865 result_type: spirv::Word,
1866 x: spirv::Word,
1867 ) -> Result<spirv::Word, dr::Error> {
1868 self.gl_normalize_id(result_type, None, x)
1869 }
1870 #[allow(clippy::too_many_arguments)]
1871 pub fn gl_normalize_id(
1872 &mut self,
1873 result_type: spirv::Word,
1874 result_id: Option<spirv::Word>,
1875 x: spirv::Word,
1876 ) -> Result<spirv::Word, dr::Error> {
1877 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1878 #[allow(unused_mut)]
1879 let mut args = vec![dr::Operand::IdRef(x)];
1880 self.ext_inst(
1881 result_type,
1882 result_id,
1883 extension_set,
1884 crate::spirv::GLOp::Normalize as spirv::Word,
1885 args,
1886 )
1887 }
1888 #[allow(clippy::too_many_arguments)]
1889 pub fn gl_face_forward(
1890 &mut self,
1891 result_type: spirv::Word,
1892 n: spirv::Word,
1893 i: spirv::Word,
1894 nref: spirv::Word,
1895 ) -> Result<spirv::Word, dr::Error> {
1896 self.gl_face_forward_id(result_type, None, n, i, nref)
1897 }
1898 #[allow(clippy::too_many_arguments)]
1899 pub fn gl_face_forward_id(
1900 &mut self,
1901 result_type: spirv::Word,
1902 result_id: Option<spirv::Word>,
1903 n: spirv::Word,
1904 i: spirv::Word,
1905 nref: spirv::Word,
1906 ) -> Result<spirv::Word, dr::Error> {
1907 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1908 #[allow(unused_mut)]
1909 let mut args = vec![
1910 dr::Operand::IdRef(n),
1911 dr::Operand::IdRef(i),
1912 dr::Operand::IdRef(nref),
1913 ];
1914 self.ext_inst(
1915 result_type,
1916 result_id,
1917 extension_set,
1918 crate::spirv::GLOp::FaceForward as spirv::Word,
1919 args,
1920 )
1921 }
1922 #[allow(clippy::too_many_arguments)]
1923 pub fn gl_reflect(
1924 &mut self,
1925 result_type: spirv::Word,
1926 i: spirv::Word,
1927 n: spirv::Word,
1928 ) -> Result<spirv::Word, dr::Error> {
1929 self.gl_reflect_id(result_type, None, i, n)
1930 }
1931 #[allow(clippy::too_many_arguments)]
1932 pub fn gl_reflect_id(
1933 &mut self,
1934 result_type: spirv::Word,
1935 result_id: Option<spirv::Word>,
1936 i: spirv::Word,
1937 n: spirv::Word,
1938 ) -> Result<spirv::Word, dr::Error> {
1939 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1940 #[allow(unused_mut)]
1941 let mut args = vec![dr::Operand::IdRef(i), dr::Operand::IdRef(n)];
1942 self.ext_inst(
1943 result_type,
1944 result_id,
1945 extension_set,
1946 crate::spirv::GLOp::Reflect as spirv::Word,
1947 args,
1948 )
1949 }
1950 #[allow(clippy::too_many_arguments)]
1951 pub fn gl_refract(
1952 &mut self,
1953 result_type: spirv::Word,
1954 i: spirv::Word,
1955 n: spirv::Word,
1956 eta: spirv::Word,
1957 ) -> Result<spirv::Word, dr::Error> {
1958 self.gl_refract_id(result_type, None, i, n, eta)
1959 }
1960 #[allow(clippy::too_many_arguments)]
1961 pub fn gl_refract_id(
1962 &mut self,
1963 result_type: spirv::Word,
1964 result_id: Option<spirv::Word>,
1965 i: spirv::Word,
1966 n: spirv::Word,
1967 eta: spirv::Word,
1968 ) -> Result<spirv::Word, dr::Error> {
1969 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
1970 #[allow(unused_mut)]
1971 let mut args = vec![
1972 dr::Operand::IdRef(i),
1973 dr::Operand::IdRef(n),
1974 dr::Operand::IdRef(eta),
1975 ];
1976 self.ext_inst(
1977 result_type,
1978 result_id,
1979 extension_set,
1980 crate::spirv::GLOp::Refract as spirv::Word,
1981 args,
1982 )
1983 }
1984 #[allow(clippy::too_many_arguments)]
1985 pub fn gl_find_i_lsb(
1986 &mut self,
1987 result_type: spirv::Word,
1988 value: spirv::Word,
1989 ) -> Result<spirv::Word, dr::Error> {
1990 self.gl_find_i_lsb_id(result_type, None, value)
1991 }
1992 #[allow(clippy::too_many_arguments)]
1993 pub fn gl_find_i_lsb_id(
1994 &mut self,
1995 result_type: spirv::Word,
1996 result_id: Option<spirv::Word>,
1997 value: spirv::Word,
1998 ) -> Result<spirv::Word, dr::Error> {
1999 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2000 #[allow(unused_mut)]
2001 let mut args = vec![dr::Operand::IdRef(value)];
2002 self.ext_inst(
2003 result_type,
2004 result_id,
2005 extension_set,
2006 crate::spirv::GLOp::FindILsb as spirv::Word,
2007 args,
2008 )
2009 }
2010 #[allow(clippy::too_many_arguments)]
2011 pub fn gl_find_s_msb(
2012 &mut self,
2013 result_type: spirv::Word,
2014 value: spirv::Word,
2015 ) -> Result<spirv::Word, dr::Error> {
2016 self.gl_find_s_msb_id(result_type, None, value)
2017 }
2018 #[allow(clippy::too_many_arguments)]
2019 pub fn gl_find_s_msb_id(
2020 &mut self,
2021 result_type: spirv::Word,
2022 result_id: Option<spirv::Word>,
2023 value: spirv::Word,
2024 ) -> Result<spirv::Word, dr::Error> {
2025 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2026 #[allow(unused_mut)]
2027 let mut args = vec![dr::Operand::IdRef(value)];
2028 self.ext_inst(
2029 result_type,
2030 result_id,
2031 extension_set,
2032 crate::spirv::GLOp::FindSMsb as spirv::Word,
2033 args,
2034 )
2035 }
2036 #[allow(clippy::too_many_arguments)]
2037 pub fn gl_find_u_msb(
2038 &mut self,
2039 result_type: spirv::Word,
2040 value: spirv::Word,
2041 ) -> Result<spirv::Word, dr::Error> {
2042 self.gl_find_u_msb_id(result_type, None, value)
2043 }
2044 #[allow(clippy::too_many_arguments)]
2045 pub fn gl_find_u_msb_id(
2046 &mut self,
2047 result_type: spirv::Word,
2048 result_id: Option<spirv::Word>,
2049 value: spirv::Word,
2050 ) -> Result<spirv::Word, dr::Error> {
2051 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2052 #[allow(unused_mut)]
2053 let mut args = vec![dr::Operand::IdRef(value)];
2054 self.ext_inst(
2055 result_type,
2056 result_id,
2057 extension_set,
2058 crate::spirv::GLOp::FindUMsb as spirv::Word,
2059 args,
2060 )
2061 }
2062 #[allow(clippy::too_many_arguments)]
2063 pub fn gl_interpolate_at_centroid(
2064 &mut self,
2065 result_type: spirv::Word,
2066 interpolant: spirv::Word,
2067 ) -> Result<spirv::Word, dr::Error> {
2068 self.gl_interpolate_at_centroid_id(result_type, None, interpolant)
2069 }
2070 #[allow(clippy::too_many_arguments)]
2071 pub fn gl_interpolate_at_centroid_id(
2072 &mut self,
2073 result_type: spirv::Word,
2074 result_id: Option<spirv::Word>,
2075 interpolant: spirv::Word,
2076 ) -> Result<spirv::Word, dr::Error> {
2077 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2078 #[allow(unused_mut)]
2079 let mut args = vec![dr::Operand::IdRef(interpolant)];
2080 self.ext_inst(
2081 result_type,
2082 result_id,
2083 extension_set,
2084 crate::spirv::GLOp::InterpolateAtCentroid as spirv::Word,
2085 args,
2086 )
2087 }
2088 #[allow(clippy::too_many_arguments)]
2089 pub fn gl_interpolate_at_sample(
2090 &mut self,
2091 result_type: spirv::Word,
2092 interpolant: spirv::Word,
2093 sample: spirv::Word,
2094 ) -> Result<spirv::Word, dr::Error> {
2095 self.gl_interpolate_at_sample_id(result_type, None, interpolant, sample)
2096 }
2097 #[allow(clippy::too_many_arguments)]
2098 pub fn gl_interpolate_at_sample_id(
2099 &mut self,
2100 result_type: spirv::Word,
2101 result_id: Option<spirv::Word>,
2102 interpolant: spirv::Word,
2103 sample: spirv::Word,
2104 ) -> Result<spirv::Word, dr::Error> {
2105 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2106 #[allow(unused_mut)]
2107 let mut args = vec![dr::Operand::IdRef(interpolant), dr::Operand::IdRef(sample)];
2108 self.ext_inst(
2109 result_type,
2110 result_id,
2111 extension_set,
2112 crate::spirv::GLOp::InterpolateAtSample as spirv::Word,
2113 args,
2114 )
2115 }
2116 #[allow(clippy::too_many_arguments)]
2117 pub fn gl_interpolate_at_offset(
2118 &mut self,
2119 result_type: spirv::Word,
2120 interpolant: spirv::Word,
2121 offset: spirv::Word,
2122 ) -> Result<spirv::Word, dr::Error> {
2123 self.gl_interpolate_at_offset_id(result_type, None, interpolant, offset)
2124 }
2125 #[allow(clippy::too_many_arguments)]
2126 pub fn gl_interpolate_at_offset_id(
2127 &mut self,
2128 result_type: spirv::Word,
2129 result_id: Option<spirv::Word>,
2130 interpolant: spirv::Word,
2131 offset: spirv::Word,
2132 ) -> Result<spirv::Word, dr::Error> {
2133 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2134 #[allow(unused_mut)]
2135 let mut args = vec![dr::Operand::IdRef(interpolant), dr::Operand::IdRef(offset)];
2136 self.ext_inst(
2137 result_type,
2138 result_id,
2139 extension_set,
2140 crate::spirv::GLOp::InterpolateAtOffset as spirv::Word,
2141 args,
2142 )
2143 }
2144 #[allow(clippy::too_many_arguments)]
2145 pub fn gl_n_min(
2146 &mut self,
2147 result_type: spirv::Word,
2148 x: spirv::Word,
2149 y: spirv::Word,
2150 ) -> Result<spirv::Word, dr::Error> {
2151 self.gl_n_min_id(result_type, None, x, y)
2152 }
2153 #[allow(clippy::too_many_arguments)]
2154 pub fn gl_n_min_id(
2155 &mut self,
2156 result_type: spirv::Word,
2157 result_id: Option<spirv::Word>,
2158 x: spirv::Word,
2159 y: spirv::Word,
2160 ) -> Result<spirv::Word, dr::Error> {
2161 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2162 #[allow(unused_mut)]
2163 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2164 self.ext_inst(
2165 result_type,
2166 result_id,
2167 extension_set,
2168 crate::spirv::GLOp::NMin as spirv::Word,
2169 args,
2170 )
2171 }
2172 #[allow(clippy::too_many_arguments)]
2173 pub fn gl_n_max(
2174 &mut self,
2175 result_type: spirv::Word,
2176 x: spirv::Word,
2177 y: spirv::Word,
2178 ) -> Result<spirv::Word, dr::Error> {
2179 self.gl_n_max_id(result_type, None, x, y)
2180 }
2181 #[allow(clippy::too_many_arguments)]
2182 pub fn gl_n_max_id(
2183 &mut self,
2184 result_type: spirv::Word,
2185 result_id: Option<spirv::Word>,
2186 x: spirv::Word,
2187 y: spirv::Word,
2188 ) -> Result<spirv::Word, dr::Error> {
2189 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2190 #[allow(unused_mut)]
2191 let mut args = vec![dr::Operand::IdRef(x), dr::Operand::IdRef(y)];
2192 self.ext_inst(
2193 result_type,
2194 result_id,
2195 extension_set,
2196 crate::spirv::GLOp::NMax as spirv::Word,
2197 args,
2198 )
2199 }
2200 #[allow(clippy::too_many_arguments)]
2201 pub fn gl_n_clamp(
2202 &mut self,
2203 result_type: spirv::Word,
2204 x: spirv::Word,
2205 min_val: spirv::Word,
2206 max_val: spirv::Word,
2207 ) -> Result<spirv::Word, dr::Error> {
2208 self.gl_n_clamp_id(result_type, None, x, min_val, max_val)
2209 }
2210 #[allow(clippy::too_many_arguments)]
2211 pub fn gl_n_clamp_id(
2212 &mut self,
2213 result_type: spirv::Word,
2214 result_id: Option<spirv::Word>,
2215 x: spirv::Word,
2216 min_val: spirv::Word,
2217 max_val: spirv::Word,
2218 ) -> Result<spirv::Word, dr::Error> {
2219 let extension_set = super::ext_inst_import(self, "GLSL.std.450");
2220 #[allow(unused_mut)]
2221 let mut args = vec![
2222 dr::Operand::IdRef(x),
2223 dr::Operand::IdRef(min_val),
2224 dr::Operand::IdRef(max_val),
2225 ];
2226 self.ext_inst(
2227 result_type,
2228 result_id,
2229 extension_set,
2230 crate::spirv::GLOp::NClamp as spirv::Word,
2231 args,
2232 )
2233 }
2234}