//------------------------------------------------------------------------------
void
keyboard(unsigned char key, int x, int y) {
switch (key) {
case 'q': quit();
case 'w': g_wire = (g_wire+1)%2; break;
case 'e': g_drawNormals = (g_drawNormals+1)%2; break;
case 'f': fitFrame(); break;
case 'a': if (g_osdPTexOcclusion) g_occlusion = !g_occlusion; linkProgram(); break;
case 'd': if (g_osdPTexDisplacement) g_displacement = !g_displacement; linkProgram();break;
case 'c': g_color = !g_color; linkProgram(); break;
case 's': schemeMenu(!g_scheme); break;
case 'm': g_moveScale = 1.0f - g_moveScale; break;
case 'p': g_ptexDebug++; break;
case 'o': g_ptexDebug = std::max(0, g_ptexDebug-1); break;
case 'g': g_gutterWidth = (g_gutterWidth+1)%8; createOsdMesh(g_level, g_kernel); break;
case 'h': g_gutterDebug = !g_gutterDebug; createOsdMesh(g_level, g_kernel); break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7': levelMenu(key-'0'); break;
}
}
//------------------------------------------------------------------------------
void
initGL() {
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glEnable(GL_LIGHT0);
glColor3f(1, 1, 1);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
GLfloat color[4] = {1, 1, 1, 1};
GLfloat position[4] = {5, 5, 10, 1};
GLfloat ambient[4] = {0.0f, 0.0f, 0.0f, 1.0f};
GLfloat diffuse[4] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat shininess = 25.0;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &shininess);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
g_quadFillProgram = linkProgram("#define PRIM_QUAD\n#define GEOMETRY_OUT_FILL\n");
g_quadLineProgram = linkProgram("#define PRIM_QUAD\n#define GEOMETRY_OUT_LINE\n");
g_triFillProgram = linkProgram("#define PRIM_TRI\n#define GEOMETRY_OUT_FILL\n");
g_triLineProgram = linkProgram("#define PRIM_TRI\n#define GEOMETRY_OUT_LINE\n");
}
unsigned int
ShaderProgram::linkProgram(Shader* vert, Shader* frag)
{
addStage(vert);
addStage(frag);
return linkProgram();
}
void NMS_ShaderManager::loadShaders(string vertexShaderFilename, string fragmentShaderFilename)
{
string key = vertexShaderFilename+fragmentShaderFilename;
if(programs.count(key) == 0) {
GLint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
const char * vsc = readFile(vertexShaderFilename);
const char * fsc = readFile(fragmentShaderFilename);
glShaderSource(vertexShader, 1, &vsc, NULL);
glShaderSource(fragmentShader, 1, &fsc, NULL);
compileShader(vertexShader, vertexShaderFilename);
compileShader(fragmentShader, fragmentShaderFilename);
program = glCreateProgram();
glAttachShader(program,vertexShader);
glAttachShader(program,fragmentShader);
linkProgram(program);
programs[key] = program;
}
glUseProgram(programs[key]);
}
bool COGLES2SLMaterialRenderer::initFromFiles( s32 &outMaterialTypeNr,
const c8 *vertexShaderFile,
const c8 *pixelShaderFile,
bool registerMaterial )
{
outMaterialTypeNr = -1;
if ( !createProgram() )
{
os::Printer::log( "Could not create shader program.", ELL_ERROR );
return false;
}
if ( !readVertexShader( vertexShaderFile ) )
{
os::Printer::log( "Error reading fixed pipeline vertex shader.", ELL_ERROR );
}
if ( !readFragmentShader( pixelShaderFile ) )
{
os::Printer::log( "Error reading fixed pipeline fragment shader.", ELL_ERROR );
}
for ( size_t i = 0; i < EVA_COUNT; ++i )
glBindAttribLocation( Program, i, sBuiltInVertexAttributeNames[i] );
if ( !linkProgram() )
{
os::Printer::log( "Error linking fixed pipeline shader program.", ELL_ERROR );
return false;
}
if ( registerMaterial )
outMaterialTypeNr = Driver->addMaterialRenderer( this );
return true;
}
bool COGLES2SLMaterialRenderer::init(s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram,
bool registerMaterial )
{
outMaterialTypeNr = -1;
if ( Program == 0 && !createProgram() )
return false;
if ( vertexShaderProgram )
if ( !createShader( GL_VERTEX_SHADER, vertexShaderProgram, "" ) )
return false;
if ( pixelShaderProgram )
if ( !createShader( GL_FRAGMENT_SHADER, pixelShaderProgram, "" ) )
return false;
for ( size_t i = 0; i < EVA_COUNT; ++i )
glBindAttribLocation( Program, i, sBuiltInVertexAttributeNames[i] );
if ( !linkProgram() )
return false;
// register myself as new material
if ( registerMaterial )
outMaterialTypeNr = Driver->addMaterialRenderer( this );
return true;
}
void GLProgram::recover()
{
m_vertexShader = loadAndCompileShader(m_vShader, GL_VERTEX_SHADER);
m_fragmentShader = loadAndCompileShader(m_fShader, GL_FRAGMENT_SHADER);
if (m_vertexShader == 0 or m_fragmentShader == 0)
{
return;
}
m_programObject = glCreateProgram();
if (m_programObject == 0)
{
CHECK_GL_ERROR;
return;
}
glAttachShader(m_programObject, m_vertexShader);
glAttachShader(m_programObject, m_fragmentShader);
for (const auto& it : m_attributes)
{
glBindAttribLocation(m_programObject, it.second->getPosition(), it.second->getName().c_str());
}
linkProgram();
}
bool COGLES2SLMaterialRenderer::init(s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram,
bool registerMaterial )
{
outMaterialTypeNr = -1;
if ( Program == 0 && !createProgram() )
return false;
if ( vertexShaderProgram )
if ( !createShader( GL_VERTEX_SHADER, vertexShaderProgram, "" ) )
return false;
if ( pixelShaderProgram )
if ( !createShader( GL_FRAGMENT_SHADER, pixelShaderProgram, "" ) )
return false;
if ( !linkProgram() )
return false;
// register myself as new material
if ( registerMaterial )
outMaterialTypeNr = Driver->addMaterialRenderer( this );
return true;
}
bool COGLES2SLMaterialRenderer::reloadFromFiles( const c8 *vertexShaderFile,
const c8 *pixelShaderFile )
{
GLsizei shaderCount;
GLuint shaderHandles[2];
glGetAttachedShaders( Program, 2, &shaderCount, shaderHandles );
glDetachShader( Program, shaderHandles[0] );
glDeleteShader( shaderHandles[0] );
glDetachShader( Program, shaderHandles[1] );
glDeleteShader( shaderHandles[1] );
if ( !readVertexShader( vertexShaderFile ) )
{
os::Printer::log( "Error reading fixed pipeline vertex shader.", ELL_ERROR );
}
if ( !readFragmentShader( pixelShaderFile ) )
{
os::Printer::log( "Error reading fixed pipeline fragment shader.", ELL_ERROR );
}
if ( !linkProgram() )
{
os::Printer::log( "Error linking fixed pipeline shader program.", ELL_ERROR );
return false;
}
else
return true;
}
GLSLProgram::GLSLProgram(const char* vert,
const char* frag,
const char* geom,
const char* tcs,
const char* tes,
bool isXformFeedback,
size_t xformFdbVaryingCount,
const char* fdbVaryings[])
: program(0), shaders{}
{
bool isProgram = false;
if (create_shaders(vert, frag, geom, tcs, tes))
{
isProgram = createProgram();
}
if (isXformFeedback && isProgram && fdbVaryings)
{
glTransformFeedbackVaryings(program,
xformFdbVaryingCount,
fdbVaryings,
GL_INTERLEAVED_ATTRIBS);
}
linkProgram();
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------
//
bool ofxAutoReloadedShader::load(string vertName, string fragName, string geomName)
{
unload();
ofShader::setGeometryOutputCount(geometryOutputCount);
ofShader::setGeometryInputType(geometryInputType);
ofShader::setGeometryOutputType(geometryOutputType);
// hackety hack, clear errors or shader will fail to compile
GLuint err = glGetError();
lastTimeCheckMillis = ofGetElapsedTimeMillis();
setMillisBetweenFileCheck( 2 * 1000 );
enableWatchFiles();
loadShaderNextFrame = false;
vertexShaderFilename = vertName;
fragmentShaderFilename = fragName;
geometryShaderFilename = geomName;
vertexShaderFile.clear();
fragmentShaderFile.clear();
geometryShaderFile.clear();
vertexShaderFile = ofFile( ofToDataPath( vertexShaderFilename ) );
fragmentShaderFile = ofFile( ofToDataPath( fragmentShaderFilename ) );
geometryShaderFile = ofFile( ofToDataPath( geometryShaderFilename ) );
ofBuffer vertexShaderBuffer = ofBufferFromFile( ofToDataPath( vertexShaderFilename ) );
ofBuffer fragmentShaderBuffer = ofBufferFromFile( ofToDataPath( fragmentShaderFilename ) );
ofBuffer geometryShaderBuffer = ofBufferFromFile( ofToDataPath( geometryShaderFilename ) );
fileChangedTimes.clear();
fileChangedTimes.push_back( getLastModified( vertexShaderFile ) );
fileChangedTimes.push_back( getLastModified( fragmentShaderFile ) );
fileChangedTimes.push_back( getLastModified( geometryShaderFile ) );
if( vertexShaderBuffer.size() > 0 )
{
setupShaderFromSource(GL_VERTEX_SHADER, vertexShaderBuffer.getText() );
}
if( fragmentShaderBuffer.size() > 0 )
{
setupShaderFromSource(GL_FRAGMENT_SHADER, fragmentShaderBuffer.getText());
}
#ifndef TARGET_OPENGLES
if( geometryShaderBuffer.size() > 0 )
{
setupShaderFromSource(GL_GEOMETRY_SHADER_EXT, geometryShaderBuffer.getText());
}
#endif
bindDefaults();
return linkProgram();
}
GLuint buildProgramFiles(const char *vert_shader_file, const char *frag_shader_file)
{
/* compile the vertex shader */
GLuint vert_shader = compileShaderFile(GL_VERTEX_SHADER, vert_shader_file);
if (vert_shader == 0)
{
return 0;
}
/* compile the fragment shader */
GLuint frag_shader = compileShaderFile(GL_FRAGMENT_SHADER, frag_shader_file);
if (frag_shader == 0)
{
glDeleteShader(vert_shader);
return 0;
}
/* link the shaders together */
GLuint program = linkProgram(2, vert_shader, frag_shader);
/* delete shader objects, so that when user destroys the program object,
the shaders will be freed too */
glDeleteShader(frag_shader);
glDeleteShader(vert_shader);
return program;
}
bool Shader::init(const char* vertexPath, const char* fragmentPath)
{
//create a vertex shader
GLuint vertexShader = genShader(GL_VERTEX_SHADER, vertexPath);
if (!vertexShader)
{
return false;
}
//create a fragment shader.
GLuint fragmentShader = genShader(GL_FRAGMENT_SHADER, fragmentPath);
if (!fragmentShader)
{
glDeleteShader(vertexShader);
return false;
}
//Link the vertex shader and fragment shader.
GLuint shader[2] = { vertexShader, fragmentShader };
mProgram = linkProgram(shader, 2);
// Delete the shaders as they're linked into our program now and no longer necessery
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
return true;
}
void UIShader::setupUI(){
float length = (gui->getGlobalCanvasWidth()-gui->getWidgetSpacing()*5);
float dim = gui->getGlobalSliderHeight();
linkProgram();
extractUniforms(fragmentShader);
for(int i = 0; i < uniforms.size(); i++){
if ( uniforms[i]->bNeedUI ){
if (uniforms[i]->type == UNIFORM_FLOAT){
gui->addSlider( uniforms[i]->name, 0.0, 1.0, &uniforms[i]->value.x );
} else if (uniforms[i]->type == UNIFORM_VEC2){
gui->addLabel( uniforms[i]->name, OFX_UI_FONT_SMALL);
gui->addMinimalSlider("x", 0.0, 1.0, &uniforms[i]->value.x,length/2.0, dim);
gui->setWidgetPosition(OFX_UI_WIDGET_POSITION_RIGHT);
gui->addMinimalSlider("y", 0.0, 1.0, &uniforms[i]->value.y, length/2.0, dim);
gui->setWidgetPosition(OFX_UI_WIDGET_POSITION_DOWN);
gui->addSpacer();
} else if (uniforms[i]->type == UNIFORM_VEC3){
gui->addLabel( uniforms[i]->name, OFX_UI_FONT_SMALL);
gui->addMinimalSlider("x", 0.0, 1.0, &uniforms[i]->value.x,length/3.0, dim);
gui->setWidgetPosition(OFX_UI_WIDGET_POSITION_RIGHT);
gui->addMinimalSlider("y", 0.0, 1.0, &uniforms[i]->value.y, length/3.0, dim);
gui->addMinimalSlider("z", 0.0, 1.0, &uniforms[i]->value.z, length/3.0, dim);
gui->setWidgetPosition(OFX_UI_WIDGET_POSITION_DOWN);
gui->addSpacer();
}
}
}
if(fragFilename != ""){
gui->addButton("OPEN",&bOpen);
}
}
void Shader::load() {
Renderer *renderer = Naquadah::getRenderer();
if (renderer != nullptr) {
std::string vertexCode = FileIO::mergeLines(FileIO::readTextFile(vertexFilename));
std::string fragmentCode = FileIO::mergeLines(FileIO::readTextFile(fragmentFilename));
std::string geometryCode = FileIO::mergeLines(FileIO::readTextFile(geometryFilename));
std::string tessCtrlCode = FileIO::mergeLines(FileIO::readTextFile(tessCtrlFilename));
std::string tessEvalCode = FileIO::mergeLines(FileIO::readTextFile(tessEvalFilename));
this->program = glCreateProgram();
vertexId = compileShader(program, GL_VERTEX_SHADER, vertexCode.c_str());
fragmentId = compileShader(program, GL_FRAGMENT_SHADER, fragmentCode.c_str());
if (geometryCode.size() > 0)
geometryId = compileShader(program, GL_GEOMETRY_SHADER, geometryCode.c_str());
if (tessCtrlCode.size() > 0 && tessEvalCode.size() > 0) {
tessCtrlId = compileShader(program, GL_TESS_CONTROL_SHADER, tessCtrlCode.c_str());
tessEvalId = compileShader(program, GL_TESS_EVALUATION_SHADER, tessEvalCode.c_str());
}
setDefaultAttributes();
if (linkProgram(program))
valid = true;
} else
valid = false;
loaded = true;
}
void COpenGLSLMaterialRenderer::init(s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram)
{
outMaterialTypeNr = -1;
if (!createProgram())
return;
#if defined(GL_ARB_vertex_shader) && defined (GL_ARB_fragment_shader)
if (vertexShaderProgram)
if (!createShader(GL_VERTEX_SHADER_ARB, vertexShaderProgram))
return;
if (pixelShaderProgram)
if (!createShader(GL_FRAGMENT_SHADER_ARB, pixelShaderProgram))
return;
#endif
if (!linkProgram())
return;
// register myself as new material
outMaterialTypeNr = Driver->addMaterialRenderer(this);
}
void moShaderGLSL::CreateShader(moText vert_source, moText frag_source)
{
m_ProgramObject = glCreateProgramObjectARB();
compileVertShader(vert_source);
compileFragShader(frag_source);
linkProgram();
}
bool Shader::loadShaders()
{
GLuint vertShader, fragShader;
// cria o programa shader
program = glCreateProgram();
// cria e compila o vertex shader
if(!compileShader(&vertShader, GL_VERTEX_SHADER, vshPath))
{
printf("Erro ao criar o vertex shader! %s\n", vshPath);
}
// cria e compila o fragment shader
if(!compileShader(&fragShader, GL_FRAGMENT_SHADER, fshPath))
{
printf("Erro ao criar o fragment shader! %s\n", fshPath);
}
printf("Attaching shaders...\n");
// dah attach nos shaders
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
// linka
if (!linkProgram(program))
{
printf("Falha ao linkar o programa: %d", program);
if (vertShader)
{
glDeleteShader(vertShader);
vertShader = 0;
}
if (fragShader)
{
glDeleteShader(fragShader);
fragShader = 0;
}
if (program)
{
glDeleteProgram(program);
program = 0;
}
return false;
}
/*
// Release vertex and fragment shaders.
if (vertShader)
glDeleteShader(vertShader);
if (fragShader)
glDeleteShader(fragShader);
return true;
*/
return true;
}
bool ofxShader::setup(string vertName, string fragName, string geomName) {
unload();
if(vertName.empty() == false) setupShaderFromFile(GL_VERTEX_SHADER, vertName);
if(fragName.empty() == false) setupShaderFromFile(GL_FRAGMENT_SHADER, fragName);
if(geomName.empty() == false) setupShaderFromFile(GL_GEOMETRY_SHADER_EXT, geomName);
return linkProgram();
}
bool UIShader::reloadShader(string _fragPath, string _vertPath, string _geomPath){
ofShader::unload();
// hackety hack, clear errors or shader will fail to compile
GLuint err = glGetError();
fragFile.clear();
fragFilename = ofToDataPath( _fragPath );
fragFile = ofFile( fragFilename );
fragChangedTimes = getLastModified( fragFile );
ofBuffer fragBuffer = ofBufferFromFile( fragFilename );
if( fragBuffer.size() > 0 ){
setupShaderFromSource(GL_FRAGMENT_SHADER, fragBuffer.getText());
}
if (_vertPath != ""){
vertFile.clear();
vertFilename = ofToDataPath(_vertPath);
vertFile = ofFile( vertFilename );
vertChangedTimes = getLastModified( vertFile );
ofBuffer vertBuffer = ofBufferFromFile( vertFilename );
if( vertBuffer.size() > 0 ){
setupShaderFromSource(GL_VERTEX_SHADER, vertBuffer.getText());
}
bVertex = true;
}
if (_geomPath != ""){
geomFile.clear();
geomFilename = ofToDataPath(_geomPath);
geomFile = ofFile( geomFilename );
geomChangedTimes = getLastModified( geomFile );
ofBuffer geomBuffer = ofBufferFromFile( geomFilename );
if( geomBuffer.size() > 0 ){
setupShaderFromSource(GL_GEOMETRY_SHADER, geomBuffer.getText());
}
setGeometryInputType(geomInType);
setGeometryOutputType(geomOutType);
setGeometryOutputCount(geomOutCount);
bGeometry = true;
}
lastTimeCheckMillis = ofGetElapsedTimeMillis();
if (linkProgram()){
extractUniforms(fragBuffer.getText());
return true;
} else {
return false;
}
}
Shader::Shader(std::initializer_list<std::pair<const ShaderType, const char *>> list) {
std::vector<GLuint> shaderIDs;
m_ProgramID = glCreateProgram();
for (auto pair : list) {
GLuint id = load(pair.first, pair.second);
shaderIDs.push_back(id);
}
linkProgram(shaderIDs);
cacheVariableLocations();
}
Shader::Shader(const char* vert_path, const char* frag_path)
{
printf("Compiling vertex shader: %s\n", vert_path);
GLuint vertex_handle = compileShader(GL_VERTEX_SHADER, vert_path);
printf("Compiling fragment shader: %s\n", frag_path);
GLuint frag_handle = compileShader(GL_FRAGMENT_SHADER, frag_path);
printf("Linking program\n");
m_program = linkProgram(vertex_handle, frag_handle);
printf("Complete\n");
}
//--------------------------------------------------------------
bool ofShader::load(string vertName, string fragName, string geomName) {
if(vertName.empty() == false) setupShaderFromFile(GL_VERTEX_SHADER, vertName);
if(fragName.empty() == false) setupShaderFromFile(GL_FRAGMENT_SHADER, fragName);
#ifndef TARGET_OPENGLES
if(geomName.empty() == false) setupShaderFromFile(GL_GEOMETRY_SHADER_EXT, geomName);
#endif
if(ofIsGLProgrammableRenderer()){
bindDefaults();
}
return linkProgram();
}
int linkProgram(const char* vshader_src, const char* fshader_src) {
GLuint program = glCreateProgram();
GLuint vshader = compileShader(GL_VERTEX_SHADER, vshader_src);
GLuint fshader = compileShader(GL_FRAGMENT_SHADER, fshader_src);
if (!linkProgram(program, vshader, fshader)) {
glDeleteProgram(program);
program = 0;
}
glDeleteShader(vshader);
glDeleteShader(fshader);
return program;
}
int main(void)
{
FILE *in = fopen("input.txt", "r");
int result;
interpreterInit();
parserInit(in);
parseInput();
linkProgram();
result = runProgram();
printf("Calculation result: %d", result);
return 0;
}
void Shader::buildProgram(sh *vtx, sh *frg)
{
GLint status;
GLchar *vtxSourceString = NULL, *frgSourceString = NULL;
float glLanguageVersion;
sscanf_s((char *)glGetString(GL_SHADING_LANGUAGE_VERSION), "%f", &glLanguageVersion);
GLuint version = static_cast<GLuint>(100 * glLanguageVersion);
const GLsizei versionStringSize = sizeof("#version 123\n");
program_handle = glCreateProgram();
vtxSourceString = (char*)malloc(vtx->byteSize + versionStringSize);
frgSourceString = (char*)malloc(frg->byteSize + versionStringSize);
sprintf(vtxSourceString, "#version %d\n%s", version, vtx->string);
sprintf(frgSourceString, "#version %d\n%s", version, frg->string);
GLuint vtxShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vtxShader, 1, (const GLchar **)&(vtxSourceString), NULL);
glCompileShader(vtxShader);
status = checkCompileError(vtxShader);
if (status == 0) {
printf("Failed to compile vtx shader:\n%s\n", vtxSourceString);
return;
}
GLuint frgShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(frgShader, 1, (const GLchar **)&(frgSourceString), NULL);
glCompileShader(frgShader);
status = checkCompileError(frgShader);
if (status == 0) {
printf("Failed to compile frg shader:\n%s\n", frgSourceString);
return;
}
free(vtxSourceString);
vtxSourceString = NULL;
free(frgSourceString);
frgSourceString = NULL;
glAttachShader(program_handle, vtxShader);
glDeleteShader(vtxShader);
glAttachShader(program_handle, frgShader);
glDeleteShader(frgShader);
linkProgram();
}
void allocResources()
{
if (!initialized)
{
GLuint shaders[shCount];
for (size_t i=0; i<shCount; ++i)
{
shaders[i] = glCreateShader(shaderDefs[i].type);
GLint len = (GLint)strlen(shaderDefs[i].source);
glShaderSource(shaders[i], 1, (const GLchar **)&shaderDefs[i].source, &len);
glCompileShader(shaders[i]);
}
simpleUIProgram = linkProgram(2, shaders[vsSimpleUI], shaders[fsSimpleUI]);
stencilCubicAreaProgram = linkProgram(1, shaders[fsStencilCubic]);
stencilCubicAreaAAProgram = linkProgram(1, shaders[fsStencilCubicAA]);
stencilQuadAreaProgram = linkProgram(1, shaders[fsStencilQuad]);
stencilArcAreaProgram = linkProgram(1, shaders[fsStencilArc]);
linGradProgram = linkProgram(3, shaders[vsCover], shaders[fsGradientCommon], shaders[fsLinearGradient]);
for (size_t i=0; i<shCount; ++i)
{
glDeleteShader(shaders[i]);
}
readyProgramsForUse();
}
initialized = true;
}
void COpenGLSLMaterialRenderer::init(s32& outMaterialTypeNr,
const c8* vertexShaderProgram,
const c8* pixelShaderProgram,
const c8* geometryShaderProgram,
scene::E_PRIMITIVE_TYPE inType, scene::E_PRIMITIVE_TYPE outType,
u32 verticesOut)
{
outMaterialTypeNr = -1;
if (!createProgram())
return;
#if defined(GL_ARB_vertex_shader) && defined (GL_ARB_fragment_shader)
if (vertexShaderProgram)
if (!createShader(GL_VERTEX_SHADER_ARB, vertexShaderProgram))
return;
if (pixelShaderProgram)
if (!createShader(GL_FRAGMENT_SHADER_ARB, pixelShaderProgram))
return;
#endif
#if defined(GL_ARB_geometry_shader4) || defined(GL_EXT_geometry_shader4) || defined(GL_NV_geometry_program4) || defined(GL_NV_geometry_shader4)
if (geometryShaderProgram && Driver->queryFeature(EVDF_GEOMETRY_SHADER))
{
if (!createShader(GL_GEOMETRY_SHADER_EXT, geometryShaderProgram))
return;
#if defined(GL_ARB_geometry_shader4) || defined(GL_EXT_geometry_shader4) || defined(GL_NV_geometry_shader4)
if (Program2) // Geometry shaders are supported only in OGL2.x+ drivers.
{
Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_INPUT_TYPE_EXT, Driver->primitiveTypeToGL(inType));
Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_OUTPUT_TYPE_EXT, Driver->primitiveTypeToGL(outType));
if (verticesOut==0)
Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_VERTICES_OUT_EXT, Driver->MaxGeometryVerticesOut);
else
Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_VERTICES_OUT_EXT, core::min_(verticesOut, Driver->MaxGeometryVerticesOut));
}
#elif defined(GL_NV_geometry_program4)
if (verticesOut==0)
Driver->extGlProgramVertexLimit(GL_GEOMETRY_PROGRAM_NV, Driver->MaxGeometryVerticesOut);
else
Driver->extGlProgramVertexLimit(GL_GEOMETRY_PROGRAM_NV, core::min_(verticesOut, Driver->MaxGeometryVerticesOut));
#endif
}
#endif
if (!linkProgram())
return;
// register myself as new material
outMaterialTypeNr = Driver->addMaterialRenderer(this);
}
ShaderInfo* Renderer::addShader(
const char* vertexShaderFilePath,
const char* fragmentShaderFilePath){
ShaderInfo* ret = getAvailableShader();
GLuint vertexShaderID = compileShaders(vertexShaderFilePath, GL_VERTEX_SHADER);
GLuint fragmentShaderID = compileShaders(fragmentShaderFilePath, GL_FRAGMENT_SHADER);
ret->progID = linkProgram(vertexShaderID, fragmentShaderID);
ret->isAvailable = false;
return ret;
}
void GL::Program::link()
{
linkProgram(m_Handle);
GL::Int logLength = 0;
GL::getProgramiv(m_Handle, GL::INFO_LOG_LENGTH, &logLength);
if (logLength > 0)
{
std::vector<char> log(static_cast<size_t>(logLength + 1), 0);
GL::getProgramInfoLog(m_Handle, logLength, nullptr, log.data());
std::clog << "Linking program \"" << name() << "\":\n" << log.data() << std::endl;
}
}
