Skip to main content

rpfm_lib/files/rigidmodel/materials/
default.rs

1//---------------------------------------------------------------------------//
2// Copyright (c) 2017-2026 Ismael Gutiérrez González. All rights reserved.
3//
4// This file is part of the Rusted PackFile Manager (RPFM) project,
5// which can be found here: https://github.com/Frodo45127/rpfm.
6//
7// This file is licensed under the MIT license, which can be found here:
8// https://github.com/Frodo45127/rpfm/blob/master/LICENSE.
9//---------------------------------------------------------------------------//
10
11use super::*;
12
13//---------------------------------------------------------------------------//
14//                            Implementation
15//---------------------------------------------------------------------------//
16
17impl Material {
18    pub fn read_default<R: ReadBytes>(data: &mut R) -> Result<Self> {
19        let mut mat = Self::default();
20
21        mat.vertex_format = VertexFormat::try_from(data.read_u16()?)?;
22        mat.name = data.read_string_u8_0padded(PADDED_SIZE_32)?;
23
24        mat.texture_directory = data.read_string_u8_0padded(PADDED_SIZE_256)?;
25        mat.filters = data.read_string_u8_0padded(PADDED_SIZE_256)?;
26
27        mat.padding_byte0 = data.read_u8()?;
28        mat.padding_byte1 = data.read_u8()?;
29
30        mat.v_pivot = Vector3::new(data.read_f32()?, data.read_f32()?, data.read_f32()?);
31
32        mat.matrix1 = Matrix3x4::new(
33            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
34            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
35            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?
36        );
37        mat.matrix2 = Matrix3x4::new(
38            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
39            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
40            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?
41        );
42        mat.matrix3 = Matrix3x4::new(
43            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
44            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
45            data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?
46        );
47
48        mat.i_matrix_index = data.read_i32()?;
49        mat.i_parent_matrix_index = data.read_i32()?;
50
51        let attachment_points_count = data.read_u32()?;
52        mat.attachment_points = Vec::with_capacity(attachment_points_count as usize);
53
54        let texture_count = data.read_u32()?;
55        mat.textures = Vec::with_capacity(texture_count as usize);
56
57        let param_string_count = data.read_u32()?;
58        mat.params_string = Vec::with_capacity(param_string_count as usize);
59
60        let param_f32_count = data.read_u32()?;
61        mat.params_f32 = Vec::with_capacity(param_f32_count as usize);
62
63        let param_i32_count = data.read_u32()?;
64        mat.params_i32 = Vec::with_capacity(param_i32_count as usize);
65
66        let param_vector4df32_count = data.read_u32()?;
67        mat.params_vector4df32 = Vec::with_capacity(param_vector4df32_count as usize);
68
69        mat.sz_padding = data.read_slice(124, false)?;
70
71        // Attachment points.
72        for _ in 0..mat.attachment_points.capacity() {
73            let mut entry = AttachmentPointEntry::default();
74
75            entry.name = data.read_string_u8_0padded(PADDED_SIZE_32)?;
76            entry.matrix = Matrix3x4::new(
77                data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
78                data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?,
79                data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?
80            );
81
82            entry.bone_id = data.read_u32()?;
83
84            mat.attachment_points.push(entry);
85        }
86
87        // Textures
88        for _ in 0..mat.textures.capacity() {
89            let mut entry = Texture::default();
90
91            entry.tex_type = TextureType::try_from(data.read_i32()?)?;
92            entry.path = data.read_string_u8_0padded(PADDED_SIZE_256)?;
93
94            mat.textures.push(entry)
95        }
96
97        // Extra material params.
98        for _ in 0..mat.params_string.capacity() {
99            mat.params_string.push((data.read_i32()?, data.read_sized_string_u8()?));
100        }
101
102        for _ in 0..mat.params_f32.capacity() {
103            mat.params_f32.push((data.read_i32()?, data.read_f32()?));
104        }
105
106        for _ in 0..mat.params_i32.capacity() {
107            mat.params_i32.push((data.read_i32()?, data.read_i32()?));
108        }
109
110        for _ in 0..mat.params_vector4df32.capacity() {
111            mat.params_vector4df32.push((data.read_i32()?, Vector4::new(data.read_f32()?, data.read_f32()?, data.read_f32()?, data.read_f32()?)));
112        }
113
114        Ok(mat)
115    }
116    pub fn write_default<W: WriteBytes>(&self, buffer: &mut W) -> Result<()> {
117        buffer.write_u16(u16::from(self.vertex_format))?;
118        buffer.write_string_u8_0padded(self.name(), PADDED_SIZE_32, true)?;
119
120        buffer.write_string_u8_0padded(self.texture_directory(), PADDED_SIZE_256, true)?;
121        buffer.write_string_u8_0padded(self.filters(), PADDED_SIZE_256, true)?;
122
123        buffer.write_u8(self.padding_byte0)?;
124        buffer.write_u8(self.padding_byte1)?;
125
126        buffer.write_f32(self.v_pivot().x)?;
127        buffer.write_f32(self.v_pivot().y)?;
128        buffer.write_f32(self.v_pivot().z)?;
129
130        buffer.write_f32(self.matrix1().m11)?;
131        buffer.write_f32(self.matrix1().m12)?;
132        buffer.write_f32(self.matrix1().m13)?;
133        buffer.write_f32(self.matrix1().m14)?;
134        buffer.write_f32(self.matrix1().m21)?;
135        buffer.write_f32(self.matrix1().m22)?;
136        buffer.write_f32(self.matrix1().m23)?;
137        buffer.write_f32(self.matrix1().m24)?;
138        buffer.write_f32(self.matrix1().m31)?;
139        buffer.write_f32(self.matrix1().m32)?;
140        buffer.write_f32(self.matrix1().m33)?;
141        buffer.write_f32(self.matrix1().m34)?;
142
143        buffer.write_f32(self.matrix2().m11)?;
144        buffer.write_f32(self.matrix2().m12)?;
145        buffer.write_f32(self.matrix2().m13)?;
146        buffer.write_f32(self.matrix2().m14)?;
147        buffer.write_f32(self.matrix2().m21)?;
148        buffer.write_f32(self.matrix2().m22)?;
149        buffer.write_f32(self.matrix2().m23)?;
150        buffer.write_f32(self.matrix2().m24)?;
151        buffer.write_f32(self.matrix2().m31)?;
152        buffer.write_f32(self.matrix2().m32)?;
153        buffer.write_f32(self.matrix2().m33)?;
154        buffer.write_f32(self.matrix2().m34)?;
155
156        buffer.write_f32(self.matrix3().m11)?;
157        buffer.write_f32(self.matrix3().m12)?;
158        buffer.write_f32(self.matrix3().m13)?;
159        buffer.write_f32(self.matrix3().m14)?;
160        buffer.write_f32(self.matrix3().m21)?;
161        buffer.write_f32(self.matrix3().m22)?;
162        buffer.write_f32(self.matrix3().m23)?;
163        buffer.write_f32(self.matrix3().m24)?;
164        buffer.write_f32(self.matrix3().m31)?;
165        buffer.write_f32(self.matrix3().m32)?;
166        buffer.write_f32(self.matrix3().m33)?;
167        buffer.write_f32(self.matrix3().m34)?;
168
169        buffer.write_i32(self.i_matrix_index)?;
170        buffer.write_i32(self.i_parent_matrix_index)?;
171
172        buffer.write_i32(self.attachment_points.len() as i32)?;
173        buffer.write_i32(self.textures.len() as i32)?;
174        buffer.write_i32(self.params_string.len() as i32)?;
175        buffer.write_i32(self.params_f32.len() as i32)?;
176        buffer.write_i32(self.params_i32.len() as i32)?;
177        buffer.write_i32(self.params_vector4df32.len() as i32)?;
178
179        buffer.write_all(self.sz_padding())?;
180
181        for att_point in self.attachment_points() {
182            buffer.write_string_u8_0padded(att_point.name(), PADDED_SIZE_32, true)?;
183
184            buffer.write_f32(att_point.matrix().m11)?;
185            buffer.write_f32(att_point.matrix().m12)?;
186            buffer.write_f32(att_point.matrix().m13)?;
187            buffer.write_f32(att_point.matrix().m14)?;
188            buffer.write_f32(att_point.matrix().m21)?;
189            buffer.write_f32(att_point.matrix().m22)?;
190            buffer.write_f32(att_point.matrix().m23)?;
191            buffer.write_f32(att_point.matrix().m24)?;
192            buffer.write_f32(att_point.matrix().m31)?;
193            buffer.write_f32(att_point.matrix().m32)?;
194            buffer.write_f32(att_point.matrix().m33)?;
195            buffer.write_f32(att_point.matrix().m34)?;
196
197            buffer.write_u32(att_point.bone_id)?;
198        }
199
200        for texture in self.textures() {
201            buffer.write_i32(i32::try_from(texture.tex_type)?)?;
202            buffer.write_string_u8_0padded(texture.path(), PADDED_SIZE_256, true)?;
203        }
204
205        for (key, param) in self.params_string() {
206            buffer.write_i32(*key)?;
207            buffer.write_sized_string_u8(param)?;
208        }
209
210        for (key, param) in self.params_f32() {
211            buffer.write_i32(*key)?;
212            buffer.write_f32(*param)?;
213        }
214
215        for (key, param) in self.params_i32() {
216            buffer.write_i32(*key)?;
217            buffer.write_i32(*param)?;
218        }
219
220        for (key, param) in self.params_vector4df32() {
221            buffer.write_i32(*key)?;
222            buffer.write_f32(param.x)?;
223            buffer.write_f32(param.y)?;
224            buffer.write_f32(param.z)?;
225            buffer.write_f32(param.w)?;
226        }
227
228        Ok(())
229    }
230}