xgl 0.2.2

Unified minimalist OpenGL 3.3 & WebGL abstractions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// Copyright (C) 2025 Daniel Mueller <deso@posteo.net>
// SPDX-License-Identifier: (Apache-2.0 OR MIT)

use std::ops::Deref;

use anyhow::anyhow;
use anyhow::Context as _;
use anyhow::Result;

use crate::sys;
use crate::sys::Gl as _;
use crate::Shader;


/// A program object.
#[derive(Debug)]
pub struct Program {
  /// The GL context.
  context: sys::Context,
  /// The program.
  program: sys::Program,
}

impl Program {
  pub fn new(shaders: &[Shader], context: &sys::Context) -> Result<Self> {
    let program = context
      .create_program()
      .context("failed to create program object")?;
    let slf = Self {
      context: context.clone(),
      program,
    };

    let () = shaders
      .iter()
      .for_each(|shader| context.attach_shader(&slf.program, shader));

    let () = context.link_program(&slf.program).map_err(|log| {
      // TODO: Should use `String::from_utf8_lossy_owned` once stable.
      let log = String::from_utf8_lossy(log.as_slice());
      anyhow!("failed to link program: {log}")
    })?;

    let () = shaders
      .iter()
      .for_each(|shader| context.detach_shader(&slf.program, shader));

    // Also perform some basic validation to check whether the program
    // could actually execute. In a more complex program we may want to
    // do that at more points in time (potentially before every "draw"
    // call).
    let () = context.validate_program(&slf.program).map_err(|log| {
      // TODO: Should use `String::from_utf8_lossy_owned` once stable.
      let log = String::from_utf8_lossy(log.as_slice());
      anyhow!("failed to validate program: {log}")
    })?;

    Ok(slf)
  }

  pub fn query_attrib_location(&self, attrib: &str) -> Result<u32> {
    let idx = self
      .context
      .attrib_location(&self.program, attrib)
      .with_context(|| format!("failed to query `{attrib}` attribute location"))?;
    Ok(idx)
  }

  pub fn query_uniform_location(&self, uniform: &str) -> Result<sys::UniformLocation> {
    let location = self
      .context
      .uniform_location(&self.program, uniform)
      .with_context(|| format!("failed to query `{uniform}` uniform location"))?;
    Ok(location)
  }

  #[inline]
  pub fn bind(&self) {
    let () = self.context.use_program(&self.program);
  }
}

impl Deref for Program {
  type Target = sys::Program;

  #[inline]
  fn deref(&self) -> &Self::Target {
    &self.program
  }
}

impl Drop for Program {
  #[inline]
  fn drop(&mut self) {
    let () = self.context.delete_program(&self.program);
  }
}


#[cfg(test)]
mod tests {
  use super::*;

  use test_fork::fork;

  use crate::winit::with_opengl_context;


  /// Check that we can create a program.
  #[fork]
  #[test]
  fn program_creation() {
    let vertex_shader = format!(
      r#"
#version {glsl_version}

in vec4 position;

void main() {{
   gl_Position = position;
}}
"#,
      glsl_version = Shader::glsl_version()
    );

    let fragment_shader = format!(
      r#"
#version {glsl_version}

out vec4 color;

void main() {{
   color = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}}
"#,
      glsl_version = Shader::glsl_version()
    );

    with_opengl_context(|| {
      let gl_context = sys::Context::default();
      let vertex_shader =
        Shader::new(sys::ShaderType::Vertex, &vertex_shader, &gl_context).unwrap();
      let fragment_shader =
        Shader::new(sys::ShaderType::Fragment, &fragment_shader, &gl_context).unwrap();
      let program = Program::new(&[vertex_shader, fragment_shader], &gl_context).unwrap();

      assert!(program.query_attrib_location("position").is_ok());
      assert!(program.query_attrib_location("foobar").is_err());
    })
  }
}