bowtie 0.2.0

2D Game engine with messaging system
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

extern crate gl;

pub enum GlErrorResult {
  NoError,
  Error(String),
}

pub enum GlError {
  ShaderError(u32),
}

pub fn pull_errors() {
  loop {
    let err = unsafe { gl::GetError() };
    if err != gl::NO_ERROR {
      println!("{}", err);
    } else {
      break;
    }
  }
}

fn buffer_to_string(buffer: &Vec<i8>) -> String {
  return String::from_utf8(
    buffer
      .iter()
      .map(|s| s.to_owned() as u8)
      .collect::<Vec<u8>>(),
  )
  .expect("Could not transform buffer to string");
}

pub fn get_error(error: GlError, max_length: i32) -> GlErrorResult {
  let mut buffer: Vec<i8> = Vec::new();
  buffer.reserve(max_length as usize);
  let mut buffer_len = 0;
  for _ in 0..max_length {
    buffer.push(0);
  }

  match error {
    GlError::ShaderError(shader_id) => unsafe {
      let mut status = -1;
      gl::GetShaderiv(shader_id, gl::COMPILE_STATUS, &mut status);

      if (status as u8) != gl::TRUE {
        gl::GetShaderInfoLog(
          shader_id,
          max_length,
          &mut buffer_len,
          &mut buffer[0],
        );
        return GlErrorResult::Error(buffer_to_string(&buffer));
      } else {
        return GlErrorResult::NoError;
      }
    },
  }
}

extern "system" fn debug_message_callback(
  source: u32,
  message_type: u32,
  _id: u32,
  severity: u32,
  length: i32,
  message: *const gl::types::GLchar,
  _user_param: *mut gl::types::GLvoid,
) {
  unsafe {
    let mut buffer: Vec<i8> = Vec::new();
    buffer.reserve(length as usize);

    for i in 0..length {
      buffer.push(std::ptr::read_volatile(message.offset(i as isize)));
    }

    println!(
      "(Severity {}) (Type {}): (Source {}) {:?}",
      severity,
      message_type,
      source,
      buffer_to_string(&buffer)
    );
  }
}

pub fn init_debug_callback() {
  unsafe {
    gl::Enable(gl::DEBUG_OUTPUT);
    gl::DebugMessageCallback(
      Some(debug_message_callback),
      0 as *const gl::types::GLvoid,
    );
  }
}