void GLSLShader::initialize()
{
//#0 PREPARE SHADER
GLuint vertexShader;
GLuint fragmentShader;
vertexShader = prepareShader("basicNew.vert", GLSL::VERTEX);
fragmentShader = prepareShader("basicNew.frag", GLSL::FRAGMENT);
//#1 CREATE PROGRAM HANDLER
programHandle = glCreateProgram();
//programHandle = glCreateProgram();
if(0 == programHandle)
{
logString += "Error creating program object\n";
exit(1);
}
//#2 ATTACH SHADER TO PROGRAM
glAttachShader( programHandle, fragmentShader );
glAttachShader( programHandle, vertexShader );
/////////////////////////////////////////////////////////////////////////////////////////////////////
std::vector<Eigen::Vector4f> vdata;
vdata.push_back(Eigen::Vector4f(-1, -1, 0, 1));
vdata.push_back(Eigen::Vector4f(1, -1, 0, 1));
vdata.push_back(Eigen::Vector4f(0, 1, 0, 1));
std::vector<Eigen::Vector4f> vdataColor;
vdataColor.push_back(Eigen::Vector4f(1, 0, 0, 1));
vdataColor.push_back(Eigen::Vector4f(0, 1, 0, 1));
vdataColor.push_back(Eigen::Vector4f(0, 0, 1, 1));
createVertexAttribute(0, "in_Vertex_Position", vdata);
// createVertexTFAttribute(0, "in_Vertex_Position", vdata);
size = vdata.size() * 4;
createVertexTFAttribute2("Color");
// createVertexAttribute(1, "in_Vertex_Color", vdataColor);
//////////////////////////////////////////////////////////////////////
//#3 LINK PROGRAM
link();
//#4 USE PROGRAM
if(isLinked())use();
printActiveAttribs();
}
void Shader::initialize()
{
//#0 PREPARE SHADER
GLuint vertexShader = prepareShader("basic.vert", GL_VERTEX_SHADER);
GLuint fragmentShader = prepareShader("basic.frag", GL_FRAGMENT_SHADER);
//#1 CREATE PROGRAM HANDLER
programHandle = glCreateProgram();
if(0 == programHandle)
{
std::cout << "Error creating program object" << std::endl;
exit(1);
}
//#2 ATTACH SHADER TO PROGRAM
glAttachShader( programHandle, fragmentShader );
glAttachShader( programHandle, vertexShader );
//#3 LINK PROGRAM
glLinkProgram(programHandle);
//#4 VERIFY LINK STATUS
GLint status;
glGetProgramiv(programHandle, GL_LINK_STATUS, &status);
if( GL_FALSE == status ) {
std::cout << "LINKING - FAILED TO LINKING SHADER PROGRAM" << std::endl;
GLint logLen;
glGetProgramiv(programHandle, GL_INFO_LOG_LENGTH, &logLen);
if(logLen > 0)
{
char *log = (char *)malloc(logLen);
GLsizei written;
glGetProgramInfoLog(programHandle, logLen, &written, log);
std::cout << "PROGRAM LINK FAIL LOG | " << log << std::endl;
}
} else {
std::cout << "OK - PROGRAM LINKED" << std::endl;
glUseProgram(programHandle);
}
preparePerVertexAttributes();
}
ShaderAtomicCounterOpsTestBase::ShaderPipeline::ShaderPipeline(glu::ShaderType testedShader, AtomicOperation* newOp)
: m_program(NULL), m_programCompute(NULL), m_testedShader(testedShader), m_atomicOp(newOp)
{
m_shaders[glu::SHADERTYPE_VERTEX] = "#version 450 core\n"
"<head>"
"in highp vec2 inPosition;\n"
"out highp vec3 vsPosition;\n"
"out highp vec4 vsColor;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(inPosition, 0.0, 1.0);\n"
" vsPosition = vec3(inPosition, 0.0);\n"
" vec4 outColor = vec4(1.0);\n"
"<atomic_operation>"
" vsColor = outColor;\n"
"}\n";
m_shaders[glu::SHADERTYPE_FRAGMENT] = "#version 450 core\n"
"<head>"
"in highp vec4 gsColor;\n"
"out highp vec4 fsColor;\n"
"void main()\n"
"{\n"
" vec4 outColor = gsColor; \n"
"<atomic_operation>"
" fsColor = outColor;\n"
"}\n";
m_shaders[glu::SHADERTYPE_TESSELLATION_CONTROL] = "#version 450 core\n"
"<head>"
"layout(vertices = 3) out;\n"
"in highp vec4 vsColor[];\n"
"in highp vec3 vsPosition[];\n"
"out highp vec3 tcsPosition[];\n"
"out highp vec4 tcsColor[];\n"
"void main()\n"
"{\n"
" tcsPosition[gl_InvocationID] = vsPosition[gl_InvocationID];\n"
" vec4 outColor = vsColor[gl_InvocationID];\n"
"<atomic_operation>"
" tcsColor[gl_InvocationID] = outColor;\n"
" gl_TessLevelInner[0] = 3;\n"
" gl_TessLevelOuter[0] = 3;\n"
" gl_TessLevelOuter[1] = 3;\n"
" gl_TessLevelOuter[2] = 3;\n"
"}\n";
m_shaders[glu::SHADERTYPE_TESSELLATION_EVALUATION] = "#version 450 core\n"
"<head>"
"layout(triangles, equal_spacing, cw) in;\n"
"in highp vec3 tcsPosition[];\n"
"in highp vec4 tcsColor[];\n"
"out highp vec4 tesColor;\n"
"void main()\n"
"{\n"
" vec3 p0 = gl_TessCoord.x * tcsPosition[0];\n"
" vec3 p1 = gl_TessCoord.y * tcsPosition[1];\n"
" vec3 p2 = gl_TessCoord.z * tcsPosition[2];\n"
" vec4 outColor = tcsColor[0];\n"
"<atomic_operation>"
" tesColor = outColor;\n"
" gl_Position = vec4(normalize(p0 + p1 + p2), 1.0);\n"
"}\n";
m_shaders[glu::SHADERTYPE_GEOMETRY] = "#version 450 core\n"
"<head>"
"layout(triangles) in;\n"
"layout(triangle_strip, max_vertices = 3) out;\n"
"in highp vec4 tesColor[];\n"
"out highp vec4 gsColor;\n"
"void main()\n"
"{\n"
" for (int i = 0; i<3; i++)\n"
" {\n"
" gl_Position = gl_in[i].gl_Position;\n"
" vec4 outColor = tesColor[i];\n"
"<atomic_operation>"
" gsColor = outColor;\n"
" EmitVertex();\n"
" }\n"
" EndPrimitive();\n"
"}\n";
m_shaders[glu::SHADERTYPE_COMPUTE] = "#version 450 core\n"
"<head>"
"layout(rgba32f, binding = 2) writeonly uniform highp image2D destImage;\n"
"layout (local_size_x = 16, local_size_y = 16) in;\n"
"void main (void)\n"
"{\n"
" vec4 outColor = vec4(1.0);\n"
"<atomic_operation>"
" imageStore(destImage, ivec2(gl_GlobalInvocationID.xy), outColor);\n"
"}\n";
// prepare shaders
std::stringstream atomicOperationStream;
atomicOperationStream << "uint returned = " << m_atomicOp->getFunction() + "(counter, ";
if (m_atomicOp->getCompareValue() != 0)
{
atomicOperationStream << m_atomicOp->getCompareValue();
atomicOperationStream << "u, ";
}
atomicOperationStream << m_atomicOp->getParamValue();
atomicOperationStream << "u);\n";
atomicOperationStream << "uint after = atomicCounter(counter);\n";
if (m_atomicOp->shouldTestReturnValue())
{
atomicOperationStream << "if(after == returned) outColor = vec4(0.0f);\n";
}
atomicOperationStream << "atomicCounterIncrement(calls);\n";
std::string headString = "#extension GL_ARB_shader_atomic_counters: enable\n"
"#extension GL_ARB_shader_atomic_counter_ops: enable\n"
"layout (binding=0) uniform atomic_uint counter;\n"
"layout (binding=1) uniform atomic_uint calls;\n";
for (unsigned int i = 0; i < glu::SHADERTYPE_LAST; ++i)
{
prepareShader(m_shaders[i], "<head>", i == testedShader ? headString : "");
prepareShader(m_shaders[i], "<atomic_operation>", i == testedShader ? atomicOperationStream.str() : "");
}
}
