citro3d/render/
effect.rs

1//! Render effects and behaviour used by the GPU.
2
3/// Test functions.
4#[repr(u8)]
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6#[doc(alias = "GPU_TESTFUNC")]
7pub enum TestFunction {
8    /// Never pass.
9    #[doc(alias = "GPU_NEVER")]
10    Never = ctru_sys::GPU_NEVER,
11
12    /// Always pass.
13    #[doc(alias = "GPU_ALWAYS")]
14    Always = ctru_sys::GPU_ALWAYS,
15
16    /// Pass if equal.
17    #[doc(alias = "GPU_EQUAL")]
18    Equal = ctru_sys::GPU_EQUAL,
19
20    /// Pass if not equal.
21    #[doc(alias = "GPU_NOTEQUAL")]
22    NotEqual = ctru_sys::GPU_NOTEQUAL,
23
24    /// Pass if less than.
25    #[doc(alias = "GPU_LESS")]
26    Less = ctru_sys::GPU_LESS,
27
28    /// Pass if less than or equal.
29    #[doc(alias = "GPU_LEQUAL")]
30    LessOrEqual = ctru_sys::GPU_LEQUAL,
31
32    /// Pass if greater than.
33    #[doc(alias = "GPU_GREATER")]
34    Greater = ctru_sys::GPU_GREATER,
35
36    /// Pass if greater than or equal.
37    #[doc(alias = "GPU_GEQUAL")]
38    GreaterOrEqual = ctru_sys::GPU_GEQUAL,
39}
40
41impl TryFrom<u8> for TestFunction {
42    type Error = String;
43
44    fn try_from(value: u8) -> Result<Self, Self::Error> {
45        match value {
46            ctru_sys::GPU_NEVER => Ok(Self::Never),
47            ctru_sys::GPU_ALWAYS => Ok(Self::Always),
48            ctru_sys::GPU_EQUAL => Ok(Self::Equal),
49            ctru_sys::GPU_NOTEQUAL => Ok(Self::NotEqual),
50            ctru_sys::GPU_LESS => Ok(Self::Less),
51            ctru_sys::GPU_LEQUAL => Ok(Self::LessOrEqual),
52            ctru_sys::GPU_GREATER => Ok(Self::Greater),
53            ctru_sys::GPU_GEQUAL => Ok(Self::GreaterOrEqual),
54            _ => Err("invalid value for TestFunction".to_string()),
55        }
56    }
57}
58/// Early depth test functions.
59#[repr(u8)]
60#[derive(Debug, Clone, Copy, PartialEq, Eq)]
61#[doc(alias = "GPU_EARLYDEPTHFUNC")]
62pub enum EarlyDepthFunction {
63    /// Pass if greater than or equal.
64    #[doc(alias = "GPU_EARLYDEPTH_GEQUAL")]
65    GreaterOrEqual = ctru_sys::GPU_EARLYDEPTH_GEQUAL,
66
67    /// Pass if greater than.
68    #[doc(alias = "GPU_EARLYDEPTH_GREATER")]
69    Greater = ctru_sys::GPU_EARLYDEPTH_GREATER,
70
71    /// Pass if less than or equal.
72    #[doc(alias = "GPU_EARLYDEPTH_LEQUAL")]
73    LessOrEqual = ctru_sys::GPU_EARLYDEPTH_LEQUAL,
74
75    /// Pass if less than.
76    #[doc(alias = "GPU_EARLYDEPTH_LESS")]
77    Less = ctru_sys::GPU_EARLYDEPTH_LESS,
78}
79
80impl TryFrom<u8> for EarlyDepthFunction {
81    type Error = String;
82
83    fn try_from(value: u8) -> Result<Self, Self::Error> {
84        match value {
85            ctru_sys::GPU_EARLYDEPTH_GEQUAL => Ok(Self::GreaterOrEqual),
86            ctru_sys::GPU_EARLYDEPTH_GREATER => Ok(Self::Greater),
87            ctru_sys::GPU_EARLYDEPTH_LEQUAL => Ok(Self::LessOrEqual),
88            ctru_sys::GPU_EARLYDEPTH_LESS => Ok(Self::Less),
89            _ => Err("invalid value for EarlyDepthFunction".to_string()),
90        }
91    }
92}
93
94/// Scissor test modes.
95#[repr(u8)]
96#[derive(Debug, Clone, Copy, PartialEq, Eq)]
97#[doc(alias = "GPU_SCISSORMODE")]
98pub enum ScissorMode {
99    /// Disable.
100    #[doc(alias = "GPU_SCISSOR_DISABLE")]
101    Disable = ctru_sys::GPU_SCISSOR_DISABLE,
102
103    /// Exclude pixels inside the scissor box.
104    #[doc(alias = "GPU_SCISSOR_INVERT")]
105    Invert = ctru_sys::GPU_SCISSOR_INVERT,
106
107    /// Exclude pixels outside of the scissor box.
108    #[doc(alias = "GPU_SCISSOR_NORMAL")]
109    Normal = ctru_sys::GPU_SCISSOR_NORMAL,
110}
111
112impl TryFrom<u8> for ScissorMode {
113    type Error = String;
114    fn try_from(value: u8) -> Result<Self, Self::Error> {
115        match value {
116            ctru_sys::GPU_SCISSOR_DISABLE => Ok(Self::Disable),
117            ctru_sys::GPU_SCISSOR_INVERT => Ok(Self::Invert),
118            ctru_sys::GPU_SCISSOR_NORMAL => Ok(Self::Normal),
119            _ => Err("invalid value for ScissorMode".to_string()),
120        }
121    }
122}
123
124/// Stencil operations.
125#[repr(u8)]
126#[derive(Debug, Clone, Copy, PartialEq, Eq)]
127#[doc(alias = "GPU_STENCILOP")]
128pub enum StencilOperation {
129    /// Keep old value. (old_stencil)
130    #[doc(alias = "GPU_STENCIL_KEEP")]
131    Keep = ctru_sys::GPU_STENCIL_KEEP,
132
133    /// Zero. (0)
134    #[doc(alias = "GPU_STENCIL_ZERO")]
135    Zero = ctru_sys::GPU_STENCIL_ZERO,
136
137    /// Replace value. (ref)
138    #[doc(alias = "GPU_STENCIL_REPLACE")]
139    Replace = ctru_sys::GPU_STENCIL_REPLACE,
140
141    /// Increment value. (old_stencil + 1 saturated to [0, 255])
142    #[doc(alias = "GPU_STENCIL_INCR")]
143    Increment = ctru_sys::GPU_STENCIL_INCR,
144
145    /// Decrement value. (old_stencil - 1 saturated to [0, 255])
146    #[doc(alias = "GPU_STENCIL_DECR")]
147    Decrement = ctru_sys::GPU_STENCIL_DECR,
148
149    /// Invert value. (~old_stencil)
150    #[doc(alias = "GPU_STENCIL_INVERT")]
151    Invert = ctru_sys::GPU_STENCIL_INVERT,
152
153    /// Increment value. (old_stencil + 1)
154    #[doc(alias = "GPU_STENCIL_INCR_WRAP")]
155    IncrementWrap = ctru_sys::GPU_STENCIL_INCR_WRAP,
156
157    /// Decrement value. (old_stencil - 1)
158    #[doc(alias = "GPU_STENCIL_DECR_WRAP")]
159    DecrementWrap = ctru_sys::GPU_STENCIL_DECR_WRAP,
160}
161
162impl TryFrom<u8> for StencilOperation {
163    type Error = String;
164    fn try_from(value: u8) -> Result<Self, Self::Error> {
165        match value {
166            ctru_sys::GPU_STENCIL_KEEP => Ok(Self::Keep),
167            ctru_sys::GPU_STENCIL_ZERO => Ok(Self::Zero),
168            ctru_sys::GPU_STENCIL_REPLACE => Ok(Self::Replace),
169            ctru_sys::GPU_STENCIL_INCR => Ok(Self::Increment),
170            ctru_sys::GPU_STENCIL_DECR => Ok(Self::Decrement),
171            ctru_sys::GPU_STENCIL_INVERT => Ok(Self::Invert),
172            ctru_sys::GPU_STENCIL_INCR_WRAP => Ok(Self::IncrementWrap),
173            ctru_sys::GPU_STENCIL_DECR_WRAP => Ok(Self::DecrementWrap),
174            _ => Err("invalid value for StencilOperation".to_string()),
175        }
176    }
177}
178
179/// Pixel write mask.
180#[repr(u8)]
181#[derive(Debug, Clone, Copy, PartialEq, Eq)]
182#[doc(alias = "GPU_WRITEMASK")]
183pub enum WriteMask {
184    /// Write red.
185    #[doc(alias = "GPU_WRITE_RED")]
186    Red = ctru_sys::GPU_WRITE_RED,
187
188    /// Write green.
189    #[doc(alias = "GPU_WRITE_GREEN")]
190    Green = ctru_sys::GPU_WRITE_GREEN,
191
192    /// Write blue.
193    #[doc(alias = "GPU_WRITE_BLUE")]
194    Blue = ctru_sys::GPU_WRITE_BLUE,
195
196    /// Write alpha.
197    #[doc(alias = "GPU_WRITE_ALPHA")]
198    Alpha = ctru_sys::GPU_WRITE_ALPHA,
199
200    /// Write depth.
201    #[doc(alias = "GPU_WRITE_DEPTH")]
202    Depth = ctru_sys::GPU_WRITE_DEPTH,
203
204    /// Write all color components.
205    #[doc(alias = "GPU_WRITE_COLOR")]
206    Color = ctru_sys::GPU_WRITE_COLOR,
207
208    /// Write all components.
209    #[doc(alias = "GPU_WRITE_ALL")]
210    All = ctru_sys::GPU_WRITE_ALL,
211}
212
213impl TryFrom<u8> for WriteMask {
214    type Error = String;
215    fn try_from(value: u8) -> Result<Self, Self::Error> {
216        match value {
217            ctru_sys::GPU_WRITE_RED => Ok(Self::Red),
218            ctru_sys::GPU_WRITE_GREEN => Ok(Self::Green),
219            ctru_sys::GPU_WRITE_BLUE => Ok(Self::Blue),
220            ctru_sys::GPU_WRITE_ALPHA => Ok(Self::Alpha),
221            ctru_sys::GPU_WRITE_DEPTH => Ok(Self::Depth),
222            ctru_sys::GPU_WRITE_COLOR => Ok(Self::Color),
223            ctru_sys::GPU_WRITE_ALL => Ok(Self::All),
224            _ => Err("invalid value for WriteMask".to_string()),
225        }
226    }
227}
228
229/// Blend modes.
230#[repr(u8)]
231#[derive(Debug, Clone, Copy, PartialEq, Eq)]
232#[doc(alias = "GPU_BLENDEQUATION")]
233pub enum BlendEquation {
234    /// Add colors.
235    #[doc(alias = "GPU_BLEND_ADD")]
236    Add = ctru_sys::GPU_BLEND_ADD,
237
238    /// Subtract colors.
239    #[doc(alias = "GPU_BLEND_SUBTRACT")]
240    Subtract = ctru_sys::GPU_BLEND_SUBTRACT,
241
242    /// Reverse-subtract colors.
243    #[doc(alias = "GPU_BLEND_REVERSE_SUBTRACT")]
244    ReverseSubtract = ctru_sys::GPU_BLEND_REVERSE_SUBTRACT,
245
246    /// Use the minimum color.
247    #[doc(alias = "GPU_BLEND_MIN")]
248    Min = ctru_sys::GPU_BLEND_MIN,
249
250    /// Use the maximum color.
251    #[doc(alias = "GPU_BLEND_MAX")]
252    Max = ctru_sys::GPU_BLEND_MAX,
253}
254
255impl TryFrom<u8> for BlendEquation {
256    type Error = String;
257    fn try_from(value: u8) -> Result<Self, Self::Error> {
258        match value {
259            ctru_sys::GPU_BLEND_ADD => Ok(Self::Add),
260            ctru_sys::GPU_BLEND_SUBTRACT => Ok(Self::Subtract),
261            ctru_sys::GPU_BLEND_REVERSE_SUBTRACT => Ok(Self::ReverseSubtract),
262            ctru_sys::GPU_BLEND_MIN => Ok(Self::Min),
263            ctru_sys::GPU_BLEND_MAX => Ok(Self::Max),
264            _ => Err("invalid value for BlendEquation".to_string()),
265        }
266    }
267}
268
269/// Blend factors.
270#[repr(u8)]
271#[derive(Debug, Clone, Copy, PartialEq, Eq)]
272#[doc(alias = "GPU_BLENDFACTOR")]
273pub enum BlendFactor {
274    /// Zero.
275    #[doc(alias = "GPU_ZERO")]
276    Zero = ctru_sys::GPU_ZERO,
277
278    /// One.
279    #[doc(alias = "GPU_ONE")]
280    One = ctru_sys::GPU_ONE,
281
282    /// Source color.
283    #[doc(alias = "GPU_SRC_COLOR")]
284    SrcColor = ctru_sys::GPU_SRC_COLOR,
285
286    /// Source color - 1.
287    #[doc(alias = "GPU_ONE_MINUS_SRC_COLOR")]
288    OneMinusSrcColor = ctru_sys::GPU_ONE_MINUS_SRC_COLOR,
289
290    /// Destination color.
291    #[doc(alias = "GPU_DST_COLOR")]
292    DstColor = ctru_sys::GPU_DST_COLOR,
293
294    /// Destination color - 1.
295    #[doc(alias = "GPU_ONE_MINUS_DST_COLOR")]
296    OneMinusDstColor = ctru_sys::GPU_ONE_MINUS_DST_COLOR,
297
298    /// Source alpha.
299    #[doc(alias = "GPU_SRC_ALPHA")]
300    SrcAlpha = ctru_sys::GPU_SRC_ALPHA,
301
302    /// Source alpha - 1.
303    #[doc(alias = "GPU_ONE_MINUS_SRC_ALPHA")]
304    OneMinusSrcAlpha = ctru_sys::GPU_ONE_MINUS_SRC_ALPHA,
305
306    /// Destination alpha.
307    #[doc(alias = "GPU_DST_ALPHA")]
308    DstAlpha = ctru_sys::GPU_DST_ALPHA,
309
310    /// Destination alpha - 1.
311    #[doc(alias = "GPU_ONE_MINUS_DST_ALPHA")]
312    OneMinusDstAlpha = ctru_sys::GPU_ONE_MINUS_DST_ALPHA,
313
314    /// Constant color.
315    #[doc(alias = "GPU_CONSTANT_COLOR")]
316    ConstantColor = ctru_sys::GPU_CONSTANT_COLOR,
317
318    /// Constant color - 1.
319    #[doc(alias = "GPU_ONE_MINUS_CONSTANT_COLOR")]
320    OneMinusConstantColor = ctru_sys::GPU_ONE_MINUS_CONSTANT_COLOR,
321
322    /// Constant alpha.
323    #[doc(alias = "GPU_CONSTANT_ALPHA")]
324    ConstantAlpha = ctru_sys::GPU_CONSTANT_ALPHA,
325
326    /// Constant alpha - 1.
327    #[doc(alias = "GPU_ONE_MINUS_CONSTANT_ALPHA")]
328    OneMinusConstantAlpha = ctru_sys::GPU_ONE_MINUS_CONSTANT_ALPHA,
329
330    /// Saturated alpha.
331    #[doc(alias = "GPU_SRC_ALPHA_SATURATE")]
332    SrcAlphaSaturate = ctru_sys::GPU_SRC_ALPHA_SATURATE,
333}
334
335impl TryFrom<u8> for BlendFactor {
336    type Error = String;
337    fn try_from(value: u8) -> Result<Self, Self::Error> {
338        match value {
339            ctru_sys::GPU_ZERO => Ok(Self::Zero),
340            ctru_sys::GPU_ONE => Ok(Self::One),
341            ctru_sys::GPU_SRC_COLOR => Ok(Self::SrcColor),
342            ctru_sys::GPU_ONE_MINUS_SRC_COLOR => Ok(Self::OneMinusSrcColor),
343            ctru_sys::GPU_DST_COLOR => Ok(Self::DstColor),
344            ctru_sys::GPU_ONE_MINUS_DST_COLOR => Ok(Self::OneMinusDstColor),
345            ctru_sys::GPU_SRC_ALPHA => Ok(Self::SrcAlpha),
346            ctru_sys::GPU_ONE_MINUS_SRC_ALPHA => Ok(Self::OneMinusSrcAlpha),
347            ctru_sys::GPU_DST_ALPHA => Ok(Self::DstAlpha),
348            ctru_sys::GPU_ONE_MINUS_DST_ALPHA => Ok(Self::OneMinusDstAlpha),
349            ctru_sys::GPU_CONSTANT_COLOR => Ok(Self::ConstantColor),
350            ctru_sys::GPU_ONE_MINUS_CONSTANT_COLOR => Ok(Self::OneMinusConstantColor),
351            ctru_sys::GPU_CONSTANT_ALPHA => Ok(Self::ConstantAlpha),
352            ctru_sys::GPU_ONE_MINUS_CONSTANT_ALPHA => Ok(Self::OneMinusConstantAlpha),
353            ctru_sys::GPU_SRC_ALPHA_SATURATE => Ok(Self::SrcAlphaSaturate),
354            _ => Err("invalid value for BlendFactor".to_string()),
355        }
356    }
357}
358
359/// Logical operations.
360#[repr(u8)]
361#[derive(Debug, Clone, Copy, PartialEq, Eq)]
362#[doc(alias = "GPU_LOGICOP")]
363pub enum LogicOperation {
364    /// Clear.
365    #[doc(alias = "GPU_LOGICOP_CLEAR")]
366    Clear = ctru_sys::GPU_LOGICOP_CLEAR,
367
368    /// Bitwise AND.
369    #[doc(alias = "GPU_LOGICOP_AND")]
370    And = ctru_sys::GPU_LOGICOP_AND,
371
372    /// Reverse bitwise AND.
373    #[doc(alias = "GPU_LOGICOP_AND_REVERSE")]
374    AndReverse = ctru_sys::GPU_LOGICOP_AND_REVERSE,
375
376    /// Copy.
377    #[doc(alias = "GPU_LOGICOP_COPY")]
378    Copy = ctru_sys::GPU_LOGICOP_COPY,
379
380    /// Set.
381    #[doc(alias = "GPU_LOGICOP_SET")]
382    Set = ctru_sys::GPU_LOGICOP_SET,
383
384    /// Inverted copy.
385    #[doc(alias = "GPU_LOGICOP_COPY_INVERTED")]
386    CopyInverted = ctru_sys::GPU_LOGICOP_COPY_INVERTED,
387
388    /// No operation.
389    #[doc(alias = "GPU_LOGICOP_NOOP")]
390    Noop = ctru_sys::GPU_LOGICOP_NOOP,
391
392    /// Invert.
393    #[doc(alias = "GPU_LOGICOP_INVERT")]
394    Invert = ctru_sys::GPU_LOGICOP_INVERT,
395
396    /// Bitwise NAND.
397    #[doc(alias = "GPU_LOGICOP_NAND")]
398    Nand = ctru_sys::GPU_LOGICOP_NAND,
399
400    /// Bitwise OR.
401    #[doc(alias = "GPU_LOGICOP_OR")]
402    Or = ctru_sys::GPU_LOGICOP_OR,
403
404    /// Bitwise NOR.
405    #[doc(alias = "GPU_LOGICOP_NOR")]
406    Nor = ctru_sys::GPU_LOGICOP_NOR,
407
408    /// Bitwise XOR.
409    #[doc(alias = "GPU_LOGICOP_XOR")]
410    Xor = ctru_sys::GPU_LOGICOP_XOR,
411
412    /// Equivalent.
413    #[doc(alias = "GPU_LOGICOP_EQUIV")]
414    Equiv = ctru_sys::GPU_LOGICOP_EQUIV,
415
416    /// Inverted bitwise AND.
417    #[doc(alias = "GPU_LOGICOP_AND_INVERTED")]
418    AndInverted = ctru_sys::GPU_LOGICOP_AND_INVERTED,
419
420    /// Reverse bitwise OR.
421    #[doc(alias = "GPU_LOGICOP_OR_REVERSE")]
422    OrReverse = ctru_sys::GPU_LOGICOP_OR_REVERSE,
423
424    /// Inverted bitwise OR.
425    #[doc(alias = "GPU_LOGICOP_OR_INVERTED")]
426    OrInverted = ctru_sys::GPU_LOGICOP_OR_INVERTED,
427}
428
429impl TryFrom<u8> for LogicOperation {
430    type Error = String;
431    fn try_from(value: u8) -> Result<Self, Self::Error> {
432        match value {
433            ctru_sys::GPU_LOGICOP_CLEAR => Ok(Self::Clear),
434            ctru_sys::GPU_LOGICOP_AND => Ok(Self::And),
435            ctru_sys::GPU_LOGICOP_AND_REVERSE => Ok(Self::AndReverse),
436            ctru_sys::GPU_LOGICOP_COPY => Ok(Self::Copy),
437            ctru_sys::GPU_LOGICOP_SET => Ok(Self::Set),
438            ctru_sys::GPU_LOGICOP_COPY_INVERTED => Ok(Self::CopyInverted),
439            ctru_sys::GPU_LOGICOP_NOOP => Ok(Self::Noop),
440            ctru_sys::GPU_LOGICOP_INVERT => Ok(Self::Invert),
441            ctru_sys::GPU_LOGICOP_NAND => Ok(Self::Nand),
442            ctru_sys::GPU_LOGICOP_OR => Ok(Self::Or),
443            ctru_sys::GPU_LOGICOP_NOR => Ok(Self::Nor),
444            ctru_sys::GPU_LOGICOP_XOR => Ok(Self::Xor),
445            ctru_sys::GPU_LOGICOP_EQUIV => Ok(Self::Equiv),
446            ctru_sys::GPU_LOGICOP_AND_INVERTED => Ok(Self::AndInverted),
447            ctru_sys::GPU_LOGICOP_OR_REVERSE => Ok(Self::OrReverse),
448            ctru_sys::GPU_LOGICOP_OR_INVERTED => Ok(Self::OrInverted),
449            _ => Err("invalid value for LogicOperation".to_string()),
450        }
451    }
452}
453
454/// Cull modes.
455#[repr(u8)]
456#[derive(Debug, Clone, Copy, PartialEq, Eq)]
457#[doc(alias = "GPU_CULLMODE")]
458pub enum CullMode {
459    /// Disabled.
460    #[doc(alias = "GPU_CULL_NONE")]
461    None = ctru_sys::GPU_CULL_NONE,
462
463    /// Front, counter-clockwise.
464    #[doc(alias = "GPU_CULL_FRONT_CCW")]
465    FrontCounterClockwise = ctru_sys::GPU_CULL_FRONT_CCW,
466
467    /// Back, counter-clockwise.
468    #[doc(alias = "GPU_CULL_BACK_CCW")]
469    BackCounterClockwise = ctru_sys::GPU_CULL_BACK_CCW,
470}
471
472impl TryFrom<u8> for CullMode {
473    type Error = String;
474    fn try_from(value: u8) -> Result<Self, Self::Error> {
475        match value {
476            ctru_sys::GPU_CULL_NONE => Ok(Self::None),
477            ctru_sys::GPU_CULL_FRONT_CCW => Ok(Self::FrontCounterClockwise),
478            ctru_sys::GPU_CULL_BACK_CCW => Ok(Self::BackCounterClockwise),
479            _ => Err("invalid value for CullMode".to_string()),
480        }
481    }
482}
483
484/// Fragment operation modes.
485#[repr(u8)]
486#[derive(Debug, Clone, Copy, PartialEq, Eq)]
487#[doc(alias = "GPU_FRAGOPMODE")]
488pub enum FragmentOperationMode {
489    /// OpenGL mode.
490    #[doc(alias = "GPU_FRAGOPMODE_GL")]
491    Gl = ctru_sys::GPU_FRAGOPMODE_GL,
492
493    /// Gas mode (?).
494    #[doc(alias = "GPU_FRAGOPMODE_GAS_ACC")]
495    GasAcc = ctru_sys::GPU_FRAGOPMODE_GAS_ACC,
496
497    /// Shadow mode (?).
498    #[doc(alias = "GPU_FRAGOPMODE_SHADOW")]
499    Shadow = ctru_sys::GPU_FRAGOPMODE_SHADOW,
500}
501
502impl TryFrom<u8> for FragmentOperationMode {
503    type Error = String;
504    fn try_from(value: u8) -> Result<Self, Self::Error> {
505        match value {
506            ctru_sys::GPU_FRAGOPMODE_GL => Ok(Self::Gl),
507            ctru_sys::GPU_FRAGOPMODE_GAS_ACC => Ok(Self::GasAcc),
508            ctru_sys::GPU_FRAGOPMODE_SHADOW => Ok(Self::Shadow),
509            _ => Err("invalid value for FragmentOperationMode".to_string()),
510        }
511    }
512}
citro3d/render/effect.rs

citro3d/render/
effect.rs
