Fix crashes on MacOS

1 files changed, 0 insertions, 340 deletions

diff --git a/src_testbed/lines/render_dim.rs b/src_testbed/lines/render_dim.rs
deleted file mode 100644
index f339cdb..0000000
--- a/src_testbed/lines/render_dim.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-pub mod r3d {
-    use bevy_core_pipeline::core_3d::Opaque3d;
-    use bevy_pbr::{
-        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
-        SetMeshViewBindGroup,
-    };
-
-    use bevy::{
-        prelude::*,
-        render::{
-            mesh::MeshVertexBufferLayout,
-            render_asset::RenderAssets,
-            render_phase::{DrawFunctions, RenderPhase, SetItemPipeline},
-            render_resource::{
-                BlendState, ColorTargetState, ColorWrites, CompareFunction, DepthBiasState,
-                DepthStencilState, FragmentState, FrontFace, MultisampleState, PipelineCache,
-                PolygonMode, PrimitiveState, PrimitiveTopology, RenderPipelineDescriptor,
-                SpecializedMeshPipeline, SpecializedMeshPipelineError, SpecializedMeshPipelines,
-                StencilFaceState, StencilState, TextureFormat, VertexAttribute, VertexBufferLayout,
-                VertexFormat, VertexState, VertexStepMode,
-            },
-            texture::BevyDefault,
-            view::{ExtractedView, Msaa},
-        },
-        utils::Hashed,
-    };
-
-    use crate::lines::{DebugLinesConfig, RenderDebugLinesMesh, DEBUG_LINES_SHADER_HANDLE};
-
-    #[derive(Resource)]
-    pub(crate) struct DebugLinePipeline {
-        mesh_pipeline: MeshPipeline,
-        shader: Handle<Shader>,
-        //always_in_front: bool,
-    }
-    impl FromWorld for DebugLinePipeline {
-        fn from_world(render_world: &mut World) -> Self {
-            //let config = render_world.get_resource::<DebugLinesConfig>().unwrap();
-            DebugLinePipeline {
-                mesh_pipeline: render_world.get_resource::<MeshPipeline>().unwrap().clone(),
-                shader: DEBUG_LINES_SHADER_HANDLE.typed(),
-                //always_in_front: config.always_in_front,
-            }
-        }
-    }
-
-    impl SpecializedMeshPipeline for DebugLinePipeline {
-        type Key = (bool, MeshPipelineKey);
-
-        fn specialize(
-            &self,
-            (depth_test, key): Self::Key,
-            layout: &MeshVertexBufferLayout,
-        ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
-            //use VertexFormat::{Float32x3, Float32x4};
-
-            let mut shader_defs = Vec::new();
-            shader_defs.push("LINES_3D".to_string().into());
-            if depth_test {
-                shader_defs.push("DEPTH_TEST_ENABLED".to_string().into());
-            }
-
-            let vertex_buffer_layout = layout.get_layout(&[
-                Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
-                Mesh::ATTRIBUTE_COLOR.at_shader_location(1),
-            ])?;
-            let (label, blend, depth_write_enabled);
-            if key.contains(MeshPipelineKey::BLEND_ALPHA) {
-                label = "transparent_mesh_pipeline".into();
-                blend = Some(BlendState::ALPHA_BLENDING);
-                // For the transparent pass, fragments that are closer will be alpha
-                // blended but their depth is not written to the depth buffer.
-                depth_write_enabled = false;
-            } else {
-                label = "opaque_mesh_pipeline".into();
-                blend = Some(BlendState::REPLACE);
-                // For the opaque and alpha mask passes, fragments that are closer
-                // will replace the current fragment value in the output and the depth is
-                // written to the depth buffer.
-                depth_write_enabled = true;
-            }
-
-            Ok(RenderPipelineDescriptor {
-                vertex: VertexState {
-                    shader: self.shader.clone_weak(),
-                    entry_point: "vertex".into(),
-                    shader_defs: shader_defs.clone(),
-                    buffers: vec![vertex_buffer_layout],
-                },
-                fragment: Some(FragmentState {
-                    shader: self.shader.clone_weak(),
-                    shader_defs,
-                    entry_point: "fragment".into(),
-                    targets: vec![Some(ColorTargetState {
-                        format: TextureFormat::bevy_default(),
-                        blend,
-                        write_mask: ColorWrites::ALL,
-                    })],
-                }),
-                layout: vec![self.mesh_pipeline.view_layout.clone()],
-                primitive: PrimitiveState {
-                    front_face: FrontFace::Ccw,
-                    cull_mode: None,
-                    unclipped_depth: false,
-                    polygon_mode: PolygonMode::Fill,
-                    conservative: false,
-                    topology: PrimitiveTopology::LineList,
-                    strip_index_format: None,
-                },
-                depth_stencil: Some(DepthStencilState {
-                    format: TextureFormat::Depth32Float,
-                    depth_write_enabled,
-                    depth_compare: CompareFunction::Greater,
-                    stencil: StencilState {
-                        front: StencilFaceState::IGNORE,
-                        back: StencilFaceState::IGNORE,
-                        read_mask: 0,
-                        write_mask: 0,
-                    },
-                    bias: DepthBiasState {
-                        constant: 0,
-                        slope_scale: 0.0,
-                        clamp: 0.0,
-                    },
-                }),
-                multisample: MultisampleState {
-                    count: key.msaa_samples(),
-                    mask: !0,
-                    alpha_to_coverage_enabled: false,
-                },
-                label: Some(label),
-                push_constant_ranges: vec![],
-            })
-        }
-    }
-
-    pub(crate) fn queue(
-        opaque_3d_draw_functions: Res<DrawFunctions<Opaque3d>>,
-        debug_line_pipeline: Res<DebugLinePipeline>,
-        mut pipelines: ResMut<SpecializedMeshPipelines<DebugLinePipeline>>,
-        mut pipeline_cache: ResMut<PipelineCache>,
-        render_meshes: Res<RenderAssets<Mesh>>,
-        msaa: Res<Msaa>,
-        material_meshes: Query<(Entity, &MeshUniform, &Handle<Mesh>), With<RenderDebugLinesMesh>>,
-        config: Res<DebugLinesConfig>,
-        mut views: Query<(&ExtractedView, &mut RenderPhase<Opaque3d>)>,
-    ) {
-        let draw_custom = opaque_3d_draw_functions
-            .read()
-            .get_id::<DrawDebugLines>()
-            .unwrap();
-        let key = MeshPipelineKey::from_msaa_samples(msaa.samples());
-        for (view, mut transparent_phase) in views.iter_mut() {
-            let view_matrix = view.transform.compute_matrix();
-            let view_row_2 = view_matrix.row(2);
-            for (entity, mesh_uniform, mesh_handle) in material_meshes.iter() {
-                if let Some(mesh) = render_meshes.get(mesh_handle) {
-                    let pipeline = pipelines
-                        .specialize(
-                            &mut pipeline_cache,
-                            &debug_line_pipeline,
-                            (config.depth_test, key),
-                            &mesh.layout,
-                        )
-                        .unwrap();
-                    transparent_phase.add(Opaque3d {
-                        entity,
-                        pipeline,
-                        draw_function: draw_custom,
-                        distance: view_row_2.dot(mesh_uniform.transform.col(3)),
-                    });
-                }
-            }
-        }
-    }
-
-    pub(crate) type DrawDebugLines = (
-        SetItemPipeline,
-        SetMeshViewBindGroup<0>,
-        SetMeshBindGroup<1>,
-        DrawMesh,
-    );
-}
-
-pub mod r2d {
-    use bevy::{
-        asset::Handle,
-        prelude::*,
-        render::{
-            mesh::MeshVertexBufferLayout,
-            render_asset::RenderAssets,
-            render_phase::{DrawFunctions, RenderPhase, SetItemPipeline},
-            render_resource::{
-                BlendState, ColorTargetState, ColorWrites, CompareFunction, DepthBiasState,
-                DepthStencilState, FragmentState, FrontFace, MultisampleState, PipelineCache,
-                PolygonMode, PrimitiveState, PrimitiveTopology, RenderPipelineDescriptor, Shader,
-                SpecializedMeshPipeline, SpecializedMeshPipelineError, SpecializedMeshPipelines,
-                StencilFaceState, StencilState, TextureFormat, VertexAttribute, VertexBufferLayout,
-                VertexFormat, VertexState, VertexStepMode,
-            },
-            texture::BevyDefault,
-            view::{Msaa, VisibleEntities},
-        },
-        utils::FloatOrd,
-    };
-    use bevy_core_pipeline::core_2d::Transparent2d;
-    use bevy_sprite::{
-        DrawMesh2d, Mesh2dHandle, Mesh2dPipeline, Mesh2dPipelineKey, Mesh2dUniform,
-        SetMesh2dBindGroup, SetMesh2dViewBindGroup,
-    };
-
-    use crate::lines::{RenderDebugLinesMesh, DEBUG_LINES_SHADER_HANDLE};
-
-    #[derive(Resource)]
-    pub(crate) struct DebugLinePipeline {
-        mesh_pipeline: Mesh2dPipeline,
-        shader: Handle<Shader>,
-    }
-    impl FromWorld for DebugLinePipeline {
-        fn from_world(render_world: &mut World) -> Self {
-            DebugLinePipeline {
-                mesh_pipeline: render_world
-                    .get_resource::<Mesh2dPipeline>()
-                    .unwrap()
-                    .clone(),
-                shader: DEBUG_LINES_SHADER_HANDLE.typed(),
-            }
-        }
-    }
-
-    impl SpecializedMeshPipeline for DebugLinePipeline {
-        type Key = Mesh2dPipelineKey;
-
-        fn specialize(
-            &self,
-            key: Self::Key,
-            layout: &MeshVertexBufferLayout,
-        ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
-            /*
-                        let mut shader_defs = Vec::new();
-                        shader_defs.push("LINES_3D".to_string());
-                        if depth_test {
-                            shader_defs.push("DEPTH_TEST_ENABLED".to_string());
-                        }
-            */
-
-            let vertex_buffer_layout = layout.get_layout(&[
-                Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
-                Mesh::ATTRIBUTE_COLOR.at_shader_location(1),
-            ])?;
-
-            Ok(RenderPipelineDescriptor {
-                vertex: VertexState {
-                    shader: self.shader.clone_weak(),
-                    entry_point: "vertex".into(),
-                    shader_defs: vec![],
-                    buffers: vec![vertex_buffer_layout],
-                },
-                fragment: Some(FragmentState {
-                    shader: self.shader.clone_weak(),
-                    shader_defs: vec![],
-                    entry_point: "fragment".into(),
-                    targets: vec![Some(ColorTargetState {
-                        format: TextureFormat::bevy_default(),
-                        blend: Some(BlendState::ALPHA_BLENDING),
-                        write_mask: ColorWrites::ALL,
-                    })],
-                }),
-                layout: vec![self.mesh_pipeline.view_layout.clone()],
-                primitive: PrimitiveState {
-                    front_face: FrontFace::Ccw,
-                    cull_mode: None,
-                    unclipped_depth: false,
-                    polygon_mode: PolygonMode::Fill,
-                    conservative: false,
-                    topology: PrimitiveTopology::LineList,
-                    strip_index_format: None,
-                },
-                depth_stencil: None,
-                multisample: MultisampleState {
-                    count: key.msaa_samples(),
-                    mask: !0,
-                    alpha_to_coverage_enabled: false,
-                },
-                label: None,
-                push_constant_ranges: vec![],
-            })
-        }
-    }
-
-    pub(crate) fn queue(
-        draw2d_functions: Res<DrawFunctions<Transparent2d>>,
-        debug_line_pipeline: Res<DebugLinePipeline>,
-        mut pipeline_cache: ResMut<PipelineCache>,
-        mut specialized_pipelines: ResMut<SpecializedMeshPipelines<DebugLinePipeline>>,
-        render_meshes: Res<RenderAssets<Mesh>>,
-        msaa: Res<Msaa>,
-        material_meshes: Query<(&Mesh2dUniform, &Mesh2dHandle), With<RenderDebugLinesMesh>>,
-        mut views: Query<(&VisibleEntities, &mut RenderPhase<Transparent2d>)>,
-    ) {
-        for (view, mut phase) in views.iter_mut() {
-            let draw_mesh2d = draw2d_functions.read().get_id::<DrawDebugLines>().unwrap();
-            let msaa_key = Mesh2dPipelineKey::from_msaa_samples(msaa.samples());
-
-            for visible_entity in &view.entities {
-                if let Ok((uniform, mesh_handle)) = material_meshes.get(*visible_entity) {
-                    if let Some(mesh) = render_meshes.get(&mesh_handle.0) {
-                        let mesh_key = msaa_key
-                            | Mesh2dPipelineKey::from_primitive_topology(
-                                PrimitiveTopology::LineList,
-                            );
-                        let mesh_z = uniform.transform.w_axis.z;
-                        let pipeline = specialized_pipelines
-                            .specialize(
-                                &mut pipeline_cache,
-                                &debug_line_pipeline,
-                                mesh_key,
-                                &mesh.layout,
-                            )
-                            .unwrap();
-                        phase.add(Transparent2d {
-                            entity: *visible_entity,
-                            draw_function: draw_mesh2d,
-                            pipeline,
-                            sort_key: FloatOrd(mesh_z),
-                            batch_range: None,
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    pub(crate) type DrawDebugLines = (
-        SetItemPipeline,
-        SetMesh2dViewBindGroup<0>,
-        SetMesh2dBindGroup<1>,
-        DrawMesh2d,
-    );
-}