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
}
void AlphaMaskTextureShader::load() {
addVertexShader("ark2d/shaders/alphamask/texture-glsl150-vertex.txt");
addFragmentShader("ark2d/shaders/alphamask/texture-glsl150-fragment.txt");
bindAttributeLocation(0, "ark_TextureId");
bindAttributeLocation(1, "ark_VertexPositionIn");
bindAttributeLocation(2, "ark_VertexNormalIn");
bindAttributeLocation(3, "ark_VertexTexCoordIn");
bindAttributeLocation(4, "ark_VertexColorIn");
bindFragmentDataLocation(0, "ark_FragColor");
link();
linkDX();
showAnyGlErrorAndExitMacro();
ShaderStore::getInstance()->addShader(m_programId, this);
RendererState::start(RendererState::SHADER, getId());
ark_ModelMatrix = getUniformVariable("ark_ModelMatrix");
ark_ViewMatrix = getUniformVariable("ark_ViewMatrix");
ark_ProjectionMatrix = getUniformVariable("ark_ProjectionMatrix");
ark_NormalMatrix = getUniformVariable("ark_NormalMatrix");
ark_TextureId = getUniformVariable("ark_TextureId");
ark_VertexPositionIn = 1;
ark_VertexNormalIn = 2;
ark_VertexTexCoordIn = 3;
ark_VertexColorIn = 4;
RendererState::start(RendererState::NONE);
}
bool link() override {
bindAttributeLocation("vCoord", vCoord);
bindAttributeLocation("vPosition", vPosition);
if (m_hasColor)
bindAttributeLocation("vColor", vColor);
return QOpenGLShaderProgram::link();
}
/*
* This function should set up which generic attribute attaches to which
* input variable of the vertex shader. I always make my vertex shaders
* use the same basic names (i.e "position" for positions...) so that it
* becomes trivial to attach vertex data to shaders, without having to
* mess around with layout qualifiers in the shaders themselves etc.
*/
void Shader::setDefaultAttributes() {
Renderer *renderer = Naquadah::getRenderer();
if (renderer != nullptr) {
bindAttributeLocation(program, VERTEX_BUFFER, "position");
bindAttributeLocation(program, UV_MAP_BUFFER, "uv_map");
bindAttributeLocation(program, NORMAL_BUFFER, "normal");
//renderer->bindAttributeLocation(program, LOC_TANGENT_BUFFER, "tangent");
}
}
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
}
bool PainterShaderProgram::link()
{
m_startTime = g_clock.seconds();
bindAttributeLocation(VERTEX_ATTR, "a_Vertex");
bindAttributeLocation(TEXCOORD_ATTR, "a_TexCoord");
if(ShaderProgram::link()) {
bind();
setupUniforms();
release();
return true;
}
return false;
}
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());
}
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 StencilShader::load() {
if (ARK2D::getPlatform() == ARK2D::PLATFORM_ANDROID) {
addVertexShader("ark2d/shaders/stencil/texture-glsles100-vertex.txt");
addFragmentShader("ark2d/shaders/stencil/texture-glsles100-fragment.txt");
} else {
addVertexShader("ark2d/shaders/stencil/texture-glsl150-vertex.txt");
bool err1 = hasError();
addFragmentShader("ark2d/shaders/stencil/texture-glsl150-fragment.txt");
bool err2 = hasError();
if (err1 || err2) {
addVertexShader("ark2d/shaders/stencil/texture-glsl130-vertex.txt");
addFragmentShader("ark2d/shaders/stencil/texture-glsl130-fragment.txt");
}
}
bindAttributeLocation(0, "ark_TextureId");
bindAttributeLocation(1, "ark_VertexPositionIn");
bindAttributeLocation(2, "ark_VertexNormalIn");
bindAttributeLocation(3, "ark_VertexTexCoordIn");
bindAttributeLocation(4, "ark_VertexColorIn");
bindFragmentDataLocation(0, "ark_FragColor");
link();
linkDX();
ShaderStore::getInstance()->addShader(m_programId, this);
RendererState::start(RendererState::SHADER, getId());
ark_ModelMatrix = getUniformVariable("ark_ModelMatrix");
ark_ViewMatrix = getUniformVariable("ark_ViewMatrix");
ark_ProjectionMatrix = getUniformVariable("ark_ProjectionMatrix");
ark_NormalMatrix = getUniformVariable("ark_NormalMatrix");
ark_TextureId = getUniformVariable("ark_TextureId");
ark_VertexPositionIn = 1;
ark_VertexNormalIn = 2;
ark_VertexTexCoordIn = 3;
ark_VertexColorIn = 4;
RendererState::start(RendererState::NONE);
}
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());
}
void Painter::initializeShaderPrograms()
{
auto gemProgram = new QOpenGLShaderProgram(this);
gemProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shader/gem.vert");
gemProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shader/gem.frag");
if (!gemProgram->link()) {
qDebug() << "Gem: Link failed";
}
gemProgram->bindAttributeLocation("a_vertex", 0);
gemProgram->bindAttributeLocation("a_normal", 1);
auto lightRayProgram = new QOpenGLShaderProgram(this);
lightRayProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shader/lightray.vert");
lightRayProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shader/lightray.frag");
if (!lightRayProgram->link()) {
qDebug() << "LightRay: Link failed";
}
lightRayProgram->bindAttributeLocation("a_vertex", 0);
lightRayProgram->bindAttributeLocation("a_color", 1);
m_shaderPrograms->insert(ShaderPrograms::GemProgram, gemProgram);
m_shaderPrograms->insert(ShaderPrograms::LighRayProgram, lightRayProgram);
auto sceneProgram = new QOpenGLShaderProgram(this);
sceneProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shader/scene.vert");
sceneProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shader/scene.frag");
if (!sceneProgram->link()) {
qDebug() << "Scene: Link failed";
}
sceneProgram->bindAttributeLocation("a_vertex", 0);
m_shaderPrograms->insert(ShaderPrograms::SceneProgram, sceneProgram);
}
void StereoBlitProgram::initializeShaders() {
glow::Shader* vertShader = glowutils::createShaderFromFile(GL_VERTEX_SHADER, "data/shader/blit/stereoblit.vert");
glow::Shader* fragShader = glowutils::createShaderFromFile(GL_FRAGMENT_SHADER, "data/shader/blit/stereoblit.frag");
bindAttributeLocation(ScreenQuad::VERTEX_ATTRIBUTE_LOCATION, "v_vertex");
attach(vertShader, fragShader);
link();
assert(checkLinkStatus());
bindFragDataLocation(0, "fragColor");
getUniform<GLint>("texture")->set(BlitProgram::TEXTURE_LOCATION);
}
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");
}
}
void PointLightingGeometryShader::load() {
setName("point-lighting-geometry");
bool err1 = false;
bool err2 = false;
if (ARK2D::getPlatform() == ARK2D::PLATFORM_ANDROID) {
addVertexShader("ark2d/shaders/point-lighting/geometry/glsles100-vertex.txt");
addFragmentShader("ark2d/shaders/point-lighting/geometry/glsles100-fragment.txt");
} else {
//addVertexShader("ark2d/shaders/point-lighting/geometry/glsl330-vertex.txt");
//bool err1 = hasError();
//addFragmentShader("ark2d/shaders/point-lighting/geometry/glsl330-fragment.txt");
//bool err2 = hasError();
//if (err1 || err2) {
err1 = false;
err2 = false;
addVertexShader("ark2d/shaders/point-lighting/geometry/glsl150-vertex.txt");
err1 = hasError();
addFragmentShader("ark2d/shaders/point-lighting/geometry/glsl150-fragment.txt");
err2 = hasError();
if (err1 || err2) {
addVertexShader("ark2d/shaders/point-lighting/geometry/glsl130-vertex.txt");
addFragmentShader("ark2d/shaders/point-lighting/geometry/glsl130-fragment.txt");
}
//}
}
ShaderStore::getInstance()->addShader(m_programId, this);
bindAttributeLocation(0, "ark_VertexPositionIn");
bindAttributeLocation(1, "ark_VertexNormalIn");
bindAttributeLocation(2, "ark_VertexColorIn");
bindFragmentDataLocation(0, "ark_FragColor");
link();
linkDX();
RendererState::start(RendererState::SHADER, getId());
ark_ModelMatrix = getUniformVariable("ark_ModelMatrix");
ark_ViewMatrix = getUniformVariable("ark_ViewMatrix");
ark_ProjectionMatrix = getUniformVariable("ark_ProjectionMatrix");
ark_NormalMatrix = getUniformVariable("ark_NormalMatrix");
_LightColor = getUniformVariable("u_sunlight.vColor");
_LightDirection = getUniformVariable("u_sunlight.vDirection");
_LightAmbientIntensity = getUniformVariable("u_sunlight.fAmbientIntensity");
_LightStrength = getUniformVariable("u_sunlight.fStrength");
_PointLightColor = getUniformVariable("u_pointlight.vColor");
_PointLightPosition = getUniformVariable("u_pointlight.vPosition");
_PointLightAmbient = getUniformVariable("u_pointlight.fAmbient");
_PointLightConstantAtt = getUniformVariable("u_pointlight.fConstantAtt");
_PointLightLinearAtt = getUniformVariable("u_pointlight.fLinearAtt");
_PointLightExpAtt = getUniformVariable("u_pointlight.fExpAtt");
ark_VertexPositionIn = 0;
ark_VertexNormalIn = 1;
ark_VertexColorIn = 2;
RendererState::start(RendererState::NONE);
}
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
}
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
}
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
}
