dom/canvas/WebGLVertexArray.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef WEBGL_VERTEX_ARRAY_H_
   7 #define WEBGL_VERTEX_ARRAY_H_
   8
   9 #include <array>
  10 #include <bitset>
  11 #include <vector>
  12
  13 #include "mozilla/IntegerRange.h"
  14
  15 #include "CacheInvalidator.h"
  16 #include "WebGLObjectModel.h"
  17 #include "WebGLStrongTypes.h"
  18
  19 namespace mozilla {
  20
  21 class WebGLBuffer;
  22 class WebGLVertexArrayFake;
  23
  24 namespace webgl {
  25 struct LinkedProgramInfo;
  26
  27 struct VertAttribLayoutData final {
  28   // Keep this packed tightly!
  29   uint32_t divisor = 0;
  30   bool isArray = false;
  31   uint8_t byteSize = 0;
  32   uint8_t byteStride = 1;  // Non-zero, at-most 255
  33   webgl::AttribBaseType baseType = webgl::AttribBaseType::Float;
  34   uint64_t byteOffset = 0;
  35 };
  36
  37 struct VertAttribBindingData final {
  38   VertAttribLayoutData layout;
  39   RefPtr<WebGLBuffer> buffer;
  40 };
  41
  42 }  // namespace webgl
  43
  44 void DoVertexAttribPointer(gl::GLContext&, uint32_t index,
  45                            const webgl::VertAttribPointerDesc&);
  46
  47 class WebGLVertexArray : public WebGLContextBoundObject {
  48   friend class ScopedDrawHelper;
  49   friend class WebGLContext;
  50   friend class WebGLVertexArrayFake;
  51   friend class WebGL2Context;
  52   friend struct webgl::LinkedProgramInfo;
  53
  54   static constexpr size_t kMaxAttribs = 32;  // gpuinfo.org says so
  55
  56   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(WebGLVertexArray, override)
  57
  58   RefPtr<WebGLBuffer> mElementArrayBuffer;
  59
  60   std::array<webgl::VertAttribBindingData, kMaxAttribs> mBindings;  // Hot data.
  61   std::array<webgl::VertAttribPointerDesc, kMaxAttribs>
  62       mDescs;  // cold data, parallel to mBindings.
  63
  64   std::bitset<kMaxAttribs> mAttribIsArrayWithNullBuffer;
  65   bool mHasBeenBound = false;
  66
  67  public:
  68   static WebGLVertexArray* Create(WebGLContext* webgl);
  69
  70  protected:
  71   explicit WebGLVertexArray(WebGLContext* webgl);
  72   ~WebGLVertexArray();
  73
  74  public:
  75   virtual void BindVertexArray() = 0;
  76
  77   void SetAttribIsArray(const uint32_t index, const bool val) {
  78     auto& binding = mBindings.at(index);
  79     binding.layout.isArray = val;
  80     mAttribIsArrayWithNullBuffer[index] =
  81         binding.layout.isArray && !binding.buffer;
  82   }
  83
  84   void AttribDivisor(const uint32_t index, const uint32_t val) {
  85     auto& binding = mBindings.at(index);
  86     binding.layout.divisor = val;
  87   }
  88
  89   void AttribPointer(const uint32_t index, WebGLBuffer* const buffer,
  90                      const webgl::VertAttribPointerDesc& desc,
  91                      const webgl::VertAttribPointerCalculated& calc) {
  92     mDescs[index] = desc;
  93
  94     auto& binding = mBindings.at(index);
  95     binding.buffer = buffer;
  96     binding.layout.byteSize = calc.byteSize;
  97     binding.layout.byteStride = calc.byteStride;
  98     binding.layout.baseType = calc.baseType;
  99     binding.layout.byteOffset = desc.byteOffset;
 100
 101     mAttribIsArrayWithNullBuffer[index] =
 102         binding.layout.isArray && !binding.buffer;
 103   }
 104
 105   const auto& AttribBinding(const uint32_t index) const {
 106     return mBindings.at(index);
 107   }
 108   const auto& AttribDesc(const uint32_t index) const {
 109     return mDescs.at(index);
 110   }
 111
 112   Maybe<uint32_t> GetAttribIsArrayWithNullBuffer() const {
 113     const auto& bitset = mAttribIsArrayWithNullBuffer;
 114     if (MOZ_LIKELY(bitset.none())) return {};
 115     for (const auto i : IntegerRange(bitset.size())) {
 116       if (bitset[i]) return Some(i);
 117     }
 118     MOZ_CRASH();
 119   }
 120
 121   Maybe<double> GetVertexAttrib(uint32_t index, GLenum pname) const;
 122   void DoVertexAttrib(uint32_t index, uint32_t vertOffset = 0) const;
 123 };
 124
 125 }  // namespace mozilla
 126
 127 #endif  // WEBGL_VERTEX_ARRAY_H_