Try and parse shader file

fn find_subsequence(haystack: &[u8], needle: &str) -> Option<usize> {
    haystack
        .windows(needle.len())
        .position(|window| window == needle.as_bytes())
}

// Rust implementation of CPP:
// https://github.com/TheCherno/Hazel/blob/7d120fb4250ecdebdcdc93137bbec7413a9bb7e2/Hazel/src/Platform/OpenGL/OpenGLShader.cpp#L66

            use std::io::Read;
            let mut parts: HashMap<ShaderStageFlags, ShaderStageInput> = HashMap::new();

            let mut file = match std::fs::File::open(&input) {
                Err(why) => panic!("couldn't open {}: {:?}", input.display(), why),
                Ok(file) => file,
            };

            let mut data = Vec::new();
            file.read_to_end(&mut data)
                .unwrap_or_else(|why| panic!("couldn't slurp {}: {:?}", input.display(), why));

            /*
            // Basic Texture Shader

            #type vertex
            #version 330 core

            #extension GL_ARB_separate_shader_objects : enable
            #extension GL_ARB_shading_language_420pack : enable

            layout(location = 0) in vec3 a_Position;
            layout(location = 1) in vec2 a_TexCoord;

            layout(set = 0, binding = 0) uniform UBO {
                mat4 ViewProjection;
                mat4 Transform;
            } u;

            out vec2 v_TexCoord;

            void main()
            {
                v_TexCoord = a_TexCoord;
                gl_Position = u.ViewProjection * u.Transform * vec4(a_Position, 1.0);
            }

            #type fragment
            #version 330 core

            layout(location = 0) out vec4 color;

            in vec2 v_TexCoord;

            uniform sampler2D u_Texture;

            void main()
            {
                color = texture(u_Texture, v_TexCoord);
            }
            */
            let type_token = "#type";
            let mut pos = find_subsequence(&data, type_token);
            while let Some(_pos) = pos {
                use std::str::from_utf8;
                data = data[_pos + 1..].to_vec();
                let mut iter = data.iter();
                let t = iter.try_fold(Vec::new(), |t, &val| match val { 10 | 13 /* '\n' | '\r' */ => None, v => { let mut _t = t; _t.push(v); Some(_t) } }).unwrap();
                data = iter
                    .skip(t.len())
                    .skip_while(|val| match val { 10 | 13 /* '\n' | '\r' */ => true, _ => false })
                    .map(|v| *v)
                    .collect();
                pos = find_subsequence(&data, type_token);
                parts.insert(
                    match from_utf8(&t[..]).unwrap() {
                        "vertex" => ShaderStageFlags::VERTEX,
                        "fragment" => ShaderStageFlags::FRAGMENT,
                        _ => ShaderStageFlags::VERTEX,
                    },
                    ShaderStageInput::Code(
                        from_utf8(if let Some(_pos) = pos {
                            &data[.._pos]
                        } else {
                            &data[..]
                        })
                        .unwrap()
                        .to_owned(),
                    ),
                );
            }