зеркало из https://github.com/mozilla/gecko-dev.git
280 строки
8.0 KiB
C++
280 строки
8.0 KiB
C++
/* -*- 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_FRAMEBUFFER_H_
|
|
#define WEBGL_FRAMEBUFFER_H_
|
|
|
|
#include <vector>
|
|
|
|
#include "mozilla/LinkedList.h"
|
|
#include "mozilla/WeakPtr.h"
|
|
#include "nsWrapperCache.h"
|
|
|
|
#include "WebGLObjectModel.h"
|
|
#include "WebGLRenderbuffer.h"
|
|
#include "WebGLStrongTypes.h"
|
|
#include "WebGLTexture.h"
|
|
#include "WebGLTypes.h"
|
|
|
|
namespace mozilla {
|
|
|
|
class WebGLFramebuffer;
|
|
class WebGLRenderbuffer;
|
|
class WebGLTexture;
|
|
|
|
template <typename T>
|
|
class PlacementArray;
|
|
|
|
namespace gl {
|
|
class GLContext;
|
|
} // namespace gl
|
|
|
|
class WebGLFBAttachPoint final {
|
|
friend class WebGLFramebuffer;
|
|
|
|
public:
|
|
const GLenum mAttachmentPoint = 0;
|
|
const bool mDeferAttachment = false;
|
|
|
|
private:
|
|
WebGLRefPtr<WebGLTexture> mTexturePtr;
|
|
WebGLRefPtr<WebGLRenderbuffer> mRenderbufferPtr;
|
|
TexImageTarget mTexImageTarget = 0;
|
|
GLint mTexImageLayer = 0;
|
|
uint32_t mTexImageLevel = 0;
|
|
|
|
////
|
|
|
|
WebGLFBAttachPoint() = default;
|
|
WebGLFBAttachPoint(const WebGLContext* webgl, GLenum attachmentPoint);
|
|
|
|
explicit WebGLFBAttachPoint(WebGLFBAttachPoint&) =
|
|
default; // Make this private.
|
|
|
|
public:
|
|
~WebGLFBAttachPoint();
|
|
|
|
////
|
|
|
|
void Unlink() { Clear(); }
|
|
|
|
bool HasAttachment() const {
|
|
return bool(mTexturePtr) | bool(mRenderbufferPtr);
|
|
}
|
|
bool IsDeleteRequested() const;
|
|
|
|
void Clear();
|
|
|
|
void SetTexImage(gl::GLContext* gl, WebGLTexture* tex, TexImageTarget target,
|
|
GLint level, GLint layer = 0);
|
|
void SetRenderbuffer(gl::GLContext* gl, WebGLRenderbuffer* rb);
|
|
|
|
WebGLTexture* Texture() const { return mTexturePtr; }
|
|
WebGLRenderbuffer* Renderbuffer() const { return mRenderbufferPtr; }
|
|
|
|
TexImageTarget ImageTarget() const { return mTexImageTarget; }
|
|
GLint Layer() const { return mTexImageLayer; }
|
|
uint32_t MipLevel() const { return mTexImageLevel; }
|
|
void AttachmentName(nsCString* out) const;
|
|
|
|
const webgl::ImageInfo* GetImageInfo() const;
|
|
|
|
bool IsComplete(WebGLContext* webgl, nsCString* const out_info) const;
|
|
|
|
void DoAttachment(gl::GLContext* gl) const;
|
|
|
|
JS::Value GetParameter(WebGLContext* webgl, JSContext* cx, GLenum target,
|
|
GLenum attachment, GLenum pname,
|
|
ErrorResult* const out_error) const;
|
|
|
|
bool IsEquivalentForFeedback(const WebGLFBAttachPoint& other) const {
|
|
if (!HasAttachment() | !other.HasAttachment()) return false;
|
|
|
|
#define _(X) (X == other.X)
|
|
return (_(mRenderbufferPtr) & _(mTexturePtr) & _(mTexImageTarget.get()) &
|
|
_(mTexImageLevel) & _(mTexImageLayer));
|
|
#undef _
|
|
}
|
|
|
|
////
|
|
|
|
struct Ordered {
|
|
const WebGLFBAttachPoint& mRef;
|
|
|
|
explicit Ordered(const WebGLFBAttachPoint& ref) : mRef(ref) {}
|
|
|
|
bool operator<(const Ordered& other) const {
|
|
MOZ_ASSERT(mRef.HasAttachment() && other.mRef.HasAttachment());
|
|
|
|
#define ORDER_BY(X) \
|
|
if (X != other.X) return X < other.X;
|
|
|
|
ORDER_BY(mRef.mRenderbufferPtr)
|
|
ORDER_BY(mRef.mTexturePtr)
|
|
ORDER_BY(mRef.mTexImageTarget.get())
|
|
ORDER_BY(mRef.mTexImageLevel)
|
|
ORDER_BY(mRef.mTexImageLayer)
|
|
|
|
#undef ORDER_BY
|
|
return false;
|
|
}
|
|
};
|
|
};
|
|
|
|
class WebGLFramebuffer final : public nsWrapperCache,
|
|
public WebGLRefCountedObject<WebGLFramebuffer>,
|
|
public LinkedListElement<WebGLFramebuffer>,
|
|
public SupportsWeakPtr<WebGLFramebuffer>,
|
|
public CacheInvalidator {
|
|
public:
|
|
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(WebGLFramebuffer)
|
|
|
|
const GLuint mGLName;
|
|
bool mHasBeenBound = false;
|
|
|
|
private:
|
|
mutable uint64_t mNumFBStatusInvals = 0;
|
|
|
|
////
|
|
|
|
protected:
|
|
WebGLFBAttachPoint mDepthAttachment;
|
|
WebGLFBAttachPoint mStencilAttachment;
|
|
WebGLFBAttachPoint mDepthStencilAttachment;
|
|
|
|
// In theory, this number can be unbounded based on the driver. However, no
|
|
// driver appears to expose more than 8. We might as well stop there too, for
|
|
// now.
|
|
// (http://opengl.gpuinfo.org/gl_stats_caps_single.php?listreportsbycap=GL_MAX_COLOR_ATTACHMENTS)
|
|
static const size_t kMaxColorAttachments =
|
|
8; // jgilbert's MacBook Pro exposes 8.
|
|
WebGLFBAttachPoint mColorAttachments[kMaxColorAttachments];
|
|
|
|
////
|
|
|
|
std::vector<WebGLFBAttachPoint*> mAttachments; // Non-null.
|
|
|
|
std::vector<const WebGLFBAttachPoint*> mColorDrawBuffers; // Non-null
|
|
const WebGLFBAttachPoint* mColorReadBuffer; // Null if NONE
|
|
|
|
////
|
|
|
|
struct CompletenessInfo final {
|
|
const WebGLFramebuffer& fb;
|
|
|
|
uint32_t width = 0;
|
|
uint32_t height = 0;
|
|
|
|
// IsFeedback
|
|
std::vector<const WebGLFBAttachPoint*> texAttachments; // Non-null
|
|
|
|
~CompletenessInfo();
|
|
};
|
|
friend struct CompletenessInfo;
|
|
|
|
mutable CacheMaybe<const CompletenessInfo> mCompletenessInfo;
|
|
|
|
////
|
|
|
|
public:
|
|
NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(WebGLFramebuffer)
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(WebGLFramebuffer)
|
|
|
|
WebGLFramebuffer(WebGLContext* webgl, GLuint fbo);
|
|
|
|
WebGLContext* GetParentObject() const { return mContext; }
|
|
virtual JSObject* WrapObject(JSContext* cx,
|
|
JS::Handle<JSObject*> givenProto) override;
|
|
|
|
private:
|
|
~WebGLFramebuffer() {
|
|
DeleteOnce();
|
|
InvalidateCaches();
|
|
}
|
|
|
|
public:
|
|
void Delete();
|
|
|
|
////
|
|
|
|
bool HasDuplicateAttachments() const;
|
|
bool HasDefinedAttachments() const;
|
|
bool HasIncompleteAttachments(nsCString* const out_info) const;
|
|
bool AllImageRectsMatch() const;
|
|
bool AllImageSamplesMatch() const;
|
|
FBStatus PrecheckFramebufferStatus(nsCString* const out_info) const;
|
|
|
|
protected:
|
|
Maybe<WebGLFBAttachPoint*> GetAttachPoint(GLenum attachment); // Fallible
|
|
Maybe<WebGLFBAttachPoint*> GetColorAttachPoint(
|
|
GLenum attachment); // Fallible
|
|
void DoDeferredAttachments() const;
|
|
void RefreshDrawBuffers() const;
|
|
void RefreshReadBuffer() const;
|
|
void ResolveAttachmentData() const;
|
|
|
|
public:
|
|
void DetachTexture(const WebGLTexture* tex);
|
|
void DetachRenderbuffer(const WebGLRenderbuffer* rb);
|
|
bool ValidateAndInitAttachments() const;
|
|
bool ValidateClearBufferType(GLenum buffer, uint32_t drawBuffer,
|
|
GLenum funcType) const;
|
|
|
|
bool ValidateForColorRead(const webgl::FormatUsageInfo** out_format,
|
|
uint32_t* out_width, uint32_t* out_height) const;
|
|
|
|
////////////////
|
|
// Getters
|
|
|
|
#define GETTER(X) \
|
|
const decltype(m##X)& X() const { return m##X; }
|
|
|
|
GETTER(DepthAttachment)
|
|
GETTER(StencilAttachment)
|
|
GETTER(DepthStencilAttachment)
|
|
GETTER(Attachments)
|
|
GETTER(ColorDrawBuffers)
|
|
GETTER(ColorReadBuffer)
|
|
|
|
#undef GETTER
|
|
|
|
const auto& ColorAttachment0() const { return mColorAttachments[0]; }
|
|
|
|
////////////////
|
|
// Invalidation
|
|
|
|
const auto* GetCompletenessInfo() const { return mCompletenessInfo.get(); }
|
|
|
|
////////////////
|
|
// WebGL funcs
|
|
|
|
bool IsCheckFramebufferStatusComplete() const {
|
|
return CheckFramebufferStatus() == LOCAL_GL_FRAMEBUFFER_COMPLETE;
|
|
}
|
|
|
|
FBStatus CheckFramebufferStatus() const;
|
|
void FramebufferRenderbuffer(GLenum attachment, GLenum rbtarget,
|
|
WebGLRenderbuffer* rb);
|
|
void FramebufferTexture2D(GLenum attachment, GLenum texImageTarget,
|
|
WebGLTexture* tex, GLint level);
|
|
void FramebufferTextureLayer(GLenum attachment, WebGLTexture* tex,
|
|
GLint level, GLint layer);
|
|
void DrawBuffers(const dom::Sequence<GLenum>& buffers);
|
|
void ReadBuffer(GLenum attachPoint);
|
|
|
|
JS::Value GetAttachmentParameter(JSContext* cx, GLenum target,
|
|
GLenum attachment, GLenum pname,
|
|
ErrorResult* const out_error);
|
|
|
|
static void BlitFramebuffer(WebGLContext* webgl, GLint srcX0, GLint srcY0,
|
|
GLint srcX1, GLint srcY1, GLint dstX0,
|
|
GLint dstY0, GLint dstX1, GLint dstY1,
|
|
GLbitfield mask, GLenum filter);
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // WEBGL_FRAMEBUFFER_H_
|