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; }