king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f4c154c05'
${ noResults }
v811_spc009/external/deqp/framework/opengl/simplereference/sglrReferenceContext.hpp

974 lines
37 KiB
Raw Blame History

#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) {}
deUint32 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 (deUint32 name) : m_name(name), m_refCount(1) {}
private:
deUint32 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 (deUint32 name, Type type, deBool 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<deUint8> 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 (deUint32 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 (deUint32 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 (deUint32 name = 0, deBool 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 (deUint32 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 (deUint32 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 (deUint32 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 (deUint32 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;
deUint32 name;
TexTarget texTarget;
int level;
int layer;
Attachment (void)
: type (ATTACHMENTTYPE_LAST)
, name (0)
, texTarget (TEXTARGET_LAST)
, level (0)
, layer (0)
{
}
};
Framebuffer (deUint32 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 (deUint32 name) : NamedObject(name) {}
~DataBuffer (void) {}
void setStorage (int size) { m_data.resize(size); }
int getSize (void) const { return (int)m_data.size(); }
const deUint8* getData (void) const { return m_data.empty() ? DE_NULL : &m_data[0]; }
deUint8* getData (void) { return m_data.empty() ? DE_NULL : &m_data[0]; }
private:
std::vector<deUint8> m_data;
};
class VertexArray : public NamedObject
{
public:
struct VertexAttribArray
{
bool enabled;
int size;
int stride;
deUint32 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 (deUint32 name, int maxVertexAttribs);
~VertexArray (void) {}
rc::DataBuffer* m_elementArrayBufferBinding;
std::vector<VertexAttribArray> m_arrays;
};
class ShaderProgramObjectContainer : public NamedObject
{
public:
ShaderProgramObjectContainer (deUint32 name, ShaderProgram* program);
~ShaderProgramObjectContainer (void);
ShaderProgram* m_program;
bool m_deleteFlag;
};
template <typename T>
class ObjectManager
{
public:
ObjectManager (void);
~ObjectManager (void);
deUint32 allocateName (void);
void insert (T* object);
T* find (deUint32 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);
deUint32 m_lastName;
std::map<deUint32, 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>
deUint32 ObjectManager<T>::allocateName (void)
{
TCU_CHECK(m_lastName != 0xffffffff);
return ++m_lastName;
}
template <typename T>
void ObjectManager<T>::insert (T* object)
{
deUint32 name = object->getName();
DE_ASSERT(object->getName() != 0);
if (name > m_lastName)
m_lastName = name;
m_objects.insert(std::pair<deUint32, T*>(name, object));
}
template <typename T>
T* ObjectManager<T>::find (deUint32 name)
{
typename std::map<deUint32, 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<deUint32, T*>::const_iterator i = m_objects.begin();
i != m_objects.end(); i++)
{
*dst++ = i->second;
}
}
} // 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 (deUint32 texture);
virtual void bindTexture (deUint32 target, deUint32 texture);
virtual void genTextures (int numTextures, deUint32* textures);
virtual void deleteTextures (int numTextures, const deUint32* textures);
virtual void bindFramebuffer (deUint32 target, deUint32 framebuffer);
virtual void genFramebuffers (int numFramebuffers, deUint32* framebuffers);
virtual void deleteFramebuffers (int numFramebuffers, const deUint32* framebuffers);
virtual void bindRenderbuffer (deUint32 target, deUint32 renderbuffer);
virtual void genRenderbuffers (int numRenderbuffers, deUint32* renderbuffers);
virtual void deleteRenderbuffers (int numRenderbuffers, const deUint32* renderbuffers);
virtual void pixelStorei (deUint32 pname, int param);
virtual void texImage1D (deUint32 target, int level, deUint32 internalFormat, int width, int border, deUint32 format, deUint32 type, const void* data);
virtual void texImage2D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int border, deUint32 format, deUint32 type, const void* data);
virtual void texImage3D (deUint32 target, int level, deUint32 internalFormat, int width, int height, int depth, int border, deUint32 format, deUint32 type, const void* data);
virtual void texSubImage1D (deUint32 target, int level, int xoffset, int width, deUint32 format, deUint32 type, const void* data);
virtual void texSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int width, int height, deUint32 format, deUint32 type, const void* data);
virtual void texSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, deUint32 format, deUint32 type, const void* data);
virtual void copyTexImage1D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int border);
virtual void copyTexImage2D (deUint32 target, int level, deUint32 internalFormat, int x, int y, int width, int height, int border);
virtual void copyTexSubImage1D (deUint32 target, int level, int xoffset, int x, int y, int width);
virtual void copyTexSubImage2D (deUint32 target, int level, int xoffset, int yoffset, int x, int y, int width, int height);
virtual void copyTexSubImage3D (deUint32 target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
virtual void texStorage2D (deUint32 target, int levels, deUint32 internalFormat, int width, int height);
virtual void texStorage3D (deUint32 target, int levels, deUint32 internalFormat, int width, int height, int depth);
virtual void texParameteri (deUint32 target, deUint32 pname, int value);
virtual void framebufferTexture2D (deUint32 target, deUint32 attachment, deUint32 textarget, deUint32 texture, int level);
virtual void framebufferTextureLayer (deUint32 target, deUint32 attachment, deUint32 texture, int level, int layer);
virtual void framebufferRenderbuffer (deUint32 target, deUint32 attachment, deUint32 renderbuffertarget, deUint32 renderbuffer);
virtual deUint32 checkFramebufferStatus (deUint32 target);
virtual void getFramebufferAttachmentParameteriv (deUint32 target, deUint32 attachment, deUint32 pname, int* params);
virtual void renderbufferStorage (deUint32 target, deUint32 internalformat, int width, int height);
virtual void renderbufferStorageMultisample (deUint32 target, int samples, deUint32 internalFormat, int width, int height);
virtual void bindBuffer (deUint32 target, deUint32 buffer);
virtual void genBuffers (int numBuffers, deUint32* buffers);
virtual void deleteBuffers (int numBuffers, const deUint32* buffers);
virtual void bufferData (deUint32 target, deIntptr size, const void* data, deUint32 usage);
virtual void bufferSubData (deUint32 target, deIntptr offset, deIntptr 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 (deUint32 buffers);
virtual void clearBufferiv (deUint32 buffer, int drawbuffer, const int* value);
virtual void clearBufferfv (deUint32 buffer, int drawbuffer, const float* value);
virtual void clearBufferuiv (deUint32 buffer, int drawbuffer, const deUint32* value);
virtual void clearBufferfi (deUint32 buffer, int drawbuffer, float depth, int stencil);
virtual void scissor (int x, int y, int width, int height);
virtual void enable (deUint32 cap);
virtual void disable (deUint32 cap);
virtual void stencilFunc (deUint32 func, int ref, deUint32 mask);
virtual void stencilOp (deUint32 sfail, deUint32 dpfail, deUint32 dppass);
virtual void stencilFuncSeparate (deUint32 face, deUint32 func, int ref, deUint32 mask);
virtual void stencilOpSeparate (deUint32 face, deUint32 sfail, deUint32 dpfail, deUint32 dppass);
virtual void depthFunc (deUint32 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 (deUint32 convention);
virtual void primitiveRestartIndex (deUint32 index);
virtual void blendEquation (deUint32 mode);
virtual void blendEquationSeparate (deUint32 modeRGB, deUint32 modeAlpha);
virtual void blendFunc (deUint32 src, deUint32 dst);
virtual void blendFuncSeparate (deUint32 srcRGB, deUint32 dstRGB, deUint32 srcAlpha, deUint32 dstAlpha);
virtual void blendColor (float red, float green, float blue, float alpha);
virtual void colorMask (deBool r, deBool g, deBool b, deBool a);
virtual void depthMask (deBool mask);
virtual void stencilMask (deUint32 mask);
virtual void stencilMaskSeparate (deUint32 face, deUint32 mask);
virtual void blitFramebuffer (int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, deUint32 mask, deUint32 filter);
virtual void invalidateSubFramebuffer(deUint32 target, int numAttachments, const deUint32* attachments, int x, int y, int width, int height);
virtual void invalidateFramebuffer (deUint32 target, int numAttachments, const deUint32* attachments);
virtual void bindVertexArray (deUint32 array);
virtual void genVertexArrays (int numArrays, deUint32* vertexArrays);
virtual void deleteVertexArrays (int numArrays, const deUint32* vertexArrays);
virtual void vertexAttribPointer (deUint32 index, int size, deUint32 type, deBool normalized, int stride, const void *pointer);
virtual void vertexAttribIPointer (deUint32 index, int size, deUint32 type, int stride, const void *pointer);
virtual void enableVertexAttribArray (deUint32 index);
virtual void disableVertexAttribArray(deUint32 index);
virtual void vertexAttribDivisor (deUint32 index, deUint32 divisor);
virtual void vertexAttrib1f (deUint32 index, float);
virtual void vertexAttrib2f (deUint32 index, float, float);
virtual void vertexAttrib3f (deUint32 index, float, float, float);
virtual void vertexAttrib4f (deUint32 index, float, float, float, float);
virtual void vertexAttribI4i (deUint32 index, deInt32, deInt32, deInt32, deInt32);
virtual void vertexAttribI4ui (deUint32 index, deUint32, deUint32, deUint32, deUint32);
virtual deInt32 getAttribLocation (deUint32 program, const char *name);
virtual void uniform1f (deInt32 location, float);
virtual void uniform1i (deInt32 location, deInt32);
virtual void uniform1fv (deInt32 index, deInt32 count, const float*);
virtual void uniform2fv (deInt32 index, deInt32 count, const float*);
virtual void uniform3fv (deInt32 index, deInt32 count, const float*);
virtual void uniform4fv (deInt32 index, deInt32 count, const float*);
virtual void uniform1iv (deInt32 index, deInt32 count, const deInt32*);
virtual void uniform2iv (deInt32 index, deInt32 count, const deInt32*);
virtual void uniform3iv (deInt32 index, deInt32 count, const deInt32*);
virtual void uniform4iv (deInt32 index, deInt32 count, const deInt32*);
virtual void uniformMatrix3fv (deInt32 location, deInt32 count, deBool transpose, const float *value);
virtual void uniformMatrix4fv (deInt32 location, deInt32 count, deBool transpose, const float *value);
virtual deInt32 getUniformLocation (deUint32 program, const char *name);
virtual void lineWidth (float);
virtual void drawArrays (deUint32 mode, int first, int count);
virtual void drawArraysInstanced (deUint32 mode, int first, int count, int instanceCount);
virtual void drawElements (deUint32 mode, int count, deUint32 type, const void *indices);
virtual void drawElementsBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int baseVertex);
virtual void drawElementsInstanced (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount);
virtual void drawElementsInstancedBaseVertex (deUint32 mode, int count, deUint32 type, const void *indices, int instanceCount, int baseVertex);
virtual void drawRangeElements (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices);
virtual void drawRangeElementsBaseVertex (deUint32 mode, deUint32 start, deUint32 end, int count, deUint32 type, const void *indices, int baseVertex);
virtual void drawArraysIndirect (deUint32 mode, const void *indirect);
virtual void drawElementsIndirect (deUint32 mode, deUint32 type, const void *indirect);
virtual void multiDrawArrays (deUint32 mode, const int* first, const int* count, int primCount);
virtual void multiDrawElements (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount);
virtual void multiDrawElementsBaseVertex (deUint32 mode, const int* count, deUint32 type, const void** indices, int primCount, const int* baseVertex);
virtual deUint32 createProgram (ShaderProgram* program);
virtual void useProgram (deUint32 program);
virtual void deleteProgram (deUint32 program);
virtual void readPixels (int x, int y, int width, int height, deUint32 format, deUint32 type, void* data);
virtual deUint32 getError (void);
virtual void finish (void);
virtual void getIntegerv (deUint32 pname, int* params);
virtual const char* getString (deUint32 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);
deUint32 blitResolveMultisampleFramebuffer (deUint32 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 (deUint32 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 (deUint32 target, rc::DataBuffer* buffer);
rc::DataBuffer* getBufferBinding (deUint32 target) const;
void* getPixelPackPtr (void* ptrOffset) const { return m_pixelPackBufferBinding ? (void*)((deUintptr)m_pixelPackBufferBinding->getData()+(deUintptr)ptrOffset) : ptrOffset; }
const void* getPixelUnpackPtr (const void* ptrOffset) const { return m_pixelUnpackBufferBinding ? (const void*)((deUintptr)m_pixelUnpackBufferBinding->getData()+(deUintptr)ptrOffset) : ptrOffset; }
bool predrawErrorChecks (deUint32 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 (deInt32 index, glu::DataType type, deInt32 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
{
deUint32 func;
int ref;
deUint32 opMask;
deUint32 opStencilFail;
deUint32 opDepthFail;
deUint32 opDepthPass;
deUint32 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;
deUint32 m_depthFunc;
float m_depthRangeNear;
float m_depthRangeFar;
float m_polygonOffsetFactor;
float m_polygonOffsetUnits;
bool m_polygonOffsetFillEnabled;
bool m_provokingFirstVertexConvention;
bool m_blendEnabled;
deUint32 m_blendModeRGB;
deUint32 m_blendModeAlpha;
deUint32 m_blendFactorSrcRGB;
deUint32 m_blendFactorDstRGB;
deUint32 m_blendFactorSrcAlpha;
deUint32 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;
deUint32 m_primitiveRestartIndex;
deUint32 m_lastError;
rr::FragmentProcessor m_fragmentProcessor;
std::vector<rr::Fragment> m_fragmentBuffer;
std::vector<float> m_fragmentDepths;
} DE_WARN_UNUSED_TYPE;
} // sglr
#endif // _SGLRREFERENCECONTEXT_HPP
Reference in new issue View Git Blame Copy Permalink