Add model scaling

lightweight_viewer/src/char_draw.rs

···
         _ => Vec3::ZERO,
     };
 
+    let scale = match shape_kind {
+        Shape::Glasses => Vec3::splat(0.15 * f32::from(st.char_info.glass_scale) + 0.4), // RFL_Model.c :784
+        Shape::Nose => Vec3::splat(0.175 * f32::from(st.char_info.nose_scale) + 0.4), // RFL_Model.c :705
+        _ => Vec3::ONE,
+    };
+
     // Closure to reduce boilerplate for writing out textures.
     let mut draw_tex = |func: fn(&mut State, &TextureView, &mut CommandEncoder), size: UVec2| {
         let texture = texture::Texture::create_texture(
···
         shape_kind,
         usize::from(shape_color),
         position,
+        scale,
         projected_texture,
     ))
 }
···
     shape: Shape,
     color: usize,
     position: Vec3,
+    scale: Vec3,
     projected_texture: Option<texture::Texture>,
 ) -> Rendered3dShape {
     let mut vertices: Vec<Vertex> = vec![];
···
         },
         texture: projected_texture,
         position,
+        scale,
     }
 }

lightweight_viewer/src/main.rs

···
     )
 }
 
-const FACES: [&str; 1] = [
+const FACES: [&str; 4] = [
     // "testguy.charinfo",
-    // "j0.charinfo",
-    // "charline.charinfo",
+    "j0.charinfo",
+    "charline.charinfo",
     "Jasmine.charinfo",
-    // "soyun.charinfo",
+    "soyun.charinfo",
 ];
 
 fn main() {

vfl/src/draw/render_3d.rs

···
     diffuse_color: [f32; 4],
     position: [f32; 3],
     _pad: f32,
+    scale: [f32; 3],
+    _pad2: f32,
 }
 
 pub trait ProgramState {
···
     pub color: Vec4,
     pub texture: Option<crate::draw::wgpu_render::texture::Texture>,
     pub position: Vec3,
+    pub scale: Vec3,
 }
 
 impl Rendered3dShape {
···
             diffuse_color: self.color.into(),
             position: self.position.into(),
             _pad: 0.0,
+            scale: self.scale.into(),
+            _pad2: 0.0,
         };
         let char_shape_buffer = st
             .device()
···
             bind_group_layouts.push(&projected_texture_bind_group_layout);
         }
 
-        let shader_module = if self.texture.is_some() {
-            st.device()
-                .create_shader_module(include_wgsl!("shader-3d-texture.wgsl"))
-        } else {
-            st.device()
-                .create_shader_module(include_wgsl!("shader-3d.wgsl"))
-        };
+        let shader_module = st
+            .device()
+            .create_shader_module(include_wgsl!("shader_3d.wgsl"));
 
         // Optional projected texture
         let projected_texture_bind_group = self.texture.as_ref().map(|texture| {
···
                 },
                 fragment: Some(wgpu::FragmentState {
                     module: &shader_module,
-                    entry_point: Some("fs_main"),
+                    entry_point: if self.texture.is_some() {
+                        Some("fs_main")
+                    } else {
+                        Some("fs_color_only")
+                    },
                     targets: &[Some(wgpu::ColorTargetState {
                         format: st.surface_fmt().add_srgb_suffix(),
                         blend: Some(BlendState::ALPHA_BLENDING),

vfl/src/draw/shader-3d-texture.wgsl vfl/src/draw/shader_3d.wgsl

···
 
 struct CharShapeUniform {
     color: vec4<f32>,
-    position: vec3<f32>
+    position: vec3<f32>,
+    scale: vec3<f32>
+}
 
-}
 @group(1) @binding(0)
 var<uniform> char_shape: CharShapeUniform;
 
···
     var out: VertexOutput;
     out.tex_coords = model.tex_coords;
     out.world_normal = model.normal;
-    var world_position: vec4<f32> = vec4<f32>(model.position + char_shape.position, 1.0);
+    var world_position: vec4<f32> = vec4<f32>((char_shape.scale * model.position) + char_shape.position, 1.0);
     out.world_position = world_position.xyz;
     out.clip_position = camera.view_proj * world_position;
     return out;
···
     let sample_position = in.tex_coords;
     let tex_color = textureSample(t_diffuse, s_diffuse, sample_position);
 
-    // if tex_color.a == 0.0 {
-    //    discard;
-    // }
+    let color = mix(char_shape.color, tex_color, tex_color.a);
+
+    if color.a == 0.0 {
+       discard;
+    }
+
+    return color;
+
+}
 
-    // return tex_color;
 
-    return mix(char_shape.color, tex_color, tex_color.a);
+@fragment
+fn fs_color_only(in: VertexOutput) -> @location(0) vec4<f32> {
+    let color = char_shape.color;
 
+    if color.a == 0.0 {
+        discard;
+    }
+
+    return color;
 }

vfl/src/draw/shader-3d.wgsl

···
-struct CameraUniform {
-    view_proj: mat4x4<f32>,
-};
-@group(0) @binding(0)
-var<uniform> camera: CameraUniform;
-
-struct CharShapeUniform {
-    color: vec4<f32>,
-    position: vec3<f32>
-}
-@group(1) @binding(0)
-var<uniform> char_shape: CharShapeUniform;
-
-struct VertexInput {
-    @location(0) position: vec3<f32>,
-    @location(1) tex_coords: vec2<f32>,
-    @location(2) normal: vec3<f32>,
-}
-
-struct VertexOutput {
-    @builtin(position) clip_position: vec4<f32>,
-    @location(0) tex_coords: vec2<f32>,
-    @location(1) world_normal: vec3<f32>,
-    @location(2) world_position: vec3<f32>,
-}
-
-@vertex
-fn vs_main(
-    model: VertexInput,
-    // instance: InstanceInput,
-) -> VertexOutput {
-    var out: VertexOutput;
-    out.tex_coords = model.tex_coords;
-    out.world_normal = model.normal;
-    var world_position: vec4<f32> = vec4<f32>(model.position + char_shape.position, 1.0);
-    out.world_position = world_position.xyz;
-    out.clip_position = camera.view_proj * world_position;
-    return out;
-}
-
-// Fragment shader
-
-@fragment
-fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-
-    let color = char_shape.color;
-
-    if color.a == 0.0 {
-        discard;
-    }
-    return color;
-    // let object_color: vec4<f32> = textureSample(t_diffuse, s_diffuse, in.tex_coords);
-
-    // // We don't need (or want) much ambient light, so 0.1 is fine
-    // let ambient_strength = 0.1;
-    // let ambient_color = light.color * ambient_strength;
-
-    // let light_dir = normalize(light.position - in.world_position);
-    // let view_dir = normalize(camera.view_pos.xyz - in.world_position);
-    // let half_dir = normalize(view_dir + light_dir);
-
-    // let diffuse_strength = max(dot(in.world_normal, light_dir), 0.0);
-    // let diffuse_color = light.color * diffuse_strength;
-
-    // let specular_strength = pow(max(dot(in.world_normal, half_dir), 0.0), 32.0);
-    // let specular_color = specular_strength * light.color;
-
-    // let result = (ambient_color + diffuse_color + specular_color) * object_color.xyz;
-
-    // return vec4<f32>(result, object_color.a);
-}