void CubeMapTextureGLTest::subImageBuffer() {
constexpr UnsignedByte zero[4*4*4] = {};
constexpr UnsignedByte subData[] = { 0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f };
CubeMapTexture texture;
texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(4), zero));
texture.setSubImage(CubeMapTexture::Coordinate::PositiveX, 0, Vector2i(1),
BufferImage2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), subData, BufferUsage::StaticDraw));
MAGNUM_VERIFY_NO_ERROR();
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
BufferImage2D image(ColorFormat::RGBA, ColorType::UnsignedByte);
texture.image(CubeMapTexture::Coordinate::PositiveX, 0, image, BufferUsage::StaticRead);
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector2i(4));
const auto imageData = image.buffer().data<UnsignedByte>();
CORRADE_COMPARE_AS(std::vector<UnsignedByte>(imageData.begin(), imageData.end()), (std::vector<UnsignedByte>{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0, 0, 0, 0,
0, 0, 0, 0, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}), TestSuite::Compare::Container);
#endif
}
void CubeMapTextureGLTest::invalidateSubImage() {
CubeMapTexture texture;
texture.setStorage(2, TextureFormat::RGBA8, Vector2i(32));
texture.invalidateSubImage(1, Vector3i(2), Vector3i(Vector2i(8), 4));
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::samplingMaxLevel() {
if(!Context::current()->isExtensionSupported<Extensions::GL::APPLE::texture_max_level>())
CORRADE_SKIP(Extensions::GL::APPLE::texture_max_level::string() + std::string(" is not supported."));
CubeMapTexture texture;
texture.setMaxLevel(750);
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::construct() {
{
CubeMapTexture texture;
MAGNUM_VERIFY_NO_ERROR();
CORRADE_VERIFY(texture.id() > 0);
}
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::samplingCompare() {
if(!Context::current()->isExtensionSupported<Extensions::GL::EXT::shadow_samplers>() ||
!Context::current()->isExtensionSupported<Extensions::GL::NV::shadow_samplers_cube>())
CORRADE_SKIP(Extensions::GL::NV::shadow_samplers_cube::string() + std::string(" is not supported."));
CubeMapTexture texture;
texture.setCompareMode(Sampler::CompareMode::CompareRefToTexture)
.setCompareFunction(Sampler::CompareFunction::GreaterOrEqual);
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::samplingSRGBDecode() {
#ifdef MAGNUM_TARGET_GLES2
if(!Context::current()->isExtensionSupported<Extensions::GL::EXT::sRGB>())
CORRADE_SKIP(Extensions::GL::EXT::sRGB::string() + std::string(" is not supported."));
#endif
if(!Context::current()->isExtensionSupported<Extensions::GL::EXT::texture_sRGB_decode>())
CORRADE_SKIP(Extensions::GL::EXT::texture_sRGB_decode::string() + std::string(" is not supported."));
CubeMapTexture texture;
texture.setSRGBDecode(false);
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::samplingBorderInteger() {
if(!Context::current()->isExtensionSupported<Extensions::GL::EXT::texture_integer>())
CORRADE_SKIP(Extensions::GL::EXT::texture_integer::string() + std::string(" is not supported."));
CubeMapTexture a;
a.setWrapping(Sampler::Wrapping::ClampToBorder)
.setBorderColor(Vector4i(1, 56, 78, -2));
CubeMapTexture b;
b.setWrapping(Sampler::Wrapping::ClampToBorder)
.setBorderColor(Vector4ui(35, 56, 78, 15));
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::samplingDepthStencilMode() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::stencil_texturing>())
CORRADE_SKIP(Extensions::GL::ARB::stencil_texturing::string() + std::string(" is not supported."));
#else
if(!Context::current()->isVersionSupported(Version::GLES310))
CORRADE_SKIP("OpenGL ES 3.1 not supported.");
#endif
CubeMapTexture texture;
texture.setDepthStencilMode(Sampler::DepthStencilMode::StencilIndex);
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::imageFullBuffer() {
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::direct_state_access>())
CORRADE_SKIP(Extensions::GL::ARB::direct_state_access::string() + std::string(" is not supported."));
CubeMapTexture texture;
texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2})
.setSubImage(0, {}, BufferImage3D{ColorFormat::RGBA, ColorType::UnsignedByte, Vector3i{2, 2, 6}, DataFull, BufferUsage::StaticDraw});
MAGNUM_VERIFY_NO_ERROR();
BufferImage3D image = texture.image(0, {ColorFormat::RGBA, ColorType::UnsignedByte}, BufferUsage::StaticRead);
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
const auto imageData = image.buffer().data<UnsignedByte>();
CORRADE_COMPARE_AS(imageData, Containers::ArrayReference<const UnsignedByte>{DataFull}, TestSuite::Compare::Container);
}
void CubeMapTextureGLTest::bind() {
CubeMapTexture texture;
texture.bind(15);
MAGNUM_VERIFY_NO_ERROR();
AbstractTexture::unbind(15);
MAGNUM_VERIFY_NO_ERROR();
AbstractTexture::bind(7, {&texture, nullptr, &texture});
MAGNUM_VERIFY_NO_ERROR();
AbstractTexture::unbind(7, 3);
MAGNUM_VERIFY_NO_ERROR();
}
void CubeMapTextureGLTest::imageBuffer() {
CubeMapTexture texture;
texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8,
BufferImage2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), Data, BufferUsage::StaticDraw));
MAGNUM_VERIFY_NO_ERROR();
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
BufferImage2D image = texture.image(CubeMapTexture::Coordinate::PositiveX, 0, {ColorFormat::RGBA, ColorType::UnsignedByte}, BufferUsage::StaticRead);
const auto imageData = image.buffer().data<UnsignedByte>();
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector2i(2));
CORRADE_COMPARE_AS(imageData, Containers::ArrayReference<const UnsignedByte>{Data}, TestSuite::Compare::Container);
#endif
}
void CubeMapTextureGLTest::image() {
CubeMapTexture texture;
texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), Data));
MAGNUM_VERIFY_NO_ERROR();
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
Image2D image = texture.image(CubeMapTexture::Coordinate::PositiveX, 0, {ColorFormat::RGBA, ColorType::UnsignedByte});
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector2i(2));
CORRADE_COMPARE_AS(
Containers::ArrayReference<const UnsignedByte>(image.data<UnsignedByte>(), image.pixelSize()*image.size().product()),
Containers::ArrayReference<const UnsignedByte>{Data}, TestSuite::Compare::Container);
#endif
}
void CubeMapTextureGLTest::imageFull() {
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::direct_state_access>())
CORRADE_SKIP(Extensions::GL::ARB::direct_state_access::string() + std::string(" is not supported."));
CubeMapTexture texture;
texture.setStorage(1, TextureFormat::RGBA8, Vector2i{2, 2})
.setSubImage(0, {}, ImageReference3D{ColorFormat::RGBA, ColorType::UnsignedByte, Vector3i{2, 2, 6}, DataFull});
MAGNUM_VERIFY_NO_ERROR();
Image3D image = texture.image(0, {ColorFormat::RGBA, ColorType::UnsignedByte});
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector3i(2, 2, 6));
CORRADE_COMPARE_AS(
Containers::ArrayReference<const UnsignedByte>(image.data<UnsignedByte>(), image.pixelSize()*image.size().product()),
Containers::ArrayReference<const UnsignedByte>{DataFull}, TestSuite::Compare::Container);
}
CubeMapTexture* CubeMapTexture::Load(
const std::string& frontFace, const std::string& backFace, const std::string& leftFace,
const std::string& rightFace, const std::string& upFace, const std::string& downFace){
CubeMapTexture* cubeMap = new CubeMapTexture();
Texture::SetActiveTextureUnit(0);
cubeMap->Bind();
if(!cubeMap->LoadCubemapFace(leftFace, GL_TEXTURE_CUBE_MAP_NEGATIVE_X)) return NULL;
if(!cubeMap->LoadCubemapFace(rightFace, GL_TEXTURE_CUBE_MAP_POSITIVE_X))return NULL;
if(!cubeMap->LoadCubemapFace(downFace, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y))return NULL;
if(!cubeMap->LoadCubemapFace(upFace, GL_TEXTURE_CUBE_MAP_POSITIVE_Y))return NULL;
if(!cubeMap->LoadCubemapFace(backFace, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))return NULL;
if(!cubeMap->LoadCubemapFace(frontFace, GL_TEXTURE_CUBE_MAP_POSITIVE_Z))return NULL;
cubeMap->GenerateMipmap();
cubeMap->Unbind();
return cubeMap;
}
void CubeMapTextureGLTest::subImageQueryBuffer() {
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::get_texture_sub_image>())
CORRADE_SKIP(Extensions::GL::ARB::get_texture_sub_image::string() + std::string(" is not supported."));
/* I'm too lazy to call setSubImage() six times */
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::direct_state_access>())
CORRADE_SKIP(Extensions::GL::ARB::direct_state_access::string() + std::string(" is not supported."));
CubeMapTexture texture;
texture.setStorage(1, TextureFormat::RGBA8, Vector2i{4})
.setSubImage(0, {}, ImageReference3D{ColorFormat::RGBA, ColorType::UnsignedByte, {4, 4, 1}, SubDataComplete});
MAGNUM_VERIFY_NO_ERROR();
BufferImage3D image = texture.subImage(0, Range3Di::fromSize({1, 1, 0}, {2, 2, 1}), {ColorFormat::RGBA, ColorType::UnsignedByte}, BufferUsage::StaticRead);
const auto imageData = image.buffer().data<UnsignedByte>();
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector3i(2, 2, 1));
CORRADE_COMPARE_AS(imageData, Containers::ArrayReference<const UnsignedByte>{Data}, TestSuite::Compare::Container);
}
void CubeMapTextureGLTest::image() {
constexpr UnsignedByte data[] = { 0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f };
CubeMapTexture texture;
texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(2), data));
MAGNUM_VERIFY_NO_ERROR();
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
Image2D image(ColorFormat::RGBA, ColorType::UnsignedByte);
texture.image(CubeMapTexture::Coordinate::PositiveX, 0, image);
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(image.size(), Vector2i(2));
CORRADE_COMPARE_AS(std::vector<UnsignedByte>(image.data(), image.data()+image.pixelSize()*image.size().product()),
std::vector<UnsignedByte>(data, data+16), TestSuite::Compare::Container);
#endif
}
void CubeMapTextureGLTest::sampling() {
CubeMapTexture texture;
texture.setMinificationFilter(Sampler::Filter::Linear, Sampler::Mipmap::Linear)
.setMagnificationFilter(Sampler::Filter::Linear)
#ifndef MAGNUM_TARGET_GLES2
.setMinLod(-750.0f)
.setMaxLod(750.0f)
#ifndef MAGNUM_TARGET_GLES
.setLodBias(0.5f)
#endif
.setBaseLevel(1)
.setMaxLevel(750)
#endif
.setWrapping(Sampler::Wrapping::ClampToBorder)
.setBorderColor(Color3(0.5f))
.setMaxAnisotropy(Sampler::maxMaxAnisotropy())
#ifndef MAGNUM_TARGET_GLES2
.setCompareMode(Sampler::CompareMode::CompareRefToTexture)
.setCompareFunction(Sampler::CompareFunction::GreaterOrEqual)
#endif
;
MAGNUM_VERIFY_NO_ERROR();
}
void FramebufferGLTest::attachCubeMapTexture() {
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::framebuffer_object>())
CORRADE_SKIP(Extensions::GL::ARB::framebuffer_object::string() + std::string(" is not available."));
#endif
Framebuffer framebuffer({{}, Vector2i(128)});
CubeMapTexture color;
#ifndef MAGNUM_TARGET_GLES2
color.setStorage(1, TextureFormat::RGBA8, Vector2i(128));
#else
color.setStorage(1, TextureFormat::RGBA, Vector2i(128));
#endif
framebuffer.attachCubeMapTexture(Framebuffer::ColorAttachment(0), color, CubeMapTexture::Coordinate::NegativeZ, 0);
CubeMapTexture depthStencil;
#ifdef MAGNUM_TARGET_GLES2
if(Context::current()->isExtensionSupported<Extensions::GL::OES::packed_depth_stencil>())
#endif
{
#ifdef MAGNUM_TARGET_GLES2
Debug() << "Using" << Extensions::GL::OES::packed_depth_stencil::string();
#endif
#ifndef MAGNUM_TARGET_GLES2
depthStencil.setStorage(1, TextureFormat::Depth24Stencil8, Vector2i(128));
framebuffer.attachCubeMapTexture(Framebuffer::BufferAttachment::DepthStencil, depthStencil, CubeMapTexture::Coordinate::NegativeZ, 0);
#else
depthStencil.setStorage(1, TextureFormat::DepthStencil, Vector2i(128));
framebuffer.attachCubeMapTexture(Framebuffer::BufferAttachment::Depth, depthStencil, CubeMapTexture::Coordinate::NegativeZ, 0)
.attachCubeMapTexture(Framebuffer::BufferAttachment::Stencil, depthStencil, CubeMapTexture::Coordinate::NegativeZ, 0);
#endif
}
#ifdef MAGNUM_TARGET_GLES2
else if(Context::current()->isExtensionSupported<Extensions::GL::OES::depth_texture>()) {
Debug() << "Using" << Extensions::GL::OES::depth_texture::string();
depthStencil.setStorage(1, TextureFormat::DepthComponent16, Vector2i(128));
framebuffer.attachCubeMapTexture(Framebuffer::BufferAttachment::Depth, depthStencil, CubeMapTexture::Coordinate::NegativeZ, 0);
}
#endif
MAGNUM_VERIFY_NO_ERROR();
CORRADE_COMPARE(framebuffer.checkStatus(FramebufferTarget::ReadDraw), Framebuffer::Status::Complete);
}
void CubeMapTextureGLTest::storage() {
CubeMapTexture texture;
texture.setStorage(5, TextureFormat::RGBA8, Vector2i(32));
MAGNUM_VERIFY_NO_ERROR();
#ifndef MAGNUM_TARGET_GLES2
#ifdef MAGNUM_TARGET_GLES
if(!Context::current()->isVersionSupported(Version::GLES310))
CORRADE_SKIP("OpenGL ES 3.1 not supported, skipping image size testing");
#endif
CORRADE_COMPARE(texture.imageSize(0), Vector2i(32));
CORRADE_COMPARE(texture.imageSize(1), Vector2i(16));
CORRADE_COMPARE(texture.imageSize(2), Vector2i(8));
CORRADE_COMPARE(texture.imageSize(3), Vector2i(4));
CORRADE_COMPARE(texture.imageSize(4), Vector2i(2));
/* Not available */
CORRADE_COMPARE(texture.imageSize(5), Vector2i(0));
MAGNUM_VERIFY_NO_ERROR();
#endif
}
CubeMap::CubeMap(const std::string& prefix, Object3D* parent, SceneGraph::DrawableGroup3D<>* group): Object3D(parent), SceneGraph::Drawable3D<>(this, group) {
CubeMapResourceManager* resourceManager = CubeMapResourceManager::instance();
/* Cube mesh */
if(!(cube = resourceManager->get<Mesh>("cube"))) {
Mesh* mesh = new Mesh;
Buffer* buffer = new Buffer;
Buffer* indexBuffer = new Buffer;
Trade::MeshData3D cubeData = Primitives::Cube::solid();
MeshTools::flipFaceWinding(*cubeData.indices());
MeshTools::compressIndices(mesh, indexBuffer, Buffer::Usage::StaticDraw, *cubeData.indices());
MeshTools::interleave(mesh, buffer, Buffer::Usage::StaticDraw, *cubeData.positions(0));
mesh->setPrimitive(cubeData.primitive())
->addVertexBuffer(buffer, 0, CubeMapShader::Position());
resourceManager->set("cube-buffer", buffer, ResourceDataState::Final, ResourcePolicy::Resident);
resourceManager->set("cube-index-buffer", indexBuffer, ResourceDataState::Final, ResourcePolicy::Resident);
resourceManager->set(cube.key(), mesh, ResourceDataState::Final, ResourcePolicy::Resident);
}
/* Cube map texture */
if(!(texture = resourceManager->get<CubeMapTexture>("texture"))) {
CubeMapTexture* cubeMap = new CubeMapTexture;
cubeMap->setWrapping(CubeMapTexture::Wrapping::ClampToEdge)
->setMagnificationFilter(CubeMapTexture::Filter::Linear)
->setMinificationFilter(CubeMapTexture::Filter::Linear, CubeMapTexture::Mipmap::Linear);
Resource<Trade::AbstractImporter> importer = resourceManager->get<Trade::AbstractImporter>("tga-importer");
/* Configure texture storage using size of first image */
importer->openFile(prefix + "+x.tga");
Trade::ImageData2D* image = importer->image2D(0);
Vector2i size = image->size();
cubeMap->setStorage(Math::log2(size.min())+1, CubeMapTexture::InternalFormat::RGB8, size);
cubeMap->setSubImage(CubeMapTexture::PositiveX, 0, {}, image);
delete image;
importer->openFile(prefix + "-x.tga");
image = importer->image2D(0);
cubeMap->setSubImage(CubeMapTexture::NegativeX, 0, {}, image);
delete image;
importer->openFile(prefix + "+y.tga");
image = importer->image2D(0);
cubeMap->setSubImage(CubeMapTexture::PositiveY, 0, {}, image);
delete image;
importer->openFile(prefix + "-y.tga");
image = importer->image2D(0);
cubeMap->setSubImage(CubeMapTexture::NegativeY, 0, {}, image);
delete image;
importer->openFile(prefix + "+z.tga");
image = importer->image2D(0);
cubeMap->setSubImage(CubeMapTexture::PositiveZ, 0, {}, image);
delete image;
importer->openFile(prefix + "-z.tga");
image = importer->image2D(0);
cubeMap->setSubImage(CubeMapTexture::NegativeZ, 0, {}, image);
delete image;
cubeMap->generateMipmap();
resourceManager->set(texture.key(), cubeMap, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* Shader */
if(!(shader = resourceManager->get<AbstractShaderProgram, CubeMapShader>("shader")))
resourceManager->set<AbstractShaderProgram>(shader.key(), new CubeMapShader, ResourceDataState::Final, ResourcePolicy::Manual);
}
void CubeMapTextureGLTest::generateMipmap() {
CubeMapTexture texture;
texture.setImage(CubeMapTexture::Coordinate::PositiveX, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(32)));
texture.setImage(CubeMapTexture::Coordinate::PositiveY, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(32)));
texture.setImage(CubeMapTexture::Coordinate::PositiveZ, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(32)));
texture.setImage(CubeMapTexture::Coordinate::NegativeX, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(32)));
texture.setImage(CubeMapTexture::Coordinate::NegativeY, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(32)));
texture.setImage(CubeMapTexture::Coordinate::NegativeZ, 0, TextureFormat::RGBA8,
ImageReference2D(ColorFormat::RGBA, ColorType::UnsignedByte, Vector2i(32)));
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
CORRADE_COMPARE(texture.imageSize(0), Vector2i(32));
CORRADE_COMPARE(texture.imageSize(1), Vector2i( 0));
#endif
texture.generateMipmap();
MAGNUM_VERIFY_NO_ERROR();
/** @todo How to test this on ES? */
#ifndef MAGNUM_TARGET_GLES
CORRADE_COMPARE(texture.imageSize(0), Vector2i(32));
CORRADE_COMPARE(texture.imageSize(1), Vector2i(16));
CORRADE_COMPARE(texture.imageSize(2), Vector2i( 8));
CORRADE_COMPARE(texture.imageSize(3), Vector2i( 4));
CORRADE_COMPARE(texture.imageSize(4), Vector2i( 2));
CORRADE_COMPARE(texture.imageSize(5), Vector2i( 1));
MAGNUM_VERIFY_NO_ERROR();
#endif
}
CubeMapTexture* CubeMapTexture::Load(int size) {
CubeMapTexture* cubeMap = new CubeMapTexture();
Texture::SetActiveTextureUnit(0);
cubeMap->Bind();
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE));
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0));
GL_C(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, 0));
GL_C(glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS));
struct RGBA {
GLubyte r;
GLubyte g;
GLubyte b;
GLubyte a;
};
RGBA green; green.r = 0;green.g = 255;green.b = 0;green.a = 255;
RGBA red; red.r = 255;red.g = 0;red.b = 0;red.a = 255;
std::vector<RGBA> testData(size * size * sizeof(RGBA), green );
std::vector<RGBA> xData(size * size * sizeof(RGBA), red);
for(int i = 0; i < 6; ++i) {
std::vector<RGBA> d = i % 2 == 0 ? testData : xData;
glTexImage2D(
GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, GL_RGBA8 , size,size, 0, GL_RGBA, GL_UNSIGNED_BYTE,
/*&d[0]*/ nullptr);
/*
GL_C(glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ));
GL_C(glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ));
*/
// GL_C(glGenerateMipmap(m_target));
}
/*
GL_C(glFinish() );
GL_C(glFlush() );
}*/
// cubeMap->SetTextureClamping();
// cubeMap->SetTextureWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
// cubeMap->GenerateMipmap();
// cubeMap->Unbind();
return cubeMap;
}
