void GlShaderProgram::link() {
bool allShaderCompiled = true;
for (size_t i = 0 ; i < attachedShaders.size() ; ++i) {
if (!attachedShaders[i]->isCompiled()) {
allShaderCompiled = false;
}
if (attachedShaders[i]->getShaderType() == Geometry) {
glProgramParameteriEXT(programObjectId, GL_GEOMETRY_INPUT_TYPE_EXT, attachedShaders[i]->getInputPrimitiveType());
glProgramParameteriEXT(programObjectId, GL_GEOMETRY_OUTPUT_TYPE_EXT, attachedShaders[i]->getOutputPrimitiveType());
GLint maxOutputVertices = maxGeometryShaderOutputVertices;
if (maxOutputVertices == 0)
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &maxOutputVertices);
glProgramParameteriEXT(programObjectId, GL_GEOMETRY_VERTICES_OUT_EXT, maxOutputVertices);
}
}
glLinkProgram(programObjectId);
getInfoLog(programObjectId, PROGRAM, programLinkLog);
GLint linked;
glGetProgramiv(programObjectId, GL_LINK_STATUS, &linked);
programLinked = allShaderCompiled && linked > 0;
}
GLuint create_gs_program(const char *vertexfile, const char *geometryfile, const char *fragmentfile, GLint input, GLint output, GLint vertices) {
GLuint program = glCreateProgram();
GLuint shader;
if (vertexfile) {
shader = create_shader(vertexfile, GL_VERTEX_SHADER);
if (!shader)
return 0;
glAttachShader(program, shader);
}
if (geometryfile) {
shader = create_shader(geometryfile, GL_GEOMETRY_SHADER);
if (!shader)
return 0;
glAttachShader(program, shader);
glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT, input);
glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, output);
glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT, vertices);
}
if (fragmentfile) {
shader = create_shader(fragmentfile, GL_FRAGMENT_SHADER);
if (!shader)
return 0;
glAttachShader(program, shader);
}
glLinkProgram(program);
GLint link_ok = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
fprintf(stderr, "glLinkProgram:");
print_log(program);
glDeleteProgram(program);
return 0;
}
return program;
}
SafeShader::SafeShader( const char *vertexShader, const char *fragmentShader, const char *geometryShader, GLint geometryInputType, GLint geometryOutputType, GLint geometryOutputVertices)
{
try {
mObj = shared_ptr<Obj>( new Obj );
mObj->mHandle = glCreateProgram();
if ( vertexShader )
loadShader( vertexShader, GL_VERTEX_SHADER_ARB );
if( fragmentShader )
loadShader( fragmentShader, GL_FRAGMENT_SHADER_ARB );
if( geometryShader ) {
loadShader( geometryShader, GL_GEOMETRY_SHADER_EXT );
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_INPUT_TYPE_EXT, geometryInputType);
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_OUTPUT_TYPE_EXT, geometryOutputType);
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_VERTICES_OUT_EXT, geometryOutputVertices);
}
link();
}
catch( gl::GlslProgCompileExc exc ){
cout << exc.what() << endl;
}
}
bool createProgram(GLuint & program, GLuint vertexShader, GLuint fragShader, GLuint geometryShader, GLenum inputType, GLenum outputType, int vertOut)
{
program = glCreateProgram();
if(vertexShader)
{
glAttachShader(program,vertexShader);
}
if(fragShader)
{
glAttachShader(program,fragShader);
}
if(geometryShader)
{
glAttachShader(program,geometryShader);
glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT, inputType);
glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, outputType);
glProgramParameteriEXT(program,GL_GEOMETRY_VERTICES_OUT_EXT,vertOut);
}
glLinkProgram(program);
return checkProgram(program);
}
/////////////////////////////////////////////////////////
// LinkProgram
//
/////////////////////////////////////////////////////////
bool glsl_program :: LinkARB()
{
int i;
GLsizei length=0;
GLint infoLength;
if(m_programARB) {
glDeleteObjectARB( m_programARB );
gem::utils::glsl::delshader(m_programARB);
m_programARB = 0;
}
m_programARB = glCreateProgramObjectARB();
for (i = 0; i < m_num; i++)
{
glAttachObjectARB( m_programARB, m_shaderObjARB[i] );
}
/* setup geometry shader */
if(glProgramParameteriEXT) {
glProgramParameteriEXT(m_program,GL_GEOMETRY_INPUT_TYPE_EXT,m_geoInType);
glProgramParameteriEXT(m_program,GL_GEOMETRY_OUTPUT_TYPE_EXT,m_geoOutType);
int temp=m_geoOutVertices;
if(temp<0)
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp);
glProgramParameteriEXT(m_program,GL_GEOMETRY_VERTICES_OUT_EXT,temp);
}
glLinkProgramARB( m_programARB );
glGetObjectParameterivARB( m_programARB, GL_OBJECT_LINK_STATUS_ARB, &m_linked );
glGetObjectParameterivARB( m_programARB, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infoLength );
GLcharARB*infoLogARB = new GLcharARB[infoLength];
glGetInfoLogARB( m_programARB, infoLength, &length, infoLogARB );
if (length)
{
post("Info_log:");
post("%s", infoLogARB);
}
//post("freeing log");
if(infoLogARB)delete[]infoLogARB;infoLogARB=NULL;
//
// If all went well, make the ProgramObject part of the current state
//
//post("did we link?");
if (m_linked) {
glUseProgramObjectARB( m_programARB );
} else {
glUseProgramObjectARB( 0 );
post("ARB Link failed!");
return false;
}
return true;
}
/////////////////////////////////////////////////////////
// LinkProgram
//
/////////////////////////////////////////////////////////
bool glsl_program :: LinkGL2()
{
GLint infoLength;
GLsizei length=0;
int i;
if(m_program) {
glDeleteProgram( m_program );
gem::utils::glsl::delshader(m_program);
m_program = 0;
}
m_program = glCreateProgram();
for (i = 0; i < m_num; i++)
{
glAttachShader( m_program, m_shaderObj[i] );
}
/* setup geometry shader */
if(glProgramParameteriEXT) {
glProgramParameteriEXT(m_program,GL_GEOMETRY_INPUT_TYPE_EXT,m_geoInType);
glProgramParameteriEXT(m_program,GL_GEOMETRY_OUTPUT_TYPE_EXT,m_geoOutType);
int temp=m_geoOutVertices;
if(temp<0)
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp);
glProgramParameteriEXT(m_program,GL_GEOMETRY_VERTICES_OUT_EXT,temp);
}
glLinkProgram( m_program );
glGetProgramiv( m_program, GL_LINK_STATUS, &m_linked );
glGetProgramiv( m_program, GL_INFO_LOG_LENGTH, &infoLength );
GLchar *infoLog = new GLchar[infoLength];
glGetProgramInfoLog( m_program, infoLength, &length, infoLog );
if (length)
{
post("Info_log:");
post("%s", infoLog);
}
if(infoLog)delete[]infoLog;infoLog=NULL;
//
// If all went well, make the ProgramObject part of the current state
//
//post("did we link?");
if (m_linked) {
glUseProgram( m_program );
} else {
glUseProgram( 0 );
post("Link failed!");
return false;
}
return true;
}
void GPU_shader_geometry_stage_primitive_io(GPUShader *shader, int input, int output, int number)
{
if (GPU_geometry_shader_support_via_extension()) {
/* geometry shaders must provide this info themselves for #version 150 and up */
glProgramParameteriEXT(shader->program, GL_GEOMETRY_INPUT_TYPE_EXT, input);
glProgramParameteriEXT(shader->program, GL_GEOMETRY_OUTPUT_TYPE_EXT, output);
glProgramParameteriEXT(shader->program, GL_GEOMETRY_VERTICES_OUT_EXT, number);
}
}
void Shader::loadShader( const char *shader, GLint shaderType, GLint geometryInputType, GLint geometryOutputType, GLint geometryOutputVertices ){
GlslProg::loadShader( shader, shaderType );
if( shaderType == GL_GEOMETRY_SHADER_EXT ){
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_INPUT_TYPE_EXT, geometryInputType);
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_OUTPUT_TYPE_EXT, geometryOutputType);
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_VERTICES_OUT_EXT, geometryOutputVertices);
}
}
DualVertexRenderer::DualVertexRenderer(const HMesh::Manifold& m, VertexAttributeVector<Vec4d>& field)
{
// Create the program
static GLuint prog = glCreateProgram();
static bool was_here = false;
if(!was_here)
{
was_here = true;
// Create s haders directly from file
static GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, vss);
static GLuint gs = create_glsl_shader(GL_GEOMETRY_SHADER_EXT, gss);
static GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);
// Attach all shaders
if(vs) glAttachShader(prog, vs);
if(gs) glAttachShader(prog, gs);
if(fs) glAttachShader(prog, fs);
// Specify input and output for the geometry shader. Note that this must be
// done before linking the program.
glProgramParameteriEXT(prog,GL_GEOMETRY_INPUT_TYPE_EXT,GL_TRIANGLES);
glProgramParameteriEXT(prog,GL_GEOMETRY_VERTICES_OUT_EXT,3);
glProgramParameteriEXT(prog,GL_GEOMETRY_OUTPUT_TYPE_EXT,GL_TRIANGLE_STRIP);
// Link the program object and print out the info log
glLinkProgram(prog);
}
GLint old_prog;
glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
glNewList(display_list,GL_COMPILE);
glUseProgram(prog);
for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f) {
if(no_edges(m, *f) != 3)
continue;
else
glBegin(GL_TRIANGLES);
for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()) {
Vec3d n(normal(m, w.vertex()));
glNormal3dv(n.get());
glColor4dv(field[w.vertex()].get());
glVertex3dv(m.pos(w.vertex()).get());
}
glEnd();
}
glUseProgram(old_prog);
glEndList();
}
//++++++++++++++++++++++++++++++++++++++++++++++++
//初期化
//--in--------------------------------------------
//頂点シェーダファイル名、
//フラグメントシェーダファイル名
//ジオメトリシェーダ
//--out-------------------------------------------
//
//++++++++++++++++++++++++++++++++++++++++++++++++
void CGLSL::Init(const char* vtx_file, const char* frg_file, const char* geo_file)
{
//シェーダオブジェクトの作成
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
geometoryShader = glCreateShader(GL_GEOMETRY_SHADER);
//プログラムの作成
shaderProg = glCreateProgram();
//読み込みとコンパイル
if(ReadShaderSource(vertexShader, vtx_file) == S_OK)
{
glCompileShader(vertexShader); //コンパイル
glAttachShader(shaderProg, vertexShader); //プログラムに登録
}
else
{
//エラー処理
}
if(ReadShaderSource(fragmentShader, frg_file) == S_OK)
{
glCompileShader(fragmentShader); //コンパイル
glAttachShader(shaderProg, fragmentShader); //プログラムに登録
}
else
{
//エラー処理
}
if(ReadShaderSource(geometoryShader, frg_file) == S_OK)
{
glCompileShader(geometoryShader); //コンパイル
glAttachShader(shaderProg, geometoryShader); //プログラムに登録
}
else
{
//エラー処理
}
glProgramParameteriEXT(shaderProg,GL_GEOMETRY_INPUT_TYPE_EXT,GL_POLYGON);
glProgramParameteriEXT(shaderProg,GL_GEOMETRY_OUTPUT_TYPE_EXT,GL_POLYGON);
int temp;
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp);
glProgramParameteriEXT(shaderProg,GL_GEOMETRY_VERTICES_OUT_EXT,temp);
glLinkProgram(shaderProg);
tangent = glGetAttribLocation(shaderProg, "tangent");
}
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);
}
EXTERN_C_ENTER
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_glProgramParameteriEXT(JNIEnv *__env, jclass clazz, jint program, jint pname, jint value) {
glProgramParameteriEXTPROC glProgramParameteriEXT = (glProgramParameteriEXTPROC)tlsGetFunction(1717);
UNUSED_PARAM(clazz)
glProgramParameteriEXT(program, pname, value);
}
t_value ml_glprogramparameteriext (value program, value type, value v)
{
CAMLparam3 (program, type, v);
GLenum pname = conv_geometry_type_table[Int_val(type)];
glProgramParameteriEXT(Long_val(program), pname, Int_val(v));
CAMLreturn (Val_unit);
}
void Shader::loadShader( ci::DataSourceRef shaderSourceRef, GLint shaderType, GLint geometryInputType, GLint geometryOutputType, GLint geometryOutputVertices )
{
if( shaderSourceRef ){
mSource[shaderType] = shaderSourceRef;
mLastTime[shaderType] = ci::fs::last_write_time( shaderSourceRef->getFilePath() );
GlslProg::loadShader( shaderSourceRef->getBuffer(), shaderType );
if( shaderType == GL_GEOMETRY_SHADER_EXT ){
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_INPUT_TYPE_EXT, geometryInputType);
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_OUTPUT_TYPE_EXT, geometryOutputType);
glProgramParameteriEXT(mObj->mHandle, GL_GEOMETRY_VERTICES_OUT_EXT, geometryOutputVertices);
mGeometryData = GeomData( geometryInputType, geometryOutputType, geometryOutputVertices );
}
}
}
void GLGeometryShader::linkShader(GLint geometryInputType,GLint geometryOutputType,GLint maxNumOutputVertices)
{
if(programObject!=0)
Misc::throwStdErr("GLGeometryShader::linkShader: Attempt to link shader program multiple times");
/* Create the program object: */
programObject=glCreateProgramObjectARB();
/* Attach all previously compiled shaders to the program object: */
for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt)
glAttachObjectARB(programObject,*vsoIt);
for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt)
glAttachObjectARB(programObject,*fsoIt);
for(HandleList::iterator gsoIt=geometryShaderObjects.begin();gsoIt!=geometryShaderObjects.end();++gsoIt)
glAttachObjectARB(programObject,*gsoIt);
/* Configure the geometry shader parameters of the program object: */
if(!geometryShaderObjects.empty())
{
/* Set the input/output parameters: */
glProgramParameteriEXT(GLuint(programObject),GL_GEOMETRY_INPUT_TYPE_EXT,geometryInputType);
glProgramParameteriEXT(GLuint(programObject),GL_GEOMETRY_OUTPUT_TYPE_EXT,geometryOutputType);
glProgramParameteriEXT(GLuint(programObject),GL_GEOMETRY_VERTICES_OUT_EXT,maxNumOutputVertices);
/* Check for errors: */
GLenum err=glGetError();
if(err!=GL_NO_ERROR)
Misc::throwStdErr("GLGeometryShader::linkShader: Error #%u while setting geometry shader parameters",err);
}
/* Link the program: */
glLinkProgramARB(programObject);
/* Check if the program linked successfully: */
GLint linkStatus;
glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
if(!linkStatus)
{
/* Get some more detailed information: */
GLcharARB linkLogBuffer[2048];
GLsizei linkLogSize;
glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
/* Signal an error: */
Misc::throwStdErr("GLGeometryShader::linkShader: Error \"%s\" while linking shader program",linkLogBuffer);
}
}
GLuint
GLSLProgram::compileProgram(const char *vsource, const char *gsource, const char *fsource,
GLenum gsInput, GLenum gsOutput, int maxVerts)
{
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
mProg = glCreateProgram();
if(vsource)
{
glShaderSource(vertexShader, 1, &vsource, 0);
glCompileShader(vertexShader);
glAttachShader(mProg, vertexShader);
}
glShaderSource(fragmentShader, 1, &fsource, 0);
glCompileShader(fragmentShader);
glAttachShader(mProg, fragmentShader);
if (gsource) {
GLuint geomShader = glCreateShader(GL_GEOMETRY_SHADER_EXT);
glShaderSource(geomShader, 1, &gsource, 0);
glCompileShader(geomShader);
glAttachShader(mProg, geomShader);
glProgramParameteriEXT(mProg, GL_GEOMETRY_INPUT_TYPE_EXT, gsInput);
glProgramParameteriEXT(mProg, GL_GEOMETRY_OUTPUT_TYPE_EXT, gsOutput);
glProgramParameteriEXT(mProg, GL_GEOMETRY_VERTICES_OUT_EXT, maxVerts);
}
glLinkProgram(mProg);
// check if program linked
GLint success = 0;
glGetProgramiv(mProg, GL_LINK_STATUS, &success);
if (!success) {
char temp[1024];
glGetProgramInfoLog(mProg, 1024, 0, temp);
LOGE("Failed to link program:\n%s\n", temp);
glDeleteProgram(mProg);
mProg = 0;
return 0;
}
return mProg;
}
GLuint GLTools::createShaderProgram(const char* vsFilename, const char* gsFilename, const char* fsFilename){
// create program
GLuint programID = glCreateProgram();
// create and attach shaders
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
string source = readFile(vsFilename);
const char* s = source.c_str();
glShaderSource(vertexShader, 1, &s, NULL);
glCompileShader(vertexShader);
printShaderInfoLog(vertexShader);
source.clear();
glAttachShader(programID, vertexShader);
glDeleteShader(vertexShader);
GLuint geometryShader = glCreateShader(GL_GEOMETRY_SHADER_EXT);
source = readFile(gsFilename);
s = source.c_str();
glShaderSource(geometryShader, 1, &s, NULL);
glCompileShader(geometryShader);
printShaderInfoLog(geometryShader);
source.clear();
glAttachShader(programID, geometryShader);
glProgramParameteriEXT(programID, GL_GEOMETRY_VERTICES_OUT_EXT, 3); //maximum number of vertices the geometry shader will emit in one invocation
glProgramParameteriEXT(programID, GL_GEOMETRY_INPUT_TYPE_EXT, GL_TRIANGLES);
glProgramParameteriEXT(programID, GL_GEOMETRY_OUTPUT_TYPE_EXT, GL_TRIANGLE_STRIP);
glDeleteShader(geometryShader);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
source = readFile(fsFilename);
s = source.c_str();
glShaderSource(fragmentShader, 1, &s, NULL);
glCompileShader(fragmentShader);
printShaderInfoLog(fragmentShader);
source.clear();
glAttachShader(programID, fragmentShader);
glDeleteShader(fragmentShader);
// link program
glLinkProgram(programID);
// check program
printProgramInfoLog(programID);
return programID;
}
void shader_object::setup_geometry_shader(GLuint itype,
GLuint otype,
GLint osize)
{
//Get max number of geometry shader output vertices
GLint n;
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &n);
//std::cout<<"Max GS output vertices:"<< n <<"\n";
if(osize > n) osize = n;
glProgramParameteriEXT(p, GL_GEOMETRY_INPUT_TYPE_EXT , itype );
glProgramParameteriEXT(p, GL_GEOMETRY_OUTPUT_TYPE_EXT , otype);
glProgramParameteriEXT(p, GL_GEOMETRY_VERTICES_OUT_EXT, osize);
if( printOpenGLError() ) exit(1);
}
inline void VL_glProgramParameteri(GLuint program, GLenum pname, GLint value)
{
if (glProgramParameteriARB)
glProgramParameteriARB(program, pname, value);
else
if (glProgramParameteriEXT)
glProgramParameteriEXT(program, pname, value);
else
VL_UNSUPPORTED_FUNC();
}
void glsl_program:: outverticesMess(GLint vertices) {
m_geoOutVertices=vertices;
if(m_program && glProgramParameteriEXT) {
int temp=m_geoOutVertices;
if(temp<0)
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp);
glProgramParameteriEXT(m_program,GL_GEOMETRY_VERTICES_OUT_EXT,temp);
}
}
//
// AttachShader
//
void CShadingProgram::AttachShader(
Ptr<const CShader> Shader
)
{
glClearErrors();
glAttachShader( m_Program, Shader->m_Shader );
if (Shader->m_Target == GL_GEOMETRY_SHADER_EXT)
{
Ptr<const CGeometryShader> GeometryShader = Shader.CastTo<const CGeometryShader>();
glProgramParameteriEXT( m_Program, GL_GEOMETRY_VERTICES_OUT_EXT, GeometryShader->m_VerticesOut );
glProgramParameteriEXT( m_Program, GL_GEOMETRY_INPUT_TYPE_EXT, GeometryShader->m_InputTopology );
glProgramParameteriEXT( m_Program, GL_GEOMETRY_OUTPUT_TYPE_EXT, GeometryShader->m_OutputTopology );
}
GLenum Error = glGetError();
if (Error != GL_NO_ERROR)
throw CException( this, Error, "::AttachShader() : An OpenGL error has occured." );
}
bool GLSLShader::changeNbMaxVertices(int nb_max_vertices)
{
m_nbMaxVertices = nb_max_vertices;
if ((*m_geom_shader_object) && (CURRENT_OGL_VERSION == 2))
{
glProgramParameteriEXT(*m_program_object, GL_GEOMETRY_VERTICES_OUT_EXT, m_nbMaxVertices);
// need to relink
return true;
}
return false;
}
/*
========================
setupProgramParameters
========================
*/
void CShader::setupProgramParameters( void )
{
GLint n;
//
// geometry shader specific program parameters
//
if( m_geometryShaderAvailable )
{
// query maximum
glGetIntegerv( GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &n );
// set maximum. may be inefficient, but of universal use.
glProgramParameteriEXT( m_program, GL_GEOMETRY_VERTICES_OUT_EXT, n );
// set primitive types
glProgramParameteriEXT( m_program, GL_GEOMETRY_INPUT_TYPE_EXT, m_geometryInputType );
glProgramParameteriEXT( m_program, GL_GEOMETRY_OUTPUT_TYPE_EXT, m_geometryOutputType );
}
}
int
GLSLProgram::LinkProgram()
{
if( Gshader != 0 )
{
glProgramParameteriEXT( Program, GL_GEOMETRY_INPUT_TYPE_EXT, InputTopology );
glProgramParameteriEXT( Program, GL_GEOMETRY_OUTPUT_TYPE_EXT, OutputTopology );
glProgramParameteriEXT( Program, GL_GEOMETRY_VERTICES_OUT_EXT, 1024 );
}
glLinkProgram( Program );
CheckGlErrors("LoadShader:Link 1");
GLchar* infoLog;
GLint infoLogLen;
GLint linkStatus;
glGetProgramiv( this->Program, GL_LINK_STATUS, &linkStatus );
CheckGlErrors("LoadShader:Link 2");
if( linkStatus == 0 )
{
glGetProgramiv( this->Program, GL_INFO_LOG_LENGTH, &infoLogLen );
fprintf( stderr, "Failed to link program -- Info Log Length = %d\n", infoLogLen );
if( infoLogLen > 0 )
{
infoLog = new GLchar[infoLogLen+1];
glGetProgramInfoLog( this->Program, infoLogLen, NULL, infoLog );
infoLog[infoLogLen] = '\0';
fprintf( stderr, "Info Log:\n%s\n", infoLog );
delete [] infoLog;
}
glDeleteProgram( Program );
glDeleteShader( Vshader );
glDeleteShader( Gshader );
glDeleteShader( Fshader );
return 0;
}
return 1;
};
//
// Create Shader Program including Geometry Shader
//
int CreateShaderProgGeom()
{
// Create program
int prog = glCreateProgram();
// Compile and add shaders
CreateShader(prog,GL_VERTEX_SHADER ,"nbody.vert");
#ifdef __APPLE__
// OpenGL 3.1 for OSX
CreateShader(prog,GL_GEOMETRY_SHADER_EXT,"nbody.geom_ext");
glProgramParameteriEXT(prog,GL_GEOMETRY_INPUT_TYPE_EXT ,GL_POINTS);
glProgramParameteriEXT(prog,GL_GEOMETRY_OUTPUT_TYPE_EXT ,GL_TRIANGLE_STRIP);
glProgramParameteriEXT(prog,GL_GEOMETRY_VERTICES_OUT_EXT,4);
#else
// OpenGL 3.2 adds layout ()
CreateShader(prog,GL_GEOMETRY_SHADER,"nbody.geom");
#endif
CreateShader(prog,GL_FRAGMENT_SHADER,"nbody.frag");
// Link program
glLinkProgram(prog);
// Check for errors
PrintProgramLog(prog);
// Return name
return prog;
}
GLuint Shader::compileProgram()
{
GLuint program = glCreateProgram();
compileShader(GL_VERTEX_SHADER, "Vertex Shader", program);
compileShader(GL_FRAGMENT_SHADER, "Fragment Shader", program);
#ifdef GL_GEOMETRY_SHADER
if (shaderSrc[GL_GEOMETRY_SHADER].length())
{
compileShader(GL_GEOMETRY_SHADER, "Geometry Shader",program);
for (map<GLenum,GLuint>::iterator i =geomParams.begin();i!=geomParams.end(); i++)
{
glProgramParameteriEXT(program,i->first,i->second);
}
}
#endif
#ifdef GL_TESS_CONTROL_SHADER
if (shaderSrc[GL_TESS_CONTROL_SHADER].length())
{
compileShader(GL_TESS_CONTROL_SHADER, "Tesselation Control Shader",program);
}
if (shaderSrc[GL_TESS_EVALUATION_SHADER].length())
{
compileShader(GL_TESS_EVALUATION_SHADER, "Tesselation Evaluation Shader",program);
}
#endif
glBindFragDataLocation(program, 0, "colorOut");
glLinkProgram(program);
// check if program linked
GLint success = 0;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success)
{
char temp[256];
glGetProgramInfoLog(program, 256, 0, temp);
cerr<<"Failed to link program:\n"<<temp<<endl;
glDeleteProgram(program);
program = 0;
}
shaderProgram = program;
return program;
}
void GLSLESProgramPipeline::compileAndLink()
{
#if OGRE_PLATFORM != OGRE_PLATFORM_NACL
GLint linkStatus = 0;
OGRE_CHECK_GL_ERROR(glGenProgramPipelinesEXT(1, &mGLProgramPipelineHandle));
OGRE_CHECK_GL_ERROR(glBindProgramPipelineEXT(mGLProgramPipelineHandle));
// Compile and attach Vertex Program
if(getVertexProgram())
{
if(getVertexProgram()->isLinked())
{
mLinked |= VERTEX_PROGRAM_LINKED;
}
else if(getMicrocodeFromCache(
getVertexProgram()->getName(),
getVertexProgram()->createGLProgramHandle()))
{
getVertexProgram()->setLinked(true);
mLinked |= VERTEX_PROGRAM_LINKED;
mTriedToLinkAndFailed = false;
}
else
{
if(!getVertexProgram()->compile(true)) {
LogManager::getSingleton().stream(LML_CRITICAL)
<< "Vertex Program " << getVertexProgram()->getName()
<< " failed to compile. See compile log above for details.";
mTriedToLinkAndFailed = true;
return;
}
GLuint programHandle = getVertexProgram()->getGLProgramHandle();
bindFixedAttributes( programHandle );
OGRE_CHECK_GL_ERROR(glProgramParameteriEXT(programHandle, GL_PROGRAM_SEPARABLE_EXT, GL_TRUE));
getVertexProgram()->attachToProgramObject(programHandle);
OGRE_CHECK_GL_ERROR(glLinkProgram(programHandle));
OGRE_CHECK_GL_ERROR(glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus));
if(linkStatus)
{
getVertexProgram()->setLinked(linkStatus);
mLinked |= VERTEX_PROGRAM_LINKED;
}
mTriedToLinkAndFailed = !linkStatus;
GLSLES::logObjectInfo( getCombinedName() + String("GLSL vertex program result : "), programHandle );
setSkeletalAnimationIncluded(getVertexProgram()->isSkeletalAnimationIncluded());
}
}
// Compile and attach Fragment Program
if(mFragmentProgram)
{
if(mFragmentProgram->isLinked())
{
mLinked |= FRAGMENT_PROGRAM_LINKED;
}
else if(getMicrocodeFromCache(
mFragmentProgram->getName(),
mFragmentProgram->createGLProgramHandle()))
{
mFragmentProgram->setLinked(true);
mLinked |= FRAGMENT_PROGRAM_LINKED;
mTriedToLinkAndFailed = false;
}
else
{
if(!mFragmentProgram->compile(true)) {
LogManager::getSingleton().stream(LML_CRITICAL)
<< "Fragment Program " << mFragmentProgram->getName()
<< " failed to compile. See compile log above for details.";
mTriedToLinkAndFailed = true;
return;
}
GLuint programHandle = mFragmentProgram->getGLProgramHandle();
OGRE_CHECK_GL_ERROR(glProgramParameteriEXT(programHandle, GL_PROGRAM_SEPARABLE_EXT, GL_TRUE));
mFragmentProgram->attachToProgramObject(programHandle);
OGRE_CHECK_GL_ERROR(glLinkProgram(programHandle));
OGRE_CHECK_GL_ERROR(glGetProgramiv(programHandle, GL_LINK_STATUS, &linkStatus));
if(linkStatus)
{
mFragmentProgram->setLinked(linkStatus);
mLinked |= FRAGMENT_PROGRAM_LINKED;
}
mTriedToLinkAndFailed = !linkStatus;
GLSLES::logObjectInfo( getCombinedName() + String("GLSL fragment program result : "), programHandle );
}
}
if(mLinked)
{
if(getVertexProgram() && getVertexProgram()->isLinked())
{
OGRE_CHECK_GL_ERROR(glUseProgramStagesEXT(mGLProgramPipelineHandle, GL_VERTEX_SHADER_BIT_EXT, getVertexProgram()->getGLProgramHandle()));
_writeToCache(getVertexProgram()->getName(), getVertexProgram()->getGLProgramHandle());
}
if(mFragmentProgram && mFragmentProgram->isLinked())
{
OGRE_CHECK_GL_ERROR(glUseProgramStagesEXT(mGLProgramPipelineHandle, GL_FRAGMENT_SHADER_BIT_EXT, mFragmentProgram->getGLProgramHandle()));
_writeToCache(mFragmentProgram->getName(), mFragmentProgram->getGLProgramHandle());
}
// Validate pipeline
GLSLES::logObjectInfo( getCombinedName() + String("GLSL program pipeline result : "), mGLProgramPipelineHandle );
if(getVertexProgram() && mFragmentProgram && Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_DEBUG))
{
glLabelObjectEXT(GL_PROGRAM_PIPELINE_OBJECT_EXT, mGLProgramPipelineHandle, 0,
(getVertexProgram()->getName() + "/" + mFragmentProgram->getName()).c_str());
}
}
#endif
}
void ofxShader::setGeometryOutputCount(int count) {
checkAndCreateProgram();
glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT, count);
}
void ofxShader::setGeometryOutputType(GLenum type) {
checkAndCreateProgram();
glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, type);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglProgramParameteriEXT(JNIEnv *env, jclass clazz, jint program, jint pname, jint value, jlong function_pointer) {
glProgramParameteriEXTPROC glProgramParameteriEXT = (glProgramParameteriEXTPROC)((intptr_t)function_pointer);
glProgramParameteriEXT(program, pname, value);
}
