| #ifndef _SGLRREFERENCECONTEXT_HPP |
| #define _SGLRREFERENCECONTEXT_HPP |
| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Reference Rendering Context. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "tcuDefs.hpp" |
| #include "sglrContext.hpp" |
| #include "tcuPixelFormat.hpp" |
| #include "tcuSurface.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuVector.hpp" |
| #include "rrFragmentOperations.hpp" |
| #include "rrRenderState.hpp" |
| #include "rrRenderer.hpp" |
| #include "rrMultisamplePixelBufferAccess.hpp" |
| #include "gluRenderContext.hpp" |
| #include "gluShaderUtil.hpp" |
| #include "deArrayBuffer.hpp" |
| |
| #include <map> |
| #include <vector> |
| |
| namespace sglr |
| { |
| namespace rc |
| { |
| |
| enum |
| { |
| MAX_TEXTURE_SIZE_LOG2 = 14, |
| MAX_TEXTURE_SIZE = 1 << MAX_TEXTURE_SIZE_LOG2 |
| }; |
| |
| class NamedObject |
| { |
| public: |
| virtual ~NamedObject(void) |
| { |
| } |
| |
| uint32_t getName(void) const |
| { |
| return m_name; |
| } |
| |
| int getRefCount(void) const |
| { |
| return m_refCount; |
| } |
| void incRefCount(void) |
| { |
| m_refCount += 1; |
| } |
| void decRefCount(void) |
| { |
| DE_ASSERT(m_refCount > 0); |
| m_refCount -= 1; |
| } |
| |
| protected: |
| NamedObject(uint32_t name) : m_name(name), m_refCount(1) |
| { |
| } |
| |
| private: |
| uint32_t m_name; |
| int m_refCount; |
| }; |
| |
| class Texture : public NamedObject |
| { |
| public: |
| enum Type |
| { |
| TYPE_1D, |
| TYPE_2D, |
| TYPE_CUBE_MAP, |
| TYPE_2D_ARRAY, |
| TYPE_3D, |
| TYPE_CUBE_MAP_ARRAY, |
| |
| TYPE_LAST |
| }; |
| |
| Texture(uint32_t name, Type type, bool seamless = true); |
| virtual ~Texture(void) |
| { |
| } |
| |
| Type getType(void) const |
| { |
| return m_type; |
| } |
| |
| int getBaseLevel(void) const |
| { |
| return m_baseLevel; |
| } |
| int getMaxLevel(void) const |
| { |
| return m_maxLevel; |
| } |
| bool isImmutable(void) const |
| { |
| return m_immutable; |
| } |
| |
| void setBaseLevel(int baseLevel) |
| { |
| m_baseLevel = baseLevel; |
| } |
| void setMaxLevel(int maxLevel) |
| { |
| m_maxLevel = maxLevel; |
| } |
| void setImmutable(void) |
| { |
| m_immutable = true; |
| } |
| |
| const tcu::Sampler &getSampler(void) const |
| { |
| return m_sampler; |
| } |
| tcu::Sampler &getSampler(void) |
| { |
| return m_sampler; |
| } |
| |
| private: |
| Type m_type; |
| |
| bool m_immutable; |
| |
| tcu::Sampler m_sampler; |
| int m_baseLevel; |
| int m_maxLevel; |
| }; |
| |
| //! Class for managing list of texture levels. |
| class TextureLevelArray |
| { |
| public: |
| TextureLevelArray(void); |
| ~TextureLevelArray(void); |
| |
| bool hasLevel(int level) const |
| { |
| return deInBounds32(level, 0, DE_LENGTH_OF_ARRAY(m_data)) && !m_data[level].empty(); |
| } |
| const tcu::PixelBufferAccess &getLevel(int level) |
| { |
| DE_ASSERT(hasLevel(level)); |
| return m_access[level]; |
| } |
| const tcu::ConstPixelBufferAccess &getLevel(int level) const |
| { |
| DE_ASSERT(hasLevel(level)); |
| return m_access[level]; |
| } |
| |
| const tcu::ConstPixelBufferAccess *getLevels(void) const |
| { |
| return &m_access[0]; |
| } |
| const tcu::ConstPixelBufferAccess *getEffectiveLevels(void) const |
| { |
| return &m_effectiveAccess[0]; |
| } |
| |
| void allocLevel(int level, const tcu::TextureFormat &format, int width, int height, int depth); |
| void clearLevel(int level); |
| |
| void clear(void); |
| |
| void updateSamplerMode(tcu::Sampler::DepthStencilMode); |
| |
| private: |
| de::ArrayBuffer<uint8_t> m_data[MAX_TEXTURE_SIZE_LOG2]; |
| tcu::PixelBufferAccess m_access[MAX_TEXTURE_SIZE_LOG2]; |
| tcu::ConstPixelBufferAccess m_effectiveAccess |
| [MAX_TEXTURE_SIZE_LOG2]; //!< the currently effective sampling mode. For Depth-stencil texture always either Depth or stencil. |
| }; |
| |
| class Texture1D : public Texture |
| { |
| public: |
| Texture1D(uint32_t name = 0); |
| virtual ~Texture1D(void); |
| |
| void clearLevels(void) |
| { |
| m_levels.clear(); |
| } |
| |
| bool hasLevel(int level) const |
| { |
| return m_levels.hasLevel(level); |
| } |
| const tcu::ConstPixelBufferAccess &getLevel(int level) const |
| { |
| return m_levels.getLevel(level); |
| } |
| const tcu::PixelBufferAccess &getLevel(int level) |
| { |
| return m_levels.getLevel(level); |
| } |
| |
| void allocLevel(int level, const tcu::TextureFormat &format, int width); |
| |
| bool isComplete(void) const; |
| |
| void updateView( |
| tcu::Sampler::DepthStencilMode |
| mode); // \note View must be refreshed after texture parameter/size changes, before calling sample*() |
| |
| tcu::Vec4 sample(float s, float lod) const; |
| void sample4(tcu::Vec4 output[4], const float packetTexcoords[4], float lodBias = 0.0f) const; |
| |
| private: |
| TextureLevelArray m_levels; |
| tcu::Texture2DView m_view; |
| }; |
| |
| class Texture2D : public Texture |
| { |
| public: |
| Texture2D(uint32_t name = 0, bool es2 = false); |
| virtual ~Texture2D(void); |
| |
| void clearLevels(void) |
| { |
| m_levels.clear(); |
| } |
| |
| bool hasLevel(int level) const |
| { |
| return m_levels.hasLevel(level); |
| } |
| const tcu::ConstPixelBufferAccess &getLevel(int level) const |
| { |
| return m_levels.getLevel(level); |
| } |
| const tcu::PixelBufferAccess &getLevel(int level) |
| { |
| return m_levels.getLevel(level); |
| } |
| |
| void allocLevel(int level, const tcu::TextureFormat &format, int width, int height); |
| |
| bool isComplete(void) const; |
| |
| void updateView( |
| tcu::Sampler::DepthStencilMode |
| mode); // \note View must be refreshed after texture parameter/size changes, before calling sample*() |
| |
| tcu::Vec4 sample(float s, float t, float lod) const; |
| void sample4(tcu::Vec4 output[4], const tcu::Vec2 packetTexcoords[4], float lodBias = 0.0f) const; |
| |
| private: |
| TextureLevelArray m_levels; |
| tcu::Texture2DView m_view; |
| }; |
| |
| class TextureCube : public Texture |
| { |
| public: |
| TextureCube(uint32_t name = 0, bool seamless = true); |
| virtual ~TextureCube(void); |
| |
| void clearLevels(void); |
| |
| bool hasFace(int level, tcu::CubeFace face) const |
| { |
| return m_levels[face].hasLevel(level); |
| } |
| const tcu::PixelBufferAccess &getFace(int level, tcu::CubeFace face) |
| { |
| return m_levels[face].getLevel(level); |
| } |
| const tcu::ConstPixelBufferAccess &getFace(int level, tcu::CubeFace face) const |
| { |
| return m_levels[face].getLevel(level); |
| } |
| |
| void allocFace(int level, tcu::CubeFace face, const tcu::TextureFormat &format, int width, int height); |
| |
| bool isComplete(void) const; |
| void updateView( |
| tcu::Sampler::DepthStencilMode |
| mode); // \note View must be refreshed after texture parameter/size changes, before calling sample*() |
| |
| tcu::Vec4 sample(float s, float t, float p, float lod) const; |
| void sample4(tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias = 0.0f) const; |
| |
| private: |
| TextureLevelArray m_levels[tcu::CUBEFACE_LAST]; |
| tcu::TextureCubeView m_view; |
| }; |
| |
| class Texture2DArray : public Texture |
| { |
| public: |
| Texture2DArray(uint32_t name = 0); |
| virtual ~Texture2DArray(void); |
| |
| void clearLevels(void) |
| { |
| m_levels.clear(); |
| } |
| |
| bool hasLevel(int level) const |
| { |
| return m_levels.hasLevel(level); |
| } |
| const tcu::ConstPixelBufferAccess &getLevel(int level) const |
| { |
| return m_levels.getLevel(level); |
| } |
| const tcu::PixelBufferAccess &getLevel(int level) |
| { |
| return m_levels.getLevel(level); |
| } |
| |
| void allocLevel(int level, const tcu::TextureFormat &format, int width, int height, int numLayers); |
| |
| bool isComplete(void) const; |
| |
| void updateView( |
| tcu::Sampler::DepthStencilMode |
| mode); // \note View must be refreshed after texture parameter/size changes, before calling sample*() |
| |
| tcu::Vec4 sample(float s, float t, float r, float lod) const; |
| void sample4(tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias = 0.0f) const; |
| |
| private: |
| TextureLevelArray m_levels; |
| tcu::Texture2DArrayView m_view; |
| }; |
| |
| class Texture3D : public Texture |
| { |
| public: |
| Texture3D(uint32_t name = 0); |
| virtual ~Texture3D(void); |
| |
| void clearLevels(void) |
| { |
| m_levels.clear(); |
| } |
| |
| bool hasLevel(int level) const |
| { |
| return m_levels.hasLevel(level); |
| } |
| const tcu::ConstPixelBufferAccess &getLevel(int level) const |
| { |
| return m_levels.getLevel(level); |
| } |
| const tcu::PixelBufferAccess &getLevel(int level) |
| { |
| return m_levels.getLevel(level); |
| } |
| |
| void allocLevel(int level, const tcu::TextureFormat &format, int width, int height, int numLayers); |
| |
| bool isComplete(void) const; |
| |
| void updateView( |
| tcu::Sampler::DepthStencilMode |
| mode); // \note View must be refreshed after texture parameter/size changes, before calling sample*() |
| |
| tcu::Vec4 sample(float s, float t, float r, float lod) const; |
| void sample4(tcu::Vec4 output[4], const tcu::Vec3 packetTexcoords[4], float lodBias = 0.0f) const; |
| |
| private: |
| TextureLevelArray m_levels; |
| tcu::Texture3DView m_view; |
| }; |
| |
| class TextureCubeArray : public Texture |
| { |
| public: |
| TextureCubeArray(uint32_t name = 0); |
| virtual ~TextureCubeArray(void); |
| |
| void clearLevels(void) |
| { |
| m_levels.clear(); |
| } |
| |
| bool hasLevel(int level) const |
| { |
| return m_levels.hasLevel(level); |
| } |
| const tcu::ConstPixelBufferAccess &getLevel(int level) const |
| { |
| return m_levels.getLevel(level); |
| } |
| const tcu::PixelBufferAccess &getLevel(int level) |
| { |
| return m_levels.getLevel(level); |
| } |
| |
| void allocLevel(int level, const tcu::TextureFormat &format, int width, int height, int numLayers); |
| |
| bool isComplete(void) const; |
| |
| void updateView( |
| tcu::Sampler::DepthStencilMode |
| mode); // \note View must be refreshed after texture parameter/size changes, before calling sample*() |
| |
| tcu::Vec4 sample(float s, float t, float r, float q, float lod) const; |
| void sample4(tcu::Vec4 output[4], const tcu::Vec4 packetTexcoords[4], float lodBias = 0.0f) const; |
| |
| private: |
| TextureLevelArray m_levels; |
| tcu::TextureCubeArrayView m_view; |
| }; |
| |
| class Renderbuffer : public NamedObject |
| { |
| public: |
| enum Format |
| { |
| FORMAT_DEPTH_COMPONENT16, |
| FORMAT_RGBA4, |
| FORMAT_RGB5_A1, |
| FORMAT_RGB565, |
| FORMAT_STENCIL_INDEX8, |
| |
| FORMAT_LAST |
| }; |
| |
| Renderbuffer(uint32_t name); |
| virtual ~Renderbuffer(void); |
| |
| void setStorage(const tcu::TextureFormat &format, int width, int height); |
| |
| int getWidth(void) const |
| { |
| return m_data.getWidth(); |
| } |
| int getHeight(void) const |
| { |
| return m_data.getHeight(); |
| } |
| tcu::TextureFormat getFormat(void) const |
| { |
| return m_data.getFormat(); |
| } |
| |
| tcu::PixelBufferAccess getAccess(void) |
| { |
| return m_data.getAccess(); |
| } |
| tcu::ConstPixelBufferAccess getAccess(void) const |
| { |
| return m_data.getAccess(); |
| } |
| |
| private: |
| tcu::TextureLevel m_data; |
| }; |
| |
| class Framebuffer : public NamedObject |
| { |
| public: |
| enum AttachmentPoint |
| { |
| ATTACHMENTPOINT_COLOR0, |
| ATTACHMENTPOINT_DEPTH, |
| ATTACHMENTPOINT_STENCIL, |
| |
| ATTACHMENTPOINT_LAST |
| }; |
| |
| enum AttachmentType |
| { |
| ATTACHMENTTYPE_RENDERBUFFER, |
| ATTACHMENTTYPE_TEXTURE, |
| |
| ATTACHMENTTYPE_LAST |
| }; |
| |
| enum TexTarget |
| { |
| TEXTARGET_2D, |
| TEXTARGET_CUBE_MAP_POSITIVE_X, |
| TEXTARGET_CUBE_MAP_POSITIVE_Y, |
| TEXTARGET_CUBE_MAP_POSITIVE_Z, |
| TEXTARGET_CUBE_MAP_NEGATIVE_X, |
| TEXTARGET_CUBE_MAP_NEGATIVE_Y, |
| TEXTARGET_CUBE_MAP_NEGATIVE_Z, |
| TEXTARGET_2D_ARRAY, |
| TEXTARGET_3D, |
| TEXTARGET_CUBE_MAP_ARRAY, |
| |
| TEXTARGET_LAST |
| }; |
| |
| struct Attachment |
| { |
| AttachmentType type; |
| uint32_t name; |
| TexTarget texTarget; |
| int level; |
| int layer; |
| |
| Attachment(void) : type(ATTACHMENTTYPE_LAST), name(0), texTarget(TEXTARGET_LAST), level(0), layer(0) |
| { |
| } |
| }; |
| |
| Framebuffer(uint32_t name); |
| virtual ~Framebuffer(void); |
| |
| Attachment &getAttachment(AttachmentPoint point) |
| { |
| return m_attachments[point]; |
| } |
| const Attachment &getAttachment(AttachmentPoint point) const |
| { |
| return m_attachments[point]; |
| } |
| |
| private: |
| Attachment m_attachments[ATTACHMENTPOINT_LAST]; |
| }; |
| |
| class DataBuffer : public NamedObject |
| { |
| public: |
| DataBuffer(uint32_t name) : NamedObject(name) |
| { |
| } |
| ~DataBuffer(void) |
| { |
| } |
| |
| void setStorage(int size) |
| { |
| m_data.resize(size); |
| } |
| |
| int getSize(void) const |
| { |
| return (int)m_data.size(); |
| } |
| const uint8_t *getData(void) const |
| { |
| return m_data.empty() ? DE_NULL : &m_data[0]; |
| } |
| uint8_t *getData(void) |
| { |
| return m_data.empty() ? DE_NULL : &m_data[0]; |
| } |
| |
| private: |
| std::vector<uint8_t> m_data; |
| }; |
| |
| class VertexArray : public NamedObject |
| { |
| public: |
| struct VertexAttribArray |
| { |
| bool enabled; |
| int size; |
| int stride; |
| uint32_t type; |
| |
| bool normalized; |
| bool integer; |
| int divisor; |
| |
| /** |
| ! These three variables define the state. bufferDeleted is needed to distinguish |
| ! drawing from user pointer and offset to a deleted buffer from each other. |
| ! |
| ! Only these three combinations are possible: |
| ! 1) bufferDeleted = false, bufferBinding = NULL, pointer = user_ptr. < render from a user ptr |
| ! 2) bufferDeleted = false, bufferBinding = ptr, pointer = offset. < render from a buffer with offset |
| ! 3) bufferDeleted = true, bufferBinding = NULL, pointer = offset < render from a deleted buffer. Don't do anything |
| ! |
| ! (bufferFreed = true) implies (bufferBinding = NULL) |
| */ |
| bool bufferDeleted; |
| rc::DataBuffer *bufferBinding; |
| const void *pointer; |
| }; |
| |
| VertexArray(uint32_t name, int maxVertexAttribs); |
| ~VertexArray(void) |
| { |
| } |
| |
| rc::DataBuffer *m_elementArrayBufferBinding; |
| std::vector<VertexAttribArray> m_arrays; |
| }; |
| |
| class ShaderProgramObjectContainer : public NamedObject |
| { |
| public: |
| ShaderProgramObjectContainer(uint32_t name, ShaderProgram *program); |
| ~ShaderProgramObjectContainer(void); |
| |
| ShaderProgram *m_program; |
| bool m_deleteFlag; |
| }; |
| |
| template <typename T> |
| class ObjectManager |
| { |
| public: |
| ObjectManager(void); |
| ~ObjectManager(void); |
| |
| uint32_t allocateName(void); |
| void insert(T *object); |
| T *find(uint32_t name); |
| |
| void acquireReference(T *object); |
| void releaseReference(T *object); |
| |
| int getCount(void) const |
| { |
| return (int)m_objects.size(); |
| } |
| void getAll(typename std::vector<T *> &objects) const; |
| |
| private: |
| ObjectManager(const ObjectManager<T> &other); |
| ObjectManager &operator=(const ObjectManager<T> &other); |
| |
| uint32_t m_lastName; |
| std::map<uint32_t, T *> m_objects; |
| }; |
| |
| template <typename T> |
| ObjectManager<T>::ObjectManager(void) : m_lastName(0) |
| { |
| } |
| |
| template <typename T> |
| ObjectManager<T>::~ObjectManager(void) |
| { |
| DE_ASSERT(m_objects.size() == 0); |
| } |
| |
| template <typename T> |
| uint32_t ObjectManager<T>::allocateName(void) |
| { |
| TCU_CHECK(m_lastName != 0xffffffff); |
| return ++m_lastName; |
| } |
| |
| template <typename T> |
| void ObjectManager<T>::insert(T *object) |
| { |
| uint32_t name = object->getName(); |
| DE_ASSERT(object->getName() != 0); |
| |
| if (name > m_lastName) |
| m_lastName = name; |
| |
| m_objects.insert(std::pair<uint32_t, T *>(name, object)); |
| } |
| |
| template <typename T> |
| T *ObjectManager<T>::find(uint32_t name) |
| { |
| typename std::map<uint32_t, T *>::iterator it = m_objects.find(name); |
| if (it != m_objects.end()) |
| return it->second; |
| else |
| return DE_NULL; |
| } |
| |
| template <typename T> |
| void ObjectManager<T>::acquireReference(T *object) |
| { |
| DE_ASSERT(find(object->getName()) == object); |
| object->incRefCount(); |
| } |
| |
| template <typename T> |
| void ObjectManager<T>::releaseReference(T *object) |
| { |
| DE_ASSERT(find(object->getName()) == object); |
| object->decRefCount(); |
| |
| if (object->getRefCount() == 0) |
| { |
| m_objects.erase(object->getName()); |
| delete object; |
| } |
| } |
| |
| template <typename T> |
| void ObjectManager<T>::getAll(typename std::vector<T *> &objects) const |
| { |
| objects.resize(m_objects.size()); |
| typename std::vector<T *>::iterator dst = objects.begin(); |
| |
| for (typename std::map<uint32_t, T *>::const_iterator i = m_objects.begin(); i != m_objects.end(); i++) |
| { |
| *dst++ = i->second; |
| } |
| } |
| |
| } // namespace rc |
| |
| struct ReferenceContextLimits |
| { |
| ReferenceContextLimits(void) |
| : contextType(glu::ApiType::es(3, 0)) |
| , maxTextureImageUnits(16) |
| , maxTexture2DSize(2048) |
| , maxTextureCubeSize(2048) |
| , maxTexture2DArrayLayers(256) |
| , maxTexture3DSize(256) |
| , maxRenderbufferSize(2048) |
| , maxVertexAttribs(16) |
| , subpixelBits(rr::RenderState::DEFAULT_SUBPIXEL_BITS) |
| { |
| } |
| |
| ReferenceContextLimits(const glu::RenderContext &renderCtx); |
| |
| void addExtension(const char *extension); |
| |
| glu::ContextType contextType; |
| |
| int maxTextureImageUnits; |
| int maxTexture2DSize; |
| int maxTextureCubeSize; |
| int maxTexture2DArrayLayers; |
| int maxTexture3DSize; |
| int maxRenderbufferSize; |
| int maxVertexAttribs; |
| int subpixelBits; |
| |
| // Both variants are needed since there are glGetString() and glGetStringi() |
| std::vector<std::string> extensionList; |
| std::string extensionStr; |
| }; |
| |
| class ReferenceContextBuffers |
| { |
| public: |
| ReferenceContextBuffers(const tcu::PixelFormat &colorBits, int depthBits, int stencilBits, int width, int height, |
| int samples = 1); |
| |
| rr::MultisamplePixelBufferAccess getColorbuffer(void) |
| { |
| return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(m_colorbuffer.getAccess()); |
| } |
| rr::MultisamplePixelBufferAccess getDepthbuffer(void) |
| { |
| return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(m_depthbuffer.getAccess()); |
| } |
| rr::MultisamplePixelBufferAccess getStencilbuffer(void) |
| { |
| return rr::MultisamplePixelBufferAccess::fromMultisampleAccess(m_stencilbuffer.getAccess()); |
| } |
| |
| private: |
| tcu::TextureLevel m_colorbuffer; |
| tcu::TextureLevel m_depthbuffer; |
| tcu::TextureLevel m_stencilbuffer; |
| }; |
| |
| class ReferenceContext : public Context |
| { |
| public: |
| ReferenceContext(const ReferenceContextLimits &limits, const rr::MultisamplePixelBufferAccess &colorbuffer, |
| const rr::MultisamplePixelBufferAccess &depthbuffer, |
| const rr::MultisamplePixelBufferAccess &stencilbuffer); |
| virtual ~ReferenceContext(void); |
| |
| virtual int getWidth(void) const |
| { |
| return m_defaultColorbuffer.raw().getHeight(); |
| } |
| virtual int getHeight(void) const |
| { |
| return m_defaultColorbuffer.raw().getDepth(); |
| } |
| |
| virtual void viewport(int x, int y, int width, int height) |
| { |
| m_viewport = tcu::IVec4(x, y, width, height); |
| } |
| virtual void activeTexture(uint32_t texture); |
| |
| virtual void bindTexture(uint32_t target, uint32_t texture); |
| virtual void genTextures(int numTextures, uint32_t *textures); |
| virtual void deleteTextures(int numTextures, const uint32_t *textures); |
| |
| virtual void bindFramebuffer(uint32_t target, uint32_t framebuffer); |
| virtual void genFramebuffers(int numFramebuffers, uint32_t *framebuffers); |
| virtual void deleteFramebuffers(int numFramebuffers, const uint32_t *framebuffers); |
| |
| virtual void bindRenderbuffer(uint32_t target, uint32_t renderbuffer); |
| virtual void genRenderbuffers(int numRenderbuffers, uint32_t *renderbuffers); |
| virtual void deleteRenderbuffers(int numRenderbuffers, const uint32_t *renderbuffers); |
| |
| virtual void pixelStorei(uint32_t pname, int param); |
| virtual void texImage1D(uint32_t target, int level, uint32_t internalFormat, int width, int border, uint32_t format, |
| uint32_t type, const void *data); |
| virtual void texImage2D(uint32_t target, int level, uint32_t internalFormat, int width, int height, int border, |
| uint32_t format, uint32_t type, const void *data); |
| virtual void texImage3D(uint32_t target, int level, uint32_t internalFormat, int width, int height, int depth, |
| int border, uint32_t format, uint32_t type, const void *data); |
| virtual void texSubImage1D(uint32_t target, int level, int xoffset, int width, uint32_t format, uint32_t type, |
| const void *data); |
| virtual void texSubImage2D(uint32_t target, int level, int xoffset, int yoffset, int width, int height, |
| uint32_t format, uint32_t type, const void *data); |
| virtual void texSubImage3D(uint32_t target, int level, int xoffset, int yoffset, int zoffset, int width, int height, |
| int depth, uint32_t format, uint32_t type, const void *data); |
| virtual void copyTexImage1D(uint32_t target, int level, uint32_t internalFormat, int x, int y, int width, |
| int border); |
| virtual void copyTexImage2D(uint32_t target, int level, uint32_t internalFormat, int x, int y, int width, |
| int height, int border); |
| virtual void copyTexSubImage1D(uint32_t target, int level, int xoffset, int x, int y, int width); |
| virtual void copyTexSubImage2D(uint32_t target, int level, int xoffset, int yoffset, int x, int y, int width, |
| int height); |
| virtual void copyTexSubImage3D(uint32_t target, int level, int xoffset, int yoffset, int zoffset, int x, int y, |
| int width, int height); |
| |
| virtual void texStorage2D(uint32_t target, int levels, uint32_t internalFormat, int width, int height); |
| virtual void texStorage3D(uint32_t target, int levels, uint32_t internalFormat, int width, int height, int depth); |
| |
| virtual void texParameteri(uint32_t target, uint32_t pname, int value); |
| |
| virtual void framebufferTexture2D(uint32_t target, uint32_t attachment, uint32_t textarget, uint32_t texture, |
| int level); |
| virtual void framebufferTextureLayer(uint32_t target, uint32_t attachment, uint32_t texture, int level, int layer); |
| virtual void framebufferRenderbuffer(uint32_t target, uint32_t attachment, uint32_t renderbuffertarget, |
| uint32_t renderbuffer); |
| virtual uint32_t checkFramebufferStatus(uint32_t target); |
| |
| virtual void getFramebufferAttachmentParameteriv(uint32_t target, uint32_t attachment, uint32_t pname, int *params); |
| |
| virtual void renderbufferStorage(uint32_t target, uint32_t internalformat, int width, int height); |
| virtual void renderbufferStorageMultisample(uint32_t target, int samples, uint32_t internalFormat, int width, |
| int height); |
| |
| virtual void bindBuffer(uint32_t target, uint32_t buffer); |
| virtual void genBuffers(int numBuffers, uint32_t *buffers); |
| virtual void deleteBuffers(int numBuffers, const uint32_t *buffers); |
| |
| virtual void bufferData(uint32_t target, intptr_t size, const void *data, uint32_t usage); |
| virtual void bufferSubData(uint32_t target, intptr_t offset, intptr_t size, const void *data); |
| |
| virtual void clearColor(float red, float green, float blue, float alpha); |
| virtual void clearDepthf(float depth); |
| virtual void clearStencil(int stencil); |
| |
| virtual void clear(uint32_t buffers); |
| virtual void clearBufferiv(uint32_t buffer, int drawbuffer, const int *value); |
| virtual void clearBufferfv(uint32_t buffer, int drawbuffer, const float *value); |
| virtual void clearBufferuiv(uint32_t buffer, int drawbuffer, const uint32_t *value); |
| virtual void clearBufferfi(uint32_t buffer, int drawbuffer, float depth, int stencil); |
| virtual void scissor(int x, int y, int width, int height); |
| |
| virtual void enable(uint32_t cap); |
| virtual void disable(uint32_t cap); |
| |
| virtual void stencilFunc(uint32_t func, int ref, uint32_t mask); |
| virtual void stencilOp(uint32_t sfail, uint32_t dpfail, uint32_t dppass); |
| virtual void stencilFuncSeparate(uint32_t face, uint32_t func, int ref, uint32_t mask); |
| virtual void stencilOpSeparate(uint32_t face, uint32_t sfail, uint32_t dpfail, uint32_t dppass); |
| |
| virtual void depthFunc(uint32_t func); |
| virtual void depthRangef(float n, float f); |
| virtual void depthRange(double n, double f); |
| |
| virtual void polygonOffset(float factor, float units); |
| virtual void provokingVertex(uint32_t convention); |
| virtual void primitiveRestartIndex(uint32_t index); |
| |
| virtual void blendEquation(uint32_t mode); |
| virtual void blendEquationSeparate(uint32_t modeRGB, uint32_t modeAlpha); |
| virtual void blendFunc(uint32_t src, uint32_t dst); |
| virtual void blendFuncSeparate(uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha); |
| virtual void blendColor(float red, float green, float blue, float alpha); |
| |
| virtual void colorMask(bool r, bool g, bool b, bool a); |
| virtual void depthMask(bool mask); |
| virtual void stencilMask(uint32_t mask); |
| virtual void stencilMaskSeparate(uint32_t face, uint32_t mask); |
| |
| virtual void blitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, |
| uint32_t mask, uint32_t filter); |
| |
| virtual void invalidateSubFramebuffer(uint32_t target, int numAttachments, const uint32_t *attachments, int x, |
| int y, int width, int height); |
| virtual void invalidateFramebuffer(uint32_t target, int numAttachments, const uint32_t *attachments); |
| |
| virtual void bindVertexArray(uint32_t array); |
| virtual void genVertexArrays(int numArrays, uint32_t *vertexArrays); |
| virtual void deleteVertexArrays(int numArrays, const uint32_t *vertexArrays); |
| |
| virtual void vertexAttribPointer(uint32_t index, int size, uint32_t type, bool normalized, int stride, |
| const void *pointer); |
| virtual void vertexAttribIPointer(uint32_t index, int size, uint32_t type, int stride, const void *pointer); |
| virtual void enableVertexAttribArray(uint32_t index); |
| virtual void disableVertexAttribArray(uint32_t index); |
| virtual void vertexAttribDivisor(uint32_t index, uint32_t divisor); |
| |
| virtual void vertexAttrib1f(uint32_t index, float); |
| virtual void vertexAttrib2f(uint32_t index, float, float); |
| virtual void vertexAttrib3f(uint32_t index, float, float, float); |
| virtual void vertexAttrib4f(uint32_t index, float, float, float, float); |
| virtual void vertexAttribI4i(uint32_t index, int32_t, int32_t, int32_t, int32_t); |
| virtual void vertexAttribI4ui(uint32_t index, uint32_t, uint32_t, uint32_t, uint32_t); |
| |
| virtual int32_t getAttribLocation(uint32_t program, const char *name); |
| |
| virtual void uniform1f(int32_t location, float); |
| virtual void uniform1i(int32_t location, int32_t); |
| virtual void uniform1fv(int32_t index, int32_t count, const float *); |
| virtual void uniform2fv(int32_t index, int32_t count, const float *); |
| virtual void uniform3fv(int32_t index, int32_t count, const float *); |
| virtual void uniform4fv(int32_t index, int32_t count, const float *); |
| virtual void uniform1iv(int32_t index, int32_t count, const int32_t *); |
| virtual void uniform2iv(int32_t index, int32_t count, const int32_t *); |
| virtual void uniform3iv(int32_t index, int32_t count, const int32_t *); |
| virtual void uniform4iv(int32_t index, int32_t count, const int32_t *); |
| virtual void uniformMatrix3fv(int32_t location, int32_t count, bool transpose, const float *value); |
| virtual void uniformMatrix4fv(int32_t location, int32_t count, bool transpose, const float *value); |
| virtual int32_t getUniformLocation(uint32_t program, const char *name); |
| |
| virtual void lineWidth(float); |
| |
| virtual void drawArrays(uint32_t mode, int first, int count); |
| virtual void drawArraysInstanced(uint32_t mode, int first, int count, int instanceCount); |
| virtual void drawElements(uint32_t mode, int count, uint32_t type, const void *indices); |
| virtual void drawElementsBaseVertex(uint32_t mode, int count, uint32_t type, const void *indices, int baseVertex); |
| virtual void drawElementsInstanced(uint32_t mode, int count, uint32_t type, const void *indices, int instanceCount); |
| virtual void drawElementsInstancedBaseVertex(uint32_t mode, int count, uint32_t type, const void *indices, |
| int instanceCount, int baseVertex); |
| virtual void drawRangeElements(uint32_t mode, uint32_t start, uint32_t end, int count, uint32_t type, |
| const void *indices); |
| virtual void drawRangeElementsBaseVertex(uint32_t mode, uint32_t start, uint32_t end, int count, uint32_t type, |
| const void *indices, int baseVertex); |
| virtual void drawArraysIndirect(uint32_t mode, const void *indirect); |
| virtual void drawElementsIndirect(uint32_t mode, uint32_t type, const void *indirect); |
| |
| virtual void multiDrawArrays(uint32_t mode, const int *first, const int *count, int primCount); |
| virtual void multiDrawElements(uint32_t mode, const int *count, uint32_t type, const void **indices, int primCount); |
| virtual void multiDrawElementsBaseVertex(uint32_t mode, const int *count, uint32_t type, const void **indices, |
| int primCount, const int *baseVertex); |
| |
| virtual uint32_t createProgram(ShaderProgram *program); |
| virtual void useProgram(uint32_t program); |
| virtual void deleteProgram(uint32_t program); |
| |
| virtual void readPixels(int x, int y, int width, int height, uint32_t format, uint32_t type, void *data); |
| virtual uint32_t getError(void); |
| virtual void finish(void); |
| |
| virtual void getIntegerv(uint32_t pname, int *params); |
| virtual const char *getString(uint32_t pname); |
| |
| // Expose helpers from Context. |
| using Context::readPixels; |
| using Context::texImage2D; |
| using Context::texSubImage2D; |
| |
| private: |
| ReferenceContext(const ReferenceContext &other); // Not allowed! |
| ReferenceContext &operator=(const ReferenceContext &other); // Not allowed! |
| |
| void deleteTexture(rc::Texture *texture); |
| void deleteFramebuffer(rc::Framebuffer *framebuffer); |
| void deleteRenderbuffer(rc::Renderbuffer *renderbuffer); |
| void deleteBuffer(rc::DataBuffer *buffer); |
| void deleteVertexArray(rc::VertexArray *vertexArray); |
| void deleteProgramObject(rc::ShaderProgramObjectContainer *sp); |
| |
| void acquireFboAttachmentReference(const rc::Framebuffer::Attachment &attachment); |
| void releaseFboAttachmentReference(const rc::Framebuffer::Attachment &attachment); |
| tcu::PixelBufferAccess getFboAttachment(const rc::Framebuffer &framebuffer, rc::Framebuffer::AttachmentPoint point); |
| |
| uint32_t blitResolveMultisampleFramebuffer(uint32_t mask, const tcu::IVec4 &srcRect, const tcu::IVec4 &dstRect, |
| bool flipX, bool flipY); |
| |
| rr::MultisamplePixelBufferAccess getDrawColorbuffer(void) |
| { |
| return (m_drawFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment( |
| *m_drawFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_COLOR0))) : |
| (m_defaultColorbuffer); |
| } |
| rr::MultisamplePixelBufferAccess getDrawDepthbuffer(void) |
| { |
| return (m_drawFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment( |
| *m_drawFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_DEPTH))) : |
| (m_defaultDepthbuffer); |
| } |
| rr::MultisamplePixelBufferAccess getDrawStencilbuffer(void) |
| { |
| return (m_drawFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment( |
| *m_drawFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_STENCIL))) : |
| (m_defaultStencilbuffer); |
| } |
| rr::MultisamplePixelBufferAccess getReadColorbuffer(void) |
| { |
| return (m_readFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment( |
| *m_readFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_COLOR0))) : |
| (m_defaultColorbuffer); |
| } |
| rr::MultisamplePixelBufferAccess getReadDepthbuffer(void) |
| { |
| return (m_readFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment( |
| *m_readFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_DEPTH))) : |
| (m_defaultDepthbuffer); |
| } |
| rr::MultisamplePixelBufferAccess getReadStencilbuffer(void) |
| { |
| return (m_readFramebufferBinding) ? (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(getFboAttachment( |
| *m_readFramebufferBinding, rc::Framebuffer::ATTACHMENTPOINT_STENCIL))) : |
| (m_defaultStencilbuffer); |
| } |
| |
| const rc::Texture2D &getTexture2D(int unitNdx) const; |
| const rc::TextureCube &getTextureCube(int unitNdx) const; |
| const tcu::IVec4 &getViewport(void) const |
| { |
| return m_viewport; |
| } |
| |
| void setError(uint32_t error); |
| |
| void setTex1DBinding(int unit, rc::Texture1D *tex1D); |
| void setTex2DBinding(int unit, rc::Texture2D *tex2D); |
| void setTexCubeBinding(int unit, rc::TextureCube *texCube); |
| void setTex2DArrayBinding(int unit, rc::Texture2DArray *tex2DArray); |
| void setTex3DBinding(int unit, rc::Texture3D *tex3D); |
| void setTexCubeArrayBinding(int unit, rc::TextureCubeArray *texCubeArray); |
| |
| void setBufferBinding(uint32_t target, rc::DataBuffer *buffer); |
| rc::DataBuffer *getBufferBinding(uint32_t target) const; |
| |
| void *getPixelPackPtr(void *ptrOffset) const |
| { |
| return m_pixelPackBufferBinding ? |
| (void *)((uintptr_t)m_pixelPackBufferBinding->getData() + (uintptr_t)ptrOffset) : |
| ptrOffset; |
| } |
| const void *getPixelUnpackPtr(const void *ptrOffset) const |
| { |
| return m_pixelUnpackBufferBinding ? |
| (const void *)((uintptr_t)m_pixelUnpackBufferBinding->getData() + (uintptr_t)ptrOffset) : |
| ptrOffset; |
| } |
| |
| bool predrawErrorChecks(uint32_t mode); |
| void drawWithReference(const rr::PrimitiveList &primitives, int instanceCount); |
| |
| // Helpers for getting valid access object based on current unpack state. |
| tcu::ConstPixelBufferAccess getUnpack2DAccess(const tcu::TextureFormat &format, int width, int height, |
| const void *data); |
| tcu::ConstPixelBufferAccess getUnpack3DAccess(const tcu::TextureFormat &format, int width, int height, int depth, |
| const void *data); |
| |
| void uniformv(int32_t index, glu::DataType type, int32_t count, const void *); |
| |
| struct TextureUnit |
| { |
| |
| rc::Texture1D *tex1DBinding; |
| rc::Texture2D *tex2DBinding; |
| rc::TextureCube *texCubeBinding; |
| rc::Texture2DArray *tex2DArrayBinding; |
| rc::Texture3D *tex3DBinding; |
| rc::TextureCubeArray *texCubeArrayBinding; |
| |
| rc::Texture1D default1DTex; |
| rc::Texture2D default2DTex; |
| rc::TextureCube defaultCubeTex; |
| rc::Texture2DArray default2DArrayTex; |
| rc::Texture3D default3DTex; |
| rc::TextureCubeArray defaultCubeArrayTex; |
| |
| TextureUnit(void) |
| : tex1DBinding(DE_NULL) |
| , tex2DBinding(DE_NULL) |
| , texCubeBinding(DE_NULL) |
| , tex2DArrayBinding(DE_NULL) |
| , tex3DBinding(DE_NULL) |
| , texCubeArrayBinding(DE_NULL) |
| , default1DTex(0) |
| , default2DTex(0) |
| , defaultCubeTex(0) |
| , default2DArrayTex(0) |
| , default3DTex(0) |
| , defaultCubeArrayTex(0) |
| { |
| } |
| }; |
| |
| struct StencilState |
| { |
| uint32_t func; |
| int ref; |
| uint32_t opMask; |
| uint32_t opStencilFail; |
| uint32_t opDepthFail; |
| uint32_t opDepthPass; |
| uint32_t writeMask; |
| |
| StencilState(void); |
| }; |
| |
| ReferenceContextLimits m_limits; |
| |
| rr::MultisamplePixelBufferAccess m_defaultColorbuffer; |
| rr::MultisamplePixelBufferAccess m_defaultDepthbuffer; |
| rr::MultisamplePixelBufferAccess m_defaultStencilbuffer; |
| rc::VertexArray m_clientVertexArray; |
| |
| tcu::IVec4 m_viewport; |
| |
| rc::ObjectManager<rc::Texture> m_textures; |
| rc::ObjectManager<rc::Framebuffer> m_framebuffers; |
| rc::ObjectManager<rc::Renderbuffer> m_renderbuffers; |
| rc::ObjectManager<rc::DataBuffer> m_buffers; |
| rc::ObjectManager<rc::VertexArray> m_vertexArrays; |
| rc::ObjectManager<rc::ShaderProgramObjectContainer> m_programs; |
| |
| int m_activeTexture; |
| std::vector<TextureUnit> m_textureUnits; |
| rc::Texture1D m_emptyTex1D; |
| rc::Texture2D m_emptyTex2D; |
| rc::TextureCube m_emptyTexCube; |
| rc::Texture2DArray m_emptyTex2DArray; |
| rc::Texture3D m_emptyTex3D; |
| rc::TextureCubeArray m_emptyTexCubeArray; |
| |
| int m_pixelUnpackRowLength; |
| int m_pixelUnpackSkipRows; |
| int m_pixelUnpackSkipPixels; |
| int m_pixelUnpackImageHeight; |
| int m_pixelUnpackSkipImages; |
| int m_pixelUnpackAlignment; |
| int m_pixelPackAlignment; |
| |
| rc::Framebuffer *m_readFramebufferBinding; |
| rc::Framebuffer *m_drawFramebufferBinding; |
| rc::Renderbuffer *m_renderbufferBinding; |
| rc::VertexArray *m_vertexArrayBinding; |
| rc::ShaderProgramObjectContainer *m_currentProgram; |
| |
| rc::DataBuffer *m_arrayBufferBinding; |
| rc::DataBuffer *m_pixelPackBufferBinding; |
| rc::DataBuffer *m_pixelUnpackBufferBinding; |
| rc::DataBuffer *m_transformFeedbackBufferBinding; |
| rc::DataBuffer *m_uniformBufferBinding; |
| rc::DataBuffer *m_copyReadBufferBinding; |
| rc::DataBuffer *m_copyWriteBufferBinding; |
| rc::DataBuffer *m_drawIndirectBufferBinding; |
| |
| tcu::Vec4 m_clearColor; |
| float m_clearDepth; |
| int m_clearStencil; |
| |
| bool m_scissorEnabled; |
| tcu::IVec4 m_scissorBox; |
| |
| bool m_stencilTestEnabled; |
| StencilState m_stencil[rr::FACETYPE_LAST]; |
| |
| bool m_depthTestEnabled; |
| uint32_t m_depthFunc; |
| float m_depthRangeNear; |
| float m_depthRangeFar; |
| |
| float m_polygonOffsetFactor; |
| float m_polygonOffsetUnits; |
| bool m_polygonOffsetFillEnabled; |
| |
| bool m_provokingFirstVertexConvention; |
| |
| bool m_blendEnabled; |
| uint32_t m_blendModeRGB; |
| uint32_t m_blendModeAlpha; |
| uint32_t m_blendFactorSrcRGB; |
| uint32_t m_blendFactorDstRGB; |
| uint32_t m_blendFactorSrcAlpha; |
| uint32_t m_blendFactorDstAlpha; |
| tcu::Vec4 m_blendColor; |
| |
| bool m_sRGBUpdateEnabled; |
| |
| bool m_depthClampEnabled; |
| |
| tcu::BVec4 m_colorMask; |
| bool m_depthMask; |
| |
| std::vector<rr::GenericVec4> m_currentAttribs; |
| float m_lineWidth; |
| |
| bool m_primitiveRestartFixedIndex; |
| bool m_primitiveRestartSettableIndex; |
| uint32_t m_primitiveRestartIndex; |
| |
| uint32_t m_lastError; |
| |
| rr::FragmentProcessor m_fragmentProcessor; |
| std::vector<rr::Fragment> m_fragmentBuffer; |
| std::vector<float> m_fragmentDepths; |
| } DE_WARN_UNUSED_TYPE; |
| |
| } // namespace sglr |
| |
| #endif // _SGLRREFERENCECONTEXT_HPP |
