以下是根据您提供的内容整理的完整示例demo，包含窗口创建、着色器程序、三角形渲染和纹理加载的完整实现：

extern crate gfx_gl;
extern crate glutin;
extern crate image;

use gfx_gl::{Gl, Shader, Program};

fn main() {
    // 1. 创建窗口和OpenGL上下文
    let mut events_loop = glutin::EventsLoop::new();
    let window = glutin::WindowBuilder::new()
        .with_title("gfx_gl 示例")
        .with_dimensions(800, 600);
    let context = glutin::ContextBuilder::new()
        .with_vsync(true);
    let gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();
    
    // 2. 加载OpenGL函数指针
    let gl = gfx_gl::Gl::load_with(|s| gl_window.get_proc_address(s));
    
    // 3. 创建着色器程序
    let program = match create_shader_program(&gl) {
        Ok(p) => p,
        Err(e) => {
            println!("着色器编译错误: {}", e);
            return;
        }
    };
    
    // 4. 加载纹理 (可选)
    let texture = match load_texture(&gl, "texture.png") {
        Ok(t) => Some(t),
        Err(e) => {
            println!("纹理加载失败: {}", e);
            None
        }
    };
    
    // 5. 主循环
    let mut running = true;
    while running {
        events_loop.poll_events(|event| {
            if let glutin::Event::WindowEvent { event, .. } = event {
                match event {
                    glutin::WindowEvent::Closed => running = false,
                    _ => (),
                }
            }
        });
        
        // 清除颜色缓冲
        gl.ClearColor(0.2, 0.3, 0.3, 1.0);
        gl.Clear(gfx_gl::COLOR_BUFFER_BIT);
        
        // 渲染三角形
        render_triangle(&gl, &program);
        
        gl_window.swap_buffers().unwrap();
    }
}

fn create_shader_program(gl: &Gl) -> Result<Program, String> {
    // 顶点着色器源码
    let vs_src = r#"
        #version 330 core
        layout (location = 0) in vec3 aPos;
        void main() {
            gl_Position = vec4(aPos, 1.0);
        }
    "#;
    
    // 片段着色器源码
    let fs_src = r#"
        #version 330 core
        out vec4 FragColor;
        void main() {
            FragColor = vec4(1.0, 0.5, 0.2, 1.0);
        }
    "#;
    
    // 编译着色器
    let vs = Shader::new(gl, gfx_gl::VERTEX_SHADER, vs_src)?;
    let fs = Shader::new(gl, gfx_gl::FRAGMENT_SHADER, fs_src)?;
    
    // 创建着色器程序
    Program::new(gl, &[vs, fs])
}

fn render_triangle(gl: &Gl, program: &Program) {
    // 顶点数据
    let vertices: [f32; 9] = [
        -0.5, -0.5, 0.0,  // 左下
         0.5, -0.5, 0.0,  // 右下
         0.0,  0.5, 0.0   // 顶部
    ];
    
    let mut vao = 0;
    let mut vbo = 0;
    
    unsafe {
        // 生成VAO和VBO
        gl.GenVertexArrays(1, &mut vao);
        gl.GenBuffers(1, &mut vbo);
        
        // 绑定VAO
        gl.BindVertexArray(vao);
        
        // 绑定VBO并设置顶点数据
        gl.BindBuffer(gfx_gl::ARRAY_BUFFER, vbo);
        gl.BufferData(
            gfx_gl::ARRAY_BUFFER,
            (vertices.len() * std::mem::size_of::<f32>()) as isize,
            vertices.as_ptr() as *const _,
            gfx_gl::STATIC_DRAW
        );
        
        // 设置顶点属性
        gl.VertexAttribPointer(
            0,  // 对应着色器中的location 0
            3,  // 顶点属性大小 (vec3)
            gfx_gl::FLOAT, 
            gfx_gl::FALSE,
            3 * std::mem::size_of::<f32>() as i32,  // 步长
            std::ptr::null()  // 偏移量
        );
        gl.EnableVertexAttribArray(0);
        
        // 解绑
        gl.BindBuffer(gfx_gl::ARRAY_BUFFER, 0);
        gl.BindVertexArray(0);
    }
    
    // 渲染
    unsafe {
        program.set_used();
        gl.BindVertexArray(vao);
        gl.DrawArrays(gfx_gl::TRIANGLES, 0, 3);
        gl.BindVertexArray(0);
    }
    
    // 清理资源
    unsafe {
        gl.DeleteVertexArrays(1, &vao);
        gl.DeleteBuffers(1, &vbo);
    }
}

fn load_texture(gl: &Gl, path: &str) -> Result<u32, image::ImageError> {
    // 使用image库加载图片
    let img = image::open(path)?.to_rgba();
    let (width, height) = img.dimensions();
    let data = img.into_raw();
    
    let mut texture = 0;
    
    unsafe {
        // 生成并绑定纹理
        gl.GenTextures(1, &mut texture);
        gl.BindTexture(gfx_gl::TEXTURE_2D, texture);
        
        // 设置纹理参数
        gl.TexParameteri(gfx_gl::TEXTURE_2D, gfx_gl::TEXTURE_WRAP_S, gfx_gl::REPEAT as i32);
        gl.TexParameteri(gfx_gl::TEXTURE_2D, gfx_gl::TEXTURE_WRAP_T, gfx_gl::REPEAT as i32);
        gl.TexParameteri(gfx_gl::TEXTURE_2D, gfx_gl::TEXTURE_MIN_FILTER, gfx_gl::LINEAR as i32);
        gl.TexParameteri(gfx_gl::TEXTURE_2D, gfx_gl::TEXTURE_MAG_FILTER, gfx_gl::LINEAR as i32);
        
        // 上传纹理数据
        gl.TexImage2D(
            gfx_gl::TEXTURE_2D,
            0,
            gfx_gl::RGBA as i32,
            width as i32,
            height as i32,
            0,
            gfx_gl::RGBA,
            gfx_gl::UNSIGNED_BYTE,
            data.as_ptr() as *const _
        );
        
        // 生成mipmap
        gl.GenerateMipmap(gfx_gl::TEXTURE_2D);
        
        // 解绑纹理
        gl.BindTexture(gfx_gl::TEXTURE_2D, 0);
    }
    
    Ok(texture)
}

这个完整示例包含了以下功能：

1. 使用glutin创建窗口和OpenGL上下文
2. 使用gfx_gl加载OpenGL函数指针
3. 创建并编译顶点和片段着色器
4. 渲染一个彩色三角形
5. 可选地加载纹理（需要准备texture.png文件）

要运行此示例，需要在Cargo.toml中添加以下依赖：

[dependencies]
gfx_gl = "0.6"
glutin = "0.21"
image = "0.23"

注意事项：

• 需要正确设置OpenGL上下文版本（示例中使用默认设置）
• 纹理加载是可选功能，需要准备相应的图片文件
• 所有OpenGL操作都在unsafe块中进行
• 资源需要手动管理，示例中正确释放了VAO、VBO等资源