Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

rust 的piston底層繪圖是用哪 一個

  1. User

    rust 的piston底層繪圖是用哪 一個

  2. Assistant

    Rust 的 Piston 框架底層繪圖通常是基於 gfx-rs(現稱為 wgpu 的前身)或直接使用 OpenGL 驅動的。具體來說:

    • Piston 本身是一個 modular 的遊戲開發框架,底層繪圖部分透過多個後端實現。
    • 最常用的繪圖後端是 gfx_graphics,它基於 gfx-rs(現已發展為 wgpu)來實作跨平台和高效能的繪圖。
    • 另一個常見且歷史悠久的是使用 OpenGL 作為底層接口的 opengl_graphics。

    所以,Piston 的底層繪圖取決於使用的繪圖後端,但最主流的是透過 gfx-rs/wgpu 或 OpenGL。

    如果你使用的是 piston_window,在很多範例中默認是用 OpenGL 作為底層繪圖API。

    簡單總結:

    繪圖後端底層API
    opengl_graphicsOpenGL
    gfx_graphicsgfx-rs / wgpu

    你可以根據需求選擇適合的底層繪圖後端。

  3. User

    OpenGL可以支援3d庫嗎

  4. Assistant

    是的,OpenGL 可以支援 3D 庫,甚至它本身就是一個專門用來進行 2D 和 3D 圖形渲染的跨平台圖形API。

    詳細說明:

    • OpenGL(Open Graphics Library) 是一個低階圖形API,用於渲染 2D 和 3D 圖形。
    • 它在設計上就是支援 3D 圖形操作,包括頂點變換、照明、貼圖、著色器等功能,因此非常適合用於開發 3D 遊戲引擎或 3D 圖形庫。
    • 許多知名的 3D 圖形庫或遊戲引擎(如 OpenSceneGraph、OGRE、甚至 Unity 早期版本)都曾使用或仍使用 OpenGL 作為底層渲染接口。
    • 使用 OpenGL,你可以開發自己的 3D 渲染管線,包括模型載入、光照、陰影、後處理效果等。

    總結

    • OpenGL 是一個功能強大的 3D 圖形渲染API,完全可以支援 3D 庫的開發與運作。
    • 你可以在 Rust 中用 OpenGL 透過如 glutin、glium 等對 OpenGL 的綁定庫來實現 3D 圖形渲染。

    如果你的問題是「OpenGL 能否配合某些 3D 庫一起用?」答案是肯定的,你可以結合多種庫一起完成 3D 功能開發。

  5. User

    piston 如何用opengl 3d庫

  6. Assistant

    Piston 本身是以模組化設計為主,核心的 piston_window 和 opengl_graphics 底層以 OpenGL 2D 為主,但你仍然可以在 Piston 框架中使用 OpenGL 的 3D 功能,方法是混合使用 OpenGL 直接呼叫(裸 OpenGL)加上 Piston 的事件循環與視窗管理。

    以下幾點說明和範例能幫助你在 Piston 中使用 OpenGL 進行 3D 繪製:


    1. Piston 支援直接底層呼叫 OpenGL

    透過 opengl_graphics,你可以取得 OpenGL Context,並且直接呼叫 OpenGL API,來畫 3D。

    核心是:

    • 用 piston_window::WindowSettings 建立視窗 (其中帶有 OpenGL Context)
    • 在事件循環中的 render callback,呼叫自己的 OpenGL 3D 繪製程式

    2. 使用 gl crate 直接呼叫 OpenGL 函數

    你可以加上 gl crate,這是最常用的 OpenGL bindings(OpenGL 函數接口),支援現代 OpenGL。

    [dependencies]
    piston_window = "0.127"  # 請確認版本
    gl = "0.14"              # 最近版本
    

    3. 範例:在 Piston 中用 OpenGL 畫簡單的 3D 三角形框架

    extern crate piston_window;
    extern crate gl;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::CString;
    use std::ptr;
    use std::str;
    
    fn main() {
        let mut window: PistonWindow =
            WindowSettings::new("Piston + OpenGL 3D", [640, 480])
            .opengl(OpenGL::V3_2)   // 使用 OpenGL 3.2+
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        // 載入 OpenGL 函式指標
        let gl = window.create_opengl_graphics(OpenGL::V3_2);
    
        unsafe {
            gl::load_with(|s| window.get_proc_address(s) as *const _);
        }
    
        // 範例僅示意——下面建立 shaders, buffers,繪製3D基本元素,複雜部份請自行設計。
    
        // 在事件迴圈中使用
        while let Some(e) = window.next() {
            if let Some(_r) = e.render_args() {
                // 清理畫面
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
                    gl::Enable(gl::DEPTH_TEST);
                }
    
                // 你的 OpenGL 3D 繪製程式碼在此
                // 例如:綁定 VAO、VBO,啟用 shader,繪製三角形
    
                // 這裡用 window 的 opengl_graphics 不能直接操作,通常要自己管理 OpenGL context
    
                // 最後交換buffer由 piston_window 自動完成
            }
        }
    }
    

    4. 建議流程

    1. 使用 WindowSettings 設定 OpenGL 版本(建議 3.2 以上,方便使用現代 OpenGL shaders)
    2. 使用 gl crate 載入 OpenGL 函數
    3. 自行寫 Vertex Shader、Fragment Shader,管理 VAO、VBO 等 OpenGL 3D 資源
    4. 在 render 回呼內呼叫 OpenGL 指令繪製 3D 物件
    5. 利用 Piston 處理事件,如鍵盤、滑鼠、視窗管理,渲染循環等

    5. 若想用現成 Rust 3D library

    如果你想用像是 gfx / wgpu 這類現代 GPU 抽象層,在一個更完整的 3D 開發環境,Piston 可能不是最佳選擇,推薦用專門的 3D 引擎或框架像是:

    • wgpu + winit 直接做 3D
    • amethyst、bevy 這類遊戲引擎

    總結

    Piston 沒有內建「3D 繪圖庫」,但是可搭配 OpenGL。你可以在 Piston 建立的 OpenGL context 裡掛載自己的、純 OpenGL 3D 繪圖程式碼。

    這讓你能結合 Piston 事件和輸入系統,自己管理 OpenGL 3D 渲染流程。


    如果需要,我可以幫你寫一個簡單的 Piston + OpenGL 3D shader 範例!

  7. User

    Piston + OpenGL 3D shade 最乾淨的程式碼 一個三角形

  8. Assistant

    下面是一份「Piston + OpenGL 3D Shader」的極簡範例程式碼,會在 Piston 建立的 OpenGL context 裡使用現代 OpenGL(3.2+)和 GLSL Shader,繪製一個旋轉的 3D 三角形。

    此範例非常基礎,只示範:

    • 如何建立 Piston 視窗並使用 OpenGL 3.2
    • 載入 OpenGL 函數
    • 建立簡單頂點著色器和片元著色器
    • 使用頂點緩衝物件 (VBO) 和頂點陣列物件 (VAO)
    • 在事件迴圈中繪製並旋轉三角形

    Cargo.toml

    [package]
    name = "piston_opengl_3d_triangle"
    version = "0.1.0"
    edition = "2018"
    
    [dependencies]
    piston_window = "0.127"
    gl = "0.14"
    nalgebra = { version = "0.32", features = ["glam"] }  # 用來做矩陣計算,可替換成你習慣的
    

    main.rs

    extern crate piston_window;
    extern crate gl;
    extern crate nalgebra as na;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::{CStr, CString};
    use std::ptr;
    use std::mem;
    use na::{Matrix4, Perspective3, Point3, Vector3};
    
    const VERTEX_SHADER_SRC: &str = r#"
    #version 150 core
    in vec3 position;
    uniform mat4 transform;
    void main() {
        gl_Position = transform * vec4(position, 1.0);
    }
    "#;
    
    const FRAGMENT_SHADER_SRC: &str = r#"
    #version 150 core
    out vec4 out_color;
    void main() {
        out_color = vec4(1.0, 0.5, 0.2, 1.0);
    }
    "#;
    
    // 編譯shader
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        let shader = gl::CreateShader(ty);
        // 傳入指標
        let c_str = CString::new(src.as_bytes()).unwrap();
        gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
        gl::CompileShader(shader);
        // 檢查錯誤
        let mut status = gl::FALSE as GLint;
        gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
        if status != (gl::TRUE as GLint) {
            let mut len = 0;
            gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
            let mut buf = Vec::with_capacity(len as usize + 1);
            buf.extend([b' '].iter().cycle().take(len as usize));
            let error = CString::from_vec_unchecked(buf);
            gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
            panic!("Shader compilation failed: {}", error.to_string_lossy());
        }
        shader
    }
    
    // 連結成program
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        let program = gl::CreateProgram();
        gl::AttachShader(program, vs);
        gl::AttachShader(program, fs);
        gl::LinkProgram(program);
    
        let mut status = gl::FALSE as GLint;
        gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
        if status != (gl::TRUE as GLint) {
            let mut len: GLint = 0;
            gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
            let mut buf = Vec::with_capacity(len as usize +1);
            buf.extend([b' '].iter().cycle().take(len as usize));
            let error = CString::from_vec_unchecked(buf);
            gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
            panic!("Program linking failed: {}", error.to_string_lossy());
        }
        program
    }
    
    fn main() {
        // 建立 Piston 視窗,指定 OpenGL 3.2+
        let opengl = OpenGL::V3_2;
        let mut window: PistonWindow = WindowSettings::new("Piston + OpenGL 3D Triangle", [800, 600])
            .graphics_api(opengl)
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        // 載入 OpenGL 函數指標
        unsafe {
            gl::load_with(|s| window.get_proc_address(s) as *const _);
        }
    
        // 建立Shader程式
        let shader_program = unsafe {
            let vertex_shader = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER);
            let fragment_shader = compile_shader(FRAGMENT_SHADER_SRC, gl::FRAGMENT_SHADER);
            let program = link_program(vertex_shader, fragment_shader);
            // shader編譯完就可以刪掉
            gl::DeleteShader(vertex_shader);
            gl::DeleteShader(fragment_shader);
            program
        };
    
        // 三角形頂點資料 (x, y, z)
        let vertices: [f32; 9] = [
            0.0,  0.5, 0.0,  // 頂點A
           -0.5, -0.5, 0.0,  // 頂點B
            0.5, -0.5, 0.0,  // 頂點C
        ];
    
        // 建立 VBO 和 VAO
        let (mut vao, mut vbo) = (0, 0);
        unsafe {
            gl::GenVertexArrays(1, &mut vao);
            gl::GenBuffers(1, &mut vbo);
    
            gl::BindVertexArray(vao);
    
            gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
            gl::BufferData(
                gl::ARRAY_BUFFER,
                (vertices.len() * mem::size_of::<GLfloat>()) as GLsizeiptr,
                vertices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            let pos_attrib = gl::GetAttribLocation(shader_program, CString::new("position").unwrap().as_ptr());
            gl::EnableVertexAttribArray(pos_attrib as GLuint);
            gl::VertexAttribPointer(
                pos_attrib as GLuint,
                3, // vec3
                gl::FLOAT,
                gl::FALSE,
                3 * mem::size_of::<GLfloat>() as GLsizei,
                ptr::null(),
            );
    
            // 先解除綁定VAO和VBO,防止誤操作
            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
            gl::BindVertexArray(0);
        }
    
        // 設定深度測試
        unsafe {
            gl::Enable(gl::DEPTH_TEST);
            gl::DepthFunc(gl::LESS);
        }
    
        // 取得uniform位置
        let uniform_transform_location = unsafe {
            let loc = gl::GetUniformLocation(shader_program, CString::new("transform").unwrap().as_ptr());
            if loc < 0 {
                panic!("Could not find uniform 'transform' in shader");
            }
            loc
        };
    
        // 時間追蹤,用來旋轉三角形
        let mut rotation: f32 = 0.0;
    
        while let Some(event) = window.next() {
            if let Some(args) = event.render_args() {
                rotation += 0.01;
    
                let (w, h) = (args.window_size[0] as f32, args.window_size[1] as f32);
                // 投影矩陣  (透視投影)
                let projection = Perspective3::new(w / h, 45_f32.to_radians(), 0.1, 100.0);
                // 視角矩陣(攝影機)
                let view = Matrix4::look_at_rh(
                    &Point3::new(0.0, 0.0, 2.0),  // 攝影機位置
                    &Point3::origin(),            // 看向原點
                    &Vector3::y_axis(),           // 上方向
                );
                // 模型矩陣(旋轉)
                let model = Matrix4::new_rotation(Vector3::z() * rotation);
    
                // 最終變換矩陣 = projection * view * model
                let transform = projection.to_homogeneous() * view * model;
    
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
    
                    gl::UseProgram(shader_program);
                    gl::BindVertexArray(vao);
    
                    // 傳送變換矩陣給shader
                    gl::UniformMatrix4fv(uniform_transform_location, 1, gl::FALSE, transform.as_ptr());
    
                    gl::DrawArrays(gl::TRIANGLES, 0, 3);
    
                    gl::BindVertexArray(0);
                }
            }
        }
    }
    

    這段程式碼說明

    • 使用 Piston 建立 OpenGL 3.2 以上視窗
    • 用 gl crate 呼叫 OpenGL 函數 (編譯、連結 shader,建立 VAO、VBO)
    • 使用 nalgebra 建立投影、視角、模型矩陣組合變換
    • 在渲染迴圈每幀更新旋轉角度並傳入 shader
    • 繪製一個基本 3D 三角形(Z 軸旋轉)

    如果你會操作 Cargo 並加上依賴,編譯並執行本範例,就能看到一個旋轉的橙色三角形!

    這就是 Piston 結合 OpenGL 3D shader 的最簡基本範例。你可以基於此擴展頂點格式、加入光照、貼圖等更完整的3D功能。

  9. User

    failed to select a version for nalgebra which could resolve this conflict

  10. Assistant

    nalgebra 在某些版本或與其他依賴有版本衝突時,可能會無法成功解析。你的錯誤訊息很可能是因為指定了不存在或相衝突的功能(feature)glam,或者你的其他依賴有衝突。


    問題點

    你的 Cargo.toml 裡面這行:

    nalgebra = { version = "0.32", features = ["glam"] }
    
    • nalgebra 本身沒有名為 glam 的 feature。glam 是另一個獨立的 Rust 矩陣和向量庫。
    • 如果你想用 nalgebra,通常不需要啟用那個 feature,直接使用即可。

    解決方案

    你有兩個選擇:


    方案1:只用 nalgebra 不帶 glam

    在 Cargo.toml 移除 glam feature,改成:

    nalgebra = "0.32"
    

    方案2:改用 glam crate(如果你喜歡更輕量的矩陣庫)

    glam = "0.24"
    

    然後重新修改程式碼使用 glam API。


    更新後的 Cargo.toml 範例如下(使用 nalgebra):

    [dependencies]
    piston_window = "0.127"
    gl = "0.14"
    nalgebra = "0.32"
    

    main.rs 里用的部分不用變,因為示例是用 nalgebra (ex: nalgebra::Matrix4、Perspective3…)


    補充說明

    如果你還是遇到版本衝突,可以:

    • cargo update 強制刷新依賴快取
    • cargo tree 看看依賴樹還有哪些版本衝突
    • 確保其他依賴沒有強制要求 nalgebra 的不同版本

    如果你需要,我可以幫你調整成只用 nalgebra 的完整版本。

  11. User

    error[E0599]: no method named get_proc_address found for struct piston_window::PistonWindow in the current scope --> src\main.rs:83:34 | 83 | gl::load_with(|s| window.get_proc_address(s) as *const _); | ^^^^^^^^^^^^^^^^ method not found in PistonWindow | help: one of the expressions' fields has a method of the same name | 83 | gl::load_with(|s| window.window.get_proc_address(s) as *const _); | +++++++

    warning[E0133]: call to unsafe function gl::CreateShader is unsafe and requires unsafe block --> src\main.rs:31:18 | 31 | let shader = gl::CreateShader(ty); | ^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior
    note: an unsafe function restricts its caller, but its body is safe by default --> src\main.rs:30:1 | 30 | unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: #[warn(unsafe_op_in_unsafe_fn)] on by default

    warning[E0133]: call to unsafe function gl::ShaderSource is unsafe and requires unsafe block
    --> src\main.rs:34:5 | 34 | gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null()); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::CompileShader is unsafe and requires unsafe block
    --> src\main.rs:35:5 | 35 | gl::CompileShader(shader); | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::GetShaderiv is unsafe and requires unsafe block
    --> src\main.rs:38:5 | 38 | gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::GetShaderiv is unsafe and requires unsafe block
    --> src\main.rs:41:9 | 41 | gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function std::ffi::CString::from_vec_unchecked is unsafe and requires unsafe block --> src\main.rs:44:21 | 44 | let error = CString::from_vec_unchecked(buf); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::GetShaderInfoLog is unsafe and requires unsafe block
    --> src\main.rs:45:9 | 45 | gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::CreateProgram is unsafe and requires unsafe block
    --> src\main.rs:53:19 | 53 | let program = gl::CreateProgram(); | ^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior
    note: an unsafe function restricts its caller, but its body is safe by default --> src\main.rs:52:1 | 52 | unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    warning[E0133]: call to unsafe function gl::AttachShader is unsafe and requires unsafe block
    --> src\main.rs:54:5 | 54 | gl::AttachShader(program, vs); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::AttachShader is unsafe and requires unsafe block
    --> src\main.rs:55:5 | 55 | gl::AttachShader(program, fs); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::LinkProgram is unsafe and requires unsafe block
    --> src\main.rs:56:5 | 56 | gl::LinkProgram(program); | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::GetProgramiv is unsafe and requires unsafe block
    --> src\main.rs:59:5 | 59 | gl::GetProgramiv(program, gl::LINK_STATUS, &mut status); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::GetProgramiv is unsafe and requires unsafe block
    --> src\main.rs:62:9 | 62 | gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
    | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function std::ffi::CString::from_vec_unchecked is unsafe and requires unsafe block --> src\main.rs:65:21 | 65 | let error = CString::from_vec_unchecked(buf); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    warning[E0133]: call to unsafe function gl::GetProgramInfoLog is unsafe and requires unsafe block --> src\main.rs:66:9 | 66 | gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function | = note: for more information, see https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html = note: consult the function's documentation for information on how to avoid undefined behavior

    Some errors have detailed explanations: E0133, E0599. For more information about an error, try rustc --explain E0133.

  12. Assistant

    你遇到兩個主要問題:

    1. PistonWindow 沒有 get_proc_address 方法
    2. Rust 2024 的重點改變:在 unsafe fn 裡呼叫其他 unsafe 函式,需要再明確加 unsafe 區塊

    1. get_proc_address 找不到

    piston_window::PistonWindow 不直接提供 get_proc_address,你需要叫取其內部的視窗 (window) 物件來呼叫。

    範例:

    gl::load_with(|s| window.window().get_proc_address(s) as *const _);
    

    注意:要用 .window() 方法存取底層視窗,再呼叫它的 get_proc_address。


    2. Rust 2024 版本的 unsafe 呼叫規範

    你定義的 unsafe fn 中呼叫了很多 unsafe 函式,Rust 新規範中必須在「unsafe 函式的函數體內,呼叫其他 unsafe 函式時仍然要用額外的 unsafe { } 包起來」,即使整個外層是 unsafe fn。


    解決方式:

    • 在你目前已標記為 unsafe fn 的函式體內,再用 unsafe { ... } 包裹所有 unsafe 呼叫。

    • 或者乾脆把函式內全部程式碼都包在一個 unsafe { ... } 裡。


    範例修正版:

    // compile_shader 保留 unsafe fn,但內部要用 unsafe 區塊包裹所有 unsafe 調用
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        unsafe {
            let shader = gl::CreateShader(ty);
            let c_str = CString::new(src.as_bytes()).unwrap();
            gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
            gl::CompileShader(shader);
    
            let mut status = gl::FALSE as GLint;
            gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len = 0;
                gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Shader compilation failed: {}", error.to_string_lossy());
            }
            shader
        }
    }
    
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        unsafe {
            let program = gl::CreateProgram();
            gl::AttachShader(program, vs);
            gl::AttachShader(program, fs);
            gl::LinkProgram(program);
    
            let mut status = gl::FALSE as GLint;
            gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len: GLint = 0;
                gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Program linking failed: {}", error.to_string_lossy());
            }
            program
        }
    }
    

    3. 內文修正 gl::load_with 範例

    將此行改為:

    gl::load_with(|s| window.window().get_proc_address(s) as *const _);
    

    完整定位呼叫底層 OpenGL loader。


    小結

    完整重點修改:

    1. gl::load_with 改成呼叫 window.window().get_proc_address
    2. 原本 unsafe fn 裡呼叫 unsafe 函式的地方,必須用 unsafe { ... } 包起來

    如果你需要,我可以幫你貼修正後的完整範例!

  13. User

    完整範例!

  14. Assistant

    以下是修正過、可編譯運行的完整範例,示範 Piston + OpenGL 3.2+ 使用 GLSL Shader 畫一個旋轉的 3D 三角形。

    包含:

    • gl::load_with 使用 window.window().get_proc_address
    • unsafe fn 內部使用 unsafe { ... }
    • 最低依賴版本,並建議用 nalgebra = "0.32"(無 glam feature)

    Cargo.toml

    [package]
    name = "piston_opengl_3d_triangle"
    version = "0.1.0"
    edition = "2018"
    
    [dependencies]
    piston_window = "0.127"
    gl = "0.14"
    nalgebra = "0.32"
    

    src/main.rs

    extern crate piston_window;
    extern crate gl;
    extern crate nalgebra as na;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::{CString};
    use std::ptr;
    use std::mem;
    use na::{Matrix4, Perspective3, Point3, Vector3};
    
    const VERTEX_SHADER_SRC: &str = r#"
    #version 150 core
    in vec3 position;
    uniform mat4 transform;
    void main() {
        gl_Position = transform * vec4(position, 1.0);
    }
    "#;
    
    const FRAGMENT_SHADER_SRC: &str = r#"
    #version 150 core
    out vec4 out_color;
    void main() {
        out_color = vec4(1.0, 0.5, 0.2, 1.0);
    }
    "#;
    
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        unsafe {
            let shader = gl::CreateShader(ty);
            let c_str = CString::new(src.as_bytes()).unwrap();
            gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
            gl::CompileShader(shader);
    
            let mut status = gl::FALSE as GLint;
            gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len = 0;
                gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Shader compilation failed: {}", error.to_string_lossy());
            }
            shader
        }
    }
    
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        unsafe {
            let program = gl::CreateProgram();
            gl::AttachShader(program, vs);
            gl::AttachShader(program, fs);
            gl::LinkProgram(program);
    
            let mut status = gl::FALSE as GLint;
            gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len: GLint = 0;
                gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Program linking failed: {}", error.to_string_lossy());
            }
            program
        }
    }
    
    fn main() {
        let opengl = OpenGL::V3_2;
        let mut window: PistonWindow = WindowSettings::new("Piston + OpenGL 3D Triangle", [800, 600])
            .graphics_api(opengl)
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        // 初始化 OpenGL 函數指標載入,注意這裡呼叫 window.window()
        unsafe {
            gl::load_with(|s| window.window().get_proc_address(s) as *const _);
        }
    
        let shader_program = unsafe {
            let vs = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER);
            let fs = compile_shader(FRAGMENT_SHADER_SRC, gl::FRAGMENT_SHADER);
            let program = link_program(vs, fs);
            gl::DeleteShader(vs);
            gl::DeleteShader(fs);
            program
        };
    
        let vertices: [f32; 9] = [
            0.0,  0.5, 0.0,  // 頂點A
           -0.5, -0.5, 0.0,  // 頂點B
            0.5, -0.5, 0.0,  // 頂點C
        ];
    
        let (mut vao, mut vbo) = (0, 0);
        unsafe {
            gl::GenVertexArrays(1, &mut vao);
            gl::GenBuffers(1, &mut vbo);
    
            gl::BindVertexArray(vao);
    
            gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
            gl::BufferData(
                gl::ARRAY_BUFFER,
                (vertices.len() * mem::size_of::<GLfloat>()) as isize,
                vertices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            let pos_attrib = gl::GetAttribLocation(shader_program, CString::new("position").unwrap().as_ptr());
            gl::EnableVertexAttribArray(pos_attrib as GLuint);
            gl::VertexAttribPointer(
                pos_attrib as GLuint,
                3,
                gl::FLOAT,
                gl::FALSE,
                3 * mem::size_of::<GLfloat>() as i32,
                ptr::null(),
            );
    
            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
            gl::BindVertexArray(0);
    
            gl::Enable(gl::DEPTH_TEST);
            gl::DepthFunc(gl::LESS);
        }
    
        let uniform_transform_loc = unsafe {
            let loc = gl::GetUniformLocation(shader_program, CString::new("transform").unwrap().as_ptr());
            if loc < 0 {
                panic!("Could not find uniform 'transform'");
            }
            loc
        };
    
        let mut rotation: f32 = 0.0;
    
        while let Some(event) = window.next() {
            if let Some(args) = event.render_args() {
                rotation += 0.01;
    
                let (w, h) = (args.window_size[0] as f32, args.window_size[1] as f32);
    
                let projection = Perspective3::new(w / h, 45.0_f32.to_radians(), 0.1, 100.0);
                let view = Matrix4::look_at_rh(
                    &Point3::new(0.0, 0.0, 2.0),
                    &Point3::origin(),
                    &Vector3::y_axis(),
                );
                let model = Matrix4::new_rotation(Vector3::z() * rotation);
    
                let transform = projection.to_homogeneous() * view * model;
    
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
    
                    gl::UseProgram(shader_program);
                    gl::BindVertexArray(vao);
    
                    gl::UniformMatrix4fv(uniform_transform_loc, 1, gl::FALSE, transform.as_ptr());
    
                    gl::DrawArrays(gl::TRIANGLES, 0, 3);
    
                    gl::BindVertexArray(0);
                }
            }
        }
    }
    

    注意:

    • 此程式必須使用支持 OpenGL 3.2 以上的 GPU 驅動及環境。
    • 啟動視窗後會見到旋轉的橙色三角形(3D 空間中繞Z軸旋轉)。
    • Piston 只負責視窗與事件循環,OpenGL 渲染流程完全由你控制。

    有任何問題或要再補充更進階的功能(貼圖、光照)都可以再問!祝你開發順利!🚀

  15. User

    error[E0599]: no method named window found for struct piston_window::PistonWindow in the current scope --> src\main.rs:85:34 | 85 | gl::load_with(|s| window.window().get_proc_address(s) as *const _); | ^^^^^^-- help: remove the arguments | | | field, not a method | help: there is a method find with a similar name, but with different arguments --> C:\Users\fer52.rustup\toolchains\nightly-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\iter\traits\iterator.rs:2850:5 | 2850 | / fn find(&mut self, predicate: P) -> OptionSelf::Item 2851 | | where 2852 | | Self: Sized, 2853 | | P: FnMut(&Self::Item) -> bool, | |______________________________________^

    For more information about this error, try rustc --explain E0599. error: could not compile my_project (bin "my_project") due to 1 previous error

  16. Assistant

    PistonWindow 的 window 不是方法而是結構體的公開欄位,應該改用 .window 直接存取,而不是 .window()。

    所以這裡:

    gl::load_with(|s| window.window().get_proc_address(s) as *const _);
    

    請改成:

    gl::load_with(|s| window.window.get_proc_address(s) as *const _);
    

    修正說明

    • piston_window::PistonWindow 中,window 是一個公開成員欄位,不是方法。
    • 因此呼叫的是欄位 .window,它是一個 GlutinWindow (或類似),這個才有 get_proc_address 方法。

    建議程式碼範例

    unsafe {
        gl::load_with(|s| window.window.get_proc_address(s) as *const _);
    }
    

    補充

    • 這個欄位名稱設計確實容易誤會成方法,請留意用法。
    • 如果你想避免用欄位存取,可以考慮直接自己用 glutin 建立視窗及載入函式指標。

    如需,我可以幫你貼整個 main.rs 把這個地方修正!

  17. User

    貼整個 main.rs

  18. Assistant

    以下是已修正 window.window 為欄位存取 (window.window.get_proc_address) 的完整 main.rs 範例,能在 Piston 環境中用 OpenGL 3.2+ 和 GLSL shader 繪製旋轉 3D 三角形:

    extern crate piston_window;
    extern crate gl;
    extern crate nalgebra as na;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::{CString};
    use std::ptr;
    use std::mem;
    use na::{Matrix4, Perspective3, Point3, Vector3};
    
    const VERTEX_SHADER_SRC: &str = r#"
    #version 150 core
    in vec3 position;
    uniform mat4 transform;
    void main() {
        gl_Position = transform * vec4(position, 1.0);
    }
    "#;
    
    const FRAGMENT_SHADER_SRC: &str = r#"
    #version 150 core
    out vec4 out_color;
    void main() {
        out_color = vec4(1.0, 0.5, 0.2, 1.0);
    }
    "#;
    
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        unsafe {
            let shader = gl::CreateShader(ty);
            let c_str = CString::new(src.as_bytes()).unwrap();
            gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
            gl::CompileShader(shader);
    
            let mut status = gl::FALSE as GLint;
            gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len = 0;
                gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Shader compilation failed: {}", error.to_string_lossy());
            }
            shader
        }
    }
    
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        unsafe {
            let program = gl::CreateProgram();
            gl::AttachShader(program, vs);
            gl::AttachShader(program, fs);
            gl::LinkProgram(program);
    
            let mut status = gl::FALSE as GLint;
            gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len: GLint = 0;
                gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Program linking failed: {}", error.to_string_lossy());
            }
            program
        }
    }
    
    fn main() {
        let opengl = OpenGL::V3_2;
        let mut window: PistonWindow = WindowSettings::new("Piston + OpenGL 3D Triangle", [800, 600])
            .graphics_api(opengl)
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        // --- 這裡修正為欄位存取 ---
        unsafe {
            gl::load_with(|s| window.window.get_proc_address(s) as *const _);
        }
    
        let shader_program = unsafe {
            let vs = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER);
            let fs = compile_shader(FRAGMENT_SHADER_SRC, gl::FRAGMENT_SHADER);
            let program = link_program(vs, fs);
            gl::DeleteShader(vs);
            gl::DeleteShader(fs);
            program
        };
    
        let vertices: [f32; 9] = [
            0.0,  0.5, 0.0,
           -0.5, -0.5, 0.0,
            0.5, -0.5, 0.0,
        ];
    
        let (mut vao, mut vbo) = (0, 0);
        unsafe {
            gl::GenVertexArrays(1, &mut vao);
            gl::GenBuffers(1, &mut vbo);
    
            gl::BindVertexArray(vao);
    
            gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
            gl::BufferData(
                gl::ARRAY_BUFFER,
                (vertices.len() * mem::size_of::<GLfloat>()) as isize,
                vertices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            let pos_attrib = gl::GetAttribLocation(shader_program, CString::new("position").unwrap().as_ptr());
            gl::EnableVertexAttribArray(pos_attrib as GLuint);
            gl::VertexAttribPointer(
                pos_attrib as GLuint,
                3,
                gl::FLOAT,
                gl::FALSE,
                3 * mem::size_of::<GLfloat>() as i32,
                ptr::null(),
            );
    
            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
            gl::BindVertexArray(0);
    
            gl::Enable(gl::DEPTH_TEST);
            gl::DepthFunc(gl::LESS);
        }
    
        let uniform_transform_loc = unsafe {
            let loc = gl::GetUniformLocation(shader_program, CString::new("transform").unwrap().as_ptr());
            if loc < 0 {
                panic!("Could not find uniform 'transform'");
            }
            loc
        };
    
        let mut rotation: f32 = 0.0;
    
        while let Some(event) = window.next() {
            if let Some(args) = event.render_args() {
                rotation += 0.01;
    
                let (w, h) = (args.window_size[0] as f32, args.window_size[1] as f32);
    
                let projection = Perspective3::new(w / h, 45.0_f32.to_radians(), 0.1, 100.0);
                let view = Matrix4::look_at_rh(
                    &Point3::new(0.0, 0.0, 2.0),
                    &Point3::origin(),
                    &Vector3::y_axis(),
                );
                let model = Matrix4::new_rotation(Vector3::z() * rotation);
    
                let transform = projection.to_homogeneous() * view * model;
    
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
    
                    gl::UseProgram(shader_program);
                    gl::BindVertexArray(vao);
    
                    gl::UniformMatrix4fv(uniform_transform_loc, 1, gl::FALSE, transform.as_ptr());
    
                    gl::DrawArrays(gl::TRIANGLES, 0, 3);
    
                    gl::BindVertexArray(0);
                }
            }
        }
    }
    

    執行時請確保:

    • 安裝好能使用 OpenGL 3.2+ 的環境
    • Cargo.toml 有加入 piston_window、gl 和 nalgebra
    • Rust toolchain穩定或nightly皆可

    如果想要我幫你修改 Cargo.toml 也告知!祝開發順利 🌟

  19. User

    如果畫一個3d三角形,360度隨機選轉

  20. Assistant

    你想讓三角形 3D 隨機選一個旋轉軸,並做 360 度旋轉(繞該軸旋轉一圈),可以用以下方式實作:


    實作思路

    1. 程式開始時,隨機選一個單位向量作為旋轉軸 (Vector3)。
    2. 每幀旋轉角度遞增(例如 0 到 2π),旋轉矩陣是繞該軸旋轉。
    3. 確保角度跑完一圈後可以重置或持續旋轉。

    在剛剛範例基礎上調整示範

    先確保在 Cargo.toml 加入 rand:

    rand = "0.8"
    

    修改 main.rs

    extern crate rand;
    use rand::Rng;
    // 其他 use 保持不變
    

    在 main() 函式開始前,加入:

    let mut rng = rand::thread_rng();
    // 隨機產生一個旋轉軸,必須是單位向量
    let axis = {
        let x: f32 = rng.gen_range(-1.0..=1.0);
        let y: f32 = rng.gen_range(-1.0..=1.0);
        let z: f32 = rng.gen_range(-1.0..=1.0);
        let v = Vector3::new(x, y, z);
        v.normalize()
    };
    

    然後每幀更新模型矩陣時:

    let model = Matrix4::from_axis_angle(&axis, rotation);
    

    代替之前繞Z軸的旋轉:

    let model = Matrix4::new_rotation(Vector3::z() * rotation);
    

    修改後關鍵段落範例

    let mut rotation: f32 = 0.0;
    let mut rng = rand::thread_rng();
    let axis = {
        let x: f32 = rng.gen_range(-1.0..=1.0);
        let y: f32 = rng.gen_range(-1.0..=1.0);
        let z: f32 = rng.gen_range(-1.0..=1.0);
        Vector3::new(x, y, z).normalize()
    };
    
    while let Some(event) = window.next() {
        if let Some(args) = event.render_args() {
            rotation += 0.02;
            if rotation > std::f32::consts::TAU {
                rotation -= std::f32::consts::TAU; // 2π 一圈
            }
    
            // 其他代码保持不变
    
            let model = Matrix4::from_axis_angle(&axis, rotation);
    
            let transform = projection.to_homogeneous() * view * model;
    
            unsafe {
                // 繪製程式保持不變
            }
        }
    }
    

    這樣三角形就會繞隨機軸旋轉一圈。


    如果要每次完成一圈就重選一個新軸,可以把重設 axis 的程式放到 if rotation > TAU 裡,做重設即可。


    有需要我可以幫你貼完整更新版的程式碼!

  21. User

    貼完整更新版的程式碼

  22. Assistant
    extern crate piston_window;
    extern crate gl;
    extern crate nalgebra as na;
    extern crate rand;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::CString;
    use std::ptr;
    use std::mem;
    use na::{Matrix4, Perspective3, Point3, Vector3};
    use rand::Rng;
    
    const VERTEX_SHADER_SRC: &str = r#"
    #version 150 core
    in vec3 position;
    uniform mat4 transform;
    void main() {
        gl_Position = transform * vec4(position, 1.0);
    }
    "#;
    
    const FRAGMENT_SHADER_SRC: &str = r#"
    #version 150 core
    out vec4 out_color;
    void main() {
        out_color = vec4(1.0, 0.5, 0.2, 1.0);
    }
    "#;
    
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        unsafe {
            let shader = gl::CreateShader(ty);
            let c_str = CString::new(src.as_bytes()).unwrap();
            gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
            gl::CompileShader(shader);
    
            let mut status = gl::FALSE as GLint;
            gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len = 0;
                gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Shader compilation failed: {}", error.to_string_lossy());
            }
            shader
        }
    }
    
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        unsafe {
            let program = gl::CreateProgram();
            gl::AttachShader(program, vs);
            gl::AttachShader(program, fs);
            gl::LinkProgram(program);
    
            let mut status = gl::FALSE as GLint;
            gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
    
            if status != (gl::TRUE as GLint) {
                let mut len: GLint = 0;
                gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize + 1);
                buf.extend([b' '].iter().cycle().take(len as usize));
                let error = CString::from_vec_unchecked(buf);
                gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
                panic!("Program linking failed: {}", error.to_string_lossy());
            }
            program
        }
    }
    
    fn main() {
        let opengl = OpenGL::V3_2;
        let mut window: PistonWindow = WindowSettings::new("Piston + OpenGL 3D Triangle", [800, 600])
            .graphics_api(opengl)
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        unsafe {
            gl::load_with(|s| window.window.get_proc_address(s) as *const _);
        }
    
        let shader_program = unsafe {
            let vs = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER);
            let fs = compile_shader(FRAGMENT_SHADER_SRC, gl::FRAGMENT_SHADER);
            let program = link_program(vs, fs);
            gl::DeleteShader(vs);
            gl::DeleteShader(fs);
            program
        };
    
        let vertices: [f32; 9] = [
            0.0,  0.5, 0.0,
           -0.5, -0.5, 0.0,
            0.5, -0.5, 0.0,
        ];
    
        let (mut vao, mut vbo) = (0, 0);
        unsafe {
            gl::GenVertexArrays(1, &mut vao);
            gl::GenBuffers(1, &mut vbo);
    
            gl::BindVertexArray(vao);
    
            gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
            gl::BufferData(
                gl::ARRAY_BUFFER,
                (vertices.len() * mem::size_of::<GLfloat>()) as isize,
                vertices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            let pos_attrib = gl::GetAttribLocation(shader_program, CString::new("position").unwrap().as_ptr());
            gl::EnableVertexAttribArray(pos_attrib as GLuint);
            gl::VertexAttribPointer(
                pos_attrib as GLuint,
                3,
                gl::FLOAT,
                gl::FALSE,
                3 * mem::size_of::<GLfloat>() as i32,
                ptr::null(),
            );
    
            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
            gl::BindVertexArray(0);
    
            gl::Enable(gl::DEPTH_TEST);
            gl::DepthFunc(gl::LESS);
        }
    
        let uniform_transform_loc = unsafe {
            let loc = gl::GetUniformLocation(shader_program, CString::new("transform").unwrap().as_ptr());
            if loc < 0 {
                panic!("Could not find uniform 'transform'");
            }
            loc
        };
    
        let mut rotation: f32 = 0.0;
        let mut rng = rand::thread_rng();
        let axis = {
            let x: f32 = rng.gen_range(-1.0..=1.0);
            let y: f32 = rng.gen_range(-1.0..=1.0);
            let z: f32 = rng.gen_range(-1.0..=1.0);
            Vector3::new(x, y, z).normalize()
        };
    
        while let Some(event) = window.next() {
            if let Some(args) = event.render_args() {
                rotation += 0.02;
                if rotation > std::f32::consts::TAU {
                    rotation -= std::f32::consts::TAU;
                }
    
                let (w, h) = (args.window_size[0] as f32, args.window_size[1] as f32);
    
                let projection = Perspective3::new(w / h, 45.0_f32.to_radians(), 0.1, 100.0);
                let view = Matrix4::look_at_rh(
                    &Point3::new(0.0, 0.0, 2.0),
                    &Point3::origin(),
                    &Vector3::y_axis(),
                );
                let model = Matrix4::from_axis_angle(&axis, rotation);
    
                let transform = projection.to_homogeneous() * view * model;
    
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
    
                    gl::UseProgram(shader_program);
                    gl::BindVertexArray(vao);
    
                    gl::UniformMatrix4fv(uniform_transform_loc, 1, gl::FALSE, transform.as_ptr());
    
                    gl::DrawArrays(gl::TRIANGLES, 0, 3);
    
                    gl::BindVertexArray(0);
                }
            }
        }
    }
    

    這份程式完整示範了:

    • 使用 rand 隨機產生旋轉軸
    • 以該軸做持續的 3D 旋轉(0~360度循環)
    • 繪製旋轉中的三角形

    請記得 Cargo.toml 中要加:

    [dependencies]
    piston_window = "0.127"
    gl = "0.14"
    nalgebra = "0.32"
    rand = "0.8"
    

    若有任何問題歡迎再問!

  23. User

    warning: unnecessary unsafe block | 84 | unsafe { | ^^^^^^ unnecessary unsafe block | = note: #[warn(unused_unsafe)] on by default

    warning: my_project (bin "my_project") generated 1 warning Finished dev profile [unoptimized + debuginfo] target(s) in 2.78s Running target\debug\my_project.exe PS C:\Users\fer52\mynewcargo\my_project> cargo run Compiling my_project v0.1.0 (C:\Users\fer52\mynewcargo\my_project) error[E0308]: mismatched types --> src\main.rs:169:50 | 169 | let model = Matrix4::from_axis_angle(&axis, rotation); | ------------------------ ^^^^^ expected &Unit<Matrix<f32, Const<3>, ..., ...>>, found &Matrix<f32, Const<3>, Const<1>, ...> | | | arguments to this function are incorrect | = note: expected reference &Unit<Matrix<_, _, _, _>> found reference &Matrix<_, _, _, _> note: associated function defined here --> C:\Users\fer52.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\nalgebra-0.32.6\src\base\cg.rs:164:12 | 164 | pub fn from_axis_angle(axis: &Unit<Vector3>, angle: T) -> Self { | ^^^^^^^^^^^^^^^

    For more information about this error, try rustc --explain E0308. error: could not compile my_project (bin "my_project") due to 1 previous error

  24. Assistant

    你這個錯誤是說 Matrix4::from_axis_angle 需要的旋轉軸是 &Unit<Vector3<f32>>,而你目前給的是 &Vector3<f32>。

    nalgebra 要求旋轉軸是單位向量包在 Unit 類型中。


    解決方法

    在宣告隨機旋轉軸時,轉成 Unit<Vector3<f32>>:

    use na::{Unit};
    
    let axis = {
        let x: f32 = rng.gen_range(-1.0..=1.0);
        let y: f32 = rng.gen_range(-1.0..=1.0);
        let z: f32 = rng.gen_range(-1.0..=1.0);
        Unit::new_normalize(Vector3::new(x, y, z))
    };
    

    Unit::new_normalize 會先計算長度並正規化。


    對應修改後的關鍵程式碼範例:

    let mut rng = rand::thread_rng();
    let axis = {
        let x: f32 = rng.gen_range(-1.0..=1.0);
        let y: f32 = rng.gen_range(-1.0..=1.0);
        let z: f32 = rng.gen_range(-1.0..=1.0);
        Unit::new_normalize(Vector3::new(x, y, z))
    };
    
    // ...
    
    let model = Matrix4::from_axis_angle(&axis, rotation);
    

    順便幫你把 warning 修掉:

    gl::load_with 那段根據 piston_window 的定義,其實 load_with 是安全函式,因此不需要 unsafe 包。

    改成:

    gl::load_with(|s| window.window.get_proc_address(s) as *const _);
    

    勿包裹在 unsafe,就能避免那個 warning。


    如果需要,我可以幫你貼完整修正版程式碼。

  25. User

    完整修正版程式碼

  26. Assistant
    extern crate piston_window;
    extern crate gl;
    extern crate nalgebra as na;
    extern crate rand;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::CString;
    use std::ptr;
    use std::mem;
    use na::{Matrix4, Perspective3, Point3, Vector3, Unit};
    use rand::Rng;
    
    const VERTEX_SHADER_SRC: &str = r#"
    #version 150 core
    in vec3 position;
    uniform mat4 transform;
    void main() {
        gl_Position = transform * vec4(position, 1.0);
    }
    "#;
    
    const FRAGMENT_SHADER_SRC: &str = r#"
    #version 150 core
    out vec4 out_color;
    void main() {
        out_color = vec4(1.0, 0.5, 0.2, 1.0);
    }
    "#;
    
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        let shader = gl::CreateShader(ty);
        let c_str = CString::new(src.as_bytes()).unwrap();
        gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
        gl::CompileShader(shader);
    
        let mut status = gl::FALSE as GLint;
        gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
    
        if status != (gl::TRUE as GLint) {
            let mut len = 0;
            gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
            let mut buf = Vec::with_capacity(len as usize + 1);
            buf.extend([b' '].iter().cycle().take(len as usize));
            let error = CString::from_vec_unchecked(buf);
            gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
            panic!("Shader compilation failed: {}", error.to_string_lossy());
        }
        shader
    }
    
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        let program = gl::CreateProgram();
        gl::AttachShader(program, vs);
        gl::AttachShader(program, fs);
        gl::LinkProgram(program);
    
        let mut status = gl::FALSE as GLint;
        gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
    
        if status != (gl::TRUE as GLint) {
            let mut len: GLint = 0;
            gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
            let mut buf = Vec::with_capacity(len as usize + 1);
            buf.extend([b' '].iter().cycle().take(len as usize));
            let error = CString::from_vec_unchecked(buf);
            gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
            panic!("Program linking failed: {}", error.to_string_lossy());
        }
        program
    }
    
    fn main() {
        let opengl = OpenGL::V3_2;
        let mut window: PistonWindow = WindowSettings::new("Piston + OpenGL 3D Triangle", [800, 600])
            .graphics_api(opengl)
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        // gl::load_with 是 safe function,不需要 unsafe 包
        gl::load_with(|s| window.window.get_proc_address(s) as *const _);
    
        let shader_program = unsafe {
            let vs = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER);
            let fs = compile_shader(FRAGMENT_SHADER_SRC, gl::FRAGMENT_SHADER);
            let program = link_program(vs, fs);
            gl::DeleteShader(vs);
            gl::DeleteShader(fs);
            program
        };
    
        let vertices: [f32; 9] = [
            0.0,  0.5, 0.0,
           -0.5, -0.5, 0.0,
            0.5, -0.5, 0.0,
        ];
    
        let (mut vao, mut vbo) = (0, 0);
        unsafe {
            gl::GenVertexArrays(1, &mut vao);
            gl::GenBuffers(1, &mut vbo);
    
            gl::BindVertexArray(vao);
    
            gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
            gl::BufferData(
                gl::ARRAY_BUFFER,
                (vertices.len() * mem::size_of::<GLfloat>()) as isize,
                vertices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            let pos_attrib = gl::GetAttribLocation(
                shader_program,
                CString::new("position").unwrap().as_ptr(),
            );
            gl::EnableVertexAttribArray(pos_attrib as GLuint);
            gl::VertexAttribPointer(
                pos_attrib as GLuint,
                3,
                gl::FLOAT,
                gl::FALSE,
                3 * mem::size_of::<GLfloat>() as i32,
                ptr::null(),
            );
    
            gl::BindBuffer(gl::ARRAY_BUFFER, 0);
            gl::BindVertexArray(0);
    
            gl::Enable(gl::DEPTH_TEST);
            gl::DepthFunc(gl::LESS);
        }
    
        let uniform_transform_loc = unsafe {
            let loc = gl::GetUniformLocation(
                shader_program,
                CString::new("transform").unwrap().as_ptr(),
            );
            if loc < 0 {
                panic!("Could not find uniform 'transform'");
            }
            loc
        };
    
        let mut rotation: f32 = 0.0;
        let mut rng = rand::thread_rng();
        let axis = {
            let x: f32 = rng.gen_range(-1.0..=1.0);
            let y: f32 = rng.gen_range(-1.0..=1.0);
            let z: f32 = rng.gen_range(-1.0..=1.0);
            Unit::new_normalize(Vector3::new(x, y, z))
        };
    
        while let Some(event) = window.next() {
            if let Some(args) = event.render_args() {
                rotation += 0.02;
                if rotation > std::f32::consts::TAU {
                    rotation -= std::f32::consts::TAU;
                }
    
                let (w, h) = (args.window_size[0] as f32, args.window_size[1] as f32);
    
                let projection = Perspective3::new(w / h, 45.0_f32.to_radians(), 0.1, 100.0);
                let view = Matrix4::look_at_rh(
                    &Point3::new(0.0, 0.0, 2.0),
                    &Point3::origin(),
                    &Vector3::y_axis(),
                );
                let model = Matrix4::from_axis_angle(&axis, rotation);
    
                let transform = projection.to_homogeneous() * view * model;
    
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
    
                    gl::UseProgram(shader_program);
                    gl::BindVertexArray(vao);
    
                    gl::UniformMatrix4fv(uniform_transform_loc, 1, gl::FALSE, transform.as_ptr());
    
                    gl::DrawArrays(gl::TRIANGLES, 0, 3);
    
                    gl::BindVertexArray(0);
                }
            }
        }
    }
    
  27. User

    這個三角形可以增加厚度嗎

  28. Assistant

    你目前這個三角形是純粹由3個點形成的平面(單面三角形),在 OpenGL 和大部分繪圖管線中,"厚度" 是沒有意義的,因為它只是個「面」而非三維實體。要讓三角形「有厚度」,也就是變成一個真實的 3D 物件(比如棱柱或三角錐),你需要用多個三角形拼成一個有體積的網格。


    增加厚度的幾種作法:

    1. 建立「三角柱」 (Triangular Prism)

    • 你可以用 6 個頂點(3 個在前面,一組 3 個在後面、往 Z 軸推移一定深度)來描述兩個三角形的面。
    • 再用三個矩形面(2 個三角形)把前後兩個三角形連接起來,形成厚度。

    簡單說你會有:

    • 前面三角形
    • 後面三角形(深度方向平移)
    • 3 個側面矩形(三角形拼接成矩形),總共 6 個三角形

    總頂點要擴充成 18 (6個點 * 3座標),然後編寫索引(index buffer)來正確繪出每個三角形。


    2. 使用多邊形建模工具匯入模型

    • 直接借助 Blender 等建模軟體建模帶厚度的三角形形狀(例如三角柱)
    • 載入模型(例如 Wavefront OBJ)
    • 用 Piston/OpenGL 繪製

    3. 用線框繪製「邊」,人為增加粗細感

    • 繪製三角形邊界 (Line Loop)
    • 用粗線條 (glLineWidth) 模擬厚度,但這是 2D 粗細,看起來厚度有限

    你的情況若想嘗試法1,寫個簡單三角柱範例:

    // 6個頂點,前三個和後三個,深度設為0.2
    let depth = 0.2;
    
    let vertices: [f32; 18] = [
        // 前面三角形 (z=0.0)
        0.0,  0.5, 0.0,
       -0.5, -0.5, 0.0,
        0.5, -0.5, 0.0,
    
        // 後面三角形 (z = -depth)
        0.0,  0.5, -depth,
       -0.5, -0.5, -depth,
        0.5, -0.5, -depth,
    ];
    
    // 用索引 (index buffer) 定義三角形,前面、後面、側面總共8個三角形
    let indices: [u32; 24] = [
        // 前面三角形
        0, 1, 2,
        // 後面三角形
        3, 5, 4,
        // 側面三角形們
        0, 3, 1,
        1, 3, 4,
    
        1, 4, 2,
        2, 4, 5,
    
        2, 5, 0,
        0, 5, 3,
    ];
    

    然後你需要用 OpenGL 的「索引繪製」 glDrawElements,加上 VBO(頂點緩衝)和 EBO(索引緩衝),繪製這個三角柱。


    總結

    • 三角形本身沒有厚度,如果想要厚度要做「立體實體」
    • 你可用多個三角形組成三角柱形狀
    • 實作有點複雜,需額外用索引和更多頂點
    • 也可以用建模軟體建好模型再載入繪製

    如果你想,我可以幫你寫這個「三角柱(帶厚度三角形)」的完整範例程式碼來演示!你可以告訴我!

  29. User

    完整範例程式碼

  30. Assistant

    下面我幫你寫一個用 Piston + OpenGL 繪製帶有厚度的三角柱(Triangular Prism)的完整範例。

    這個範例會:

    • 使用頂點陣列(VBO)和索引陣列(EBO)定義帶厚度的三角形(前後兩個三角形和連接側面)
    • 使用基本的 shader 繪製
    • 用之前的隨機旋轉軸做旋轉

    Cargo.toml

    請維持剛剛的設定,加入這些依賴:

    [dependencies]
    piston_window = "0.127"
    gl = "0.14"
    nalgebra = "0.32"
    rand = "0.8"
    

    main.rs

    extern crate piston_window;
    extern crate gl;
    extern crate nalgebra as na;
    extern crate rand;
    
    use piston_window::*;
    use gl::types::*;
    use std::ffi::CString;
    use std::ptr;
    use std::mem;
    use na::{Matrix4, Perspective3, Point3, Vector3, Unit};
    use rand::Rng;
    
    const VERTEX_SHADER_SRC: &str = r#"
    #version 150 core
    in vec3 position;
    uniform mat4 transform;
    void main() {
        gl_Position = transform * vec4(position, 1.0);
    }
    "#;
    
    const FRAGMENT_SHADER_SRC: &str = r#"
    #version 150 core
    out vec4 out_color;
    void main() {
        out_color = vec4(0.8, 0.4, 0.1, 1.0);  // 棕橘色
    }
    "#;
    
    unsafe fn compile_shader(src: &str, ty: GLenum) -> GLuint {
        let shader = gl::CreateShader(ty);
        let c_str = CString::new(src.as_bytes()).unwrap();
        gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
        gl::CompileShader(shader);
    
        let mut status = gl::FALSE as GLint;
        gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
    
        if status != (gl::TRUE as GLint) {
            let mut len = 0;
            gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
            let mut buf = Vec::with_capacity(len as usize + 1);
            buf.extend([b' '].iter().cycle().take(len as usize));
            let error = CString::from_vec_unchecked(buf);
            gl::GetShaderInfoLog(shader, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
            panic!("Shader compilation failed: {}", error.to_string_lossy());
        }
        shader
    }
    
    unsafe fn link_program(vs: GLuint, fs: GLuint) -> GLuint {
        let program = gl::CreateProgram();
        gl::AttachShader(program, vs);
        gl::AttachShader(program, fs);
        gl::LinkProgram(program);
    
        let mut status = gl::FALSE as GLint;
        gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);
    
        if status != (gl::TRUE as GLint) {
            let mut len: GLint = 0;
            gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
            let mut buf = Vec::with_capacity(len as usize + 1);
            buf.extend([b' '].iter().cycle().take(len as usize));
            let error = CString::from_vec_unchecked(buf);
            gl::GetProgramInfoLog(program, len, ptr::null_mut(), error.as_ptr() as *mut GLchar);
            panic!("Program linking failed: {}", error.to_string_lossy());
        }
        program
    }
    
    fn main() {
        let opengl = OpenGL::V3_2;
        let mut window: PistonWindow = WindowSettings::new("Triangular Prism with Thickness", [800, 600])
            .graphics_api(opengl)
            .exit_on_esc(true)
            .build()
            .unwrap();
    
        gl::load_with(|s| window.window.get_proc_address(s) as *const _);
    
        let shader_program = unsafe {
            let vs = compile_shader(VERTEX_SHADER_SRC, gl::VERTEX_SHADER);
            let fs = compile_shader(FRAGMENT_SHADER_SRC, gl::FRAGMENT_SHADER);
            let program = link_program(vs, fs);
    
            gl::DeleteShader(vs);
            gl::DeleteShader(fs);
    
            program
        };
    
        // 六個頂點:前後三角形
        let depth = 0.2;
    
        let vertices: [f32; 18] = [
            // 前面三角形 (z=0.0)
             0.0,  0.5,  0.0,
            -0.5, -0.5,  0.0,
             0.5, -0.5,  0.0,
    
            // 後面三角形 (z=-depth)
             0.0,  0.5, -depth,
            -0.5, -0.5, -depth,
             0.5, -0.5, -depth,
        ];
    
        // 24 個索引:前面,後面,側邊三角形
        let indices: [u32; 24] = [
            // 前面三角形
            0, 1, 2,
            // 後面三角形(三角形要逆序確保面向外)
            3, 5, 4,
    
            // 左側面
            0, 3, 1,
            1, 3, 4,
    
            // 右側面
            1, 4, 2,
            2, 4, 5,
    
            // 底部
            2, 5, 0,
            0, 5, 3,
        ];
    
        let (mut vao, mut vbo, mut ebo) = (0, 0, 0);
    
        unsafe {
            gl::GenVertexArrays(1, &mut vao);
            gl::GenBuffers(1, &mut vbo);
            gl::GenBuffers(1, &mut ebo);
    
            gl::BindVertexArray(vao);
    
            // VBO
            gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
            gl::BufferData(
                gl::ARRAY_BUFFER,
                (vertices.len() * mem::size_of::<GLfloat>()) as isize,
                vertices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            // EBO
            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, ebo);
            gl::BufferData(
                gl::ELEMENT_ARRAY_BUFFER,
                (indices.len() * mem::size_of::<u32>()) as isize,
                indices.as_ptr() as *const _,
                gl::STATIC_DRAW,
            );
    
            let pos_attrib = gl::GetAttribLocation(shader_program, CString::new("position").unwrap().as_ptr());
            gl::EnableVertexAttribArray(pos_attrib as GLuint);
            gl::VertexAttribPointer(
                pos_attrib as GLuint,
                3,
                gl::FLOAT,
                gl::FALSE,
                3 * mem::size_of::<GLfloat>() as i32,
                ptr::null(),
            );
    
            gl::BindVertexArray(0);
    
            gl::Enable(gl::DEPTH_TEST);
            gl::DepthFunc(gl::LESS);
        }
    
        let uniform_transform_loc = unsafe {
            let loc = gl::GetUniformLocation(shader_program, CString::new("transform").unwrap().as_ptr());
            if loc < 0 {
                panic!("Could not find uniform 'transform'");
            }
            loc
        };
    
        let mut rotation: f32 = 0.0;
        let mut rng = rand::thread_rng();
        let axis = {
            let x: f32 = rng.gen_range(-1.0..=1.0);
            let y: f32 = rng.gen_range(-1.0..=1.0);
            let z: f32 = rng.gen_range(-1.0..=1.0);
            Unit::new_normalize(Vector3::new(x, y, z))
        };
    
        while let Some(event) = window.next() {
            if let Some(args) = event.render_args() {
                rotation += 0.02;
                if rotation > std::f32::consts::TAU {
                    rotation -= std::f32::consts::TAU;
                }
    
                let (w, h) = (args.window_size[0] as f32, args.window_size[1] as f32);
    
                let projection = Perspective3::new(w / h, 45.0_f32.to_radians(), 0.1, 100.0);
                let view = Matrix4::look_at_rh(
                    &Point3::new(0.0, 0.0, 2.0),
                    &Point3::origin(),
                    &Vector3::y_axis(),
                );
                let model = Matrix4::from_axis_angle(&axis, rotation);
    
                let transform = projection.to_homogeneous() * view * model;
    
                unsafe {
                    gl::ClearColor(0.1, 0.2, 0.3, 1.0);
                    gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
    
                    gl::UseProgram(shader_program);
                    gl::BindVertexArray(vao);
    
                    // 用索引繪製整個三角柱
                    gl::UniformMatrix4fv(uniform_transform_loc, 1, gl::FALSE, transform.as_ptr());
    
                    gl::DrawElements(
                        gl::TRIANGLES,
                        indices.len() as i32,
                        gl::UNSIGNED_INT,
                        ptr::null(),
                    );
    
                    gl::BindVertexArray(0);
                }
            }
        }
    }
    

    功能說明

    • 三角柱頂點 vertices 宣告了前後兩個三角形(六個點)。
    • indices 宣告了前後兩面及三個側面各自的三角形,總共 8 個三角形(24索引)。
    • 透過索引緩衝(EBO)用 glDrawElements 繪製實體厚度的幾何。
    • 隨機旋轉軸持續旋轉3D。

    你編譯執行後會看到一個帶厚度的橙色三角柱在3D空間裡旋轉。

    有需要可再幫你微調加上光照、貼圖等效果。祝你使用愉快!