Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 03:15:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1458870 - Update Cargo lockfiles and re-vendor rust dependencies. r=jrmuizel

Browse Source 
MozReview-Commit-ID: GQilwX8rUAR

--HG--
extra : rebase_source : 4c8a813e42c4ba02c361cb56be04386926aecbc4
This commit is contained in:
Kartikaya Gupta 2018-05-08 10:36:19 -04:00
parent c7cceabe9a
commit fc31bfdc8a
6 changed files with 389 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Cargo.lock generated
View File

@ -854,7 +854,7 @@ dependencies = [
[[package]]
name = "gleam"
version = "0.4.32"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"gl_generator 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2286,7 +2286,7 @@ dependencies = [
"euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)",
"freetype 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"gleam 0.4.32 (registry+https://github.com/rust-lang/crates.io-index)",
"gleam 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2328,7 +2328,7 @@ dependencies = [
"dwrote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)",
"foreign-types 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"gleam 0.4.32 (registry+https://github.com/rust-lang/crates.io-index)",
"gleam 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rayon 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
"thread_profiler 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
@ -2536,7 +2536,7 @@ dependencies = [
"checksum gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)" = "5e33ec290da0d127825013597dbdfc28bee4964690c7ce1166cbc2a7bd08b1bb"
"checksum gdi32-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0912515a8ff24ba900422ecda800b52f4016a56251922d397c576bf92c690518"
"checksum gl_generator 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a795170cbd85b5a7baa58d6d7525cae6a03e486859860c220f7ebbbdd379d0a"
"checksum gleam 0.4.32 (registry+https://github.com/rust-lang/crates.io-index)" = "70363479f033b72dbd558fd3b6f153dd824bf4f9dcd05dfcff6cd29a3eb9a63d"
"checksum gleam 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e47b39459e47b76be4d2c82702932cdc66df09dcb8f813424167991adb8b3380"
"checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
"checksum httparse 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "af2f2dd97457e8fb1ae7c5a420db346af389926e36f43768b96f101546b04a07"
"checksum humantime 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0484fda3e7007f2a4a0d9c3a703ca38c71c54c55602ce4660c419fd32e188c9e"

2
third_party/rust/gleam/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{".travis.yml":"29b74b95210896ce634c11a9037638668473b5a1b3b1716c505cb04dbb6341fa","COPYING":"ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a","Cargo.toml":"7eb0bbf4c4679d7be4c073b22b77036fa5f89264ee615bbf1f93bdbcc1b9fe75","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3","README.md":"2de24b7458d6b88f20324303a48acf64a4f2bbfb83d2ec4d6ff2b4f4a1fd2275","build.rs":"a1616d76f35b3a6015c2ee22ecf13eb225095b22e4190ef5ef2fcd9197b43ad1","src/gl.rs":"982935c8c519e749b42f124ed105a3cacefc186d597f476bd72ea7c88a3e5070","src/gl_fns.rs":"ea24ea0c6deb06af7809140facd5e0f7fce2bb5b340ef425ce0b10029e95294a","src/gles_fns.rs":"aaced55ced12f5dcbeec9ee88eb91696ab65ca24c41cb6fd7f2bdf380641ceb7","src/lib.rs":"16610c19b45a3f26d56b379a3591aa2e4fc9477e7bd88f86b31c6ea32e834861"},"package":"70363479f033b72dbd558fd3b6f153dd824bf4f9dcd05dfcff6cd29a3eb9a63d"}
{"files":{".travis.yml":"29b74b95210896ce634c11a9037638668473b5a1b3b1716c505cb04dbb6341fa","COPYING":"ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a","Cargo.toml":"96141412a2322a5dfe693d87d5792e7c9859340f751109856024b9870d2289d3","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3","README.md":"2de24b7458d6b88f20324303a48acf64a4f2bbfb83d2ec4d6ff2b4f4a1fd2275","build.rs":"a1616d76f35b3a6015c2ee22ecf13eb225095b22e4190ef5ef2fcd9197b43ad1","src/gl.rs":"0a2f631a09ddfa267d6dcf2274342529b6f487e1cb982b92e1111a64c1d7437e","src/gl_fns.rs":"ead6bbdc6a937264275e849ed84ab9b1be83624fcea31aa7bde2d933390ee151","src/gles_fns.rs":"ba64f9a124af370121ba526c262ccb0f87ebf6f99115fc25e2a9ae5a8d39af34","src/lib.rs":"16610c19b45a3f26d56b379a3591aa2e4fc9477e7bd88f86b31c6ea32e834861"},"package":"e47b39459e47b76be4d2c82702932cdc66df09dcb8f813424167991adb8b3380"}

2
third_party/rust/gleam/Cargo.toml vendored
View File

@ -12,7 +12,7 @@
[package]
name = "gleam"
version = "0.4.32"
version = "0.5.0"
authors = ["The Servo Project Developers"]
build = "build.rs"
description = "Generated OpenGL bindings and wrapper for Servo."

298
third_party/rust/gleam/src/gl.rs vendored
View File

@ -101,37 +101,54 @@ pub struct DebugMessage {
pub severity: GLenum,
}
pub trait Gl {
macro_rules! declare_gl_apis {
// garbo is a hack to handle unsafe methods.
($($(unsafe $([$garbo:expr])*)* fn $name:ident(&self $(, $arg:ident: $t:ty)* $(,)*) $(-> $retty:ty)* ;)+) => {
pub trait Gl {
$($(unsafe $($garbo)*)* fn $name(&self $(, $arg:$t)*) $(-> $retty)* ;)+
}
impl Gl for ErrorCheckingGl {
$($(unsafe $($garbo)*)* fn $name(&self $(, $arg:$t)*) $(-> $retty)* {
let rv = self.gl.$name($($arg,)*);
assert_eq!(self.gl.get_error(), 0);
rv
})+
}
}
}
declare_gl_apis! {
fn get_type(&self) -> GlType;
fn buffer_data_untyped(&self,
target: GLenum,
size: GLsizeiptr,
data: *const GLvoid,
usage: GLenum);
target: GLenum,
size: GLsizeiptr,
data: *const GLvoid,
usage: GLenum);
fn buffer_sub_data_untyped(&self,
target: GLenum,
offset: isize,
size: GLsizeiptr,
data: *const GLvoid);
target: GLenum,
offset: isize,
size: GLsizeiptr,
data: *const GLvoid);
fn tex_buffer(&self, target: GLenum, internal_format: GLenum, buffer: GLuint);
fn shader_source(&self, shader: GLuint, strings: &[&[u8]]);
fn read_buffer(&self, mode: GLenum);
fn read_pixels_into_buffer(&self,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
pixel_type: GLenum,
dst_buffer: &mut [u8]);
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
pixel_type: GLenum,
dst_buffer: &mut [u8]);
fn read_pixels(&self,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
pixel_type: GLenum)
-> Vec<u8>;
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
pixel_type: GLenum)
-> Vec<u8>;
fn sample_coverage(&self, value: GLclampf, invert: bool);
fn polygon_offset(&self, factor: GLfloat, units: GLfloat);
fn pixel_store_i(&self, name: GLenum, param: GLint);
@ -175,9 +192,9 @@ pub trait Gl {
fn bind_buffer_base(&self, target: GLenum, index: GLuint, buffer: GLuint);
fn bind_buffer_range(&self, target: GLenum, index: GLuint, buffer: GLuint, offset: GLintptr, size: GLsizeiptr);
fn uniform_block_binding(&self,
program: GLuint,
uniform_block_index: GLuint,
uniform_block_binding: GLuint);
program: GLuint,
uniform_block_index: GLuint,
uniform_block_binding: GLuint);
fn bind_buffer(&self, target: GLenum, buffer: GLuint);
fn bind_vertex_array(&self, vao: GLuint);
fn bind_renderbuffer(&self, target: GLenum, renderbuffer: GLuint);
@ -195,22 +212,22 @@ pub trait Gl {
ty: GLenum,
opt_data: Option<&[u8]>);
fn compressed_tex_image_2d(&self,
target: GLenum,
level: GLint,
internal_format: GLenum,
width: GLsizei,
height: GLsizei,
border: GLint,
data: &[u8]);
target: GLenum,
level: GLint,
internal_format: GLenum,
width: GLsizei,
height: GLsizei,
border: GLint,
data: &[u8]);
fn compressed_tex_sub_image_2d(&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
data: &[u8]);
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
width: GLsizei,
height: GLsizei,
format: GLenum,
data: &[u8]);
fn tex_image_3d(&self,
target: GLenum,
level: GLint,
@ -223,33 +240,33 @@ pub trait Gl {
ty: GLenum,
opt_data: Option<&[u8]>);
fn copy_tex_image_2d(&self,
target: GLenum,
level: GLint,
internal_format: GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
border: GLint);
target: GLenum,
level: GLint,
internal_format: GLenum,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei,
border: GLint);
fn copy_tex_sub_image_2d(&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei);
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei);
fn copy_tex_sub_image_3d(&self,
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei);
target: GLenum,
level: GLint,
xoffset: GLint,
yoffset: GLint,
zoffset: GLint,
x: GLint,
y: GLint,
width: GLsizei,
height: GLsizei);
fn tex_sub_image_2d(&self,
target: GLenum,
level: GLint,
@ -295,37 +312,42 @@ pub trait Gl {
ty: GLenum,
offset: usize);
fn get_tex_image_into_buffer(&self,
target: GLenum,
level: GLint,
format: GLenum,
ty: GLenum,
output: &mut [u8]);
fn get_integer_v(&self, name: GLenum) -> GLint;
fn get_integer_64v(&self, name: GLenum) -> GLint64;
fn get_integer_iv(&self, name: GLenum, index: GLuint) -> GLint;
fn get_integer_64iv(&self, name: GLenum, index: GLuint) -> GLint64;
fn get_boolean_v(&self, name: GLenum) -> GLboolean;
fn get_float_v(&self, name: GLenum) -> GLfloat;
target: GLenum,
level: GLint,
format: GLenum,
ty: GLenum,
output: &mut [u8]);
unsafe fn get_integer_v(&self, name: GLenum, result: &mut [GLint]);
unsafe fn get_integer_64v(&self, name: GLenum, result: &mut [GLint64]);
unsafe fn get_integer_iv(&self, name: GLenum, index: GLuint, result: &mut [GLint]);
unsafe fn get_integer_64iv(&self, name: GLenum, index: GLuint, result: &mut [GLint64]);
unsafe fn get_boolean_v(&self, name: GLenum, result: &mut [GLboolean]);
unsafe fn get_float_v(&self, name: GLenum, result: &mut [GLfloat]);
fn get_framebuffer_attachment_parameter_iv(&self,
target: GLenum,
attachment: GLenum,
pname: GLenum) -> GLint;
target: GLenum,
attachment: GLenum,
pname: GLenum) -> GLint;
fn get_renderbuffer_parameter_iv(&self,
target: GLenum,
pname: GLenum) -> GLint;
fn get_tex_parameter_iv(&self, target: GLenum, name: GLenum) -> GLint;
fn get_tex_parameter_fv(&self, target: GLenum, name: GLenum) -> GLfloat;
fn tex_parameter_i(&self, target: GLenum, pname: GLenum, param: GLint);
fn tex_parameter_f(&self, target: GLenum, pname: GLenum, param: GLfloat);
fn framebuffer_texture_2d(&self,
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint);
target: GLenum,
attachment: GLenum,
textarget: GLenum,
texture: GLuint,
level: GLint);
fn framebuffer_texture_layer(&self,
target: GLenum,
attachment: GLenum,
texture: GLuint,
level: GLint,
layer: GLint);
target: GLenum,
attachment: GLenum,
texture: GLuint,
level: GLint,
layer: GLint);
fn blit_framebuffer(&self,
src_x0: GLint,
src_y0: GLint,
@ -339,55 +361,54 @@ pub trait Gl {
filter: GLenum);
fn vertex_attrib_4f(&self, index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat);
fn vertex_attrib_pointer_f32(&self,
index: GLuint,
size: GLint,
normalized: bool,
stride: GLsizei,
offset: GLuint);
index: GLuint,
size: GLint,
normalized: bool,
stride: GLsizei,
offset: GLuint);
fn vertex_attrib_pointer(&self,
index: GLuint,
size: GLint,
type_: GLenum,
normalized: bool,
stride: GLsizei,
offset: GLuint);
index: GLuint,
size: GLint,
type_: GLenum,
normalized: bool,
stride: GLsizei,
offset: GLuint);
fn vertex_attrib_i_pointer(&self,
index: GLuint,
size: GLint,
type_: GLenum,
stride: GLsizei,
offset: GLuint);
index: GLuint,
size: GLint,
type_: GLenum,
stride: GLsizei,
offset: GLuint);
fn vertex_attrib_divisor(&self, index: GLuint, divisor: GLuint);
fn viewport(&self, x: GLint, y: GLint, width: GLsizei, height: GLsizei);
fn get_viewport(&self) -> (GLint, GLint, GLsizei, GLsizei);
fn scissor(&self, x: GLint, y: GLint, width: GLsizei, height: GLsizei);
fn line_width(&self, width: GLfloat);
fn use_program(&self, program: GLuint);
fn validate_program(&self, program: GLuint);
fn draw_arrays(&self, mode: GLenum, first: GLint, count: GLsizei);
fn draw_arrays_instanced(&self,
mode: GLenum,
first: GLint,
count: GLsizei,
primcount: GLsizei);
mode: GLenum,
first: GLint,
count: GLsizei,
primcount: GLsizei);
fn draw_elements(&self,
mode: GLenum,
count: GLsizei,
element_type: GLenum,
indices_offset: GLuint);
mode: GLenum,
count: GLsizei,
element_type: GLenum,
indices_offset: GLuint);
fn draw_elements_instanced(&self,
mode: GLenum,
count: GLsizei,
element_type: GLenum,
indices_offset: GLuint,
primcount: GLsizei);
mode: GLenum,
count: GLsizei,
element_type: GLenum,
indices_offset: GLuint,
primcount: GLsizei);
fn blend_color(&self, r: f32, g: f32, b: f32, a: f32);
fn blend_func(&self, sfactor: GLenum, dfactor: GLenum);
fn blend_func_separate(&self,
src_rgb: GLenum,
dest_rgb: GLenum,
src_alpha: GLenum,
dest_alpha: GLenum);
src_rgb: GLenum,
dest_rgb: GLenum,
src_alpha: GLenum,
dest_alpha: GLenum);
fn blend_equation(&self, mode: GLenum);
fn blend_equation_separate(&self, mode_rgb: GLenum, mode_alpha: GLenum);
fn color_mask(&self, r: bool, g: bool, b: bool, a: bool);
@ -439,22 +460,22 @@ pub trait Gl {
fn get_frag_data_location(&self, program: GLuint, name: &str) -> c_int;
fn get_uniform_location(&self, program: GLuint, name: &str) -> c_int;
fn get_program_info_log(&self, program: GLuint) -> String;
fn get_program_iv(&self, program: GLuint, pname: GLenum) -> GLint;
unsafe fn get_program_iv(&self, program: GLuint, pname: GLenum, result: &mut [GLint]);
fn get_program_binary(&self, program: GLuint) -> (Vec<u8>, GLenum);
fn program_binary(&self, program: GLuint, format: GLenum, binary: &[u8]);
fn program_parameter_i(&self, program: GLuint, pname: GLenum, value: GLint);
fn get_vertex_attrib_iv(&self, index: GLuint, pname: GLenum) -> GLint;
fn get_vertex_attrib_fv(&self, index: GLuint, pname: GLenum) -> Vec<GLfloat>;
unsafe fn get_vertex_attrib_iv(&self, index: GLuint, pname: GLenum, result: &mut [GLint]);
unsafe fn get_vertex_attrib_fv(&self, index: GLuint, pname: GLenum, result: &mut [GLfloat]);
fn get_vertex_attrib_pointer_v(&self, index: GLuint, pname: GLenum) -> GLsizeiptr;
fn get_buffer_parameter_iv(&self, target: GLuint, pname: GLenum) -> GLint;
fn get_shader_info_log(&self, shader: GLuint) -> String;
fn get_string(&self, which: GLenum) -> String;
fn get_string_i(&self, which: GLenum, index: GLuint) -> String;
fn get_shader_iv(&self, shader: GLuint, pname: GLenum) -> GLint;
unsafe fn get_shader_iv(&self, shader: GLuint, pname: GLenum, result: &mut [GLint]);
fn get_shader_precision_format(&self,
shader_type: GLuint,
precision_type: GLuint)
-> (GLint, GLint, GLint);
shader_type: GLuint,
precision_type: GLuint)
-> (GLint, GLint, GLint);
fn compile_shader(&self, shader: GLuint);
fn create_program(&self) -> GLuint;
fn delete_program(&self, program: GLuint);
@ -505,15 +526,20 @@ pub trait Gl {
name: &str,
) -> GLint;
fn alias_point_size_range(&self) -> (GLfloat, GLfloat);
/// Returns the the maximum supported width and height of the viewport.
fn max_viewport_dims(&self) -> (GLint, GLint);
// GL_KHR_debug
fn get_debug_messages(&self) -> Vec<DebugMessage>;
}
pub struct ErrorCheckingGl {
gl: Rc<Gl>,
}
impl ErrorCheckingGl {
pub fn wrap(fns: Rc<Gl>) -> Rc<Gl> {
Rc::new(ErrorCheckingGl { gl: fns }) as Rc<Gl>
}
}
#[inline]
pub fn buffer_data<T>(gl_: &Gl, target: GLenum, data: &[T], usage: GLenum) {
gl_.buffer_data_untyped(target,

225
third_party/rust/gleam/src/gl_fns.rs vendored
View File

@ -655,52 +655,40 @@ impl Gl for GlFns {
}
}
fn get_integer_v(&self, name: GLenum) -> GLint {
let mut result = 0;
unsafe {
self.ffi_gl_.GetIntegerv(name, &mut result);
}
result
#[inline]
unsafe fn get_integer_v(&self, name: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetIntegerv(name, result.as_mut_ptr());
}
fn get_integer_64v(&self, name: GLenum) -> GLint64 {
let mut result = 0;
unsafe {
self.ffi_gl_.GetInteger64v(name, &mut result);
}
result
#[inline]
unsafe fn get_integer_64v(&self, name: GLenum, result: &mut [GLint64]) {
assert!(!result.is_empty());
self.ffi_gl_.GetInteger64v(name, result.as_mut_ptr());
}
fn get_integer_iv(&self, name: GLenum, index: GLuint) -> GLint {
let mut result = 0;
unsafe {
self.ffi_gl_.GetIntegeri_v(name, index, &mut result);
}
result
#[inline]
unsafe fn get_integer_iv(&self, name: GLenum, index: GLuint, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetIntegeri_v(name, index, result.as_mut_ptr());
}
fn get_integer_64iv(&self, name: GLenum, index: GLuint) -> GLint64 {
let mut result = 0;
unsafe {
self.ffi_gl_.GetInteger64i_v(name, index, &mut result);
}
result
#[inline]
unsafe fn get_integer_64iv(&self, name: GLenum, index: GLuint, result: &mut [GLint64]) {
assert!(!result.is_empty());
self.ffi_gl_.GetInteger64i_v(name, index, result.as_mut_ptr());
}
fn get_boolean_v(&self, name: GLenum) -> GLboolean {
let mut result = 0 as GLboolean;
unsafe {
self.ffi_gl_.GetBooleanv(name, &mut result);
}
result
#[inline]
unsafe fn get_boolean_v(&self, name: GLenum, result: &mut [GLboolean]) {
assert!(!result.is_empty());
self.ffi_gl_.GetBooleanv(name, result.as_mut_ptr());
}
fn get_float_v(&self, name: GLenum) -> GLfloat {
let mut result = 0 as GLfloat;
unsafe {
self.ffi_gl_.GetFloatv(name, &mut result);
}
result
#[inline]
unsafe fn get_float_v(&self, name: GLenum, result: &mut [GLfloat]) {
assert!(!result.is_empty());
self.ffi_gl_.GetFloatv(name, result.as_mut_ptr());
}
fn get_framebuffer_attachment_parameter_iv(&self, target: GLenum, attachment: GLenum, pname: GLenum) -> GLint {
@ -711,6 +699,14 @@ impl Gl for GlFns {
result
}
fn get_renderbuffer_parameter_iv(&self, target: GLenum, pname: GLenum) -> GLint {
let mut result: GLint = 0;
unsafe {
self.ffi_gl_.GetRenderbufferParameteriv(target, pname, &mut result);
}
result
}
fn get_tex_parameter_iv(&self, target: GLenum, pname: GLenum) -> GLint {
let mut result: GLint = 0;
unsafe {
@ -857,14 +853,6 @@ impl Gl for GlFns {
}
}
fn get_viewport(&self) -> (GLint, GLint, GLsizei, GLsizei) {
unsafe {
let mut ret = [0; 4];
self.ffi_gl_.GetIntegerv(ffi::VIEWPORT, ret.as_mut_ptr());
(ret[0], ret[1], ret[2], ret[3])
}
}
fn scissor(&self, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {
unsafe {
self.ffi_gl_.Scissor(x, y, width, height);
@ -1212,28 +1200,49 @@ impl Gl for GlFns {
}
fn get_active_attrib(&self, program: GLuint, index: GLuint) -> (i32, u32, String) {
let buf_size = self.get_program_iv(program, ffi::ACTIVE_ATTRIBUTE_MAX_LENGTH);
let mut name = vec![0u8; buf_size as usize];
let mut buf_size = [0];
unsafe {
self.get_program_iv(program, ffi::ACTIVE_ATTRIBUTE_MAX_LENGTH, &mut buf_size);
}
let mut name = vec![0u8; buf_size[0] as usize];
let mut length = 0 as GLsizei;
let mut size = 0 as i32;
let mut type_ = 0 as u32;
unsafe {
self.ffi_gl_.GetActiveAttrib(program, index, buf_size, &mut length, &mut size, &mut type_, name.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetActiveAttrib(
program,
index,
buf_size[0],
&mut length,
&mut size,
&mut type_,
name.as_mut_ptr() as *mut GLchar,
);
}
name.truncate(if length > 0 {length as usize} else {0});
(size, type_, String::from_utf8(name).unwrap())
}
fn get_active_uniform(&self, program: GLuint, index: GLuint) -> (i32, u32, String) {
let buf_size = self.get_program_iv(program, ffi::ACTIVE_UNIFORM_MAX_LENGTH);
let mut name = vec![0 as u8; buf_size as usize];
let mut buf_size = [0];
unsafe {
self.get_program_iv(program, ffi::ACTIVE_UNIFORM_MAX_LENGTH, &mut buf_size);
}
let mut name = vec![0 as u8; buf_size[0] as usize];
let mut length: GLsizei = 0;
let mut size: i32 = 0;
let mut type_: u32 = 0;
unsafe {
self.ffi_gl_.GetActiveUniform(program, index, buf_size, &mut length, &mut size,
&mut type_, name.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetActiveUniform(
program,
index,
buf_size[0],
&mut length,
&mut size,
&mut type_,
name.as_mut_ptr() as *mut GLchar,
);
}
name.truncate(if length > 0 { length as usize } else { 0 });
@ -1310,47 +1319,55 @@ impl Gl for GlFns {
}
fn get_program_info_log(&self, program: GLuint) -> String {
let max_len = self.get_program_iv(program, ffi::INFO_LOG_LENGTH);
let mut result = vec![0u8; max_len as usize];
let mut max_len = [0];
unsafe {
self.get_program_iv(program, ffi::INFO_LOG_LENGTH, &mut max_len);
}
let mut result = vec![0u8; max_len[0] as usize];
let mut result_len = 0 as GLsizei;
unsafe {
self.ffi_gl_.GetProgramInfoLog(program,
max_len as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetProgramInfoLog(
program,
max_len[0] as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar,
);
}
result.truncate(if result_len > 0 {result_len as usize} else {0});
String::from_utf8(result).unwrap()
}
fn get_program_iv(&self, program: GLuint, pname: GLenum) -> GLint {
let mut result = 0 as GLint;
unsafe {
self.ffi_gl_.GetProgramiv(program, pname, &mut result);
}
result
#[inline]
unsafe fn get_program_iv(&self, program: GLuint, pname: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetProgramiv(program, pname, result.as_mut_ptr());
}
fn get_program_binary(&self, program: GLuint) -> (Vec<u8>, GLenum) {
if !self.ffi_gl_.GetProgramBinary.is_loaded() {
return (Vec::new(), NONE);
}
let len = self.get_program_iv(program, ffi::PROGRAM_BINARY_LENGTH);
if len <= 0 {
let mut len = [0];
unsafe {
self.get_program_iv(program, ffi::PROGRAM_BINARY_LENGTH, &mut len);
}
if len[0] <= 0 {
return (Vec::new(), NONE);
}
let mut binary: Vec<u8> = Vec::with_capacity(len as usize);
let mut binary: Vec<u8> = Vec::with_capacity(len[0] as usize);
let mut format = NONE;
let mut out_len = 0;
unsafe {
binary.set_len(len as usize);
self.ffi_gl_.GetProgramBinary(program,
len,
&mut out_len as *mut GLsizei,
&mut format,
binary.as_mut_ptr() as *mut c_void);
binary.set_len(len[0] as usize);
self.ffi_gl_.GetProgramBinary(
program,
len[0],
&mut out_len as *mut GLsizei,
&mut format,
binary.as_mut_ptr() as *mut c_void,
);
}
if len != out_len {
if len[0] != out_len {
return (Vec::new(), NONE);
}
@ -1378,20 +1395,16 @@ impl Gl for GlFns {
}
}
fn get_vertex_attrib_iv(&self, index: GLuint, pname: GLenum) -> GLint {
let mut result = 0 as GLint;
unsafe {
self.ffi_gl_.GetVertexAttribiv(index, pname, &mut result);
}
result
#[inline]
unsafe fn get_vertex_attrib_iv(&self, index: GLuint, pname: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetVertexAttribiv(index, pname, result.as_mut_ptr());
}
fn get_vertex_attrib_fv(&self, index: GLuint, pname: GLenum) -> Vec<GLfloat> {
let mut result = vec![0 as GLfloat; 4];
unsafe {
self.ffi_gl_.GetVertexAttribfv(index, pname, result.as_mut_ptr());
}
result
#[inline]
unsafe fn get_vertex_attrib_fv(&self, index: GLuint, pname: GLenum, result: &mut [GLfloat]) {
assert!(!result.is_empty());
self.ffi_gl_.GetVertexAttribfv(index, pname, result.as_mut_ptr());
}
fn get_vertex_attrib_pointer_v(&self, index: GLuint, pname: GLenum) -> GLsizeiptr {
@ -1411,14 +1424,19 @@ impl Gl for GlFns {
}
fn get_shader_info_log(&self, shader: GLuint) -> String {
let max_len = self.get_shader_iv(shader, ffi::INFO_LOG_LENGTH);
let mut result = vec![0u8; max_len as usize];
let mut max_len = [0];
unsafe {
self.get_shader_iv(shader, ffi::INFO_LOG_LENGTH, &mut max_len);
}
let mut result = vec![0u8; max_len[0] as usize];
let mut result_len = 0 as GLsizei;
unsafe {
self.ffi_gl_.GetShaderInfoLog(shader,
max_len as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetShaderInfoLog(
shader,
max_len[0] as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar,
);
}
result.truncate(if result_len > 0 {result_len as usize} else {0});
String::from_utf8(result).unwrap()
@ -1446,12 +1464,9 @@ impl Gl for GlFns {
}
}
fn get_shader_iv(&self, shader: GLuint, pname: GLenum) -> GLint {
let mut result = 0 as GLint;
unsafe {
self.ffi_gl_.GetShaderiv(shader, pname, &mut result);
}
result
unsafe fn get_shader_iv(&self, shader: GLuint, pname: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetShaderiv(shader, pname, result.as_mut_ptr());
}
fn get_shader_precision_format(&self, _shader_type: GLuint, precision_type: GLuint) -> (GLint, GLint, GLint) {
@ -1750,22 +1765,6 @@ impl Gl for GlFns {
}
}
fn alias_point_size_range(&self) -> (GLfloat, GLfloat) {
unsafe {
let mut ret = [0.; 2];
self.ffi_gl_.GetFloatv(ffi::ALIASED_POINT_SIZE_RANGE, ret.as_mut_ptr());
(ret[0], ret[1])
}
}
fn max_viewport_dims(&self) -> (GLint, GLint) {
unsafe {
let mut ret = [0; 2];
self.ffi_gl_.GetIntegerv(ffi::MAX_VIEWPORT_DIMS, ret.as_mut_ptr());
(ret[0], ret[1])
}
}
// GL_KHR_debug
fn get_debug_messages(&self) -> Vec<DebugMessage> {
if !self.ffi_gl_.GetDebugMessageLog.is_loaded() {

220
third_party/rust/gleam/src/gles_fns.rs vendored
View File

@ -674,51 +674,46 @@ impl Gl for GlesFns {
panic!("not supported");
}
fn get_integer_v(&self, name: GLenum) -> GLint {
let mut result = 0;
unsafe {
self.ffi_gl_.GetIntegerv(name, &mut result);
}
result
#[inline]
unsafe fn get_integer_v(&self, name: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetIntegerv(name, result.as_mut_ptr());
}
fn get_integer_64v(&self, name: GLenum) -> GLint64 {
let mut result = 0;
unsafe {
self.ffi_gl_.GetInteger64v(name, &mut result);
}
result
#[inline]
unsafe fn get_integer_64v(&self, name: GLenum, result: &mut [GLint64]) {
assert!(!result.is_empty());
self.ffi_gl_.GetInteger64v(name, result.as_mut_ptr());
}
fn get_integer_iv(&self, name: GLenum, index: GLuint) -> GLint {
let mut result = 0;
unsafe {
self.ffi_gl_.GetIntegeri_v(name, index, &mut result);
}
result
#[inline]
unsafe fn get_integer_iv(&self, name: GLenum, index: GLuint, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetIntegeri_v(name, index, result.as_mut_ptr());
}
fn get_integer_64iv(&self, name: GLenum, index: GLuint) -> GLint64 {
let mut result = 0;
unsafe {
self.ffi_gl_.GetInteger64i_v(name, index, &mut result);
}
result
#[inline]
unsafe fn get_integer_64iv(&self, name: GLenum, index: GLuint, result: &mut [GLint64]) {
assert!(!result.is_empty());
self.ffi_gl_.GetInteger64i_v(name, index, result.as_mut_ptr());
}
fn get_boolean_v(&self, name: GLenum) -> GLboolean {
let mut result = 0 as GLboolean;
unsafe {
self.ffi_gl_.GetBooleanv(name, &mut result);
}
result
#[inline]
unsafe fn get_boolean_v(&self, name: GLenum, result: &mut [GLboolean]) {
assert!(!result.is_empty());
self.ffi_gl_.GetBooleanv(name, result.as_mut_ptr());
}
fn get_float_v(&self, name: GLenum) -> GLfloat {
let mut result = 0 as GLfloat;
#[inline]
unsafe fn get_float_v(&self, name: GLenum, result: &mut [GLfloat]) {
assert!(!result.is_empty());
self.ffi_gl_.GetFloatv(name, result.as_mut_ptr());
}
fn get_renderbuffer_parameter_iv(&self, target: GLenum, pname: GLenum) -> GLint {
let mut result: GLint = 0;
unsafe {
self.ffi_gl_.GetFloatv(name, &mut result);
self.ffi_gl_.GetRenderbufferParameteriv(target, pname, &mut result);
}
result
}
@ -877,14 +872,6 @@ impl Gl for GlesFns {
}
}
fn get_viewport(&self) -> (GLint, GLint, GLsizei, GLsizei) {
unsafe {
let mut ret = [0; 4];
self.ffi_gl_.GetIntegerv(ffi::VIEWPORT, ret.as_mut_ptr());
(ret[0], ret[1], ret[2], ret[3])
}
}
fn scissor(&self, x: GLint, y: GLint, width: GLsizei, height: GLsizei) {
unsafe {
self.ffi_gl_.Scissor(x, y, width, height);
@ -1228,28 +1215,49 @@ impl Gl for GlesFns {
}
fn get_active_attrib(&self, program: GLuint, index: GLuint) -> (i32, u32, String) {
let buf_size = self.get_program_iv(program, ffi::ACTIVE_ATTRIBUTE_MAX_LENGTH);
let mut name = vec![0u8; buf_size as usize];
let mut buf_size = [0];
unsafe {
self.get_program_iv(program, ffi::ACTIVE_ATTRIBUTE_MAX_LENGTH, &mut buf_size);
}
let mut name = vec![0u8; buf_size[0] as usize];
let mut length = 0 as GLsizei;
let mut size = 0 as i32;
let mut type_ = 0 as u32;
unsafe {
self.ffi_gl_.GetActiveAttrib(program, index, buf_size, &mut length, &mut size, &mut type_, name.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetActiveAttrib(
program,
index,
buf_size[0],
&mut length,
&mut size,
&mut type_,
name.as_mut_ptr() as *mut GLchar,
);
}
name.truncate(if length > 0 {length as usize} else {0});
(size, type_, String::from_utf8(name).unwrap())
}
fn get_active_uniform(&self, program: GLuint, index: GLuint) -> (i32, u32, String) {
let buf_size = self.get_program_iv(program, ffi::ACTIVE_UNIFORM_MAX_LENGTH);
let mut name = vec![0 as u8; buf_size as usize];
let mut buf_size = [0];
unsafe {
self.get_program_iv(program, ffi::ACTIVE_UNIFORM_MAX_LENGTH, &mut buf_size);
}
let mut name = vec![0 as u8; buf_size[0] as usize];
let mut length: GLsizei = 0;
let mut size: i32 = 0;
let mut type_: u32 = 0;
unsafe {
self.ffi_gl_.GetActiveUniform(program, index, buf_size, &mut length, &mut size,
&mut type_, name.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetActiveUniform(
program,
index,
buf_size[0],
&mut length,
&mut size,
&mut type_,
name.as_mut_ptr() as *mut GLchar,
);
}
name.truncate(if length > 0 { length as usize } else { 0 });
@ -1324,44 +1332,52 @@ impl Gl for GlesFns {
}
fn get_program_info_log(&self, program: GLuint) -> String {
let max_len = self.get_program_iv(program, ffi::INFO_LOG_LENGTH);
let mut result = vec![0u8; max_len as usize];
let mut max_len = [0];
unsafe {
self.get_program_iv(program, ffi::INFO_LOG_LENGTH, &mut max_len);
}
let mut result = vec![0u8; max_len[0] as usize];
let mut result_len = 0 as GLsizei;
unsafe {
self.ffi_gl_.GetProgramInfoLog(program,
max_len as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetProgramInfoLog(
program,
max_len[0] as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar,
);
}
result.truncate(if result_len > 0 {result_len as usize} else {0});
String::from_utf8(result).unwrap()
}
fn get_program_iv(&self, program: GLuint, pname: GLenum) -> GLint {
let mut result = 0 as GLint;
unsafe {
self.ffi_gl_.GetProgramiv(program, pname, &mut result);
}
result
#[inline]
unsafe fn get_program_iv(&self, program: GLuint, pname: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetProgramiv(program, pname, result.as_mut_ptr());
}
fn get_program_binary(&self, program: GLuint) -> (Vec<u8>, GLenum) {
let len = self.get_program_iv(program, ffi::PROGRAM_BINARY_LENGTH);
if len <= 0 {
let mut len = [0];
unsafe {
self.get_program_iv(program, ffi::PROGRAM_BINARY_LENGTH, &mut len);
}
if len[0] <= 0 {
return (Vec::new(), NONE);
}
let mut binary: Vec<u8> = Vec::with_capacity(len as usize);
let mut binary: Vec<u8> = Vec::with_capacity(len[0] as usize);
let mut format = NONE;
let mut out_len = 0;
unsafe {
binary.set_len(len as usize);
self.ffi_gl_.GetProgramBinary(program,
len,
&mut out_len as *mut GLsizei,
&mut format,
binary.as_mut_ptr() as *mut c_void);
binary.set_len(len[0] as usize);
self.ffi_gl_.GetProgramBinary(
program,
len[0],
&mut out_len as *mut GLsizei,
&mut format,
binary.as_mut_ptr() as *mut c_void,
);
}
if len != out_len {
if len[0] != out_len {
return (Vec::new(), NONE);
}
@ -1383,20 +1399,16 @@ impl Gl for GlesFns {
}
}
fn get_vertex_attrib_iv(&self, index: GLuint, pname: GLenum) -> GLint {
let mut result = 0 as GLint;
unsafe {
self.ffi_gl_.GetVertexAttribiv(index, pname, &mut result);
}
result
#[inline]
unsafe fn get_vertex_attrib_iv(&self, index: GLuint, pname: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetVertexAttribiv(index, pname, result.as_mut_ptr());
}
fn get_vertex_attrib_fv(&self, index: GLuint, pname: GLenum) -> Vec<GLfloat> {
let mut result = vec![0 as GLfloat; 4];
unsafe {
self.ffi_gl_.GetVertexAttribfv(index, pname, result.as_mut_ptr());
}
result
#[inline]
unsafe fn get_vertex_attrib_fv(&self, index: GLuint, pname: GLenum, result: &mut [GLfloat]) {
assert!(!result.is_empty());
self.ffi_gl_.GetVertexAttribfv(index, pname, result.as_mut_ptr());
}
fn get_vertex_attrib_pointer_v(&self, index: GLuint, pname: GLenum) -> GLsizeiptr {
@ -1416,14 +1428,19 @@ impl Gl for GlesFns {
}
fn get_shader_info_log(&self, shader: GLuint) -> String {
let max_len = self.get_shader_iv(shader, ffi::INFO_LOG_LENGTH);
let mut result = vec![0u8; max_len as usize];
let mut max_len = [0];
unsafe {
self.get_shader_iv(shader, ffi::INFO_LOG_LENGTH, &mut max_len);
}
let mut result = vec![0u8; max_len[0] as usize];
let mut result_len = 0 as GLsizei;
unsafe {
self.ffi_gl_.GetShaderInfoLog(shader,
max_len as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar);
self.ffi_gl_.GetShaderInfoLog(
shader,
max_len[0] as GLsizei,
&mut result_len,
result.as_mut_ptr() as *mut GLchar,
);
}
result.truncate(if result_len > 0 {result_len as usize} else {0});
String::from_utf8(result).unwrap()
@ -1451,12 +1468,9 @@ impl Gl for GlesFns {
}
}
fn get_shader_iv(&self, shader: GLuint, pname: GLenum) -> GLint {
let mut result = 0 as GLint;
unsafe {
self.ffi_gl_.GetShaderiv(shader, pname, &mut result);
}
result
unsafe fn get_shader_iv(&self, shader: GLuint, pname: GLenum, result: &mut [GLint]) {
assert!(!result.is_empty());
self.ffi_gl_.GetShaderiv(shader, pname, result.as_mut_ptr());
}
fn get_shader_precision_format(&self,
@ -1711,22 +1725,6 @@ impl Gl for GlesFns {
panic!("not supported");
}
fn alias_point_size_range(&self) -> (GLfloat, GLfloat) {
unsafe {
let mut ret = [0.; 2];
self.ffi_gl_.GetFloatv(ffi::ALIASED_POINT_SIZE_RANGE, ret.as_mut_ptr());
(ret[0], ret[1])
}
}
fn max_viewport_dims(&self) -> (GLint, GLint) {
unsafe {
let mut ret = [0; 2];
self.ffi_gl_.GetIntegerv(ffi::MAX_VIEWPORT_DIMS, ret.as_mut_ptr());
(ret[0], ret[1])
}
}
// GL_KHR_debug
fn get_debug_messages(&self) -> Vec<DebugMessage> {
if !self.ffi_gl_.GetDebugMessageLog.is_loaded() {