ReflectorShader::ReflectorShader() {
Utility::Resource rs("data");
Shader vert(Version::GL330, Shader::Type::Vertex);
vert.addSource(rs.get("ReflectorShader.vert"));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
attachShader(vert);
Shader frag(Version::GL330, Shader::Type::Fragment);
frag.addSource(rs.get("ReflectorShader.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
attachShader(frag);
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
transformationMatrixUniform = uniformLocation("transformationMatrix");
normalMatrixUniform = uniformLocation("normalMatrix");
projectionMatrixUniform = uniformLocation("projectionMatrix");
cameraMatrixUniform = uniformLocation("cameraMatrix");
reflectivityUniform = uniformLocation("reflectivity");
diffuseColorUniform = uniformLocation("diffuseColor");
setUniform(uniformLocation("textureData"), TextureLayer);
setUniform(uniformLocation("tarnishTextureData"), TarnishTextureLayer);
}
template<UnsignedInt dimensions> Flat<dimensions>::Flat(const Flags flags): transformationProjectionMatrixUniform(0), colorUniform(1), _flags(flags) {
#ifdef MAGNUM_BUILD_STATIC
/* Import resources on static build, if not already */
if(!Utility::Resource::hasGroup("MagnumShaders"))
importShaderResources();
#endif
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current().supportedVersion({Version::GL320, Version::GL310, Version::GL300, Version::GL210});
#else
const Version version = Context::current().supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert = Implementation::createCompatibilityShader(rs, version, Shader::Type::Vertex);
Shader frag = Implementation::createCompatibilityShader(rs, version, Shader::Type::Fragment);
vert.addSource(flags & Flag::Textured ? "#define TEXTURED\n" : "")
.addSource(rs.get("generic.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
frag.addSource(flags & Flag::Textured ? "#define TEXTURED\n" : "")
.addSource(rs.get("Flat.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
attachShaders({vert, frag});
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current().isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
if(flags & Flag::Textured) bindAttributeLocation(TextureCoordinates::Location, "textureCoordinates");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
colorUniform = uniformLocation("color");
}
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>(version))
#endif
{
if(flags & Flag::Textured) setUniform(uniformLocation("textureData"), TextureLayer);
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
/* Default to fully opaque white so we can see the texture */
if(flags & Flag::Textured) setColor(Color4(1.0f));
#endif
}
MyShader::MyShader() {
#ifndef MAGNUM_TARGET_GLES
Shader vert(Version::GL210, Shader::Type::Vertex);
Shader frag(Version::GL210, Shader::Type::Fragment);
#else
Shader vert(Version::GLES200, Shader::Type::Vertex);
Shader frag(Version::GLES200, Shader::Type::Fragment);
#endif
vert.addSource(
"attribute lowp vec4 position;\n"
"void main() {\n"
" gl_Position = position;\n"
"}\n");
frag.addSource(
"void main() {\n"
" gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n"
"}\n");
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
attachShaders({vert, frag});
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
explicit XfbInterleavedShader() {
#ifndef MAGNUM_TARGET_GLES
Shader vert(Version::GL300, Shader::Type::Vertex);
#else
Shader vert(Version::GLES300, Shader::Type::Vertex);
Shader frag(Version::GLES300, Shader::Type::Fragment);
#endif
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.addSource(
"in mediump vec2 inputData;\n"
"out mediump vec2 output1;\n"
"out mediump float output2;\n"
"void main() {\n"
" output1 = inputData + vec2(1.0, -1.0);\n"
" output2 = inputData.x - inputData.y + 5.0;\n"
"}\n").compile());
#ifndef MAGNUM_TARGET_GLES
attachShader(vert);
#else
/* ES for some reason needs both vertex and fragment shader */
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.addSource("void main() {}\n").compile());
attachShaders({vert, frag});
#endif
bindAttributeLocation(Input::Location, "inputData");
setTransformFeedbackOutputs({"output1", "gl_SkipComponents1", "output2"}, TransformFeedbackBufferMode::InterleavedAttributes);
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
void FreeTypeFont::doFillGlyphCache(GlyphCache& cache, const std::vector<char32_t>& characters)
#endif
{
/** @bug Crash when atlas is too small */
/* Get glyph codes from characters */
std::vector<FT_UInt> charIndices;
charIndices.resize(characters.size()+1);
charIndices[0] = 0;
std::transform(characters.begin(), characters.end(), charIndices.begin()+1,
[this](const char32_t c) { return FT_Get_Char_Index(ftFont, c); });
/* Remove duplicates (e.g. uppercase and lowercase mapped to same glyph) */
std::sort(charIndices.begin(), charIndices.end());
charIndices.erase(std::unique(charIndices.begin(), charIndices.end()), charIndices.end());
/* Sizes of all characters */
std::vector<Vector2i> charSizes;
charSizes.reserve(charIndices.size());
for(FT_UInt c: charIndices) {
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Load_Glyph(ftFont, c, FT_LOAD_DEFAULT) == 0);
charSizes.push_back(Vector2i(ftFont->glyph->metrics.width, ftFont->glyph->metrics.height)/64);
}
/* Create texture atlas */
const std::vector<Rectanglei> charPositions = cache.reserve(charSizes);
/* Render all characters to the atlas and create character map */
unsigned char* pixmap = new unsigned char[cache.textureSize().product()]();
/** @todo Some better way for this */
#ifndef MAGNUM_TARGET_GLES2
Image2D image(ImageFormat::Red, ImageType::UnsignedByte, cache.textureSize(), pixmap);
#else
Image2D image(Context::current() && Context::current()->isExtensionSupported<Extensions::GL::EXT::texture_rg>() ?
ImageFormat::Red : ImageFormat::Luminance, ImageType::UnsignedByte, cache.textureSize(), pixmap);
#endif
for(std::size_t i = 0; i != charPositions.size(); ++i) {
/* Load and render glyph */
/** @todo B&W only if radius != 0 */
FT_GlyphSlot glyph = ftFont->glyph;
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Load_Glyph(ftFont, charIndices[i], FT_LOAD_DEFAULT) == 0);
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Render_Glyph(glyph, FT_RENDER_MODE_NORMAL) == 0);
/* Copy rendered bitmap to texture image */
const FT_Bitmap& bitmap = glyph->bitmap;
CORRADE_INTERNAL_ASSERT(std::abs(bitmap.width-charPositions[i].width()) <= 2);
CORRADE_INTERNAL_ASSERT(std::abs(bitmap.rows-charPositions[i].height()) <= 2);
for(Int yin = 0, yout = charPositions[i].bottom(), ymax = bitmap.rows; yin != ymax; ++yin, ++yout)
for(Int xin = 0, xout = charPositions[i].left(), xmax = bitmap.width; xin != xmax; ++xin, ++xout)
pixmap[yout*cache.textureSize().x() + xout] = bitmap.buffer[(bitmap.rows-yin-1)*bitmap.width + xin];
/* Insert glyph parameters into cache */
cache.insert(charIndices[i],
Vector2i(glyph->bitmap_left, glyph->bitmap_top-charPositions[i].height()),
charPositions[i]);
}
/* Set cache image */
cache.setImage({}, image);
}
template<UnsignedInt dimensions> DistanceFieldVector<dimensions>::DistanceFieldVector(): transformationProjectionMatrixUniform(0), colorUniform(1), outlineColorUniform(2), outlineRangeUniform(3), smoothnessUniform(4) {
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current()->supportedVersion({Version::GL320, Version::GL310, Version::GL300, Version::GL210});
#else
const Version version = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader frag(version, Shader::Type::Vertex);
frag.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("generic.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
AbstractShaderProgram::attachShader(frag);
Shader vert(version, Shader::Type::Fragment);
vert.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("DistanceFieldVector.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
AbstractShaderProgram::attachShader(vert);
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::Position::Location, "position");
AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::TextureCoordinates::Location, "textureCoordinates");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(AbstractShaderProgram::link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationProjectionMatrixUniform = AbstractShaderProgram::uniformLocation("transformationProjectionMatrix");
colorUniform = AbstractShaderProgram::uniformLocation("color");
outlineColorUniform = AbstractShaderProgram::uniformLocation("outlineColor");
outlineRangeUniform = AbstractShaderProgram::uniformLocation("outlineRange");
smoothnessUniform = AbstractShaderProgram::uniformLocation("smoothness");
}
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>(version))
#endif
{
AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"),
AbstractVector<dimensions>::VectorTextureLayer);
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
setOutlineRange(0.5f, 1.0f);
setSmoothness(0.04f);
#endif
}
template<UnsignedInt dimensions> Flat<dimensions>::Flat(const Flags flags): transformationProjectionMatrixUniform(0), colorUniform(1), _flags(flags) {
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current()->supportedVersion({Version::GL320, Version::GL310, Version::GL300, Version::GL210});
#else
const Version version = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert(version, Shader::Type::Vertex);
vert.addSource(flags & Flag::Textured ? "#define TEXTURED\n" : "")
.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("generic.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
attachShader(vert);
Shader frag(version, Shader::Type::Fragment);
frag.addSource(flags & Flag::Textured ? "#define TEXTURED\n" : "")
.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("Flat.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
attachShader(frag);
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
if(flags & Flag::Textured) bindAttributeLocation(TextureCoordinates::Location, "textureCoordinates");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
colorUniform = uniformLocation("color");
}
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>(version))
#endif
{
if(flags & Flag::Textured) setUniform(uniformLocation("textureData"), TextureLayer);
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
setColor(Color4(1.0f)); // Default to white, with full transperancy (so we can see the texture)
#endif
}
template<UnsignedInt dimensions> Vector<dimensions>::Vector(): transformationProjectionMatrixUniform(0), backgroundColorUniform(1), colorUniform(2) {
#ifdef MAGNUM_BUILD_STATIC
/* Import resources on static build, if not already */
if(!Utility::Resource::hasGroup("MagnumShaders"))
importShaderResources();
#endif
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current()->supportedVersion({Version::GL320, Version::GL310, Version::GL300, Version::GL210});
#else
const Version version = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert = Implementation::createCompatibilityShader(rs, version, Shader::Type::Vertex);
Shader frag = Implementation::createCompatibilityShader(rs, version, Shader::Type::Fragment);
vert.addSource(rs.get("generic.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
frag.addSource(rs.get("Vector.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
AbstractShaderProgram::attachShaders({vert, frag});
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::Position::Location, "position");
AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::TextureCoordinates::Location, "textureCoordinates");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(AbstractShaderProgram::link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationProjectionMatrixUniform = AbstractShaderProgram::uniformLocation("transformationProjectionMatrix");
backgroundColorUniform = AbstractShaderProgram::uniformLocation("backgroundColor");
colorUniform = AbstractShaderProgram::uniformLocation("color");
}
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>(version))
#endif
{
AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), AbstractVector<dimensions>::VectorTextureLayer);
}
}
explicit MyShader() {
Shader vert(Version::GL210, Shader::Type::Vertex);
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.addSource(
"attribute lowp vec4 position;\n"
"void main() {\n"
" gl_Position = position;\n"
"}\n").compile());
attachShader(vert);
bindAttributeLocation(Position::Location, "position");
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
template<UnsignedInt dimensions> Vector<dimensions>::Vector(): transformationProjectionMatrixUniform(0), colorUniform(1) {
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
Version v = Context::current()->supportedVersion({Version::GL320, Version::GL210});
#else
Version v = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert(v, Shader::Type::Vertex);
vert.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
AbstractShaderProgram::attachShader(vert);
Shader frag(v, Shader::Type::Fragment);
frag.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("Vector.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
AbstractShaderProgram::attachShader(frag);
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>() ||
Context::current()->version() == Version::GL210)
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::Position::Location, "position");
AbstractShaderProgram::bindAttributeLocation(AbstractVector<dimensions>::TextureCoordinates::Location, "textureCoordinates");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(AbstractShaderProgram::link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>())
#endif
{
transformationProjectionMatrixUniform = AbstractShaderProgram::uniformLocation("transformationProjectionMatrix");
colorUniform = AbstractShaderProgram::uniformLocation("color");
}
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>())
#endif
{
AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), AbstractVector<dimensions>::VectorTextureLayer);
}
}
bool Configuration::parse(std::istream& in) {
try {
/* It looks like BOM */
if(in.peek() == String::Bom[0]) {
char bom[4];
in.get(bom, 4);
/* This is not a BOM, rewind back */
if(bom != String::Bom) in.seekg(0);
/* Or set flag */
else _flags |= InternalFlag::HasBom;
}
/* Parse file */
CORRADE_INTERNAL_ASSERT_OUTPUT(parse(in, this, {}).empty());
} catch(std::string e) {
Error() << "Utility::Configuration::Configuration():" << e;
clear();
return false;
}
return true;
}
std::string Directory::executableLocation() {
/* Linux */
#if defined(__linux__)
/* Reallocate like hell until we have enough place to store the path. Can't
use lstat because the /proc/self/exe symlink is not a real symlink and
so stat::st_size returns 0. POSIX, WHAT THE HELL. */
constexpr const char self[]{"/proc/self/exe"};
std::string path(4, '\0');
ssize_t size;
while((size = readlink(self, &path[0], path.size())) == ssize_t(path.size()))
path.resize(path.size()*2);
CORRADE_INTERNAL_ASSERT(size > 0);
path.resize(size);
return path;
/* OSX, iOS */
#elif defined(CORRADE_TARGET_APPLE)
/* Get path size (need to set it to 0 to avoid filling nullptr with random
data and crashing) */
std::uint32_t size = 0;
CORRADE_INTERNAL_ASSERT_OUTPUT(_NSGetExecutablePath(nullptr, &size) == -1);
/* Allocate proper size and get the path */
std::string path(size, '\0');
CORRADE_INTERNAL_ASSERT_OUTPUT(_NSGetExecutablePath(&path[0], &size) == 0);
return path;
/* Windows (not RT) */
#elif defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT)
HMODULE module = GetModuleHandle(nullptr);
std::string path(MAX_PATH, '\0');
std::size_t size = GetModuleFileName(module, &path[0], path.size());
path.resize(size);
return fromNativeSeparators(path);
/* hardcoded for Emscripten */
#elif defined(CORRADE_TARGET_EMSCRIPTEN)
return "/app.js";
/* Not implemented */
#else
return std::string{};
#endif
}
template<UnsignedInt dimensions> VertexColor<dimensions>::VertexColor(): transformationProjectionMatrixUniform(0) {
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current()->supportedVersion({Version::GL310, Version::GL300, Version::GL210});
#else
const Version version = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert(version, Shader::Type::Vertex);
vert.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
attachShader(vert);
Shader frag(version, Shader::Type::Fragment);
frag.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("VertexColor.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
attachShader(frag);
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
bindAttributeLocation(Color::Location, "color");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
setTransformationProjectionMatrix(typename DimensionTraits<dimensions, Float>::MatrixType());
#endif
}
void GlyphCache::insert(const UnsignedInt glyph, const Vector2i& position, const Range2Di& rectangle) {
const std::pair<Vector2i, Range2Di> glyphData = {position-_padding, rectangle.padded(_padding)};
/* Overwriting "Not Found" glyph */
if(glyph == 0) glyphs[0] = glyphData;
/* Inserting new glyph */
else CORRADE_INTERNAL_ASSERT_OUTPUT(glyphs.insert({glyph, glyphData}).second);
}
MotionBlurCamera::MotionBlurShader::MotionBlurShader() {
Utility::Resource rs("shaders");
GL::Shader vert(GL::Version::GL330, GL::Shader::Type::Vertex);
GL::Shader frag(GL::Version::GL330, GL::Shader::Type::Fragment);
vert.addSource(rs.get("MotionBlurShader.vert"));
frag.addSource(rs.get("MotionBlurShader.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, frag}));
attachShaders({vert, frag});
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
for(Int i = 0; i != MotionBlurCamera::FrameCount; ++i)
setUniform(uniformLocation(Utility::formatString("frame[{}]", i)), i);
}
ShadowCasterShader::ShadowCasterShader() {
MAGNUM_ASSERT_GL_VERSION_SUPPORTED(GL::Version::GL330);
const Utility::Resource rs{"shadow-data"};
GL::Shader vert{GL::Version::GL330, GL::Shader::Type::Vertex};
GL::Shader frag{GL::Version::GL330, GL::Shader::Type::Fragment};
vert.addSource(rs.get("ShadowCaster.vert"));
frag.addSource(rs.get("ShadowCaster.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(GL::Shader::compile({vert, frag}));
attachShaders({vert, frag});
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
_transformationMatrixUniform = uniformLocation("transformationMatrix");
}
MyShader::MyShader() {
Utility::Resource rs("QueryGLTest");
#ifndef MAGNUM_TARGET_GLES
Shader vert(Version::GL210, Shader::Type::Vertex);
Shader frag(Version::GL210, Shader::Type::Fragment);
#else
Shader vert(Version::GLES200, Shader::Type::Vertex);
Shader frag(Version::GLES200, Shader::Type::Fragment);
#endif
vert.addSource(rs.get("MyShader.vert"));
frag.addSource(rs.get("MyShader.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
attachShaders({vert, frag});
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
template<UnsignedInt dimensions> Flat<dimensions>::Flat(): transformationProjectionMatrixUniform(0), colorUniform(1) {
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
Version v = Context::current()->supportedVersion({Version::GL320, Version::GL210});
#else
Version v = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader frag(v, Shader::Type::Vertex);
frag.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get(vertexShaderName<dimensions>()));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
attachShader(frag);
Shader vert(v, Shader::Type::Fragment);
vert.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("Flat.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
attachShader(vert);
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>() ||
Context::current()->version() == Version::GL210)
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>())
#endif
{
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
colorUniform = uniformLocation("color");
}
}
TexturedTriangleShader::TexturedTriangleShader() {
MAGNUM_ASSERT_VERSION_SUPPORTED(Version::GL330);
Utility::Resource rs("data");
Shader vert(Version::GL330, Shader::Type::Vertex);
vert.addSource(rs.get("TexturedTriangleShader.vert"));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
attachShader(vert);
Shader frag(Version::GL330, Shader::Type::Fragment);
frag.addSource(rs.get("TexturedTriangleShader.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
attachShader(frag);
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
colorUniform = uniformLocation("color");
setUniform(uniformLocation("textureData"), TextureLayer);
}
TexturedTriangleShader::TexturedTriangleShader() {
MAGNUM_ASSERT_VERSION_SUPPORTED(Version::GL330);
const Utility::Resource rs{"textured-triangle-data"};
Shader vert{Version::GL330, Shader::Type::Vertex};
Shader frag{Version::GL330, Shader::Type::Fragment};
vert.addSource(rs.get("TexturedTriangleShader.vert"));
frag.addSource(rs.get("TexturedTriangleShader.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
attachShaders({vert, frag});
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
_colorUniform = uniformLocation("color");
setUniform(uniformLocation("textureData"), TextureLayer);
}
explicit MyShader() {
#ifndef MAGNUM_TARGET_GLES
Shader vert(Version::GL300, Shader::Type::Vertex);
#else
Shader vert(Version::GLES300, Shader::Type::Vertex);
Shader frag(Version::GLES300, Shader::Type::Fragment);
#endif
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.addSource(
"out mediump vec2 outputData;\n"
"void main() {\n"
" outputData = vec2(1.0, -1.0);\n"
"}\n").compile());
#ifndef MAGNUM_TARGET_GLES
attachShader(vert);
#else
/* ES for some reason needs both vertex and fragment shader */
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.addSource("void main() {}\n").compile());
attachShaders({vert, frag});
#endif
setTransformFeedbackOutputs({"outputData"}, TransformFeedbackBufferMode::SeparateAttributes);
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
}
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<GL::Mesh>("cube"))) {
Trade::MeshData3D cubeData = Primitives::cubeSolid();
MeshTools::flipFaceWinding(cubeData.indices());
GL::Buffer* buffer = new GL::Buffer;
buffer->setData(MeshTools::interleave(cubeData.positions(0)), GL::BufferUsage::StaticDraw);
Containers::Array<char> indexData;
MeshIndexType indexType;
UnsignedInt indexStart, indexEnd;
std::tie(indexData, indexType, indexStart, indexEnd) = MeshTools::compressIndices(cubeData.indices());
GL::Buffer* indexBuffer = new GL::Buffer;
indexBuffer->setData(indexData, GL::BufferUsage::StaticDraw);
GL::Mesh* mesh = new GL::Mesh;
mesh->setPrimitive(cubeData.primitive())
.setCount(cubeData.indices().size())
.addVertexBuffer(*buffer, 0, CubeMapShader::Position{})
.setIndexBuffer(*indexBuffer, 0, indexType, indexStart, indexEnd);
resourceManager.set("cube-buffer", buffer, ResourceDataState::Final, ResourcePolicy::Resident)
.set("cube-index-buffer", indexBuffer, ResourceDataState::Final, ResourcePolicy::Resident)
.set(_cube.key(), mesh, ResourceDataState::Final, ResourcePolicy::Resident);
}
/* Cube map texture */
if(!(_texture = resourceManager.get<GL::CubeMapTexture>("texture"))) {
GL::CubeMapTexture* cubeMap = new GL::CubeMapTexture;
cubeMap->setWrapping(GL::SamplerWrapping::ClampToEdge)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setMinificationFilter(GL::SamplerFilter::Linear, GL::SamplerMipmap::Linear);
Resource<Trade::AbstractImporter> importer = resourceManager.get<Trade::AbstractImporter>("jpeg-importer");
/* Configure texture storage using size of first image */
importer->openFile(prefix + "+x.jpg");
Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
CORRADE_INTERNAL_ASSERT(image);
Vector2i size = image->size();
cubeMap->setStorage(Math::log2(size.min())+1, GL::TextureFormat::RGB8, size)
.setSubImage(GL::CubeMapCoordinate::PositiveX, 0, {}, *image);
importer->openFile(prefix + "-x.jpg");
CORRADE_INTERNAL_ASSERT_OUTPUT(image = importer->image2D(0));
cubeMap->setSubImage(GL::CubeMapCoordinate::NegativeX, 0, {}, *image);
importer->openFile(prefix + "+y.jpg");
CORRADE_INTERNAL_ASSERT_OUTPUT(image = importer->image2D(0));
cubeMap->setSubImage(GL::CubeMapCoordinate::PositiveY, 0, {}, *image);
importer->openFile(prefix + "-y.jpg");
CORRADE_INTERNAL_ASSERT_OUTPUT(image = importer->image2D(0));
cubeMap->setSubImage(GL::CubeMapCoordinate::NegativeY, 0, {}, *image);
importer->openFile(prefix + "+z.jpg");
CORRADE_INTERNAL_ASSERT_OUTPUT(image = importer->image2D(0));
cubeMap->setSubImage(GL::CubeMapCoordinate::PositiveZ, 0, {}, *image);
importer->openFile(prefix + "-z.jpg");
CORRADE_INTERNAL_ASSERT_OUTPUT(image = importer->image2D(0));
cubeMap->setSubImage(GL::CubeMapCoordinate::NegativeZ, 0, {}, *image);
cubeMap->generateMipmap();
resourceManager.set(_texture.key(), cubeMap, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* Shader */
if(!(_shader = resourceManager.get<GL::AbstractShaderProgram, CubeMapShader>("shader")))
resourceManager.set<GL::AbstractShaderProgram>(_shader.key(), new CubeMapShader, ResourceDataState::Final, ResourcePolicy::Manual);
}
void FreeTypeFont::doClose() {
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Done_Face(ftFont) == 0);
_data = nullptr;
ftFont = nullptr;
}
void FreeTypeFont::finalize() {
if(!library) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Done_FreeType(library) == 0);
library = nullptr;
}
void FreeTypeFont::initialize() {
if(library) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Init_FreeType(&library) == 0);
}
MeshVisualizer::MeshVisualizer(const Flags flags): flags(flags), transformationProjectionMatrixUniform(0), viewportSizeUniform(1), colorUniform(2), wireframeColorUniform(3), wireframeWidthUniform(4), smoothnessUniform(5) {
#ifndef MAGNUM_TARGET_GLES
if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader)) {
MAGNUM_ASSERT_VERSION_SUPPORTED(Version::GL320);
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::geometry_shader4);
}
#elif defined(MAGNUM_TARGET_GLES2)
if(flags & Flag::Wireframe)
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::OES::standard_derivatives);
#endif
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current()->supportedVersion({Version::GL320, Version::GL310, Version::GL300, Version::GL210});
CORRADE_INTERNAL_ASSERT_OUTPUT(flags & Flag::NoGeometryShader || version >= Version::GL320);
#else
const Version version = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert = Implementation::createCompatibilityShader(rs, version, Shader::Type::Vertex);
Shader frag = Implementation::createCompatibilityShader(rs, version, Shader::Type::Fragment);
vert.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
#ifdef MAGNUM_TARGET_WEBGL
.addSource("#define SUBSCRIPTING_WORKAROUND\n")
#elif defined(MAGNUM_TARGET_GLES2)
.addSource(Context::current()->detectedDriver() & Context::DetectedDriver::ProbablyAngle ?
"#define SUBSCRIPTING_WORKAROUND\n" : "")
#endif
.addSource(rs.get("generic.glsl"))
.addSource(rs.get("MeshVisualizer.vert"));
frag.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
.addSource(rs.get("MeshVisualizer.frag"));
#ifndef MAGNUM_TARGET_GLES
std::optional<Shader> geom;
if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader)) {
geom = Implementation::createCompatibilityShader(rs, version, Shader::Type::Geometry);
geom->addSource(rs.get("MeshVisualizer.geom"));
}
#endif
#ifndef MAGNUM_TARGET_GLES
if(geom) Shader::compile({vert, *geom, frag});
else
#endif
Shader::compile({vert, frag});
attachShaders({vert, frag});
#ifndef MAGNUM_TARGET_GLES
if(geom) attachShader(*geom);
#endif
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isVersionSupported(Version::GL310))
#endif
{
bindAttributeLocation(VertexIndex::Location, "vertexIndex");
}
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
colorUniform = uniformLocation("color");
if(flags & Flag::Wireframe) {
wireframeColorUniform = uniformLocation("wireframeColor");
wireframeWidthUniform = uniformLocation("wireframeWidth");
smoothnessUniform = uniformLocation("smoothness");
if(!(flags & Flag::NoGeometryShader))
viewportSizeUniform = uniformLocation("viewportSize");
}
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
setColor(Color3(1.0f));
if(flags & Flag::Wireframe) {
setWireframeColor(Color3(0.0f));
setWireframeWidth(1.0f);
setSmoothness(2.0f);
}
#endif
}
MeshVisualizer::MeshVisualizer(const Flags flags): flags(flags), transformationProjectionMatrixUniform(0), viewportSizeUniform(1), colorUniform(2), wireframeColorUniform(3), wireframeWidthUniform(4), smoothnessUniform(5) {
#ifndef MAGNUM_TARGET_GLES
if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader))
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::geometry_shader4);
#elif defined(MAGNUM_TARGET_GLES2)
if(flags & Flag::Wireframe)
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::OES::standard_derivatives);
#endif
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version v = Context::current()->supportedVersion({Version::GL320, Version::GL310, Version::GL210});
#else
const Version v = Context::current()->supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert(v, Shader::Type::Vertex);
vert.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("MeshVisualizer.vert"));
CORRADE_INTERNAL_ASSERT_OUTPUT(vert.compile());
vert.compile();
attachShader(vert);
#ifndef MAGNUM_TARGET_GLES
if(flags & Flag::Wireframe && !(flags & Flag::NoGeometryShader)) {
Shader geom(v, Shader::Type::Geometry);
geom.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("MeshVisualizer.geom"));
CORRADE_INTERNAL_ASSERT_OUTPUT(geom.compile());
geom.compile();
attachShader(geom);
}
#endif
Shader frag(v, Shader::Type::Fragment);
frag.addSource(flags & Flag::Wireframe ? "#define WIREFRAME_RENDERING\n" : "")
.addSource(flags & Flag::NoGeometryShader ? "#define NO_GEOMETRY_SHADER\n" : "")
.addSource(rs.get("compatibility.glsl"))
.addSource(rs.get("MeshVisualizer.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(frag.compile());
frag.compile();
attachShader(frag);
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>() ||
Context::current()->version() == Version::GL210)
#else
if(!Context::current()->isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isVersionSupported(Version::GL310))
#endif
{
bindAttributeLocation(VertexIndex::Location, "vertexIndex");
}
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
link();
#ifndef MAGNUM_TARGET_GLES
if(!Context::current()->isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>())
#endif
{
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
colorUniform = uniformLocation("color");
if(flags & Flag::Wireframe) {
wireframeColorUniform = uniformLocation("wireframeColor");
wireframeWidthUniform = uniformLocation("wireframeWidth");
smoothnessUniform = uniformLocation("smoothness");
if(!(flags & Flag::NoGeometryShader))
viewportSizeUniform = uniformLocation("viewportSize");
}
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
setColor(Color3<>(1.0f));
if(flags & Flag::Wireframe) {
setWireframeColor(Color3<>(0.0f));
setWireframeWidth(1.0f);
setSmoothness(2.0f);
}
#endif
}
Phong::Phong(const Flags flags): transformationMatrixUniform(0), projectionMatrixUniform(1), normalMatrixUniform(2), lightUniform(3), diffuseColorUniform(4), ambientColorUniform(5), specularColorUniform(6), lightColorUniform(7), shininessUniform(8), _flags(flags) {
#ifdef MAGNUM_BUILD_STATIC
/* Import resources on static build, if not already */
if(!Utility::Resource::hasGroup("MagnumShaders"))
importShaderResources();
#endif
Utility::Resource rs("MagnumShaders");
#ifndef MAGNUM_TARGET_GLES
const Version version = Context::current().supportedVersion({Version::GL320, Version::GL310, Version::GL300, Version::GL210});
#else
const Version version = Context::current().supportedVersion({Version::GLES300, Version::GLES200});
#endif
Shader vert = Implementation::createCompatibilityShader(rs, version, Shader::Type::Vertex);
Shader frag = Implementation::createCompatibilityShader(rs, version, Shader::Type::Fragment);
vert.addSource(flags ? "#define TEXTURED\n" : "")
.addSource(rs.get("generic.glsl"))
.addSource(rs.get("Phong.vert"));
frag.addSource(flags & Flag::AmbientTexture ? "#define AMBIENT_TEXTURE\n" : "")
.addSource(flags & Flag::DiffuseTexture ? "#define DIFFUSE_TEXTURE\n" : "")
.addSource(flags & Flag::SpecularTexture ? "#define SPECULAR_TEXTURE\n" : "")
.addSource(rs.get("Phong.frag"));
CORRADE_INTERNAL_ASSERT_OUTPUT(Shader::compile({vert, frag}));
attachShaders({vert, frag});
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::GL::ARB::explicit_attrib_location>(version))
#else
if(!Context::current().isVersionSupported(Version::GLES300))
#endif
{
bindAttributeLocation(Position::Location, "position");
bindAttributeLocation(Normal::Location, "normal");
if(flags) bindAttributeLocation(TextureCoordinates::Location, "textureCoordinates");
}
CORRADE_INTERNAL_ASSERT_OUTPUT(link());
#ifndef MAGNUM_TARGET_GLES
if(!Context::current().isExtensionSupported<Extensions::GL::ARB::explicit_uniform_location>(version))
#endif
{
transformationMatrixUniform = uniformLocation("transformationMatrix");
projectionMatrixUniform = uniformLocation("projectionMatrix");
normalMatrixUniform = uniformLocation("normalMatrix");
lightUniform = uniformLocation("light");
ambientColorUniform = uniformLocation("ambientColor");
diffuseColorUniform = uniformLocation("diffuseColor");
specularColorUniform = uniformLocation("specularColor");
lightColorUniform = uniformLocation("lightColor");
shininessUniform = uniformLocation("shininess");
}
#ifndef MAGNUM_TARGET_GLES
if(flags && !Context::current().isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>(version))
#endif
{
if(flags & Flag::AmbientTexture) setUniform(uniformLocation("ambientTexture"), AmbientTextureLayer);
if(flags & Flag::DiffuseTexture) setUniform(uniformLocation("diffuseTexture"), DiffuseTextureLayer);
if(flags & Flag::SpecularTexture) setUniform(uniformLocation("specularTexture"), SpecularTextureLayer);
}
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
/* Default to fully opaque white so we can see the textures */
if(flags & Flag::AmbientTexture) setAmbientColor(Color4{1.0f});
else setAmbientColor(Color4{0.0f, 1.0f});
if(flags & Flag::DiffuseTexture) setDiffuseColor(Color4{1.0f});
setSpecularColor(Color4{1.0f});
setLightColor(Color4{.0f});
setShininess(80.0f);
#endif
}
OpenGLFunctionLoader::OpenGLFunctionLoader() {
CORRADE_INTERNAL_ASSERT_OUTPUT(library = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY));
}
Vector2 FreeTypeFont::doGlyphAdvance(const UnsignedInt glyph) {
CORRADE_INTERNAL_ASSERT_OUTPUT(FT_Load_Glyph(ftFont, glyph, FT_LOAD_DEFAULT) == 0);
return Vector2(ftFont->glyph->advance.x, ftFont->glyph->advance.y)/64.0f;
}
