fix: transparency, and fix #43

.gitignore

@@ -2,3 +2,4 @@ target
 .vscode
 tools
 res
+resources/*.png

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blue_engine"
-version = "0.4.30"
+version = "0.4.31"
 authors = ["Elham Aryanpur <elhamaryanpur5@gmail.com>"]
 edition = "2021"
 description = "General-Purpose, Easy-to-use, Fast, and Portable graphics engine"

examples/dev/dev.rs

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 use blue_engine::{
     primitive_shapes::{cube, square, triangle, uv_sphere},
     uniform_type::Matrix,
@@ -24,7 +26,16 @@ fn main() {
         .renderer
         .build_texture(
             "background",
-            TextureData::Path("resources/SimpleJacob.png"),
+            TextureData::Path("resources/player.png"),
+            blue_engine::TextureMode::Clamp,
+        )
+        .unwrap();
+
+    let texture3 = engine
+        .renderer
+        .build_texture(
+            "background",
+            TextureData::Path("resources/image.png"),
             blue_engine::TextureMode::Clamp,
         )
         .unwrap();
@@ -56,6 +67,23 @@ fn main() {
         .unwrap()
         .set_position(0.2f32, 0f32, 0.001f32);
 
+    square(
+        "alt2",
+        ObjectSettings::default(),
+        &mut engine.renderer,
+        &mut engine.objects,
+    );
+    engine
+        .objects
+        .get_mut("alt2")
+        .unwrap()
+        .set_texture(texture3);
+    engine
+        .objects
+        .get_mut("alt2")
+        .unwrap()
+        .set_position(-0.2f32, 0f32, 0.001f32);
+
     let speed = -0.05;
     engine
         .update_loop(move |renderer, _window, objects, input, camera, plugins| {

src/header.rs

@@ -366,7 +366,7 @@ impl Default for ShaderSettings {
             conservative: false,
             count: 1,
             mask: !0,
-            alpha_to_coverage_enabled: false,
+            alpha_to_coverage_enabled: true,
         }
     }
 }

src/objects.rs

@@ -32,9 +32,11 @@ impl Renderer {
             ),
         ])?;
 
+        let shader_source = ShaderBuilder::new(DEFAULT_SHADER.to_string(), settings.camera_effect);
+
         let shader = self.build_shader(
             name.as_str(),
-            DEFAULT_SHADER.to_string(),
+            shader_source.shader.clone(),
             Some(&uniform.1),
             settings.shader_settings,
         )?;
@@ -84,7 +86,7 @@ impl Renderer {
             color: crate::uniform_type::Array4 {
                 data: crate::utils::default_resources::DEFAULT_COLOR,
             },
-            shader_builder: ShaderBuilder::new(settings.camera_effect),
+            shader_builder: shader_source,
             shader_settings: settings.shader_settings,
             camera_effect: settings.camera_effect,
             uniform_buffers: vec![
@@ -505,94 +507,50 @@ impl Object {
 #[derive(Debug)]
 pub struct ShaderBuilder {
     pub shader: String,
+    pub camera_effect: bool,
+    pub configs: Vec<(String, (String, String))>,
 }
 
 impl ShaderBuilder {
-    pub fn new(camera_effect: bool) -> Self {
-        Self {
-            shader: format!(
-                "{}{}{}",
-                format!(
-                    // step 1 define blocks
-                    "\n{}\n{}\n{}",
-                    r#"
-struct TransformationUniforms {
-    transform_matrix: mat4x4<f32>,
-};
-@group(2) @binding(0)
-var<uniform> transform_uniform: TransformationUniforms;"#,
+    pub fn new(shader_source: String, camera_effect: bool) -> Self {
+        let mut shader_builder = Self {
+            shader: shader_source,
+            camera_effect,
+            configs: vec![(
+                "//@CAMERA_STRUCT".to_string(),
+                (
                     r#"
-struct FragmentUniforms {
-    color: vec4<f32>,
-};
-@group(2) @binding(1)
-var<uniform> fragment_uniforms: FragmentUniforms;"#,
-                    if camera_effect {
-                        r#"
-struct CameraUniforms {
-    camera_matrix: mat4x4<f32>,
-};
-@group(1) @binding(0)
-var<uniform> camera_uniform: CameraUniforms;"#
-                    } else {
-                        ""
-                    }
+            struct CameraUniforms {
+                camera_matrix: mat4x4<f32>,
+            };
+            @group(1) @binding(0)
+            var<uniform> camera_uniform: CameraUniforms;"#
+                        .to_string(),
+                    r#""#.to_string(),
                 ),
-                format!(
-                    // step 2 define input and output for vertex
-                    "\n{}",
-                    r#"struct VertexInput {
-    @location(0) position: vec3<f32>,
-    @location(1) texture_coordinates: vec2<f32>,
-};
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) texture_coordinates: vec2<f32>,
-};
-
-struct InstanceInput {
-    @location(3) model_matrix_0: vec4<f32>,
-    @location(4) model_matrix_1: vec4<f32>,
-    @location(5) model_matrix_2: vec4<f32>,
-    @location(6) model_matrix_3: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var texture_diffuse: texture_2d<f32>;
-
-@group(0) @binding(1)
-var sampler_diffuse: sampler;"#
+            ), (
+                "//@CAMERA_VERTEX".to_string(),
+                (
+                    r#"out.position = camera_uniform.camera_matrix * model_matrix * (transform_uniform.transform_matrix * vec4<f32>(input.position, 1.0));"#
+                        .to_string(),
+                    r#"out.position = model_matrix * (transform_uniform.transform_matrix * vec4<f32>(input.position, 1.0));"#.to_string(),
                 ),
-                format!(
-                    // step 4 vertex stage according to data before
-                    "\n// ===== VERTEX STAGE ===== //\n{}\n{}\n{}",
-                    r#"@vertex
-fn vs_main(input: VertexInput, instance: InstanceInput,) -> VertexOutput {
-    let model_matrix = mat4x4<f32>(
-        instance.model_matrix_0,
-        instance.model_matrix_1,
-        instance.model_matrix_2,
-        instance.model_matrix_3,
-    );
-
-    var out: VertexOutput;
-    out.texture_coordinates = input.texture_coordinates;"#,
-                    if camera_effect {
-                        "out.position = camera_uniform.camera_matrix * model_matrix * (transform_uniform.transform_matrix * vec4<f32>(input.position, 1.0));"
-                    } else {
-                        "out.position = model_matrix * (transform_uniform.transform_matrix * vec4<f32>(input.position, 1.0));"
-                    },
-                    r#"return out;
-}
+            )],
+        };
+        shader_builder.build();
 
-// ===== Fragment STAGE ===== //
-@fragment
-fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
-    return textureSample(texture_diffuse, sampler_diffuse, input.texture_coordinates) * fragment_uniforms.color;
-}"#
-                )
-            ),
+        shader_builder
+    }
+
+    pub fn build(&mut self) {
+        if self.camera_effect {
+            for i in &self.configs {
+                self.shader = self.shader.replace(&i.0, &i.1 .0);
+            }
+        } else {
+            for i in &self.configs {
+                self.shader = self.shader.replace(&i.0, &i.1 .1);
+            }
         }
     }
 }

src/utils/default_resources.rs

@@ -4,75 +4,7 @@
  * The license is same as the one on the root.
 */
 
-pub const DEFAULT_SHADER: &str = r#"
-// Vertex Stage
-
-
-struct CameraUniforms {
-    camera_matrix: mat4x4<f32>,
-};
-@group(1) @binding(0)
-var<uniform> camera_uniform: CameraUniforms;
-
-
-struct TransformationUniforms {
-    transform_matrix: mat4x4<f32>,
-};
-@group(2) @binding(0)
-var<uniform> transform_uniform: TransformationUniforms;
-
-struct VertexInput {
-    @location(0) position: vec3<f32>,
-    @location(1) texture_coordinates: vec2<f32>,
-};
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) texture_coordinates: vec2<f32>,
-};
-
-struct InstanceInput {
-    @location(3) model_matrix_0: vec4<f32>,
-    @location(4) model_matrix_1: vec4<f32>,
-    @location(5) model_matrix_2: vec4<f32>,
-    @location(6) model_matrix_3: vec4<f32>,
-};
-
-@vertex
-fn vs_main(input: VertexInput, instance: InstanceInput) -> VertexOutput {
-    let model_matrix = mat4x4<f32>(
-        instance.model_matrix_0,
-        instance.model_matrix_1,
-        instance.model_matrix_2,
-        instance.model_matrix_3,
-    );
-
-    var out: VertexOutput;
-    out.texture_coordinates = input.texture_coordinates;
-    out.position = camera_uniform.camera_matrix * model_matrix * (transform_uniform.transform_matrix * vec4<f32>(input.position, 1.0));
-    return out;
-}
-
-// Fragment Stage
-
-
-struct FragmentUniforms {
-    color: vec4<f32>,
-};
-@group(2) @binding(1)
-var<uniform> fragment_uniforms: FragmentUniforms;
-
-@group(0) @binding(0)
-var texture_diffuse: texture_2d<f32>;
-
-@group(0) @binding(1)
-var sampler_diffuse: sampler;
-
-@fragment
-fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
-    return textureSample(texture_diffuse, sampler_diffuse, input.texture_coordinates) * fragment_uniforms.color;
-}
-"#;
+pub const DEFAULT_SHADER: &str = include_str!("./default_shader.wgsl");
 
 pub const DEFAULT_TEXTURE: &[u8] = &[
     137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0,
@@ -101,7 +33,7 @@ pub const DEFAULT_TEXTURE: &[u8] = &[
     174, 66, 96, 130,
 ];
 
-pub const DEFAULT_COLOR: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
+pub const DEFAULT_COLOR: [f32; 4] = [1.0, 1.0, 1.0, 0.0];
 
 pub const DEFAULT_MATRIX_4: crate::header::uniform_type::Matrix =
     crate::header::uniform_type::Matrix {

src/utils/default_shader.wgsl

@@ -0,0 +1,64 @@
+// blocks
+
+//@CAMERA_STRUCT
+
+struct TransformationUniforms {
+    transform_matrix: mat4x4<f32>,
+};
+@group(2) @binding(0)
+var<uniform> transform_uniform: TransformationUniforms;
+
+struct VertexInput {
+    @location(0) position: vec3<f32>,
+    @location(1) texture_coordinates: vec2<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texture_coordinates: vec2<f32>,
+};
+
+struct InstanceInput {
+    @location(3) model_matrix_0: vec4<f32>,
+    @location(4) model_matrix_1: vec4<f32>,
+    @location(5) model_matrix_2: vec4<f32>,
+    @location(6) model_matrix_3: vec4<f32>,
+};
+
+// Vertex Stage
+@vertex
+fn vs_main(input: VertexInput, instance: InstanceInput) -> VertexOutput {
+    let model_matrix = mat4x4<f32>(
+        instance.model_matrix_0,
+        instance.model_matrix_1,
+        instance.model_matrix_2,
+        instance.model_matrix_3,
+    );
+
+    var out: VertexOutput;
+    out.texture_coordinates = input.texture_coordinates;
+    //@CAMERA_VERTEX
+    return out;
+}
+
+// Fragment Stage
+struct FragmentUniforms {
+    color: vec4<f32>,
+};
+@group(2) @binding(1)
+var<uniform> fragment_uniforms: FragmentUniforms;
+
+@group(0) @binding(0)
+var texture_diffuse: texture_2d<f32>;
+
+@group(0) @binding(1)
+var sampler_diffuse: sampler;
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+    if fragment_uniforms.color.w == 0.0 {
+        return textureSample(texture_diffuse, sampler_diffuse, input.texture_coordinates);
+    } else {
+        return textureSample(texture_diffuse, sampler_diffuse, input.texture_coordinates) * fragment_uniforms.color;
+    }
+}