// Create shader program from vertex shader and fragment shader files
GLuint loadGLSLProgram(const char *vertFileName, const char *fragFileName)
{
GLint linked;
GLuint program;
program = glCreateProgram();
if (!attachShader(program, GL_VERTEX_SHADER, vertFileName)) {
glDeleteProgram(program);
fprintf(stderr, "Couldn't attach vertex shader from file %s\n", vertFileName);
return 0;
}
if (!attachShader(program, GL_FRAGMENT_SHADER, fragFileName)) {
glDeleteProgram(program);
fprintf(stderr, "Couldn't attach fragment shader from file %s\n", fragFileName);
return 0;
}
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked) {
glDeleteProgram(program);
char temp[256];
glGetProgramInfoLog(program, 256, 0, temp);
fprintf(stderr, "Failed to link program: %s\n", temp);
return 0;
}
return program;
}
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);
}
bool GLProgram::load(std::string vshPath,std::string fshPath){
if(!create())return false;
if(!m_Vsh.load(GL_VERTEX_SHADER,vshPath)){
release();
return false;
}
if(!m_Fsh.load(GL_FRAGMENT_SHADER,fshPath)){
release();
return false;
}
attachShader(m_Vsh);
attachShader(m_Fsh);
onPreLink();
if(!link()){
release();
return false;
}
onPostLink();
detachShader(m_Vsh);
detachShader(m_Fsh);
m_Vsh.release();
m_Fsh.release();
return true;
}
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
}
SpriteProgram::SpriteProgram() : ShaderProgram(2)
{
attachShader("sprite.vs");
attachShader("sprite.fs");
glBindAttribLocation(handle(), VERTEX, "CornerVertex");
glBindAttribLocation(handle(), TEXTURE, "TexCoord");
linkAndBind();
glUniform1i(mUniformTexture, 0);
}
CardProgram::CardProgram() : ShaderProgram(2)
{
attachShader("card.vs");
attachShader("card.fs");
glBindAttribLocation(handle(), VERTEX, "CardVertex");
glBindAttribLocation(handle(), TEXTURE, "CardTextureCoordinate");
linkAndBind();
glUniform1i(mUniformCardTexture, 0);
useTexture(true);
}
ColorCorrectionShader::ColorCorrectionShader() {
Corrade::Utility::Resource rs("shader");
attachShader(Shader::fromData(Version::GL330, Shader::Type::Vertex, rs.get("ColorCorrectionShader.vert")));
attachShader(Shader::fromData(Version::GL330, Shader::Type::Fragment, rs.get("ColorCorrectionShader.frag")));
link();
transformationProjectionMatrixUniform = uniformLocation("transformationProjectionMatrix");
setUniform(uniformLocation("textureData"), TextureLayer);
setUniform(uniformLocation("colorCorrectionTextureData"), ColorCorrectionTextureLayer);
}
Program(std::string vs, std::string fs, std::string feedbackVar) {
name = glCreateProgram();
std::string vs_src = readFile(vs);
std::string fs_src = readFile(fs);
attachShader(vs_src, GL_VERTEX_SHADER);
attachShader(fs_src, GL_FRAGMENT_SHADER);
if (feedbackVar.length() > 0) {
const GLchar* feedbackVaryings[] = { feedbackVar.c_str() };
glTransformFeedbackVaryings(name, 1, feedbackVaryings, GL_INTERLEAVED_ATTRIBS);
}
link();
}
/**
* Create a default SdkEnv instance
*/
SdkEnv* newDefaultSdkEnv()
{
SdkEnv *env = (SdkEnv *)calloc(1, sizeof(SdkEnv));
if (NULL == env){
return NULL;
}
if (initDefaultEGL(env) < 0) {
LogE("Failed initDefaultEGL\n");
freeSdkEnv(env);
return NULL;
}
chrbuf_t *userCmd = newChrbuf (USER_CMD_CAPABILITY);
if (NULL == userCmd) {
LogE ("Failed newChrbuf for userCmd\n");
freeSdkEnv (env);
return NULL;
}
env->userCmd = userCmd;
char *vertSource = NULL;
int count = readFile(VERT_SHADER_FILE, &vertSource);
if (count < 0) {
LogE("Failed open vertex shader file:%s\n", VERT_SHADER_FILE);
freeSdkEnv(env);
return NULL;
}
Log("Read %s OK.\n", VERT_SHADER_FILE);
env->userData.nVertSource = count;
env->userData.vertSource = vertSource;
char *fragSource = NULL;
count = readFile(FRAG_SHADER_FILE, &fragSource);
if (count < 0) {
LogE("Failed read fragment shader file:%s\n", FRAG_SHADER_FILE);
free (vertSource);
freeSdkEnv(env);
return NULL;
}
env->userData.nFragSource = count;
env->userData.fragSource = fragSource;
Log("Read %s OK.\n", FRAG_SHADER_FILE);
if (attachShader(env, vertSource, fragSource) < 0) {
LogE("Failed attachShader\n");
free (vertSource);
free (fragSource);
freeSdkEnv(env);
return NULL;
}
if (initGlBuffers (env) < 0) {
LogE ("Failed init OpenGL buffers.\n");
return NULL;
}
env->status = SDK_STATUS_OK;
return env;
}
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());
}
bool EndPatchProgram::loadShaders()
{
string vertSource, contSource, evalSource, geomSource, fragSource;
string directory = IOUtil::executionPath() + "\\Shaders\\";
if( ! IOUtil::readWholeFile( directory + "end_patch.vert", vertSource ) ||
! attachShader( vertSource, GL_VERTEX_SHADER ) )
{
return false;
}
if( ! IOUtil::readWholeFile( directory + "end_patch.frag", fragSource ) ||
! attachShader( fragSource, GL_FRAGMENT_SHADER ) )
{
return false;
}
return true;
}
void SGLShaderProgram::attachShader(SGLShader shader)
{
if(shader.type == GL_VERTEX_SHADER)
vertPath = shader.path;
else if(shader.type == GL_FRAGMENT_SHADER)
fragPath = shader.path;
attachShader(shader.shaderID);
}
TEST(ShaderLib,failLink)
{
constexpr auto *shaderName="Test5";
auto shader = ngl::ShaderLib::instance();
shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF);
constexpr auto Vertex="Test5Vert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX );
shader->loadShaderSource(Vertex,"files/vertLinkErr.glsl");
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
constexpr auto Fragment="Test5Frag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT );
shader->loadShaderSource(Fragment,"files/fragLinkErr.glsl");
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
shader->attachShaderToProgram(shaderName,Vertex);
shader->attachShaderToProgram(shaderName,Fragment);
EXPECT_FALSE(shader->linkProgramObject(shaderName))<<"This should not link as in and out don't match";
}
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
}
ShaderProgram::ShaderProgram(std::string name, std::vector<Shader> shaders) :
m_name(name),
m_linked(false)
{
m_ID = glCreateProgram();
for(unsigned int i=0; i<shaders.size(); i++){
attachShader(shaders.at(i));
}
}
void KisOpenGLHDRExposureProgram::createProgram()
{
KisOpenGLFragmentShader *shader = KisOpenGLFragmentShader::createFromSourceCodeFile("hdr_exposure.frag");
Q_CHECK_PTR(shader);
if (shader && shader->isValid()) {
attachShader(*shader);
link();
}
delete shader;
}
bool ShaderProgram::attachShaderFile(GLenum type, const char *source_file, GLuint *shader_id)
{
std::string source;
if (!utils::fs::loadFile(source_file, &source))
{
return false;
}
return attachShader(type, source.c_str(), shader_id);
}
TEST(ShaderLib,loadPartsFailFragment)
{
auto shader = ngl::ShaderLib::instance();
shader->createShaderProgram("Test4",ngl::ErrorExit::OFF);
constexpr auto Fragment="Test4Frag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT ,ngl::ErrorExit::OFF);
shader->loadShaderSource(Fragment,"files/fragErr.glsl");
EXPECT_FALSE(shader->compileShader(Fragment))<<"error compiling vert shader";
}
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");
}
}
ShaderProgram::ShaderProgram(std::string vertexshader,std::string fragmentshader)
{
// Initially, we have zero shaders attached to the program
m_shadercount = 0;
m_shaderProgramHandle = glCreateProgram();
//set up shaders
Shader vertexShader(GL_VERTEX_SHADER);
vertexShader.loadFromFile(SHADERS_PATH + vertexshader);
vertexShader.compile();
Shader fragmentShader(GL_FRAGMENT_SHADER);
fragmentShader.loadFromFile(SHADERS_PATH + fragmentshader);
fragmentShader.compile();
//set up shaderprogram
attachShader(vertexShader);
attachShader(fragmentShader);
link();
}
TEST(ShaderLib,loadPartsFailVertex)
{
auto shader = ngl::ShaderLib::instance();
shader->createShaderProgram("Test3",ngl::ErrorExit::OFF);
constexpr auto Vertex="Test3Vert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX ,ngl::ErrorExit::OFF);
shader->loadShaderSource(Vertex,"files/vertErr.glsl");
EXPECT_FALSE(shader->compileShader(Vertex))<<"error compiling vert shader";
}
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);
}
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());
}
TEST(ShaderLib,editShader)
{
auto shader = ngl::ShaderLib::instance();
auto *shaderName="Edit";
shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF);
constexpr auto Vertex="EditVert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX ,ngl::ErrorExit::OFF);
shader->loadShaderSource(Vertex,"files/EditVert.glsl");
EXPECT_TRUE(shader->editShader(Vertex,"@breakMe","1.0"))<<"edit shader set breakMe ";
EXPECT_TRUE(shader->editShader(Vertex,"@numLights","2"))<<"edit shader";
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
constexpr auto Fragment="EditFrag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT,ngl::ErrorExit::OFF );
shader->loadShaderSource(Fragment,"files/EditFrag.glsl");
EXPECT_TRUE(shader->editShader(Fragment,"@numLights","2"))<<"edit shader";
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
shader->attachShaderToProgram(shaderName,Vertex);
shader->attachShaderToProgram(shaderName,Fragment);
EXPECT_TRUE(shader->linkProgramObject(shaderName))<<"First Link";
(*shader)[shaderName]->use();
EXPECT_TRUE(shader->getCurrentShaderName()==shaderName);
// Now re-edit
shader->resetEdits(Vertex);
shader->resetEdits(Fragment);
EXPECT_TRUE(shader->editShader(Vertex,"@numLights","5"))<<"edit shader 2nd";
EXPECT_TRUE(shader->editShader(Vertex,"@breakMe","1.0"))<<"edit shader set breakMe 2nd";
EXPECT_TRUE(shader->editShader(Fragment,"@numLights","5"))<<"edit shader";
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
EXPECT_TRUE(shader->linkProgramObject(shaderName));
}
void
ShaderProgram::attachGeometryShader(PrimitiveType inputPrimitiveType,
PrimitiveType outputPrimitiveType,
int maxOutputVertices,
const char *shader)
{
attachShader(m_id, GL_GEOMETRY_SHADER_ARB, shader);
// set input/output primitive types
glProgramParameteriEXT(m_id, GL_GEOMETRY_INPUT_TYPE_EXT, primitiveTypeToGL(inputPrimitiveType));
glProgramParameteriEXT(m_id, GL_GEOMETRY_OUTPUT_TYPE_EXT, primitiveTypeToGL(outputPrimitiveType));
// set maximum output vertices
glProgramParameteriEXT(m_id, GL_GEOMETRY_VERTICES_OUT_EXT, maxOutputVertices);
}
TEST(ShaderLib,loadParts)
{
auto shader = ngl::ShaderLib::instance();
auto *shaderName="Test2";
shader->createShaderProgram(shaderName,ngl::ErrorExit::OFF);
constexpr auto Vertex="Test2Vert";
shader->attachShader( Vertex, ngl::ShaderType::VERTEX );
shader->loadShaderSource(Vertex,"files/vert.glsl");
EXPECT_TRUE(shader->compileShader(Vertex))<<"error compiling vert shader";
constexpr auto Fragment="Test2Frag";
shader->attachShader( Fragment, ngl::ShaderType::FRAGMENT );
shader->loadShaderSource(Fragment,"files/frag.glsl");
EXPECT_TRUE(shader->compileShader(Fragment))<<"error compiling vert shader";
shader->attachShaderToProgram(shaderName,Vertex);
shader->attachShaderToProgram(shaderName,Fragment);
EXPECT_TRUE(shader->linkProgramObject(shaderName));
(*shader)[shaderName]->use();
EXPECT_TRUE(shader->getCurrentShaderName()==shaderName);
}
bool ShaderProgram::initWitchShaderElements(const list<ShaderElement *> & shaderElements)
{
if (glIsProgram(_shaderProgramId = glCreateProgram()) != GL_TRUE)
{
return false;
}
for (auto item = shaderElements.begin(); item != shaderElements.end(); ++item)
{
if (!(*item)->_compile_pass())
{
continue;
}
attachShader(*(*item));
}
return true;
}
osg::Node* makeShadedSpheres()
{
int numSpheres = 5;
osg::Group* rootNode = new osg::Group;
{
osg::StateSet* ss = rootNode->getOrCreateStateSet();
//ss->addUniform( new osg::Uniform( "LightPosition", osg::Vec3(0,0,4) ) );
//ss->addUniform( new osg::Uniform( "Color2", osg::Vec3(0,1,0) ) );
}
osg::Geode* model = new osg::Geode();
model->addDrawable(new osg::ShapeDrawable( new osg::Sphere(osg::Vec3(0,0,0),1) ));
osg::Group* parent = rootNode;
for( int i = 0; i < numSpheres; ++i )
{
osg::PositionAttitudeTransform* xform = new osg::PositionAttitudeTransform();
xform->addChild( model );
parent->addChild( xform );
#if 0 //[
// absolute positioning of peers
xform->setPosition( osg::Vec3(i,0,0) * 2.2 );
#else
// relative positioning of children
xform->setPosition( osg::Vec3(1,0,0) * 2.2 );
parent = xform;
#endif //]
attachShader( xform, i );
}
return rootNode;
}
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());
}
/**
* attach fragment shader loaded from shader_file
*/
bool attachFragShader(const char *shader_file)
{
return attachShader(shader_file, GL_FRAGMENT_SHADER);
}
