313 lines
9.1 KiB
C++
313 lines
9.1 KiB
C++
//
|
|
// VROTexture.h
|
|
// ViroRenderer
|
|
//
|
|
// Created by Raj Advani on 11/17/15.
|
|
// Copyright © 2015 Viro Media. All rights reserved.
|
|
//
|
|
|
|
#ifndef VROTexture_h
|
|
#define VROTexture_h
|
|
|
|
#include <memory>
|
|
#include <vector>
|
|
#include "VRODefines.h"
|
|
|
|
// Constants for ETC2 ripped from NDKr9 headers
|
|
#define GL_COMPRESSED_RGB8_ETC2 0x9274
|
|
#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
|
|
|
|
class VROTextureSubstrate;
|
|
class VRODriver;
|
|
class VROImage;
|
|
class VROData;
|
|
class VROFrameScheduler;
|
|
|
|
enum class VROTextureType {
|
|
None = 1,
|
|
Texture2D = 2,
|
|
TextureCube = 4,
|
|
TextureEGLImage = 8
|
|
};
|
|
|
|
// Texture formats for source data
|
|
enum class VROTextureFormat {
|
|
ETC2_RGBA8_EAC,
|
|
ASTC_4x4_LDR,
|
|
RGBA8,
|
|
RGB565,
|
|
RGB8,
|
|
RGB9_E5,
|
|
};
|
|
|
|
// Texture formats for storage on the GPU
|
|
// (e.g. we can load an RGBA8 texture and store it as RGBA4 to
|
|
// preserve GPU memory)
|
|
enum class VROTextureInternalFormat {
|
|
RGBA8,
|
|
RGBA4,
|
|
RGB565,
|
|
YCBCR,
|
|
RGB9_E5,
|
|
};
|
|
|
|
enum class VROMipmapMode {
|
|
None, // Do not use mipmaps
|
|
Pregenerated, // Mipmaps are baked into the texture data
|
|
Runtime, // Build mipmaps at texture loading time
|
|
};
|
|
|
|
enum class VROStereoMode {
|
|
None = 1, // No stereo is applied, image is fully represented in the texture.
|
|
LeftRight = 2, // Side by side stereoscopic image, with the left image shown to the left eye.
|
|
RightLeft = 3, // Side by side stereoscopic image, with the right image shown to the left eye.
|
|
TopBottom = 4, // Over/Under stereoscopic image, with the top image shown to the left eye.
|
|
BottomTop = 5 // Over/Under stereoscopic image, with the bottom image shown to the left eye.
|
|
};
|
|
|
|
enum class VROWrapMode {
|
|
Clamp,
|
|
Repeat,
|
|
ClampToBorder,
|
|
Mirror
|
|
};
|
|
|
|
enum class VROFilterMode {
|
|
None,
|
|
Nearest,
|
|
Linear
|
|
};
|
|
|
|
class VROTexture : public std::enable_shared_from_this<VROTexture> {
|
|
|
|
public:
|
|
|
|
/*
|
|
Create a new VROTexture with no underlying image data.
|
|
The image data must be injected via setSubstrate(). This is
|
|
the preferred constructor for multi-substrate textures
|
|
(e.g. YCbCr).
|
|
*/
|
|
VROTexture(VROTextureType type,
|
|
VROTextureInternalFormat internalFormat,
|
|
VROStereoMode stereoMode = VROStereoMode::None);
|
|
|
|
/*
|
|
Create a new VROTexture with the given underlying substrate.
|
|
*/
|
|
VROTexture(VROTextureType type,
|
|
std::unique_ptr<VROTextureSubstrate> substrate,
|
|
VROStereoMode stereoMode = VROStereoMode::None);
|
|
|
|
/*
|
|
Create a new VROTexture from a VROImage.
|
|
*/
|
|
VROTexture(VROTextureInternalFormat internalFormat, bool sRGB,
|
|
VROMipmapMode mipmapMode,
|
|
std::shared_ptr<VROImage> image,
|
|
VROStereoMode stereoMode = VROStereoMode::None);
|
|
|
|
VROTexture(VROTextureInternalFormat internalFormat, bool sRGB,
|
|
std::vector<std::shared_ptr<VROImage>> &images,
|
|
VROStereoMode stereoMode = VROStereoMode::None);
|
|
|
|
/*
|
|
Create a new VROTexture from the given raw data in the given format.
|
|
The format parameter defines the input format of the data, and
|
|
internal format specifies how to store the texture in GPU memory.
|
|
Set sRGB to true if the texture is in sRGB color space (gamma 2.2), and
|
|
should be gamma-uncorrected into linear RGB space when sampled, for better
|
|
accuracy during shader computations. This should *only* be used if gamma
|
|
correction is enabled on the framebuffer or shader (to convert
|
|
from linear back to gamma 2.2 space when writing to the framebuffer).
|
|
*/
|
|
VROTexture(VROTextureType type,
|
|
VROTextureFormat format,
|
|
VROTextureInternalFormat internalFormat, bool sRGB,
|
|
VROMipmapMode mipmapMode,
|
|
std::vector<std::shared_ptr<VROData>> &data,
|
|
int width, int height,
|
|
std::vector<uint32_t> mipSizes,
|
|
VROStereoMode stereoMode = VROStereoMode::None);
|
|
|
|
virtual ~VROTexture();
|
|
|
|
/*
|
|
Delete any rendering resources. Invoked prior to destruction, on the
|
|
rendering thread.
|
|
*/
|
|
virtual void deleteGL() {}
|
|
|
|
VROTextureType getType() const {
|
|
return _type;
|
|
}
|
|
uint32_t getTextureId() const {
|
|
return _textureId;
|
|
}
|
|
|
|
/*
|
|
Get the texture ready for usage now, in advance of when it's visible. If not invoked,
|
|
the texture will be initialized when it is made visible.
|
|
*/
|
|
void prewarm(std::shared_ptr<VRODriver> driver);
|
|
|
|
/*
|
|
Get the substrates for this texture, loading them if necessary. If a scheduler is provided,
|
|
then the substrates will be loaded asynchronously via the scheduler; otherwise, the
|
|
substrates will be loaded immediately in a blocking fashion.
|
|
*/
|
|
int getNumSubstrates() const;
|
|
VROTextureSubstrate *getSubstrate(int index, std::shared_ptr<VRODriver> &driver, VROFrameScheduler *scheduler);
|
|
|
|
/*
|
|
Textures may have their substrates set externally if they are created and
|
|
managed elsewhere.
|
|
*/
|
|
void setSubstrate(int index, std::unique_ptr<VROTextureSubstrate> substrate);
|
|
|
|
VROTextureInternalFormat getInternalFormat() const {
|
|
return _internalFormat;
|
|
}
|
|
VROStereoMode getStereoMode() const {
|
|
return _stereoMode;
|
|
}
|
|
|
|
/*
|
|
True if this texture has an alpha channel.
|
|
*/
|
|
bool hasAlpha() const;
|
|
|
|
/*
|
|
Access and set wrap properties.
|
|
*/
|
|
VROWrapMode getWrapS() const {
|
|
return _wrapS;
|
|
}
|
|
void setWrapS(VROWrapMode wrapMode) {
|
|
_wrapS = wrapMode;
|
|
}
|
|
VROWrapMode getWrapT() const {
|
|
return _wrapT;
|
|
}
|
|
void setWrapT(VROWrapMode wrapMode) {
|
|
_wrapT = wrapMode;
|
|
}
|
|
|
|
/*
|
|
Access and set filtering properties.
|
|
*/
|
|
VROFilterMode getMinificationFilter() const {
|
|
return _minificationFilter;
|
|
}
|
|
void setMinificationFilter(VROFilterMode filter) {
|
|
_minificationFilter = filter;
|
|
}
|
|
VROFilterMode getMagnificationFilter() const {
|
|
return _magnificationFilter;
|
|
}
|
|
void setMagnificationFilter(VROFilterMode filter) {
|
|
_magnificationFilter = filter;
|
|
}
|
|
VROFilterMode getMipFilter() const {
|
|
return _mipFilter;
|
|
}
|
|
void setMipFilter(VROFilterMode filter) {
|
|
_mipFilter = filter;
|
|
}
|
|
|
|
/*
|
|
Width and height (available for any 2D texture created through an image).
|
|
*/
|
|
int getWidth() const {
|
|
return _width;
|
|
}
|
|
int getHeight() const {
|
|
return _height;
|
|
}
|
|
|
|
private:
|
|
|
|
uint32_t _textureId;
|
|
const VROTextureType _type;
|
|
|
|
/*
|
|
The image is retained until the texture is hydrated, after which the
|
|
substrate is populated.
|
|
|
|
Vector of images is used for cube textures.
|
|
*/
|
|
std::vector<std::shared_ptr<VROImage>> _images;
|
|
|
|
/*
|
|
If the underlying texture is compressed, its raw data is retined until the
|
|
substrate is populated. Cube textures contain six faces, all other
|
|
textures will only have one element in this vector.
|
|
*/
|
|
std::vector<std::shared_ptr<VROData>> _data;
|
|
|
|
/*
|
|
The format of the source data (_data).
|
|
*/
|
|
VROTextureFormat _format;
|
|
|
|
/*
|
|
The format in which we want to store the data on the GPU.
|
|
(defaults to RGBA8, and is ignored if we're using a compressed
|
|
source data format: compressed textures are always stored in their
|
|
source format).
|
|
*/
|
|
VROTextureInternalFormat _internalFormat;
|
|
int _width, _height;
|
|
|
|
/*
|
|
The mipmap generation mode for this texture. Determines if mipmaps
|
|
are loaded from the source data (pregenerated), generated at runtime,
|
|
or not used at all. The _mipSizes vector indicates the compessed size
|
|
of each mip-level in the source data, if _mipmapMode = Pregenerated.
|
|
*/
|
|
VROMipmapMode _mipmapMode;
|
|
std::vector<uint32_t> _mipSizes;
|
|
|
|
/*
|
|
Representation of the texture in the underlying hardware. Textures typically
|
|
have one substrate, but some textures (e.g. YCbCr) may have multiple planes,
|
|
each represented by a separate substrate.
|
|
*/
|
|
std::vector<std::unique_ptr<VROTextureSubstrate>> _substrates;
|
|
|
|
/*
|
|
True if the underlying substrate should gamma-uncorrect the texture data
|
|
into linear space when sampled. Typically only diffuse texture are stored
|
|
in sRGB formats and therefore need gamma-uncorrection.
|
|
*/
|
|
bool _sRGB;
|
|
|
|
/*
|
|
Represents the stereo property of the image, if any.
|
|
*/
|
|
VROStereoMode _stereoMode;
|
|
|
|
/*
|
|
Wrap and filtering properties.
|
|
*/
|
|
VROWrapMode _wrapS, _wrapT;
|
|
VROFilterMode _minificationFilter, _magnificationFilter, _mipFilter;
|
|
|
|
/*
|
|
Converts the image(s) into a substrate. May be asynchronously executed.
|
|
*/
|
|
void hydrate(std::shared_ptr<VRODriver> &driver);
|
|
|
|
/*
|
|
Set the number of substrates to be used by this texture.
|
|
*/
|
|
void setNumSubstrates(int numSubstrates);
|
|
|
|
/*
|
|
Get the number of substrates used by the given texture format.
|
|
*/
|
|
int getNumSubstratesForFormat(VROTextureInternalFormat format) const;
|
|
};
|
|
|
|
#endif /* VROTexture_h */
|