void ImageDataTest::release() {
unsigned char data[] = {'b', 'e', 'e', 'r'};
ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 4}, data);
const unsigned char* const pointer = a.release();
CORRADE_COMPARE(pointer, data);
CORRADE_COMPARE(a.data(), nullptr);
CORRADE_COMPARE(a.size(), Vector2i());
}
Billboard::Billboard(const Trade::ImageData2D& image, Buffer* colorCorrectionBuffer, Object2D* parent, SceneGraph::DrawableGroup2D* group): Object2D(parent), SceneGraph::Drawable2D(*this, group) {
Trade::MeshData2D square = Primitives::Square::solid();
buffer.setData(square.positions(0), BufferUsage::StaticDraw);
mesh.setPrimitive(square.primitive())
.setVertexCount(square.positions(0).size())
.addVertexBuffer(buffer, 0, ColorCorrectionShader::Position());
texture.setWrapping(Sampler::Wrapping::ClampToBorder)
.setMagnificationFilter(Sampler::Filter::Linear)
.setMinificationFilter(Sampler::Filter::Linear)
.setImage(0, TextureFormat::RGBA8, image);
colorCorrectionTexture.setBuffer(BufferTextureFormat::R32F, *colorCorrectionBuffer);
scale(Vector2::yScale(Float(image.size()[1])/image.size()[0]));
}
namespace Magnum { namespace Trade { namespace Test {
class ImageDataTest: public TestSuite::Tester {
public:
explicit ImageDataTest();
void construct();
void constructCopy();
void constructMove();
void toReference();
void release();
};
ImageDataTest::ImageDataTest() {
addTests({&ImageDataTest::construct,
&ImageDataTest::constructCopy,
&ImageDataTest::constructMove,
&ImageDataTest::toReference,
&ImageDataTest::release});
}
void ImageDataTest::construct() {
auto data = new unsigned char[3];
Trade::ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
CORRADE_COMPARE(a.format(), ColorFormat::Red);
CORRADE_COMPARE(a.type(), ColorType::UnsignedByte);
CORRADE_COMPARE(a.size(), Vector2i(1, 3));
CORRADE_COMPARE(a.data(), data);
}
void ImageDataTest::constructCopy() {
CORRADE_VERIFY(!(std::is_constructible<Trade::ImageData2D, const Trade::ImageData2D&>{}));
CORRADE_VERIFY(!(std::is_assignable<Trade::ImageData2D, const Trade::ImageData2D&>{}));
}
void ImageDataTest::constructMove() {
auto data = new unsigned char[3];
Trade::ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
Trade::ImageData2D b(std::move(a));
CORRADE_COMPARE(a.data(), nullptr);
CORRADE_COMPARE(a.size(), Vector2i());
CORRADE_COMPARE(b.format(), ColorFormat::Red);
CORRADE_COMPARE(b.type(), ColorType::UnsignedByte);
CORRADE_COMPARE(b.size(), Vector2i(1, 3));
CORRADE_COMPARE(b.data(), data);
auto data2 = new unsigned char[3];
Trade::ImageData2D c(ColorFormat::RGBA, ColorType::UnsignedShort, {2, 6}, data2);
c = std::move(b);
CORRADE_COMPARE(b.data(), data2);
CORRADE_COMPARE(b.size(), Vector2i(2, 6));
CORRADE_COMPARE(c.format(), ColorFormat::Red);
CORRADE_COMPARE(c.type(), ColorType::UnsignedByte);
CORRADE_COMPARE(c.size(), Vector2i(1, 3));
CORRADE_COMPARE(c.data(), data);
}
void ImageDataTest::toReference() {
auto data = new unsigned char[3];
const Trade::ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 3}, data);
ImageReference2D b = a;
CORRADE_COMPARE(b.format(), ColorFormat::Red);
CORRADE_COMPARE(b.type(), ColorType::UnsignedByte);
CORRADE_COMPARE(b.size(), Vector2i(1, 3));
CORRADE_COMPARE(b.data(), data);
CORRADE_VERIFY((std::is_convertible<const Trade::ImageData2D&, ImageReference2D>::value));
{
#ifdef CORRADE_GCC47_COMPATIBILITY
CORRADE_EXPECT_FAIL("Rvalue references for *this are not supported in GCC < 4.8.1.");
#endif
CORRADE_VERIFY(!(std::is_convertible<const Trade::ImageData2D, ImageReference2D>::value));
CORRADE_VERIFY(!(std::is_convertible<const Trade::ImageData2D&&, ImageReference2D>::value));
}
}
void ImageDataTest::release() {
unsigned char data[] = {'b', 'e', 'e', 'r'};
ImageData2D a(ColorFormat::Red, ColorType::UnsignedByte, {1, 4}, data);
const unsigned char* const pointer = a.release();
CORRADE_COMPARE(pointer, data);
CORRADE_COMPARE(a.data(), nullptr);
CORRADE_COMPARE(a.size(), Vector2i());
}
}}}
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);
}