1#[derive(Default)]
3pub struct ComputePipelineAssetAccessor(PropertyPath);
4
5impl FieldAccessor for ComputePipelineAssetAccessor {
6 fn new(property_path: PropertyPath) -> Self {
7 ComputePipelineAssetAccessor(property_path)
8 }
9}
10
11impl RecordAccessor for ComputePipelineAssetAccessor {
12 fn schema_name() -> &'static str {
13 "ComputePipelineAsset"
14 }
15}
16
17impl ComputePipelineAssetAccessor {
18 pub fn entry_name(&self) -> StringFieldAccessor {
19 StringFieldAccessor::new(self.0.push("entry_name"))
20 }
21
22 pub fn shader_module(&self) -> AssetRefFieldAccessor {
23 AssetRefFieldAccessor::new(self.0.push("shader_module"))
24 }
25}
26pub struct ComputePipelineAssetRef<'a>(PropertyPath, DataContainerRef<'a>);
27
28impl<'a> FieldRef<'a> for ComputePipelineAssetRef<'a> {
29 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
30 ComputePipelineAssetRef(property_path, data_container)
31 }
32}
33
34impl<'a> RecordRef for ComputePipelineAssetRef<'a> {
35 fn schema_name() -> &'static str {
36 "ComputePipelineAsset"
37 }
38}
39
40impl<'a> ComputePipelineAssetRef<'a> {
41 pub fn entry_name(&self) -> StringFieldRef {
42 StringFieldRef::new(self.0.push("entry_name"), self.1.clone())
43 }
44
45 pub fn shader_module(&self) -> AssetRefFieldRef {
46 AssetRefFieldRef::new(self.0.push("shader_module"), self.1.clone())
47 }
48}
49pub struct ComputePipelineAssetRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
50
51impl<'a> FieldRefMut<'a> for ComputePipelineAssetRefMut<'a> {
52 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
53 ComputePipelineAssetRefMut(property_path, data_container.clone())
54 }
55}
56
57impl<'a> RecordRefMut for ComputePipelineAssetRefMut<'a> {
58 fn schema_name() -> &'static str {
59 "ComputePipelineAsset"
60 }
61}
62
63impl<'a> ComputePipelineAssetRefMut<'a> {
64 pub fn entry_name(self: &'a Self) -> StringFieldRefMut {
65 StringFieldRefMut::new(self.0.push("entry_name"), &self.1)
66 }
67
68 pub fn shader_module(self: &'a Self) -> AssetRefFieldRefMut {
69 AssetRefFieldRefMut::new(self.0.push("shader_module"), &self.1)
70 }
71}
72pub struct ComputePipelineAssetRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
73
74impl Field for ComputePipelineAssetRecord {
75 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
76 ComputePipelineAssetRecord(property_path, data_container.clone())
77 }
78}
79
80impl Record for ComputePipelineAssetRecord {
81 type Reader<'a> = ComputePipelineAssetRef<'a>;
82 type Writer<'a> = ComputePipelineAssetRefMut<'a>;
83 type Accessor = ComputePipelineAssetAccessor;
84
85 fn schema_name() -> &'static str {
86 "ComputePipelineAsset"
87 }
88}
89
90impl ComputePipelineAssetRecord {
91 pub fn entry_name(self: &Self) -> StringField {
92 StringField::new(self.0.push("entry_name"), &self.1)
93 }
94
95 pub fn shader_module(self: &Self) -> AssetRefField {
96 AssetRefField::new(self.0.push("shader_module"), &self.1)
97 }
98}
99#[derive(Default)]
100pub struct GpuCompressedImageAssetAccessor(PropertyPath);
101
102impl FieldAccessor for GpuCompressedImageAssetAccessor {
103 fn new(property_path: PropertyPath) -> Self {
104 GpuCompressedImageAssetAccessor(property_path)
105 }
106}
107
108impl RecordAccessor for GpuCompressedImageAssetAccessor {
109 fn schema_name() -> &'static str {
110 "GpuCompressedImageAsset"
111 }
112}
113
114impl GpuCompressedImageAssetAccessor {
115}
116pub struct GpuCompressedImageAssetRef<'a>(PropertyPath, DataContainerRef<'a>);
117
118impl<'a> FieldRef<'a> for GpuCompressedImageAssetRef<'a> {
119 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
120 GpuCompressedImageAssetRef(property_path, data_container)
121 }
122}
123
124impl<'a> RecordRef for GpuCompressedImageAssetRef<'a> {
125 fn schema_name() -> &'static str {
126 "GpuCompressedImageAsset"
127 }
128}
129
130impl<'a> GpuCompressedImageAssetRef<'a> {
131}
132pub struct GpuCompressedImageAssetRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
133
134impl<'a> FieldRefMut<'a> for GpuCompressedImageAssetRefMut<'a> {
135 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
136 GpuCompressedImageAssetRefMut(property_path, data_container.clone())
137 }
138}
139
140impl<'a> RecordRefMut for GpuCompressedImageAssetRefMut<'a> {
141 fn schema_name() -> &'static str {
142 "GpuCompressedImageAsset"
143 }
144}
145
146impl<'a> GpuCompressedImageAssetRefMut<'a> {
147}
148pub struct GpuCompressedImageAssetRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
149
150impl Field for GpuCompressedImageAssetRecord {
151 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
152 GpuCompressedImageAssetRecord(property_path, data_container.clone())
153 }
154}
155
156impl Record for GpuCompressedImageAssetRecord {
157 type Reader<'a> = GpuCompressedImageAssetRef<'a>;
158 type Writer<'a> = GpuCompressedImageAssetRefMut<'a>;
159 type Accessor = GpuCompressedImageAssetAccessor;
160
161 fn schema_name() -> &'static str {
162 "GpuCompressedImageAsset"
163 }
164}
165
166impl GpuCompressedImageAssetRecord {
167}
168#[derive(Default)]
169pub struct GpuCompressedImageImportedDataAccessor(PropertyPath);
170
171impl FieldAccessor for GpuCompressedImageImportedDataAccessor {
172 fn new(property_path: PropertyPath) -> Self {
173 GpuCompressedImageImportedDataAccessor(property_path)
174 }
175}
176
177impl RecordAccessor for GpuCompressedImageImportedDataAccessor {
178 fn schema_name() -> &'static str {
179 "GpuCompressedImageImportedData"
180 }
181}
182
183impl GpuCompressedImageImportedDataAccessor {
184 pub fn data_layers(&self) -> DynamicArrayFieldAccessor::<GpuImageSubresourceLayerAccessor> {
185 DynamicArrayFieldAccessor::<GpuImageSubresourceLayerAccessor>::new(self.0.push("data_layers"))
186 }
187
188 pub fn data_single_buffer(&self) -> BytesFieldAccessor {
189 BytesFieldAccessor::new(self.0.push("data_single_buffer"))
190 }
191
192 pub fn format(&self) -> EnumFieldAccessor::<GpuImageAssetDataFormatEnum> {
193 EnumFieldAccessor::<GpuImageAssetDataFormatEnum>::new(self.0.push("format"))
194 }
195
196 pub fn height(&self) -> U32FieldAccessor {
197 U32FieldAccessor::new(self.0.push("height"))
198 }
199
200 pub fn is_cube_texture(&self) -> BooleanFieldAccessor {
201 BooleanFieldAccessor::new(self.0.push("is_cube_texture"))
202 }
203
204 pub fn width(&self) -> U32FieldAccessor {
205 U32FieldAccessor::new(self.0.push("width"))
206 }
207}
208pub struct GpuCompressedImageImportedDataRef<'a>(PropertyPath, DataContainerRef<'a>);
209
210impl<'a> FieldRef<'a> for GpuCompressedImageImportedDataRef<'a> {
211 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
212 GpuCompressedImageImportedDataRef(property_path, data_container)
213 }
214}
215
216impl<'a> RecordRef for GpuCompressedImageImportedDataRef<'a> {
217 fn schema_name() -> &'static str {
218 "GpuCompressedImageImportedData"
219 }
220}
221
222impl<'a> GpuCompressedImageImportedDataRef<'a> {
223 pub fn data_layers(&self) -> DynamicArrayFieldRef::<GpuImageSubresourceLayerRef> {
224 DynamicArrayFieldRef::<GpuImageSubresourceLayerRef>::new(self.0.push("data_layers"), self.1.clone())
225 }
226
227 pub fn data_single_buffer(&self) -> BytesFieldRef {
228 BytesFieldRef::new(self.0.push("data_single_buffer"), self.1.clone())
229 }
230
231 pub fn format(&self) -> EnumFieldRef::<GpuImageAssetDataFormatEnum> {
232 EnumFieldRef::<GpuImageAssetDataFormatEnum>::new(self.0.push("format"), self.1.clone())
233 }
234
235 pub fn height(&self) -> U32FieldRef {
236 U32FieldRef::new(self.0.push("height"), self.1.clone())
237 }
238
239 pub fn is_cube_texture(&self) -> BooleanFieldRef {
240 BooleanFieldRef::new(self.0.push("is_cube_texture"), self.1.clone())
241 }
242
243 pub fn width(&self) -> U32FieldRef {
244 U32FieldRef::new(self.0.push("width"), self.1.clone())
245 }
246}
247pub struct GpuCompressedImageImportedDataRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
248
249impl<'a> FieldRefMut<'a> for GpuCompressedImageImportedDataRefMut<'a> {
250 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
251 GpuCompressedImageImportedDataRefMut(property_path, data_container.clone())
252 }
253}
254
255impl<'a> RecordRefMut for GpuCompressedImageImportedDataRefMut<'a> {
256 fn schema_name() -> &'static str {
257 "GpuCompressedImageImportedData"
258 }
259}
260
261impl<'a> GpuCompressedImageImportedDataRefMut<'a> {
262 pub fn data_layers(self: &'a Self) -> DynamicArrayFieldRefMut::<GpuImageSubresourceLayerRefMut> {
263 DynamicArrayFieldRefMut::<GpuImageSubresourceLayerRefMut>::new(self.0.push("data_layers"), &self.1)
264 }
265
266 pub fn data_single_buffer(self: &'a Self) -> BytesFieldRefMut {
267 BytesFieldRefMut::new(self.0.push("data_single_buffer"), &self.1)
268 }
269
270 pub fn format(self: &'a Self) -> EnumFieldRefMut::<GpuImageAssetDataFormatEnum> {
271 EnumFieldRefMut::<GpuImageAssetDataFormatEnum>::new(self.0.push("format"), &self.1)
272 }
273
274 pub fn height(self: &'a Self) -> U32FieldRefMut {
275 U32FieldRefMut::new(self.0.push("height"), &self.1)
276 }
277
278 pub fn is_cube_texture(self: &'a Self) -> BooleanFieldRefMut {
279 BooleanFieldRefMut::new(self.0.push("is_cube_texture"), &self.1)
280 }
281
282 pub fn width(self: &'a Self) -> U32FieldRefMut {
283 U32FieldRefMut::new(self.0.push("width"), &self.1)
284 }
285}
286pub struct GpuCompressedImageImportedDataRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
287
288impl Field for GpuCompressedImageImportedDataRecord {
289 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
290 GpuCompressedImageImportedDataRecord(property_path, data_container.clone())
291 }
292}
293
294impl Record for GpuCompressedImageImportedDataRecord {
295 type Reader<'a> = GpuCompressedImageImportedDataRef<'a>;
296 type Writer<'a> = GpuCompressedImageImportedDataRefMut<'a>;
297 type Accessor = GpuCompressedImageImportedDataAccessor;
298
299 fn schema_name() -> &'static str {
300 "GpuCompressedImageImportedData"
301 }
302}
303
304impl GpuCompressedImageImportedDataRecord {
305 pub fn data_layers(self: &Self) -> DynamicArrayField::<GpuImageSubresourceLayerRecord> {
306 DynamicArrayField::<GpuImageSubresourceLayerRecord>::new(self.0.push("data_layers"), &self.1)
307 }
308
309 pub fn data_single_buffer(self: &Self) -> BytesField {
310 BytesField::new(self.0.push("data_single_buffer"), &self.1)
311 }
312
313 pub fn format(self: &Self) -> EnumField::<GpuImageAssetDataFormatEnum> {
314 EnumField::<GpuImageAssetDataFormatEnum>::new(self.0.push("format"), &self.1)
315 }
316
317 pub fn height(self: &Self) -> U32Field {
318 U32Field::new(self.0.push("height"), &self.1)
319 }
320
321 pub fn is_cube_texture(self: &Self) -> BooleanField {
322 BooleanField::new(self.0.push("is_cube_texture"), &self.1)
323 }
324
325 pub fn width(self: &Self) -> U32Field {
326 U32Field::new(self.0.push("width"), &self.1)
327 }
328}
329#[derive(Default)]
330pub struct GpuImageAssetAccessor(PropertyPath);
331
332impl FieldAccessor for GpuImageAssetAccessor {
333 fn new(property_path: PropertyPath) -> Self {
334 GpuImageAssetAccessor(property_path)
335 }
336}
337
338impl RecordAccessor for GpuImageAssetAccessor {
339 fn schema_name() -> &'static str {
340 "GpuImageAsset"
341 }
342}
343
344impl GpuImageAssetAccessor {
345 pub fn basis_compression(&self) -> BooleanFieldAccessor {
346 BooleanFieldAccessor::new(self.0.push("basis_compression"))
347 }
348
349 pub fn basis_compression_settings(&self) -> GpuImageBasisCompressionSettingsAccessor {
350 GpuImageBasisCompressionSettingsAccessor::new(self.0.push("basis_compression_settings"))
351 }
352
353 pub fn color_space(&self) -> EnumFieldAccessor::<GpuImageColorSpaceEnum> {
354 EnumFieldAccessor::<GpuImageColorSpaceEnum>::new(self.0.push("color_space"))
355 }
356
357 pub fn mip_generation(&self) -> EnumFieldAccessor::<GpuImageMipGenerationEnum> {
358 EnumFieldAccessor::<GpuImageMipGenerationEnum>::new(self.0.push("mip_generation"))
359 }
360}
361pub struct GpuImageAssetRef<'a>(PropertyPath, DataContainerRef<'a>);
362
363impl<'a> FieldRef<'a> for GpuImageAssetRef<'a> {
364 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
365 GpuImageAssetRef(property_path, data_container)
366 }
367}
368
369impl<'a> RecordRef for GpuImageAssetRef<'a> {
370 fn schema_name() -> &'static str {
371 "GpuImageAsset"
372 }
373}
374
375impl<'a> GpuImageAssetRef<'a> {
376 pub fn basis_compression(&self) -> BooleanFieldRef {
377 BooleanFieldRef::new(self.0.push("basis_compression"), self.1.clone())
378 }
379
380 pub fn basis_compression_settings(&self) -> GpuImageBasisCompressionSettingsRef {
381 GpuImageBasisCompressionSettingsRef::new(self.0.push("basis_compression_settings"), self.1.clone())
382 }
383
384 pub fn color_space(&self) -> EnumFieldRef::<GpuImageColorSpaceEnum> {
385 EnumFieldRef::<GpuImageColorSpaceEnum>::new(self.0.push("color_space"), self.1.clone())
386 }
387
388 pub fn mip_generation(&self) -> EnumFieldRef::<GpuImageMipGenerationEnum> {
389 EnumFieldRef::<GpuImageMipGenerationEnum>::new(self.0.push("mip_generation"), self.1.clone())
390 }
391}
392pub struct GpuImageAssetRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
393
394impl<'a> FieldRefMut<'a> for GpuImageAssetRefMut<'a> {
395 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
396 GpuImageAssetRefMut(property_path, data_container.clone())
397 }
398}
399
400impl<'a> RecordRefMut for GpuImageAssetRefMut<'a> {
401 fn schema_name() -> &'static str {
402 "GpuImageAsset"
403 }
404}
405
406impl<'a> GpuImageAssetRefMut<'a> {
407 pub fn basis_compression(self: &'a Self) -> BooleanFieldRefMut {
408 BooleanFieldRefMut::new(self.0.push("basis_compression"), &self.1)
409 }
410
411 pub fn basis_compression_settings(self: &'a Self) -> GpuImageBasisCompressionSettingsRefMut {
412 GpuImageBasisCompressionSettingsRefMut::new(self.0.push("basis_compression_settings"), &self.1)
413 }
414
415 pub fn color_space(self: &'a Self) -> EnumFieldRefMut::<GpuImageColorSpaceEnum> {
416 EnumFieldRefMut::<GpuImageColorSpaceEnum>::new(self.0.push("color_space"), &self.1)
417 }
418
419 pub fn mip_generation(self: &'a Self) -> EnumFieldRefMut::<GpuImageMipGenerationEnum> {
420 EnumFieldRefMut::<GpuImageMipGenerationEnum>::new(self.0.push("mip_generation"), &self.1)
421 }
422}
423pub struct GpuImageAssetRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
424
425impl Field for GpuImageAssetRecord {
426 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
427 GpuImageAssetRecord(property_path, data_container.clone())
428 }
429}
430
431impl Record for GpuImageAssetRecord {
432 type Reader<'a> = GpuImageAssetRef<'a>;
433 type Writer<'a> = GpuImageAssetRefMut<'a>;
434 type Accessor = GpuImageAssetAccessor;
435
436 fn schema_name() -> &'static str {
437 "GpuImageAsset"
438 }
439}
440
441impl GpuImageAssetRecord {
442 pub fn basis_compression(self: &Self) -> BooleanField {
443 BooleanField::new(self.0.push("basis_compression"), &self.1)
444 }
445
446 pub fn basis_compression_settings(self: &Self) -> GpuImageBasisCompressionSettingsRecord {
447 GpuImageBasisCompressionSettingsRecord::new(self.0.push("basis_compression_settings"), &self.1)
448 }
449
450 pub fn color_space(self: &Self) -> EnumField::<GpuImageColorSpaceEnum> {
451 EnumField::<GpuImageColorSpaceEnum>::new(self.0.push("color_space"), &self.1)
452 }
453
454 pub fn mip_generation(self: &Self) -> EnumField::<GpuImageMipGenerationEnum> {
455 EnumField::<GpuImageMipGenerationEnum>::new(self.0.push("mip_generation"), &self.1)
456 }
457}
458#[derive(Copy, Clone)]
459pub enum GpuImageAssetDataFormatEnum {
460 RGBA32_Linear,
461 RGBA32_Srgb,
462 Basis_Linear,
463 Basis_Srgb,
464 BC1_UNorm_Linear,
465 BC1_UNorm_Srgb,
466 BC2_UNorm_Linear,
467 BC2_UNorm_Srgb,
468 BC3_UNorm_Linear,
469 BC3_UNorm_Srgb,
470 BC4_UNorm,
471 BC4_SNorm,
472 BC5_UNorm,
473 BC5_SNorm,
474 BC6H_UFloat,
475 BC6H_SFloat,
476 BC7_Unorm_Linear,
477 BC7_Unorm_Srgb,
478}
479
480impl Enum for GpuImageAssetDataFormatEnum {
481 fn to_symbol_name(&self) -> &'static str {
482 match self {
483 GpuImageAssetDataFormatEnum::RGBA32_Linear => "RGBA32_Linear",
484 GpuImageAssetDataFormatEnum::RGBA32_Srgb => "RGBA32_Srgb",
485 GpuImageAssetDataFormatEnum::Basis_Linear => "Basis_Linear",
486 GpuImageAssetDataFormatEnum::Basis_Srgb => "Basis_Srgb",
487 GpuImageAssetDataFormatEnum::BC1_UNorm_Linear => "BC1_UNorm_Linear",
488 GpuImageAssetDataFormatEnum::BC1_UNorm_Srgb => "BC1_UNorm_Srgb",
489 GpuImageAssetDataFormatEnum::BC2_UNorm_Linear => "BC2_UNorm_Linear",
490 GpuImageAssetDataFormatEnum::BC2_UNorm_Srgb => "BC2_UNorm_Srgb",
491 GpuImageAssetDataFormatEnum::BC3_UNorm_Linear => "BC3_UNorm_Linear",
492 GpuImageAssetDataFormatEnum::BC3_UNorm_Srgb => "BC3_UNorm_Srgb",
493 GpuImageAssetDataFormatEnum::BC4_UNorm => "BC4_UNorm",
494 GpuImageAssetDataFormatEnum::BC4_SNorm => "BC4_SNorm",
495 GpuImageAssetDataFormatEnum::BC5_UNorm => "BC5_UNorm",
496 GpuImageAssetDataFormatEnum::BC5_SNorm => "BC5_SNorm",
497 GpuImageAssetDataFormatEnum::BC6H_UFloat => "BC6H_UFloat",
498 GpuImageAssetDataFormatEnum::BC6H_SFloat => "BC6H_SFloat",
499 GpuImageAssetDataFormatEnum::BC7_Unorm_Linear => "BC7_Unorm_Linear",
500 GpuImageAssetDataFormatEnum::BC7_Unorm_Srgb => "BC7_Unorm_Srgb",
501 }
502 }
503
504 fn from_symbol_name(str: &str) -> Option<GpuImageAssetDataFormatEnum> {
505 match str {
506 "RGBA32_Linear" => Some(GpuImageAssetDataFormatEnum::RGBA32_Linear),
507 "RGBA32_Srgb" => Some(GpuImageAssetDataFormatEnum::RGBA32_Srgb),
508 "Basis_Linear" => Some(GpuImageAssetDataFormatEnum::Basis_Linear),
509 "Basis_Srgb" => Some(GpuImageAssetDataFormatEnum::Basis_Srgb),
510 "BC1_UNorm_Linear" => Some(GpuImageAssetDataFormatEnum::BC1_UNorm_Linear),
511 "BC1_UNorm_Srgb" => Some(GpuImageAssetDataFormatEnum::BC1_UNorm_Srgb),
512 "BC2_UNorm_Linear" => Some(GpuImageAssetDataFormatEnum::BC2_UNorm_Linear),
513 "BC2_UNorm_Srgb" => Some(GpuImageAssetDataFormatEnum::BC2_UNorm_Srgb),
514 "BC3_UNorm_Linear" => Some(GpuImageAssetDataFormatEnum::BC3_UNorm_Linear),
515 "BC3_UNorm_Srgb" => Some(GpuImageAssetDataFormatEnum::BC3_UNorm_Srgb),
516 "BC4_UNorm" => Some(GpuImageAssetDataFormatEnum::BC4_UNorm),
517 "BC4_SNorm" => Some(GpuImageAssetDataFormatEnum::BC4_SNorm),
518 "BC5_UNorm" => Some(GpuImageAssetDataFormatEnum::BC5_UNorm),
519 "BC5_SNorm" => Some(GpuImageAssetDataFormatEnum::BC5_SNorm),
520 "BC6H_UFloat" => Some(GpuImageAssetDataFormatEnum::BC6H_UFloat),
521 "BC6H_SFloat" => Some(GpuImageAssetDataFormatEnum::BC6H_SFloat),
522 "BC7_Unorm_Linear" => Some(GpuImageAssetDataFormatEnum::BC7_Unorm_Linear),
523 "BC7_Unorm_Srgb" => Some(GpuImageAssetDataFormatEnum::BC7_Unorm_Srgb),
524 _ => None,
525 }
526 }
527}
528
529impl GpuImageAssetDataFormatEnum {
530 pub fn schema_name() -> &'static str {
531 "GpuImageAssetDataFormat"
532 }
533}
534#[derive(Default)]
535pub struct GpuImageBasisCompressionSettingsAccessor(PropertyPath);
536
537impl FieldAccessor for GpuImageBasisCompressionSettingsAccessor {
538 fn new(property_path: PropertyPath) -> Self {
539 GpuImageBasisCompressionSettingsAccessor(property_path)
540 }
541}
542
543impl RecordAccessor for GpuImageBasisCompressionSettingsAccessor {
544 fn schema_name() -> &'static str {
545 "GpuImageBasisCompressionSettings"
546 }
547}
548
549impl GpuImageBasisCompressionSettingsAccessor {
550 pub fn compression_type(&self) -> EnumFieldAccessor::<GpuImageBasisCompressionTypeEnum> {
551 EnumFieldAccessor::<GpuImageBasisCompressionTypeEnum>::new(self.0.push("compression_type"))
552 }
553
554 pub fn quality(&self) -> U32FieldAccessor {
555 U32FieldAccessor::new(self.0.push("quality"))
556 }
557}
558pub struct GpuImageBasisCompressionSettingsRef<'a>(PropertyPath, DataContainerRef<'a>);
559
560impl<'a> FieldRef<'a> for GpuImageBasisCompressionSettingsRef<'a> {
561 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
562 GpuImageBasisCompressionSettingsRef(property_path, data_container)
563 }
564}
565
566impl<'a> RecordRef for GpuImageBasisCompressionSettingsRef<'a> {
567 fn schema_name() -> &'static str {
568 "GpuImageBasisCompressionSettings"
569 }
570}
571
572impl<'a> GpuImageBasisCompressionSettingsRef<'a> {
573 pub fn compression_type(&self) -> EnumFieldRef::<GpuImageBasisCompressionTypeEnum> {
574 EnumFieldRef::<GpuImageBasisCompressionTypeEnum>::new(self.0.push("compression_type"), self.1.clone())
575 }
576
577 pub fn quality(&self) -> U32FieldRef {
578 U32FieldRef::new(self.0.push("quality"), self.1.clone())
579 }
580}
581pub struct GpuImageBasisCompressionSettingsRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
582
583impl<'a> FieldRefMut<'a> for GpuImageBasisCompressionSettingsRefMut<'a> {
584 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
585 GpuImageBasisCompressionSettingsRefMut(property_path, data_container.clone())
586 }
587}
588
589impl<'a> RecordRefMut for GpuImageBasisCompressionSettingsRefMut<'a> {
590 fn schema_name() -> &'static str {
591 "GpuImageBasisCompressionSettings"
592 }
593}
594
595impl<'a> GpuImageBasisCompressionSettingsRefMut<'a> {
596 pub fn compression_type(self: &'a Self) -> EnumFieldRefMut::<GpuImageBasisCompressionTypeEnum> {
597 EnumFieldRefMut::<GpuImageBasisCompressionTypeEnum>::new(self.0.push("compression_type"), &self.1)
598 }
599
600 pub fn quality(self: &'a Self) -> U32FieldRefMut {
601 U32FieldRefMut::new(self.0.push("quality"), &self.1)
602 }
603}
604pub struct GpuImageBasisCompressionSettingsRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
605
606impl Field for GpuImageBasisCompressionSettingsRecord {
607 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
608 GpuImageBasisCompressionSettingsRecord(property_path, data_container.clone())
609 }
610}
611
612impl Record for GpuImageBasisCompressionSettingsRecord {
613 type Reader<'a> = GpuImageBasisCompressionSettingsRef<'a>;
614 type Writer<'a> = GpuImageBasisCompressionSettingsRefMut<'a>;
615 type Accessor = GpuImageBasisCompressionSettingsAccessor;
616
617 fn schema_name() -> &'static str {
618 "GpuImageBasisCompressionSettings"
619 }
620}
621
622impl GpuImageBasisCompressionSettingsRecord {
623 pub fn compression_type(self: &Self) -> EnumField::<GpuImageBasisCompressionTypeEnum> {
624 EnumField::<GpuImageBasisCompressionTypeEnum>::new(self.0.push("compression_type"), &self.1)
625 }
626
627 pub fn quality(self: &Self) -> U32Field {
628 U32Field::new(self.0.push("quality"), &self.1)
629 }
630}
631#[derive(Copy, Clone)]
632pub enum GpuImageBasisCompressionTypeEnum {
633 Etc1S,
634 Uastc,
635}
636
637impl Enum for GpuImageBasisCompressionTypeEnum {
638 fn to_symbol_name(&self) -> &'static str {
639 match self {
640 GpuImageBasisCompressionTypeEnum::Etc1S => "Etc1S",
641 GpuImageBasisCompressionTypeEnum::Uastc => "Uastc",
642 }
643 }
644
645 fn from_symbol_name(str: &str) -> Option<GpuImageBasisCompressionTypeEnum> {
646 match str {
647 "Etc1S" => Some(GpuImageBasisCompressionTypeEnum::Etc1S),
648 "Uastc" => Some(GpuImageBasisCompressionTypeEnum::Uastc),
649 _ => None,
650 }
651 }
652}
653
654impl GpuImageBasisCompressionTypeEnum {
655 pub fn schema_name() -> &'static str {
656 "GpuImageBasisCompressionType"
657 }
658}
659#[derive(Copy, Clone)]
660pub enum GpuImageColorSpaceEnum {
661 Srgb,
662 Linear,
663}
664
665impl Enum for GpuImageColorSpaceEnum {
666 fn to_symbol_name(&self) -> &'static str {
667 match self {
668 GpuImageColorSpaceEnum::Srgb => "Srgb",
669 GpuImageColorSpaceEnum::Linear => "Linear",
670 }
671 }
672
673 fn from_symbol_name(str: &str) -> Option<GpuImageColorSpaceEnum> {
674 match str {
675 "Srgb" => Some(GpuImageColorSpaceEnum::Srgb),
676 "Linear" => Some(GpuImageColorSpaceEnum::Linear),
677 _ => None,
678 }
679 }
680}
681
682impl GpuImageColorSpaceEnum {
683 pub fn schema_name() -> &'static str {
684 "GpuImageColorSpace"
685 }
686}
687#[derive(Default)]
688pub struct GpuImageImportedDataAccessor(PropertyPath);
689
690impl FieldAccessor for GpuImageImportedDataAccessor {
691 fn new(property_path: PropertyPath) -> Self {
692 GpuImageImportedDataAccessor(property_path)
693 }
694}
695
696impl RecordAccessor for GpuImageImportedDataAccessor {
697 fn schema_name() -> &'static str {
698 "GpuImageImportedData"
699 }
700}
701
702impl GpuImageImportedDataAccessor {
703 pub fn height(&self) -> U32FieldAccessor {
704 U32FieldAccessor::new(self.0.push("height"))
705 }
706
707 pub fn image_bytes(&self) -> BytesFieldAccessor {
708 BytesFieldAccessor::new(self.0.push("image_bytes"))
709 }
710
711 pub fn width(&self) -> U32FieldAccessor {
712 U32FieldAccessor::new(self.0.push("width"))
713 }
714}
715pub struct GpuImageImportedDataRef<'a>(PropertyPath, DataContainerRef<'a>);
716
717impl<'a> FieldRef<'a> for GpuImageImportedDataRef<'a> {
718 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
719 GpuImageImportedDataRef(property_path, data_container)
720 }
721}
722
723impl<'a> RecordRef for GpuImageImportedDataRef<'a> {
724 fn schema_name() -> &'static str {
725 "GpuImageImportedData"
726 }
727}
728
729impl<'a> GpuImageImportedDataRef<'a> {
730 pub fn height(&self) -> U32FieldRef {
731 U32FieldRef::new(self.0.push("height"), self.1.clone())
732 }
733
734 pub fn image_bytes(&self) -> BytesFieldRef {
735 BytesFieldRef::new(self.0.push("image_bytes"), self.1.clone())
736 }
737
738 pub fn width(&self) -> U32FieldRef {
739 U32FieldRef::new(self.0.push("width"), self.1.clone())
740 }
741}
742pub struct GpuImageImportedDataRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
743
744impl<'a> FieldRefMut<'a> for GpuImageImportedDataRefMut<'a> {
745 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
746 GpuImageImportedDataRefMut(property_path, data_container.clone())
747 }
748}
749
750impl<'a> RecordRefMut for GpuImageImportedDataRefMut<'a> {
751 fn schema_name() -> &'static str {
752 "GpuImageImportedData"
753 }
754}
755
756impl<'a> GpuImageImportedDataRefMut<'a> {
757 pub fn height(self: &'a Self) -> U32FieldRefMut {
758 U32FieldRefMut::new(self.0.push("height"), &self.1)
759 }
760
761 pub fn image_bytes(self: &'a Self) -> BytesFieldRefMut {
762 BytesFieldRefMut::new(self.0.push("image_bytes"), &self.1)
763 }
764
765 pub fn width(self: &'a Self) -> U32FieldRefMut {
766 U32FieldRefMut::new(self.0.push("width"), &self.1)
767 }
768}
769pub struct GpuImageImportedDataRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
770
771impl Field for GpuImageImportedDataRecord {
772 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
773 GpuImageImportedDataRecord(property_path, data_container.clone())
774 }
775}
776
777impl Record for GpuImageImportedDataRecord {
778 type Reader<'a> = GpuImageImportedDataRef<'a>;
779 type Writer<'a> = GpuImageImportedDataRefMut<'a>;
780 type Accessor = GpuImageImportedDataAccessor;
781
782 fn schema_name() -> &'static str {
783 "GpuImageImportedData"
784 }
785}
786
787impl GpuImageImportedDataRecord {
788 pub fn height(self: &Self) -> U32Field {
789 U32Field::new(self.0.push("height"), &self.1)
790 }
791
792 pub fn image_bytes(self: &Self) -> BytesField {
793 BytesField::new(self.0.push("image_bytes"), &self.1)
794 }
795
796 pub fn width(self: &Self) -> U32Field {
797 U32Field::new(self.0.push("width"), &self.1)
798 }
799}
800#[derive(Copy, Clone)]
801pub enum GpuImageMipGenerationEnum {
802 NoMips,
803 Precomputed,
804 Runtime,
805}
806
807impl Enum for GpuImageMipGenerationEnum {
808 fn to_symbol_name(&self) -> &'static str {
809 match self {
810 GpuImageMipGenerationEnum::NoMips => "NoMips",
811 GpuImageMipGenerationEnum::Precomputed => "Precomputed",
812 GpuImageMipGenerationEnum::Runtime => "Runtime",
813 }
814 }
815
816 fn from_symbol_name(str: &str) -> Option<GpuImageMipGenerationEnum> {
817 match str {
818 "NoMips" => Some(GpuImageMipGenerationEnum::NoMips),
819 "Precomputed" => Some(GpuImageMipGenerationEnum::Precomputed),
820 "Runtime" => Some(GpuImageMipGenerationEnum::Runtime),
821 _ => None,
822 }
823 }
824}
825
826impl GpuImageMipGenerationEnum {
827 pub fn schema_name() -> &'static str {
828 "GpuImageMipGeneration"
829 }
830}
831#[derive(Default)]
832pub struct GpuImageSubresourceLayerAccessor(PropertyPath);
833
834impl FieldAccessor for GpuImageSubresourceLayerAccessor {
835 fn new(property_path: PropertyPath) -> Self {
836 GpuImageSubresourceLayerAccessor(property_path)
837 }
838}
839
840impl RecordAccessor for GpuImageSubresourceLayerAccessor {
841 fn schema_name() -> &'static str {
842 "GpuImageSubresourceLayer"
843 }
844}
845
846impl GpuImageSubresourceLayerAccessor {
847 pub fn mip_levels(&self) -> DynamicArrayFieldAccessor::<GpuImageSubresourceMipLevelAccessor> {
848 DynamicArrayFieldAccessor::<GpuImageSubresourceMipLevelAccessor>::new(self.0.push("mip_levels"))
849 }
850}
851pub struct GpuImageSubresourceLayerRef<'a>(PropertyPath, DataContainerRef<'a>);
852
853impl<'a> FieldRef<'a> for GpuImageSubresourceLayerRef<'a> {
854 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
855 GpuImageSubresourceLayerRef(property_path, data_container)
856 }
857}
858
859impl<'a> RecordRef for GpuImageSubresourceLayerRef<'a> {
860 fn schema_name() -> &'static str {
861 "GpuImageSubresourceLayer"
862 }
863}
864
865impl<'a> GpuImageSubresourceLayerRef<'a> {
866 pub fn mip_levels(&self) -> DynamicArrayFieldRef::<GpuImageSubresourceMipLevelRef> {
867 DynamicArrayFieldRef::<GpuImageSubresourceMipLevelRef>::new(self.0.push("mip_levels"), self.1.clone())
868 }
869}
870pub struct GpuImageSubresourceLayerRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
871
872impl<'a> FieldRefMut<'a> for GpuImageSubresourceLayerRefMut<'a> {
873 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
874 GpuImageSubresourceLayerRefMut(property_path, data_container.clone())
875 }
876}
877
878impl<'a> RecordRefMut for GpuImageSubresourceLayerRefMut<'a> {
879 fn schema_name() -> &'static str {
880 "GpuImageSubresourceLayer"
881 }
882}
883
884impl<'a> GpuImageSubresourceLayerRefMut<'a> {
885 pub fn mip_levels(self: &'a Self) -> DynamicArrayFieldRefMut::<GpuImageSubresourceMipLevelRefMut> {
886 DynamicArrayFieldRefMut::<GpuImageSubresourceMipLevelRefMut>::new(self.0.push("mip_levels"), &self.1)
887 }
888}
889pub struct GpuImageSubresourceLayerRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
890
891impl Field for GpuImageSubresourceLayerRecord {
892 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
893 GpuImageSubresourceLayerRecord(property_path, data_container.clone())
894 }
895}
896
897impl Record for GpuImageSubresourceLayerRecord {
898 type Reader<'a> = GpuImageSubresourceLayerRef<'a>;
899 type Writer<'a> = GpuImageSubresourceLayerRefMut<'a>;
900 type Accessor = GpuImageSubresourceLayerAccessor;
901
902 fn schema_name() -> &'static str {
903 "GpuImageSubresourceLayer"
904 }
905}
906
907impl GpuImageSubresourceLayerRecord {
908 pub fn mip_levels(self: &Self) -> DynamicArrayField::<GpuImageSubresourceMipLevelRecord> {
909 DynamicArrayField::<GpuImageSubresourceMipLevelRecord>::new(self.0.push("mip_levels"), &self.1)
910 }
911}
912#[derive(Default)]
913pub struct GpuImageSubresourceMipLevelAccessor(PropertyPath);
914
915impl FieldAccessor for GpuImageSubresourceMipLevelAccessor {
916 fn new(property_path: PropertyPath) -> Self {
917 GpuImageSubresourceMipLevelAccessor(property_path)
918 }
919}
920
921impl RecordAccessor for GpuImageSubresourceMipLevelAccessor {
922 fn schema_name() -> &'static str {
923 "GpuImageSubresourceMipLevel"
924 }
925}
926
927impl GpuImageSubresourceMipLevelAccessor {
928 pub fn bytes(&self) -> BytesFieldAccessor {
929 BytesFieldAccessor::new(self.0.push("bytes"))
930 }
931
932 pub fn height(&self) -> U32FieldAccessor {
933 U32FieldAccessor::new(self.0.push("height"))
934 }
935
936 pub fn width(&self) -> U32FieldAccessor {
937 U32FieldAccessor::new(self.0.push("width"))
938 }
939}
940pub struct GpuImageSubresourceMipLevelRef<'a>(PropertyPath, DataContainerRef<'a>);
941
942impl<'a> FieldRef<'a> for GpuImageSubresourceMipLevelRef<'a> {
943 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
944 GpuImageSubresourceMipLevelRef(property_path, data_container)
945 }
946}
947
948impl<'a> RecordRef for GpuImageSubresourceMipLevelRef<'a> {
949 fn schema_name() -> &'static str {
950 "GpuImageSubresourceMipLevel"
951 }
952}
953
954impl<'a> GpuImageSubresourceMipLevelRef<'a> {
955 pub fn bytes(&self) -> BytesFieldRef {
956 BytesFieldRef::new(self.0.push("bytes"), self.1.clone())
957 }
958
959 pub fn height(&self) -> U32FieldRef {
960 U32FieldRef::new(self.0.push("height"), self.1.clone())
961 }
962
963 pub fn width(&self) -> U32FieldRef {
964 U32FieldRef::new(self.0.push("width"), self.1.clone())
965 }
966}
967pub struct GpuImageSubresourceMipLevelRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
968
969impl<'a> FieldRefMut<'a> for GpuImageSubresourceMipLevelRefMut<'a> {
970 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
971 GpuImageSubresourceMipLevelRefMut(property_path, data_container.clone())
972 }
973}
974
975impl<'a> RecordRefMut for GpuImageSubresourceMipLevelRefMut<'a> {
976 fn schema_name() -> &'static str {
977 "GpuImageSubresourceMipLevel"
978 }
979}
980
981impl<'a> GpuImageSubresourceMipLevelRefMut<'a> {
982 pub fn bytes(self: &'a Self) -> BytesFieldRefMut {
983 BytesFieldRefMut::new(self.0.push("bytes"), &self.1)
984 }
985
986 pub fn height(self: &'a Self) -> U32FieldRefMut {
987 U32FieldRefMut::new(self.0.push("height"), &self.1)
988 }
989
990 pub fn width(self: &'a Self) -> U32FieldRefMut {
991 U32FieldRefMut::new(self.0.push("width"), &self.1)
992 }
993}
994pub struct GpuImageSubresourceMipLevelRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
995
996impl Field for GpuImageSubresourceMipLevelRecord {
997 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
998 GpuImageSubresourceMipLevelRecord(property_path, data_container.clone())
999 }
1000}
1001
1002impl Record for GpuImageSubresourceMipLevelRecord {
1003 type Reader<'a> = GpuImageSubresourceMipLevelRef<'a>;
1004 type Writer<'a> = GpuImageSubresourceMipLevelRefMut<'a>;
1005 type Accessor = GpuImageSubresourceMipLevelAccessor;
1006
1007 fn schema_name() -> &'static str {
1008 "GpuImageSubresourceMipLevel"
1009 }
1010}
1011
1012impl GpuImageSubresourceMipLevelRecord {
1013 pub fn bytes(self: &Self) -> BytesField {
1014 BytesField::new(self.0.push("bytes"), &self.1)
1015 }
1016
1017 pub fn height(self: &Self) -> U32Field {
1018 U32Field::new(self.0.push("height"), &self.1)
1019 }
1020
1021 pub fn width(self: &Self) -> U32Field {
1022 U32Field::new(self.0.push("width"), &self.1)
1023 }
1024}
1025#[derive(Default)]
1026pub struct GraphicsPipelineShaderStageAccessor(PropertyPath);
1027
1028impl FieldAccessor for GraphicsPipelineShaderStageAccessor {
1029 fn new(property_path: PropertyPath) -> Self {
1030 GraphicsPipelineShaderStageAccessor(property_path)
1031 }
1032}
1033
1034impl RecordAccessor for GraphicsPipelineShaderStageAccessor {
1035 fn schema_name() -> &'static str {
1036 "GraphicsPipelineShaderStage"
1037 }
1038}
1039
1040impl GraphicsPipelineShaderStageAccessor {
1041 pub fn entry_name(&self) -> StringFieldAccessor {
1042 StringFieldAccessor::new(self.0.push("entry_name"))
1043 }
1044
1045 pub fn shader_module(&self) -> AssetRefFieldAccessor {
1046 AssetRefFieldAccessor::new(self.0.push("shader_module"))
1047 }
1048}
1049pub struct GraphicsPipelineShaderStageRef<'a>(PropertyPath, DataContainerRef<'a>);
1050
1051impl<'a> FieldRef<'a> for GraphicsPipelineShaderStageRef<'a> {
1052 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1053 GraphicsPipelineShaderStageRef(property_path, data_container)
1054 }
1055}
1056
1057impl<'a> RecordRef for GraphicsPipelineShaderStageRef<'a> {
1058 fn schema_name() -> &'static str {
1059 "GraphicsPipelineShaderStage"
1060 }
1061}
1062
1063impl<'a> GraphicsPipelineShaderStageRef<'a> {
1064 pub fn entry_name(&self) -> StringFieldRef {
1065 StringFieldRef::new(self.0.push("entry_name"), self.1.clone())
1066 }
1067
1068 pub fn shader_module(&self) -> AssetRefFieldRef {
1069 AssetRefFieldRef::new(self.0.push("shader_module"), self.1.clone())
1070 }
1071}
1072pub struct GraphicsPipelineShaderStageRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1073
1074impl<'a> FieldRefMut<'a> for GraphicsPipelineShaderStageRefMut<'a> {
1075 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1076 GraphicsPipelineShaderStageRefMut(property_path, data_container.clone())
1077 }
1078}
1079
1080impl<'a> RecordRefMut for GraphicsPipelineShaderStageRefMut<'a> {
1081 fn schema_name() -> &'static str {
1082 "GraphicsPipelineShaderStage"
1083 }
1084}
1085
1086impl<'a> GraphicsPipelineShaderStageRefMut<'a> {
1087 pub fn entry_name(self: &'a Self) -> StringFieldRefMut {
1088 StringFieldRefMut::new(self.0.push("entry_name"), &self.1)
1089 }
1090
1091 pub fn shader_module(self: &'a Self) -> AssetRefFieldRefMut {
1092 AssetRefFieldRefMut::new(self.0.push("shader_module"), &self.1)
1093 }
1094}
1095pub struct GraphicsPipelineShaderStageRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1096
1097impl Field for GraphicsPipelineShaderStageRecord {
1098 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1099 GraphicsPipelineShaderStageRecord(property_path, data_container.clone())
1100 }
1101}
1102
1103impl Record for GraphicsPipelineShaderStageRecord {
1104 type Reader<'a> = GraphicsPipelineShaderStageRef<'a>;
1105 type Writer<'a> = GraphicsPipelineShaderStageRefMut<'a>;
1106 type Accessor = GraphicsPipelineShaderStageAccessor;
1107
1108 fn schema_name() -> &'static str {
1109 "GraphicsPipelineShaderStage"
1110 }
1111}
1112
1113impl GraphicsPipelineShaderStageRecord {
1114 pub fn entry_name(self: &Self) -> StringField {
1115 StringField::new(self.0.push("entry_name"), &self.1)
1116 }
1117
1118 pub fn shader_module(self: &Self) -> AssetRefField {
1119 AssetRefField::new(self.0.push("shader_module"), &self.1)
1120 }
1121}
1122#[derive(Default)]
1123pub struct MaterialAssetAccessor(PropertyPath);
1124
1125impl FieldAccessor for MaterialAssetAccessor {
1126 fn new(property_path: PropertyPath) -> Self {
1127 MaterialAssetAccessor(property_path)
1128 }
1129}
1130
1131impl RecordAccessor for MaterialAssetAccessor {
1132 fn schema_name() -> &'static str {
1133 "MaterialAsset"
1134 }
1135}
1136
1137impl MaterialAssetAccessor {
1138 pub fn passes(&self) -> DynamicArrayFieldAccessor::<MaterialPassAccessor> {
1139 DynamicArrayFieldAccessor::<MaterialPassAccessor>::new(self.0.push("passes"))
1140 }
1141}
1142pub struct MaterialAssetRef<'a>(PropertyPath, DataContainerRef<'a>);
1143
1144impl<'a> FieldRef<'a> for MaterialAssetRef<'a> {
1145 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1146 MaterialAssetRef(property_path, data_container)
1147 }
1148}
1149
1150impl<'a> RecordRef for MaterialAssetRef<'a> {
1151 fn schema_name() -> &'static str {
1152 "MaterialAsset"
1153 }
1154}
1155
1156impl<'a> MaterialAssetRef<'a> {
1157 pub fn passes(&self) -> DynamicArrayFieldRef::<MaterialPassRef> {
1158 DynamicArrayFieldRef::<MaterialPassRef>::new(self.0.push("passes"), self.1.clone())
1159 }
1160}
1161pub struct MaterialAssetRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1162
1163impl<'a> FieldRefMut<'a> for MaterialAssetRefMut<'a> {
1164 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1165 MaterialAssetRefMut(property_path, data_container.clone())
1166 }
1167}
1168
1169impl<'a> RecordRefMut for MaterialAssetRefMut<'a> {
1170 fn schema_name() -> &'static str {
1171 "MaterialAsset"
1172 }
1173}
1174
1175impl<'a> MaterialAssetRefMut<'a> {
1176 pub fn passes(self: &'a Self) -> DynamicArrayFieldRefMut::<MaterialPassRefMut> {
1177 DynamicArrayFieldRefMut::<MaterialPassRefMut>::new(self.0.push("passes"), &self.1)
1178 }
1179}
1180pub struct MaterialAssetRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1181
1182impl Field for MaterialAssetRecord {
1183 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1184 MaterialAssetRecord(property_path, data_container.clone())
1185 }
1186}
1187
1188impl Record for MaterialAssetRecord {
1189 type Reader<'a> = MaterialAssetRef<'a>;
1190 type Writer<'a> = MaterialAssetRefMut<'a>;
1191 type Accessor = MaterialAssetAccessor;
1192
1193 fn schema_name() -> &'static str {
1194 "MaterialAsset"
1195 }
1196}
1197
1198impl MaterialAssetRecord {
1199 pub fn passes(self: &Self) -> DynamicArrayField::<MaterialPassRecord> {
1200 DynamicArrayField::<MaterialPassRecord>::new(self.0.push("passes"), &self.1)
1201 }
1202}
1203#[derive(Default)]
1204pub struct MaterialInstanceAssetAccessor(PropertyPath);
1205
1206impl FieldAccessor for MaterialInstanceAssetAccessor {
1207 fn new(property_path: PropertyPath) -> Self {
1208 MaterialInstanceAssetAccessor(property_path)
1209 }
1210}
1211
1212impl RecordAccessor for MaterialInstanceAssetAccessor {
1213 fn schema_name() -> &'static str {
1214 "MaterialInstanceAsset"
1215 }
1216}
1217
1218impl MaterialInstanceAssetAccessor {
1219 pub fn material(&self) -> AssetRefFieldAccessor {
1220 AssetRefFieldAccessor::new(self.0.push("material"))
1221 }
1222
1223 pub fn slot_assignments(&self) -> DynamicArrayFieldAccessor::<MaterialInstanceSlotAssignmentAccessor> {
1224 DynamicArrayFieldAccessor::<MaterialInstanceSlotAssignmentAccessor>::new(self.0.push("slot_assignments"))
1225 }
1226}
1227pub struct MaterialInstanceAssetRef<'a>(PropertyPath, DataContainerRef<'a>);
1228
1229impl<'a> FieldRef<'a> for MaterialInstanceAssetRef<'a> {
1230 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1231 MaterialInstanceAssetRef(property_path, data_container)
1232 }
1233}
1234
1235impl<'a> RecordRef for MaterialInstanceAssetRef<'a> {
1236 fn schema_name() -> &'static str {
1237 "MaterialInstanceAsset"
1238 }
1239}
1240
1241impl<'a> MaterialInstanceAssetRef<'a> {
1242 pub fn material(&self) -> AssetRefFieldRef {
1243 AssetRefFieldRef::new(self.0.push("material"), self.1.clone())
1244 }
1245
1246 pub fn slot_assignments(&self) -> DynamicArrayFieldRef::<MaterialInstanceSlotAssignmentRef> {
1247 DynamicArrayFieldRef::<MaterialInstanceSlotAssignmentRef>::new(self.0.push("slot_assignments"), self.1.clone())
1248 }
1249}
1250pub struct MaterialInstanceAssetRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1251
1252impl<'a> FieldRefMut<'a> for MaterialInstanceAssetRefMut<'a> {
1253 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1254 MaterialInstanceAssetRefMut(property_path, data_container.clone())
1255 }
1256}
1257
1258impl<'a> RecordRefMut for MaterialInstanceAssetRefMut<'a> {
1259 fn schema_name() -> &'static str {
1260 "MaterialInstanceAsset"
1261 }
1262}
1263
1264impl<'a> MaterialInstanceAssetRefMut<'a> {
1265 pub fn material(self: &'a Self) -> AssetRefFieldRefMut {
1266 AssetRefFieldRefMut::new(self.0.push("material"), &self.1)
1267 }
1268
1269 pub fn slot_assignments(self: &'a Self) -> DynamicArrayFieldRefMut::<MaterialInstanceSlotAssignmentRefMut> {
1270 DynamicArrayFieldRefMut::<MaterialInstanceSlotAssignmentRefMut>::new(self.0.push("slot_assignments"), &self.1)
1271 }
1272}
1273pub struct MaterialInstanceAssetRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1274
1275impl Field for MaterialInstanceAssetRecord {
1276 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1277 MaterialInstanceAssetRecord(property_path, data_container.clone())
1278 }
1279}
1280
1281impl Record for MaterialInstanceAssetRecord {
1282 type Reader<'a> = MaterialInstanceAssetRef<'a>;
1283 type Writer<'a> = MaterialInstanceAssetRefMut<'a>;
1284 type Accessor = MaterialInstanceAssetAccessor;
1285
1286 fn schema_name() -> &'static str {
1287 "MaterialInstanceAsset"
1288 }
1289}
1290
1291impl MaterialInstanceAssetRecord {
1292 pub fn material(self: &Self) -> AssetRefField {
1293 AssetRefField::new(self.0.push("material"), &self.1)
1294 }
1295
1296 pub fn slot_assignments(self: &Self) -> DynamicArrayField::<MaterialInstanceSlotAssignmentRecord> {
1297 DynamicArrayField::<MaterialInstanceSlotAssignmentRecord>::new(self.0.push("slot_assignments"), &self.1)
1298 }
1299}
1300#[derive(Default)]
1301pub struct MaterialInstanceSlotAssignmentAccessor(PropertyPath);
1302
1303impl FieldAccessor for MaterialInstanceSlotAssignmentAccessor {
1304 fn new(property_path: PropertyPath) -> Self {
1305 MaterialInstanceSlotAssignmentAccessor(property_path)
1306 }
1307}
1308
1309impl RecordAccessor for MaterialInstanceSlotAssignmentAccessor {
1310 fn schema_name() -> &'static str {
1311 "MaterialInstanceSlotAssignment"
1312 }
1313}
1314
1315impl MaterialInstanceSlotAssignmentAccessor {
1316 pub fn array_index(&self) -> U32FieldAccessor {
1317 U32FieldAccessor::new(self.0.push("array_index"))
1318 }
1319
1320 pub fn buffer_data(&self) -> NullableFieldAccessor::<BytesFieldAccessor> {
1321 NullableFieldAccessor::<BytesFieldAccessor>::new(self.0.push("buffer_data"))
1322 }
1323
1324 pub fn image(&self) -> AssetRefFieldAccessor {
1325 AssetRefFieldAccessor::new(self.0.push("image"))
1326 }
1327
1328 pub fn sampler(&self) -> StringFieldAccessor {
1329 StringFieldAccessor::new(self.0.push("sampler"))
1330 }
1331
1332 pub fn slot_name(&self) -> StringFieldAccessor {
1333 StringFieldAccessor::new(self.0.push("slot_name"))
1334 }
1335}
1336pub struct MaterialInstanceSlotAssignmentRef<'a>(PropertyPath, DataContainerRef<'a>);
1337
1338impl<'a> FieldRef<'a> for MaterialInstanceSlotAssignmentRef<'a> {
1339 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1340 MaterialInstanceSlotAssignmentRef(property_path, data_container)
1341 }
1342}
1343
1344impl<'a> RecordRef for MaterialInstanceSlotAssignmentRef<'a> {
1345 fn schema_name() -> &'static str {
1346 "MaterialInstanceSlotAssignment"
1347 }
1348}
1349
1350impl<'a> MaterialInstanceSlotAssignmentRef<'a> {
1351 pub fn array_index(&self) -> U32FieldRef {
1352 U32FieldRef::new(self.0.push("array_index"), self.1.clone())
1353 }
1354
1355 pub fn buffer_data(&self) -> NullableFieldRef::<BytesFieldRef> {
1356 NullableFieldRef::<BytesFieldRef>::new(self.0.push("buffer_data"), self.1.clone())
1357 }
1358
1359 pub fn image(&self) -> AssetRefFieldRef {
1360 AssetRefFieldRef::new(self.0.push("image"), self.1.clone())
1361 }
1362
1363 pub fn sampler(&self) -> StringFieldRef {
1364 StringFieldRef::new(self.0.push("sampler"), self.1.clone())
1365 }
1366
1367 pub fn slot_name(&self) -> StringFieldRef {
1368 StringFieldRef::new(self.0.push("slot_name"), self.1.clone())
1369 }
1370}
1371pub struct MaterialInstanceSlotAssignmentRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1372
1373impl<'a> FieldRefMut<'a> for MaterialInstanceSlotAssignmentRefMut<'a> {
1374 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1375 MaterialInstanceSlotAssignmentRefMut(property_path, data_container.clone())
1376 }
1377}
1378
1379impl<'a> RecordRefMut for MaterialInstanceSlotAssignmentRefMut<'a> {
1380 fn schema_name() -> &'static str {
1381 "MaterialInstanceSlotAssignment"
1382 }
1383}
1384
1385impl<'a> MaterialInstanceSlotAssignmentRefMut<'a> {
1386 pub fn array_index(self: &'a Self) -> U32FieldRefMut {
1387 U32FieldRefMut::new(self.0.push("array_index"), &self.1)
1388 }
1389
1390 pub fn buffer_data(self: &'a Self) -> NullableFieldRefMut::<BytesFieldRefMut> {
1391 NullableFieldRefMut::<BytesFieldRefMut>::new(self.0.push("buffer_data"), &self.1)
1392 }
1393
1394 pub fn image(self: &'a Self) -> AssetRefFieldRefMut {
1395 AssetRefFieldRefMut::new(self.0.push("image"), &self.1)
1396 }
1397
1398 pub fn sampler(self: &'a Self) -> StringFieldRefMut {
1399 StringFieldRefMut::new(self.0.push("sampler"), &self.1)
1400 }
1401
1402 pub fn slot_name(self: &'a Self) -> StringFieldRefMut {
1403 StringFieldRefMut::new(self.0.push("slot_name"), &self.1)
1404 }
1405}
1406pub struct MaterialInstanceSlotAssignmentRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1407
1408impl Field for MaterialInstanceSlotAssignmentRecord {
1409 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1410 MaterialInstanceSlotAssignmentRecord(property_path, data_container.clone())
1411 }
1412}
1413
1414impl Record for MaterialInstanceSlotAssignmentRecord {
1415 type Reader<'a> = MaterialInstanceSlotAssignmentRef<'a>;
1416 type Writer<'a> = MaterialInstanceSlotAssignmentRefMut<'a>;
1417 type Accessor = MaterialInstanceSlotAssignmentAccessor;
1418
1419 fn schema_name() -> &'static str {
1420 "MaterialInstanceSlotAssignment"
1421 }
1422}
1423
1424impl MaterialInstanceSlotAssignmentRecord {
1425 pub fn array_index(self: &Self) -> U32Field {
1426 U32Field::new(self.0.push("array_index"), &self.1)
1427 }
1428
1429 pub fn buffer_data(self: &Self) -> NullableField::<BytesField> {
1430 NullableField::<BytesField>::new(self.0.push("buffer_data"), &self.1)
1431 }
1432
1433 pub fn image(self: &Self) -> AssetRefField {
1434 AssetRefField::new(self.0.push("image"), &self.1)
1435 }
1436
1437 pub fn sampler(self: &Self) -> StringField {
1438 StringField::new(self.0.push("sampler"), &self.1)
1439 }
1440
1441 pub fn slot_name(self: &Self) -> StringField {
1442 StringField::new(self.0.push("slot_name"), &self.1)
1443 }
1444}
1445#[derive(Default)]
1446pub struct MaterialPassAccessor(PropertyPath);
1447
1448impl FieldAccessor for MaterialPassAccessor {
1449 fn new(property_path: PropertyPath) -> Self {
1450 MaterialPassAccessor(property_path)
1451 }
1452}
1453
1454impl RecordAccessor for MaterialPassAccessor {
1455 fn schema_name() -> &'static str {
1456 "MaterialPass"
1457 }
1458}
1459
1460impl MaterialPassAccessor {
1461 pub fn fixed_function_state(&self) -> StringFieldAccessor {
1462 StringFieldAccessor::new(self.0.push("fixed_function_state"))
1463 }
1464
1465 pub fn fragment_stage(&self) -> GraphicsPipelineShaderStageAccessor {
1466 GraphicsPipelineShaderStageAccessor::new(self.0.push("fragment_stage"))
1467 }
1468
1469 pub fn name(&self) -> StringFieldAccessor {
1470 StringFieldAccessor::new(self.0.push("name"))
1471 }
1472
1473 pub fn phase(&self) -> StringFieldAccessor {
1474 StringFieldAccessor::new(self.0.push("phase"))
1475 }
1476
1477 pub fn vertex_stage(&self) -> GraphicsPipelineShaderStageAccessor {
1478 GraphicsPipelineShaderStageAccessor::new(self.0.push("vertex_stage"))
1479 }
1480}
1481pub struct MaterialPassRef<'a>(PropertyPath, DataContainerRef<'a>);
1482
1483impl<'a> FieldRef<'a> for MaterialPassRef<'a> {
1484 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1485 MaterialPassRef(property_path, data_container)
1486 }
1487}
1488
1489impl<'a> RecordRef for MaterialPassRef<'a> {
1490 fn schema_name() -> &'static str {
1491 "MaterialPass"
1492 }
1493}
1494
1495impl<'a> MaterialPassRef<'a> {
1496 pub fn fixed_function_state(&self) -> StringFieldRef {
1497 StringFieldRef::new(self.0.push("fixed_function_state"), self.1.clone())
1498 }
1499
1500 pub fn fragment_stage(&self) -> GraphicsPipelineShaderStageRef {
1501 GraphicsPipelineShaderStageRef::new(self.0.push("fragment_stage"), self.1.clone())
1502 }
1503
1504 pub fn name(&self) -> StringFieldRef {
1505 StringFieldRef::new(self.0.push("name"), self.1.clone())
1506 }
1507
1508 pub fn phase(&self) -> StringFieldRef {
1509 StringFieldRef::new(self.0.push("phase"), self.1.clone())
1510 }
1511
1512 pub fn vertex_stage(&self) -> GraphicsPipelineShaderStageRef {
1513 GraphicsPipelineShaderStageRef::new(self.0.push("vertex_stage"), self.1.clone())
1514 }
1515}
1516pub struct MaterialPassRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1517
1518impl<'a> FieldRefMut<'a> for MaterialPassRefMut<'a> {
1519 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1520 MaterialPassRefMut(property_path, data_container.clone())
1521 }
1522}
1523
1524impl<'a> RecordRefMut for MaterialPassRefMut<'a> {
1525 fn schema_name() -> &'static str {
1526 "MaterialPass"
1527 }
1528}
1529
1530impl<'a> MaterialPassRefMut<'a> {
1531 pub fn fixed_function_state(self: &'a Self) -> StringFieldRefMut {
1532 StringFieldRefMut::new(self.0.push("fixed_function_state"), &self.1)
1533 }
1534
1535 pub fn fragment_stage(self: &'a Self) -> GraphicsPipelineShaderStageRefMut {
1536 GraphicsPipelineShaderStageRefMut::new(self.0.push("fragment_stage"), &self.1)
1537 }
1538
1539 pub fn name(self: &'a Self) -> StringFieldRefMut {
1540 StringFieldRefMut::new(self.0.push("name"), &self.1)
1541 }
1542
1543 pub fn phase(self: &'a Self) -> StringFieldRefMut {
1544 StringFieldRefMut::new(self.0.push("phase"), &self.1)
1545 }
1546
1547 pub fn vertex_stage(self: &'a Self) -> GraphicsPipelineShaderStageRefMut {
1548 GraphicsPipelineShaderStageRefMut::new(self.0.push("vertex_stage"), &self.1)
1549 }
1550}
1551pub struct MaterialPassRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1552
1553impl Field for MaterialPassRecord {
1554 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1555 MaterialPassRecord(property_path, data_container.clone())
1556 }
1557}
1558
1559impl Record for MaterialPassRecord {
1560 type Reader<'a> = MaterialPassRef<'a>;
1561 type Writer<'a> = MaterialPassRefMut<'a>;
1562 type Accessor = MaterialPassAccessor;
1563
1564 fn schema_name() -> &'static str {
1565 "MaterialPass"
1566 }
1567}
1568
1569impl MaterialPassRecord {
1570 pub fn fixed_function_state(self: &Self) -> StringField {
1571 StringField::new(self.0.push("fixed_function_state"), &self.1)
1572 }
1573
1574 pub fn fragment_stage(self: &Self) -> GraphicsPipelineShaderStageRecord {
1575 GraphicsPipelineShaderStageRecord::new(self.0.push("fragment_stage"), &self.1)
1576 }
1577
1578 pub fn name(self: &Self) -> StringField {
1579 StringField::new(self.0.push("name"), &self.1)
1580 }
1581
1582 pub fn phase(self: &Self) -> StringField {
1583 StringField::new(self.0.push("phase"), &self.1)
1584 }
1585
1586 pub fn vertex_stage(self: &Self) -> GraphicsPipelineShaderStageRecord {
1587 GraphicsPipelineShaderStageRecord::new(self.0.push("vertex_stage"), &self.1)
1588 }
1589}
1590#[derive(Default)]
1591pub struct ShaderPackageAssetAccessor(PropertyPath);
1592
1593impl FieldAccessor for ShaderPackageAssetAccessor {
1594 fn new(property_path: PropertyPath) -> Self {
1595 ShaderPackageAssetAccessor(property_path)
1596 }
1597}
1598
1599impl RecordAccessor for ShaderPackageAssetAccessor {
1600 fn schema_name() -> &'static str {
1601 "ShaderPackageAsset"
1602 }
1603}
1604
1605impl ShaderPackageAssetAccessor {
1606}
1607pub struct ShaderPackageAssetRef<'a>(PropertyPath, DataContainerRef<'a>);
1608
1609impl<'a> FieldRef<'a> for ShaderPackageAssetRef<'a> {
1610 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1611 ShaderPackageAssetRef(property_path, data_container)
1612 }
1613}
1614
1615impl<'a> RecordRef for ShaderPackageAssetRef<'a> {
1616 fn schema_name() -> &'static str {
1617 "ShaderPackageAsset"
1618 }
1619}
1620
1621impl<'a> ShaderPackageAssetRef<'a> {
1622}
1623pub struct ShaderPackageAssetRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1624
1625impl<'a> FieldRefMut<'a> for ShaderPackageAssetRefMut<'a> {
1626 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1627 ShaderPackageAssetRefMut(property_path, data_container.clone())
1628 }
1629}
1630
1631impl<'a> RecordRefMut for ShaderPackageAssetRefMut<'a> {
1632 fn schema_name() -> &'static str {
1633 "ShaderPackageAsset"
1634 }
1635}
1636
1637impl<'a> ShaderPackageAssetRefMut<'a> {
1638}
1639pub struct ShaderPackageAssetRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1640
1641impl Field for ShaderPackageAssetRecord {
1642 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1643 ShaderPackageAssetRecord(property_path, data_container.clone())
1644 }
1645}
1646
1647impl Record for ShaderPackageAssetRecord {
1648 type Reader<'a> = ShaderPackageAssetRef<'a>;
1649 type Writer<'a> = ShaderPackageAssetRefMut<'a>;
1650 type Accessor = ShaderPackageAssetAccessor;
1651
1652 fn schema_name() -> &'static str {
1653 "ShaderPackageAsset"
1654 }
1655}
1656
1657impl ShaderPackageAssetRecord {
1658}
1659#[derive(Default)]
1660pub struct ShaderPackageImportedDataAccessor(PropertyPath);
1661
1662impl FieldAccessor for ShaderPackageImportedDataAccessor {
1663 fn new(property_path: PropertyPath) -> Self {
1664 ShaderPackageImportedDataAccessor(property_path)
1665 }
1666}
1667
1668impl RecordAccessor for ShaderPackageImportedDataAccessor {
1669 fn schema_name() -> &'static str {
1670 "ShaderPackageImportedData"
1671 }
1672}
1673
1674impl ShaderPackageImportedDataAccessor {
1675 pub fn bytes(&self) -> BytesFieldAccessor {
1676 BytesFieldAccessor::new(self.0.push("bytes"))
1677 }
1678}
1679pub struct ShaderPackageImportedDataRef<'a>(PropertyPath, DataContainerRef<'a>);
1680
1681impl<'a> FieldRef<'a> for ShaderPackageImportedDataRef<'a> {
1682 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1683 ShaderPackageImportedDataRef(property_path, data_container)
1684 }
1685}
1686
1687impl<'a> RecordRef for ShaderPackageImportedDataRef<'a> {
1688 fn schema_name() -> &'static str {
1689 "ShaderPackageImportedData"
1690 }
1691}
1692
1693impl<'a> ShaderPackageImportedDataRef<'a> {
1694 pub fn bytes(&self) -> BytesFieldRef {
1695 BytesFieldRef::new(self.0.push("bytes"), self.1.clone())
1696 }
1697}
1698pub struct ShaderPackageImportedDataRefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1699
1700impl<'a> FieldRefMut<'a> for ShaderPackageImportedDataRefMut<'a> {
1701 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1702 ShaderPackageImportedDataRefMut(property_path, data_container.clone())
1703 }
1704}
1705
1706impl<'a> RecordRefMut for ShaderPackageImportedDataRefMut<'a> {
1707 fn schema_name() -> &'static str {
1708 "ShaderPackageImportedData"
1709 }
1710}
1711
1712impl<'a> ShaderPackageImportedDataRefMut<'a> {
1713 pub fn bytes(self: &'a Self) -> BytesFieldRefMut {
1714 BytesFieldRefMut::new(self.0.push("bytes"), &self.1)
1715 }
1716}
1717pub struct ShaderPackageImportedDataRecord(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1718
1719impl Field for ShaderPackageImportedDataRecord {
1720 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1721 ShaderPackageImportedDataRecord(property_path, data_container.clone())
1722 }
1723}
1724
1725impl Record for ShaderPackageImportedDataRecord {
1726 type Reader<'a> = ShaderPackageImportedDataRef<'a>;
1727 type Writer<'a> = ShaderPackageImportedDataRefMut<'a>;
1728 type Accessor = ShaderPackageImportedDataAccessor;
1729
1730 fn schema_name() -> &'static str {
1731 "ShaderPackageImportedData"
1732 }
1733}
1734
1735impl ShaderPackageImportedDataRecord {
1736 pub fn bytes(self: &Self) -> BytesField {
1737 BytesField::new(self.0.push("bytes"), &self.1)
1738 }
1739}
1740#[derive(Default)]
1741pub struct Vec3Accessor(PropertyPath);
1742
1743impl FieldAccessor for Vec3Accessor {
1744 fn new(property_path: PropertyPath) -> Self {
1745 Vec3Accessor(property_path)
1746 }
1747}
1748
1749impl RecordAccessor for Vec3Accessor {
1750 fn schema_name() -> &'static str {
1751 "Vec3"
1752 }
1753}
1754
1755impl Vec3Accessor {
1756 pub fn x(&self) -> F32FieldAccessor {
1757 F32FieldAccessor::new(self.0.push("x"))
1758 }
1759
1760 pub fn y(&self) -> F32FieldAccessor {
1761 F32FieldAccessor::new(self.0.push("y"))
1762 }
1763
1764 pub fn z(&self) -> F32FieldAccessor {
1765 F32FieldAccessor::new(self.0.push("z"))
1766 }
1767}
1768pub struct Vec3Ref<'a>(PropertyPath, DataContainerRef<'a>);
1769
1770impl<'a> FieldRef<'a> for Vec3Ref<'a> {
1771 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1772 Vec3Ref(property_path, data_container)
1773 }
1774}
1775
1776impl<'a> RecordRef for Vec3Ref<'a> {
1777 fn schema_name() -> &'static str {
1778 "Vec3"
1779 }
1780}
1781
1782impl<'a> Vec3Ref<'a> {
1783 pub fn x(&self) -> F32FieldRef {
1784 F32FieldRef::new(self.0.push("x"), self.1.clone())
1785 }
1786
1787 pub fn y(&self) -> F32FieldRef {
1788 F32FieldRef::new(self.0.push("y"), self.1.clone())
1789 }
1790
1791 pub fn z(&self) -> F32FieldRef {
1792 F32FieldRef::new(self.0.push("z"), self.1.clone())
1793 }
1794}
1795pub struct Vec3RefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1796
1797impl<'a> FieldRefMut<'a> for Vec3RefMut<'a> {
1798 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1799 Vec3RefMut(property_path, data_container.clone())
1800 }
1801}
1802
1803impl<'a> RecordRefMut for Vec3RefMut<'a> {
1804 fn schema_name() -> &'static str {
1805 "Vec3"
1806 }
1807}
1808
1809impl<'a> Vec3RefMut<'a> {
1810 pub fn x(self: &'a Self) -> F32FieldRefMut {
1811 F32FieldRefMut::new(self.0.push("x"), &self.1)
1812 }
1813
1814 pub fn y(self: &'a Self) -> F32FieldRefMut {
1815 F32FieldRefMut::new(self.0.push("y"), &self.1)
1816 }
1817
1818 pub fn z(self: &'a Self) -> F32FieldRefMut {
1819 F32FieldRefMut::new(self.0.push("z"), &self.1)
1820 }
1821}
1822pub struct Vec3Record(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1823
1824impl Field for Vec3Record {
1825 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1826 Vec3Record(property_path, data_container.clone())
1827 }
1828}
1829
1830impl Record for Vec3Record {
1831 type Reader<'a> = Vec3Ref<'a>;
1832 type Writer<'a> = Vec3RefMut<'a>;
1833 type Accessor = Vec3Accessor;
1834
1835 fn schema_name() -> &'static str {
1836 "Vec3"
1837 }
1838}
1839
1840impl Vec3Record {
1841 pub fn x(self: &Self) -> F32Field {
1842 F32Field::new(self.0.push("x"), &self.1)
1843 }
1844
1845 pub fn y(self: &Self) -> F32Field {
1846 F32Field::new(self.0.push("y"), &self.1)
1847 }
1848
1849 pub fn z(self: &Self) -> F32Field {
1850 F32Field::new(self.0.push("z"), &self.1)
1851 }
1852}
1853#[derive(Default)]
1854pub struct Vec4Accessor(PropertyPath);
1855
1856impl FieldAccessor for Vec4Accessor {
1857 fn new(property_path: PropertyPath) -> Self {
1858 Vec4Accessor(property_path)
1859 }
1860}
1861
1862impl RecordAccessor for Vec4Accessor {
1863 fn schema_name() -> &'static str {
1864 "Vec4"
1865 }
1866}
1867
1868impl Vec4Accessor {
1869 pub fn w(&self) -> F32FieldAccessor {
1870 F32FieldAccessor::new(self.0.push("w"))
1871 }
1872
1873 pub fn x(&self) -> F32FieldAccessor {
1874 F32FieldAccessor::new(self.0.push("x"))
1875 }
1876
1877 pub fn y(&self) -> F32FieldAccessor {
1878 F32FieldAccessor::new(self.0.push("y"))
1879 }
1880
1881 pub fn z(&self) -> F32FieldAccessor {
1882 F32FieldAccessor::new(self.0.push("z"))
1883 }
1884}
1885pub struct Vec4Ref<'a>(PropertyPath, DataContainerRef<'a>);
1886
1887impl<'a> FieldRef<'a> for Vec4Ref<'a> {
1888 fn new(property_path: PropertyPath, data_container: DataContainerRef<'a>) -> Self {
1889 Vec4Ref(property_path, data_container)
1890 }
1891}
1892
1893impl<'a> RecordRef for Vec4Ref<'a> {
1894 fn schema_name() -> &'static str {
1895 "Vec4"
1896 }
1897}
1898
1899impl<'a> Vec4Ref<'a> {
1900 pub fn w(&self) -> F32FieldRef {
1901 F32FieldRef::new(self.0.push("w"), self.1.clone())
1902 }
1903
1904 pub fn x(&self) -> F32FieldRef {
1905 F32FieldRef::new(self.0.push("x"), self.1.clone())
1906 }
1907
1908 pub fn y(&self) -> F32FieldRef {
1909 F32FieldRef::new(self.0.push("y"), self.1.clone())
1910 }
1911
1912 pub fn z(&self) -> F32FieldRef {
1913 F32FieldRef::new(self.0.push("z"), self.1.clone())
1914 }
1915}
1916pub struct Vec4RefMut<'a>(PropertyPath, Rc<RefCell<DataContainerRefMut<'a>>>);
1917
1918impl<'a> FieldRefMut<'a> for Vec4RefMut<'a> {
1919 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<DataContainerRefMut<'a>>>) -> Self {
1920 Vec4RefMut(property_path, data_container.clone())
1921 }
1922}
1923
1924impl<'a> RecordRefMut for Vec4RefMut<'a> {
1925 fn schema_name() -> &'static str {
1926 "Vec4"
1927 }
1928}
1929
1930impl<'a> Vec4RefMut<'a> {
1931 pub fn w(self: &'a Self) -> F32FieldRefMut {
1932 F32FieldRefMut::new(self.0.push("w"), &self.1)
1933 }
1934
1935 pub fn x(self: &'a Self) -> F32FieldRefMut {
1936 F32FieldRefMut::new(self.0.push("x"), &self.1)
1937 }
1938
1939 pub fn y(self: &'a Self) -> F32FieldRefMut {
1940 F32FieldRefMut::new(self.0.push("y"), &self.1)
1941 }
1942
1943 pub fn z(self: &'a Self) -> F32FieldRefMut {
1944 F32FieldRefMut::new(self.0.push("z"), &self.1)
1945 }
1946}
1947pub struct Vec4Record(PropertyPath, Rc<RefCell<Option<DataContainer>>>);
1948
1949impl Field for Vec4Record {
1950 fn new(property_path: PropertyPath, data_container: &Rc<RefCell<Option<DataContainer>>>) -> Self {
1951 Vec4Record(property_path, data_container.clone())
1952 }
1953}
1954
1955impl Record for Vec4Record {
1956 type Reader<'a> = Vec4Ref<'a>;
1957 type Writer<'a> = Vec4RefMut<'a>;
1958 type Accessor = Vec4Accessor;
1959
1960 fn schema_name() -> &'static str {
1961 "Vec4"
1962 }
1963}
1964
1965impl Vec4Record {
1966 pub fn w(self: &Self) -> F32Field {
1967 F32Field::new(self.0.push("w"), &self.1)
1968 }
1969
1970 pub fn x(self: &Self) -> F32Field {
1971 F32Field::new(self.0.push("x"), &self.1)
1972 }
1973
1974 pub fn y(self: &Self) -> F32Field {
1975 F32Field::new(self.0.push("y"), &self.1)
1976 }
1977
1978 pub fn z(self: &Self) -> F32Field {
1979 F32Field::new(self.0.push("z"), &self.1)
1980 }
1981}