Add VertexArrayObject support for WebGL2

The implementation was already in place for OpenGL ES.
My approach with this patch is to add support for WebGL2 by
sharing the implementation between the WebGL2 and GLES.

components/script/dom/mod.rs

@@ -527,6 +527,7 @@ pub mod userscripts;
 pub mod validation;
 pub mod validitystate;
 pub mod values;
+pub mod vertexarrayobject;
 pub mod videotrack;
 pub mod videotracklist;
 pub mod virtualmethods;
@@ -560,6 +561,7 @@ pub mod webglsync;
 pub mod webgltexture;
 pub mod webgltransformfeedback;
 pub mod webgluniformlocation;
+pub mod webglvertexarrayobject;
 pub mod webglvertexarrayobjectoes;
 pub mod websocket;
 pub mod wheelevent;

components/script/dom/vertexarrayobject.rs

@@ -0,0 +1,296 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::dom::bindings::cell::{ref_filter_map, DomRefCell, Ref};
+use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
+use crate::dom::bindings::root::{Dom, MutNullableDom};
+use crate::dom::webglbuffer::WebGLBuffer;
+use crate::dom::webglrenderingcontext::WebGLRenderingContext;
+use canvas_traits::webgl::{
+    ActiveAttribInfo, WebGLCommand, WebGLError, WebGLResult, WebGLVertexArrayId,
+};
+use std::cell::Cell;
+
+#[derive(JSTraceable, MallocSizeOf)]
+#[unrooted_must_root_lint::must_root]
+pub struct VertexArrayObject {
+    context: Dom<WebGLRenderingContext>,
+    id: Option<WebGLVertexArrayId>,
+    ever_bound: Cell<bool>,
+    is_deleted: Cell<bool>,
+    vertex_attribs: DomRefCell<Box<[VertexAttribData]>>,
+    element_array_buffer: MutNullableDom<WebGLBuffer>,
+}
+
+impl VertexArrayObject {
+    pub fn new(context: &WebGLRenderingContext, id: Option<WebGLVertexArrayId>) -> Self {
+        let max_vertex_attribs = context.limits().max_vertex_attribs as usize;
+        Self {
+            context: Dom::from_ref(context),
+            id,
+            ever_bound: Default::default(),
+            is_deleted: Default::default(),
+            vertex_attribs: DomRefCell::new(vec![Default::default(); max_vertex_attribs].into()),
+            element_array_buffer: Default::default(),
+        }
+    }
+
+    pub fn id(&self) -> Option<WebGLVertexArrayId> {
+        self.id
+    }
+
+    pub fn is_deleted(&self) -> bool {
+        self.is_deleted.get()
+    }
+
+    pub fn delete(&self, fallible: bool) {
+        assert!(self.id.is_some());
+        if self.is_deleted.get() {
+            return;
+        }
+        self.is_deleted.set(true);
+        let cmd = WebGLCommand::DeleteVertexArray(self.id.unwrap());
+        if fallible {
+            self.context.send_command_ignored(cmd);
+        } else {
+            self.context.send_command(cmd);
+        }
+
+        for attrib_data in &**self.vertex_attribs.borrow() {
+            if let Some(buffer) = attrib_data.buffer() {
+                buffer.decrement_attached_counter();
+            }
+        }
+        if let Some(buffer) = self.element_array_buffer.get() {
+            buffer.decrement_attached_counter();
+        }
+    }
+
+    pub fn ever_bound(&self) -> bool {
+        return self.ever_bound.get();
+    }
+
+    pub fn set_ever_bound(&self) {
+        self.ever_bound.set(true);
+    }
+
+    pub fn element_array_buffer(&self) -> &MutNullableDom<WebGLBuffer> {
+        &self.element_array_buffer
+    }
+
+    pub fn get_vertex_attrib(&self, index: u32) -> Option<Ref<VertexAttribData>> {
+        ref_filter_map(self.vertex_attribs.borrow(), |attribs| {
+            attribs.get(index as usize)
+        })
+    }
+
+    pub fn vertex_attrib_pointer(
+        &self,
+        index: u32,
+        size: i32,
+        type_: u32,
+        normalized: bool,
+        stride: i32,
+        offset: i64,
+    ) -> WebGLResult<()> {
+        let mut attribs = self.vertex_attribs.borrow_mut();
+        let data = attribs
+            .get_mut(index as usize)
+            .ok_or(WebGLError::InvalidValue)?;
+
+        if size < 1 || size > 4 {
+            return Err(WebGLError::InvalidValue);
+        }
+
+        // https://www.khronos.org/registry/webgl/specs/latest/1.0/#BUFFER_OFFSET_AND_STRIDE
+        // https://www.khronos.org/registry/webgl/specs/latest/1.0/#VERTEX_STRIDE
+        if stride < 0 || stride > 255 || offset < 0 {
+            return Err(WebGLError::InvalidValue);
+        }
+        let bytes_per_component: i32 = match type_ {
+            constants::BYTE | constants::UNSIGNED_BYTE => 1,
+            constants::SHORT | constants::UNSIGNED_SHORT => 2,
+            constants::FLOAT => 4,
+            _ => return Err(WebGLError::InvalidEnum),
+        };
+        if offset % bytes_per_component as i64 > 0 || stride % bytes_per_component > 0 {
+            return Err(WebGLError::InvalidOperation);
+        }
+
+        let buffer = self.context.array_buffer();
+        match buffer {
+            Some(ref buffer) => buffer.increment_attached_counter(),
+            None if offset != 0 => {
+                // https://github.com/KhronosGroup/WebGL/pull/2228
+                return Err(WebGLError::InvalidOperation);
+            },
+            _ => {},
+        }
+        self.context.send_command(WebGLCommand::VertexAttribPointer(
+            index,
+            size,
+            type_,
+            normalized,
+            stride,
+            offset as u32,
+        ));
+        if let Some(old) = data.buffer() {
+            old.decrement_attached_counter();
+        }
+
+        *data = VertexAttribData {
+            enabled_as_array: data.enabled_as_array,
+            size: size as u8,
+            type_,
+            bytes_per_vertex: size as u8 * bytes_per_component as u8,
+            normalized,
+            stride: stride as u8,
+            offset: offset as u32,
+            buffer: buffer.map(|b| Dom::from_ref(&*b)),
+            divisor: data.divisor,
+        };
+
+        Ok(())
+    }
+
+    pub fn vertex_attrib_divisor(&self, index: u32, value: u32) {
+        self.vertex_attribs.borrow_mut()[index as usize].divisor = value;
+    }
+
+    pub fn enabled_vertex_attrib_array(&self, index: u32, value: bool) {
+        self.vertex_attribs.borrow_mut()[index as usize].enabled_as_array = value;
+    }
+
+    pub fn unbind_buffer(&self, buffer: &WebGLBuffer) {
+        for attrib in &mut **self.vertex_attribs.borrow_mut() {
+            if let Some(b) = attrib.buffer() {
+                if b.id() != buffer.id() {
+                    continue;
+                }
+                b.decrement_attached_counter();
+            }
+            attrib.buffer = None;
+        }
+        if self
+            .element_array_buffer
+            .get()
+            .map_or(false, |b| buffer == &*b)
+        {
+            buffer.decrement_attached_counter();
+            self.element_array_buffer.set(None);
+        }
+    }
+
+    pub fn validate_for_draw(
+        &self,
+        required_len: u32,
+        instance_count: u32,
+        active_attribs: &[ActiveAttribInfo],
+    ) -> WebGLResult<()> {
+        // TODO(nox): Cache limits per VAO.
+        let attribs = self.vertex_attribs.borrow();
+        // https://www.khronos.org/registry/webgl/specs/latest/1.0/#6.2
+        if attribs
+            .iter()
+            .any(|data| data.enabled_as_array && data.buffer.is_none())
+        {
+            return Err(WebGLError::InvalidOperation);
+        }
+        let mut has_active_attrib = false;
+        let mut has_divisor_0 = false;
+        for active_info in active_attribs {
+            if active_info.location < 0 {
+                continue;
+            }
+            has_active_attrib = true;
+            let attrib = &attribs[active_info.location as usize];
+            if attrib.divisor == 0 {
+                has_divisor_0 = true;
+            }
+            if !attrib.enabled_as_array {
+                continue;
+            }
+            // https://www.khronos.org/registry/webgl/specs/latest/1.0/#6.6
+            if required_len > 0 && instance_count > 0 {
+                let max_vertices = attrib.max_vertices();
+                if attrib.divisor == 0 {
+                    if max_vertices < required_len {
+                        return Err(WebGLError::InvalidOperation);
+                    }
+                } else if max_vertices
+                    .checked_mul(attrib.divisor)
+                    .map_or(false, |v| v < instance_count)
+                {
+                    return Err(WebGLError::InvalidOperation);
+                }
+            }
+        }
+        if has_active_attrib && !has_divisor_0 {
+            return Err(WebGLError::InvalidOperation);
+        }
+        Ok(())
+    }
+}
+
+impl Drop for VertexArrayObject {
+    fn drop(&mut self) {
+        if self.id.is_some() {
+            self.delete(true);
+        }
+    }
+}
+
+#[derive(Clone, JSTraceable, MallocSizeOf)]
+#[unrooted_must_root_lint::must_root]
+pub struct VertexAttribData {
+    pub enabled_as_array: bool,
+    pub size: u8,
+    pub type_: u32,
+    bytes_per_vertex: u8,
+    pub normalized: bool,
+    pub stride: u8,
+    pub offset: u32,
+    pub buffer: Option<Dom<WebGLBuffer>>,
+    pub divisor: u32,
+}
+
+impl Default for VertexAttribData {
+    #[allow(unrooted_must_root)]
+    fn default() -> Self {
+        Self {
+            enabled_as_array: false,
+            size: 4,
+            type_: constants::FLOAT,
+            bytes_per_vertex: 16,
+            normalized: false,
+            stride: 0,
+            offset: 0,
+            buffer: None,
+            divisor: 0,
+        }
+    }
+}
+
+impl VertexAttribData {
+    pub fn buffer(&self) -> Option<&WebGLBuffer> {
+        self.buffer.as_ref().map(|b| &**b)
+    }
+
+    pub fn max_vertices(&self) -> u32 {
+        let capacity = (self.buffer().unwrap().capacity() as u32).saturating_sub(self.offset);
+        if capacity < self.bytes_per_vertex as u32 {
+            0
+        } else if self.stride == 0 {
+            capacity / self.bytes_per_vertex as u32
+        } else if self.stride < self.bytes_per_vertex {
+            (capacity - (self.bytes_per_vertex - self.stride) as u32) / self.stride as u32
+        } else {
+            let mut max = capacity / self.stride as u32;
+            if capacity % self.stride as u32 >= self.bytes_per_vertex as u32 {
+                max += 1;
+            }
+            max
+        }
+    }
+}