blob: 9f78939688bd7912e741d9bcd47eb6c0a8f1572c [file] [log] [blame]
#ifndef _GLUTEXTURE_HPP
#define _GLUTEXTURE_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 Texture classes.
*//*--------------------------------------------------------------------*/
#include "gluDefs.hpp"
#include "tcuTexture.hpp"
#include "tcuCompressedTexture.hpp"
#include "tcuResource.hpp"
#include "gluRenderContext.hpp"
#include "gluContextInfo.hpp"
#include "deArrayBuffer.hpp"
#include <vector>
#include <string>
namespace glu
{
/*--------------------------------------------------------------------*//*!
* \brief 1D Texture only supported on OpenGL
*//*--------------------------------------------------------------------*/
class Texture1D
{
public:
Texture1D(const RenderContext &context, uint32_t format, uint32_t dataType, int width);
Texture1D(const RenderContext &context, uint32_t internalFormat, int width);
~Texture1D(void);
tcu::Texture1D &getRefTexture(void)
{
return m_refTexture;
}
const tcu::Texture1D &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
void upload(void);
private:
Texture1D(const Texture1D &other); // Not allowed!
Texture1D &operator=(const Texture1D &other); // Not allowed!
const RenderContext &m_context;
uint32_t m_format; //!< Internal format.
tcu::Texture1D m_refTexture;
uint32_t m_glTexture;
} DE_WARN_UNUSED_TYPE;
/*--------------------------------------------------------------------*//*!
* \brief 2D Texture
*//*--------------------------------------------------------------------*/
class Texture2D
{
public:
Texture2D(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams = tcu::TexDecompressionParams());
Texture2D(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int height);
Texture2D(const RenderContext &context, uint32_t internalFormat, int width, int height);
virtual ~Texture2D(void);
virtual void upload(void); // Not supported on compressed textures.
tcu::Texture2D &getRefTexture(void)
{
return m_refTexture;
}
const tcu::Texture2D &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
static Texture2D *create(const RenderContext &context, const ContextInfo &contextInfo, const tcu::Archive &archive,
int numLevels, const std::vector<std::string> &filenames);
static Texture2D *create(const RenderContext &context, const ContextInfo &contextInfo, const tcu::Archive &archive,
int numLevels, const char *const *filenames);
static Texture2D *create(const RenderContext &context, const ContextInfo &contextInfo, const tcu::Archive &archive,
const char *filename)
{
return create(context, contextInfo, archive, 1, &filename);
}
protected:
const RenderContext &m_context;
bool m_isCompressed;
uint32_t m_format; //!< Internal format.
tcu::Texture2D m_refTexture;
uint32_t m_glTexture;
private:
Texture2D(const Texture2D &other); // Not allowed!
Texture2D &operator=(const Texture2D &other); // Not allowed!
void loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams);
} DE_WARN_UNUSED_TYPE;
class ImmutableTexture2D : public Texture2D
{
public:
ImmutableTexture2D(const RenderContext &context, uint32_t internalFormat, int width, int height);
void upload(void); // Not supported on compressed textures.
private:
ImmutableTexture2D(const ImmutableTexture2D &other); // Not allowed!
ImmutableTexture2D &operator=(const ImmutableTexture2D &other); // Not allowed!
};
/*--------------------------------------------------------------------*//*!
* \brief Cube Map Texture
*//*--------------------------------------------------------------------*/
class TextureCube
{
public:
// For compressed cubemap constructor and create() function input level pointers / filenames are expected
// to laid out to array in following order:
// { l0_neg_x, l0_pos_x, l0_neg_y, l0_pos_y, l0_neg_z, l0_pos_z, l1_neg_x, l1_pos_x, ... }
TextureCube(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams = tcu::TexDecompressionParams());
TextureCube(const RenderContext &context, uint32_t format, uint32_t dataType, int size);
TextureCube(const RenderContext &context, uint32_t internalFormat, int size);
~TextureCube(void);
void upload(void); // Not supported on compressed textures.
tcu::TextureCube &getRefTexture(void)
{
return m_refTexture;
}
const tcu::TextureCube &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
static TextureCube *create(const RenderContext &context, const ContextInfo &contextInfo,
const tcu::Archive &archive, int numLevels, const std::vector<std::string> &filenames);
static TextureCube *create(const RenderContext &context, const ContextInfo &contextInfo,
const tcu::Archive &archive, int numLevels, const char *const *filenames);
private:
TextureCube(const TextureCube &other); // Not allowed!
TextureCube &operator=(const TextureCube &other); // Not allowed!
void loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams);
const RenderContext &m_context;
bool m_isCompressed;
uint32_t m_format; //!< Internal format.
tcu::TextureCube m_refTexture;
uint32_t m_glTexture;
} DE_WARN_UNUSED_TYPE;
/*--------------------------------------------------------------------*//*!
* \brief 2D Array Texture
* \note Not supported on OpenGL ES 2
*//*--------------------------------------------------------------------*/
class Texture2DArray
{
public:
Texture2DArray(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int height,
int numLayers);
Texture2DArray(const RenderContext &context, uint32_t internalFormat, int width, int height, int numLayers);
Texture2DArray(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams = tcu::TexDecompressionParams());
~Texture2DArray(void);
void upload(void);
tcu::Texture2DArray &getRefTexture(void)
{
return m_refTexture;
}
const tcu::Texture2DArray &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
private:
Texture2DArray(const Texture2DArray &other); // Not allowed!
Texture2DArray &operator=(const Texture2DArray &other); // Not allowed!
void loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams);
const RenderContext &m_context;
bool m_isCompressed;
uint32_t m_format; //!< Internal format.
tcu::Texture2DArray m_refTexture;
uint32_t m_glTexture;
} DE_WARN_UNUSED_TYPE;
/*--------------------------------------------------------------------*//*!
* \brief 1D Array Texture
* \note Only supported on OpenGL
*//*--------------------------------------------------------------------*/
class Texture1DArray
{
public:
Texture1DArray(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int numLayers);
Texture1DArray(const RenderContext &context, uint32_t internalFormat, int width, int numLayers);
~Texture1DArray(void);
void upload(void);
tcu::Texture1DArray &getRefTexture(void)
{
return m_refTexture;
}
const tcu::Texture1DArray &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
private:
Texture1DArray(const Texture1DArray &other); // Not allowed!
Texture1DArray &operator=(const Texture1DArray &other); // Not allowed!
const RenderContext &m_context;
uint32_t m_format; //!< Internal format.
tcu::Texture1DArray m_refTexture;
uint32_t m_glTexture;
} DE_WARN_UNUSED_TYPE;
/*--------------------------------------------------------------------*//*!
* \brief 3D Texture
* \note Not supported on OpenGL ES 2
*//*--------------------------------------------------------------------*/
class Texture3D
{
public:
Texture3D(const RenderContext &context, uint32_t format, uint32_t dataType, int width, int height, int depth);
Texture3D(const RenderContext &context, uint32_t internalFormat, int width, int height, int depth);
Texture3D(const RenderContext &context, const ContextInfo &contextInfo, int numLevels,
const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams = tcu::TexDecompressionParams());
~Texture3D(void);
void upload(void);
tcu::Texture3D &getRefTexture(void)
{
return m_refTexture;
}
const tcu::Texture3D &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
private:
Texture3D(const Texture3D &other); // Not allowed!
Texture3D &operator=(const Texture3D &other); // Not allowed!
void loadCompressed(int numLevels, const tcu::CompressedTexture *levels,
const tcu::TexDecompressionParams &decompressionParams);
const RenderContext &m_context;
bool m_isCompressed;
uint32_t m_format; //!< Internal format.
tcu::Texture3D m_refTexture;
uint32_t m_glTexture;
} DE_WARN_UNUSED_TYPE;
/*--------------------------------------------------------------------*//*!
* \brief Cube Map Array Texture
* \note Not supported on OpenGL ES 3.0 or lower
*//*--------------------------------------------------------------------*/
class TextureCubeArray
{
public:
TextureCubeArray(const RenderContext &context, uint32_t format, uint32_t dataType, int size, int numLayers);
TextureCubeArray(const RenderContext &context, uint32_t internalFormat, int size, int numLayers);
~TextureCubeArray(void);
void upload(void);
tcu::TextureCubeArray &getRefTexture(void)
{
return m_refTexture;
}
const tcu::TextureCubeArray &getRefTexture(void) const
{
return m_refTexture;
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
private:
TextureCubeArray(const TextureCubeArray &other); // Not allowed!
TextureCubeArray &operator=(const TextureCubeArray &other); // Not allowed!
const RenderContext &m_context;
bool m_isCompressed;
uint32_t m_format; //!< Internal format.
tcu::TextureCubeArray m_refTexture;
uint32_t m_glTexture;
} DE_WARN_UNUSED_TYPE;
/*--------------------------------------------------------------------*//*!
* \brief 1D Texture Buffer only supported on OpenGL
*//*--------------------------------------------------------------------*/
class TextureBuffer
{
public:
TextureBuffer(const RenderContext &context, uint32_t internalFormat, size_t bufferSize);
TextureBuffer(const RenderContext &context, uint32_t internalFormat, size_t bufferSize, size_t offset, size_t size,
const void *data = DE_NULL);
~TextureBuffer(void);
// \note Effective pixel buffer access must be limited to w <= GL_MAX_TEXTURE_BUFFER_SIZE
const tcu::PixelBufferAccess getFullRefTexture(void);
const tcu::ConstPixelBufferAccess getFullRefTexture(void) const;
// \note mutating buffer storage will invalidate existing pixel buffer accesses
de::ArrayBuffer<uint8_t> &getRefBuffer(void)
{
return m_refBuffer;
}
const de::ArrayBuffer<uint8_t> &getRefBuffer(void) const
{
return m_refBuffer;
}
size_t getSize(void) const
{
return m_size;
}
size_t getOffset(void) const
{
return m_offset;
}
size_t getBufferSize(void) const
{
return m_refBuffer.size();
}
uint32_t getGLTexture(void) const
{
return m_glTexture;
}
uint32_t getGLBuffer(void) const
{
return m_glBuffer;
}
void upload(void);
private:
void init(uint32_t internalFormat, size_t bufferSize, size_t offset, size_t size, const void *data);
TextureBuffer(const TextureBuffer &other); // Not allowed!
TextureBuffer &operator=(const TextureBuffer &other); // Not allowed!
const RenderContext &m_context;
uint32_t m_format; //!< Internal format.
de::ArrayBuffer<uint8_t> m_refBuffer;
size_t m_offset;
size_t m_size;
uint32_t m_glTexture;
uint32_t m_glBuffer;
} DE_WARN_UNUSED_TYPE;
} // namespace glu
#endif // _GLUTEXTURE_HPP