WebGLProgram.h - mozsearch

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* 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 http://mozilla.org/MPL/2.0/. */

#ifndef WEBGL_PROGRAM_H_

#define WEBGL_PROGRAM_H_

#include <bitset>

#include <map>

#include <memory>

#include <set>

#include <vector>

#include "mozilla/RefPtr.h"

#include "mozilla/Vector.h"

#include "mozilla/WeakPtr.h"

#include "CacheInvalidator.h"

#include "WebGLObjectModel.h"

#include "WebGLTypes.h"

namespace mozilla {

class ErrorResult;

class WebGLContext;

class WebGLProgram;

class WebGLShader;

namespace dom {

template <typename>

struct Nullable;

class OwningUnsignedLongOrUint32ArrayOrBoolean;

template <typename>

class Sequence;

}  // namespace dom

namespace webgl {

enum class TextureBaseType : uint8_t;

struct UniformBlockInfo final {

  const ActiveUniformBlockInfo& info;

  const IndexedBufferBinding* binding = nullptr;

};

struct FragOutputInfo final {

  const uint8_t loc;

  const std::string userName;

  const std::string mappedName;

  const TextureBaseType baseType;

};

struct CachedDrawFetchLimits final {

  uint64_t maxVerts = UINT64_MAX;

  uint64_t maxInstances = UINT64_MAX;

  std::vector<BufferAndIndex> usedBuffers;

  CachedDrawFetchLimits() = default;

  explicit CachedDrawFetchLimits(const CachedDrawFetchLimits&) = delete;

  CachedDrawFetchLimits(CachedDrawFetchLimits&&) = default;

  CachedDrawFetchLimits& operator=(CachedDrawFetchLimits&&) = default;

};

// -

void UniformAs1fv(gl::GLContext& gl, GLint location, GLsizei count,

                  bool transpose, const void* any);

struct ActiveUniformValidationInfo final {

  const ActiveUniformInfo& info;

  bool isArray = false;

  uint8_t channelsPerElem = 0;

  decltype(&UniformAs1fv) pfn = nullptr;

  static ActiveUniformValidationInfo Make(const ActiveUniformInfo&);

};

struct SamplerUniformInfo final {

  const nsTArray<RefPtr<WebGLTexture>>& texListForType;

  // = const decltype(WebGLContext::mBound2DTextures)&

  const webgl::TextureBaseType texBaseType;

  const bool isShadowSampler;

  Vector<uint8_t, 8> texUnits = decltype(texUnits)();

};

struct LocationInfo final {

  const ActiveUniformValidationInfo info;

  const uint32_t indexIntoUniform;

  SamplerUniformInfo* const samplerInfo;

  auto PrettyName() const {

    auto ret = info.info.name;

    if (info.isArray) {

      ret += "[";

      ret += std::to_string(indexIntoUniform);

      ret += "]";

    return ret;

};

// -

struct LinkedProgramInfo final : public RefCounted<LinkedProgramInfo>,

                                 public SupportsWeakPtr,

                                 public CacheInvalidator {

  friend class mozilla::WebGLProgram;

  MOZ_DECLARE_REFCOUNTED_TYPENAME(LinkedProgramInfo)

  //////

  WebGLProgram* const prog;

  const GLenum transformFeedbackBufferMode;

  std::bitset<kMaxDrawBuffers> hasOutput = 0;

  std::unordered_map<uint8_t, const FragOutputInfo> fragOutputs;

  uint8_t zLayerCount = 1;

  mutable std::vector<size_t> componentsPerTFVert;

  bool attrib0Active = false;

  GLint webgl_gl_VertexID_Offset = -1;  // Location

  // -

  std::map<std::string, std::string> nameMap;

  webgl::LinkActiveInfo active;

  std::vector<std::unique_ptr<SamplerUniformInfo>> samplerUniforms;

  std::unordered_map<uint32_t, LocationInfo> locationMap;

  mutable std::vector<UniformBlockInfo> uniformBlocks;

  //////

 private:

  mutable CachedDrawFetchLimits mScratchFetchLimits;

 public:

  const CachedDrawFetchLimits* GetDrawFetchLimits() const;

  //////

  explicit LinkedProgramInfo(WebGLProgram* prog);

  ~LinkedProgramInfo();

};

}  // namespace webgl

class WebGLProgram final : public WebGLContextBoundObject {

  friend class WebGLTransformFeedback;

  friend struct webgl::LinkedProgramInfo;

  MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(WebGLProgram, override)

 public:

  explicit WebGLProgram(WebGLContext* webgl);

  void Delete();

  // GL funcs

  void AttachShader(WebGLShader& shader);

  void BindAttribLocation(GLuint index, const std::string& name);

  void DetachShader(const WebGLShader& shader);

  void UniformBlockBinding(GLuint uniformBlockIndex,

                           GLuint uniformBlockBinding) const;

  void LinkProgram();

  bool UseProgram() const;

  bool ValidateProgram() const;

  ////////////////

  void TransformFeedbackVaryings(const std::vector<std::string>& varyings,

                                 GLenum bufferMode);

  bool IsLinked() const { return mMostRecentLinkInfo; }

  const webgl::LinkedProgramInfo* LinkInfo() const {

    return mMostRecentLinkInfo.get();

  const auto& VertShader() const { return mVertShader; }

  const auto& FragShader() const { return mFragShader; }

  const auto& LinkLog() const { return mLinkLog; }

 private:

  ~WebGLProgram();

  void LinkAndUpdate();

  bool ValidateForLink();

  bool ValidateAfterTentativeLink(std::string* const out_linkLog) const;

 public:

  const GLuint mGLName;

 private:

  RefPtr<WebGLShader> mVertShader;

  RefPtr<WebGLShader> mFragShader;

  size_t mNumActiveTFOs;

  std::map<std::string, GLuint> mNextLink_BoundAttribLocs;

  std::vector<std::string> mNextLink_TransformFeedbackVaryings;

  GLenum mNextLink_TransformFeedbackBufferMode;

  std::string mLinkLog;

  RefPtr<const webgl::LinkedProgramInfo> mMostRecentLinkInfo;

};

}  // namespace mozilla

#endif  // WEBGL_PROGRAM_H_