/*
* Start up GLUT and tell it what to do
*/
int main(int argc,char* argv[])
{
// Initialize GLUT
glutInit(&argc,argv);
// Request double buffered, true color window with Z buffering at 600x600
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(600,600);
glutCreateWindow("NDC RGB Shader");
#ifdef USEGLEW
// Initialize GLEW
if (glewInit()!=GLEW_OK) Fatal("Error initializing GLEW\n");
if (!GLEW_VERSION_2_0) Fatal("OpenGL 2.0 not supported\n");
#endif
// Set callbacks
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutSpecialFunc(special);
glutKeyboardFunc(key);
// Load object
model = LoadOBJ("tyra.obj");
// Create Shader Programs
shader[1] = CreateShaderProg("ndcrgb.vert","ndcrgb.frag");
shader[2] = CreateShaderProg("ndcrgb.vert",NULL);
shader[3] = CreateShaderProg(NULL,"ndcrgb2.frag");
// Initialize location
x = y = z = 0;
// Pass control to GLUT so it can interact with the user
ErrCheck("init");
glutMainLoop();
return 0;
}
void InitGlareShader (void)
{
int bOk;
ogl.m_states.bDepthBlending = 0;
#if SHADER_SOFT_CORONAS
PrintLog ("building corona blending shader program\n");
DeleteShaderProg (NULL);
if (ogl.m_states.bRender2TextureOk && ogl.m_states.bShadersOk) {
ogl.m_states.bDepthBlending = 1;
for (int i = 0; i < 2; i++) {
if (hGlareShader [i])
DeleteShaderProg (&hGlareShader [i]);
bOk = CreateShaderProg (&hGlareShader [i]) &&
CreateShaderFunc (&hGlareShader [i], &hGlareFS [i], &hGlareVS [i], glareFS [i], glareVS, 1) &&
LinkShaderProg (&hGlareShader [i]);
if (!bOk) {
ogl.ClearError (0);
ogl.m_states.bDepthBlending = 0;
while (i)
DeleteShaderProg (&hGlareShader [--i]);
return;
}
}
}
#endif
}
void InitTexMergeShaders (void)
{
int i, b;
if (!gameStates.ogl.bShadersOk)
gameOpts->ogl.bGlTexMerge = 0;
if (!gameOpts->ogl.bGlTexMerge)
gameStates.render.textures.bGlsTexMergeOk = 0;
else {
LogErr ("building texturing shader programs\n");
for (i = 0; i < 2; i++) {
if (tmShaderProgs [i])
DeleteShaderProg (tmShaderProgs + i);
b = CreateShaderProg (tmShaderProgs + i) &&
CreateShaderFunc (tmShaderProgs + i, tmf + i, tmv + i, texMergeFS [i], texMergeVS [i], 1) &&
- LinkShaderProg (tmShaderProgs + i);
if (i == 2)
gameStates.render.textures.bHaveMaskShader = b;
else
gameStates.render.textures.bGlsTexMergeOk = b;
if (!gameStates.render.textures.bGlsTexMergeOk) {
while (i)
DeleteShaderProg (tmShaderProgs + --i);
break;
}
}
if (!gameStates.render.textures.bGlsTexMergeOk)
gameOpts->ogl.bGlTexMerge = 0;
}
if (!(gameOpts->ogl.bGlTexMerge && gameStates.render.textures.bGlsTexMergeOk))
gameStates.ogl.bHaveTexCompression = 0;
}
/*
* Start up GLUT and tell it what to do
*/
int main(int argc,char* argv[])
{
// Initialize GLUT
glutInit(&argc,argv);
// Request double buffered, true color window with Z buffering at 600x600
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(600,600);
glutCreateWindow("OpenGL 4");
#ifdef USEGLEW
// Initialize GLEW
if (glewInit()!=GLEW_OK) Fatal("Error initializing GLEW\n");
if (!GLEW_VERSION_4_3) Fatal("OpenGL 4.3 not supported\n");
#endif
// Set callbacks
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutSpecialFunc(special);
glutKeyboardFunc(key);
glutIdleFunc(idle);
// Load crate
crate = LoadTexBMP("pi.bmp");
// Create Shader Programs
shader = CreateShaderProg("gl430.vert","gl430.frag");
// Initialize cube
InitCube();
// Pass control to GLUT so it can interact with the user
ErrCheck("init");
glutMainLoop();
return 0;
}
/*
* Start up GLUT and tell it what to do
*/
int main(int argc,char* argv[])
{
int n;
// Initialize GLUT
glutInit(&argc,argv);
// Request double buffered, true color window with Z buffering at 600x600
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(600,600);
glutCreateWindow("Stored Textures");
#ifdef USEGLEW
// Initialize GLEW
if (glewInit()!=GLEW_OK) Fatal("Error initializing GLEW\n");
if (!GLEW_VERSION_2_0) Fatal("OpenGL 2.0 not supported\n");
#endif
// Set callbacks
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutSpecialFunc(special);
glutKeyboardFunc(key);
glutIdleFunc(idle);
// Make sure enough texture units are available
glGetIntegerv(GL_MAX_TEXTURE_UNITS,&n);
if (n<4) Fatal("Insufficient texture Units %d\n",n);
// Allocate quadric for ball
ball = gluNewQuadric();
// Load daytime textures
day[0] = LoadTexBMP("day01.bmp");
day[1] = LoadTexBMP("day02.bmp");
day[2] = LoadTexBMP("day03.bmp");
day[3] = LoadTexBMP("day04.bmp");
day[4] = LoadTexBMP("day05.bmp");
day[5] = LoadTexBMP("day06.bmp");
day[6] = LoadTexBMP("day07.bmp");
day[7] = LoadTexBMP("day08.bmp");
day[8] = LoadTexBMP("day09.bmp");
day[9] = LoadTexBMP("day10.bmp");
day[10] = LoadTexBMP("day11.bmp");
day[11] = LoadTexBMP("day12.bmp");
// Load nightime texture
glActiveTexture(GL_TEXTURE2);
night = LoadTexBMP("night.bmp");
// Load cloud & gloss texture
glActiveTexture(GL_TEXTURE3);
cloudgloss = LoadTexBMP("cloudgloss.bmp");
// Create shader programs
shader = CreateShaderProg("earth.vert","earth.frag");
// Pass control to GLUT so it can interact with the user
ErrCheck("init");
glutMainLoop();
return 0;
}
void RenderShadowTexture (void)
{
if (!(shadowProg ||
(CreateShaderProg (&shadowProg) &&
CreateShaderFunc (&shadowProg, &shadowFS, &shadowVS, pszShadowFS, pszShadowVS, 1) &&
LinkShaderProg (&shadowProg))))
return;
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
glLoadIdentity ();
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity ();
glOrtho (0, 1, 1, 0, 0, 1);
glDisable (GL_DEPTH_TEST);
glDepthMask (0);
#if 1
glDisable (GL_BLEND);
#else
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
glEnable (GL_TEXTURE_2D);
ogl.SelectTMU (GL_TEXTURE0);
shadowBuf.SetTranspType (0);
if (shadowBuf.Bind (0))
return;
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
#if 0
glUseProgramObject (shadowProg);
glUniform1i (glGetUniformLocation (shadowProg, "shadowTex"), 0);
#endif
glBegin (GL_QUADS);
glTexCoord2d (0,0);
glVertex2d (0,0);
glTexCoord2d (1,0);
glVertex2d (0.5,0);
glTexCoord2d (1,-1);
glVertex2d (0.5,0.5);
glTexCoord2d (0,-1);
glVertex2d (0,0.5);
glEnd ();
if (ogl.m_states.bShadersOk)
glUseProgramObject (0);
glEnable (GL_DEPTH_TEST);
glDepthMask (1);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glPopMatrix ();
}
void InitHeadlightShaders (int nLights)
{
int i, j, bOk;
char *pszFS;
if (nLights < 0) {
nLights = gameData.render.ogl.nHeadLights;
gameData.render.ogl.nHeadLights = 0;
}
if (nLights == gameData.render.ogl.nHeadLights)
return;
gameStates.render.bHaveDynLights = 0;
PrintLog ("building lighting shader programs\n");
if ((gameStates.ogl.bHeadLight = (gameStates.ogl.bShadersOk && gameOpts->render.nPath))) {
gameStates.render.bHaveDynLights = 1;
for (i = 0; i < 2; i++) {
for (j = 0; j < 4; j++) {
if (headLightShaderProgs [i][j])
DeleteShaderProg (&headLightShaderProgs [i][j]);
#if 1//ndef _DEBUG
if (nLights == 1)
pszFS = headLightFS [i][j];
else
#endif
pszFS = BuildLightingShader (headLightFS [i][j + 4], nLights);
bOk = (pszFS != NULL) &&
CreateShaderProg (&headLightShaderProgs [i][j]) &&
CreateShaderFunc (&headLightShaderProgs [i][j], &lfs [i][j], &lvs [i][j], pszFS, headLightVS [i][j], 1) &&
LinkShaderProg (&headLightShaderProgs [i][j]);
if (pszFS && (nLights > 1))
D2_FREE (pszFS);
if (!bOk) {
DeleteHeadLightShader ();
nLights = 0;
break;
}
}
}
}
gameData.render.ogl.nHeadLights = nLights;
}
void InitLightingShaders (int nLights)
{
int i, bOk;
char *pszFS;
if (nLights < 0) {
nLights = gameData.render.ogl.nHeadLights;
gameData.render.ogl.nHeadLights = 0;
}
if (nLights == gameData.render.ogl.nHeadLights)
return;
gameStates.render.bHaveDynLights = 0;
LogErr ("building lighting shader programs\n");
if ((gameStates.ogl.bHeadLight = (gameStates.ogl.bShadersOk && gameOpts->render.nPath))) {
gameStates.render.bHaveDynLights = 1;
for (i = 0; i < 4; i++) {
if (lightingShaderProgs [i])
DeleteShaderProg (lightingShaderProgs + i);
#ifndef _DEBUG
if (nLights == 1)
pszFS = lightingFS [i];
else
#endif
pszFS = BuildLightingShader (lightingFS [i + 4], nLights);
bOk = (pszFS != NULL) &&
CreateShaderProg (lightingShaderProgs + i) &&
CreateShaderFunc (lightingShaderProgs + i, lfs + i, lvs + i, pszFS, lightingVS [i % 4], 1) &&
LinkShaderProg (lightingShaderProgs + i);
if (pszFS && (nLights > 1))
D2_FREE (pszFS);
if (!bOk) {
gameStates.ogl.bHeadLight = 0;
while (i)
DeleteShaderProg (lightingShaderProgs + --i);
nLights = 0;
break;
}
}
}
gameData.render.ogl.nHeadLights = nLights;
}
void InitBlurShader (void)
{
int bOk;
PrintLog ("building blur shader program\n");
DeleteShaderProg (NULL);
if (gameStates.ogl.bRender2TextureOk && gameStates.ogl.bShadersOk && RENDERPATH) {
gameStates.ogl.bHaveBlur = 1;
if (hBlurShader)
DeleteShaderProg (&hBlurShader);
bOk = CreateShaderProg (&hBlurShader) &&
CreateShaderFunc (&hBlurShader, &hBlurFS, &hBlurVS, blurFS, blurVS, 1) &&
LinkShaderProg (&hBlurShader);
if (!bOk) {
gameStates.ogl.bHaveBlur = 0;
DeleteShaderProg (&hBlurShader);
return;
}
ogl.ClearError (0);
}
}
/*
* Start up GLUT and tell it what to do
*/
int main(int argc,char* argv[])
{
// Initialize GLUT
glutInit(&argc,argv);
// Make sure a pattern file is specified
if (argc!=2) Fatal("Usage: %s <RLE pattern-file>\n",argv[0]);
file = argv[1];
// Request double buffered, true color window with Z buffering at 600x600
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_ALPHA);
glutInitWindowSize(800,480);
glutCreateWindow("Conway's Game of Life");
#ifdef USEGLEW
// Initialize GLEW
if (glewInit()!=GLEW_OK) Fatal("Error initializing GLEW\n");
if (!GLEW_VERSION_2_0) Fatal("OpenGL 2.0 not supported\n");
#endif
// Set callbacks
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(key);
glutIdleFunc(move?idle:NULL);
// Maximum texture size
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&MaxTexSize);
// Background color
glClearColor(0,0,0,0);
// Create Shader Programs
shader = CreateShaderProg(NULL,"life.frag");
// Image texture
glBindTexture(GL_TEXTURE_2D,img);
// Nearest returns exact cell values
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
// Wrap to create circular universe
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
// Pass control to GLUT so it can interact with the user
ErrCheck("init");
glutMainLoop();
return 0;
}
void InitGlareShader (void)
{
int bOk;
gameStates.ogl.bDepthBlending = 0;
#if SHADER_SOFT_CORONAS
LogErr ("building corona blending shader program\n");
DeleteShaderProg (NULL);
if (gameStates.ogl.bRender2TextureOk && gameStates.ogl.bShadersOk && gameOpts->render.nPath) {
gameStates.ogl.bDepthBlending = 1;
if (hGlareShader)
DeleteShaderProg (&hGlareShader);
bOk = CreateShaderProg (&hGlareShader) &&
CreateShaderFunc (&hGlareShader, &hGlareFS, &hGlareVS, glareFS, glareVS, 1) &&
LinkShaderProg (&hGlareShader);
if (!bOk) {
gameStates.ogl.bDepthBlending = 0;
DeleteShaderProg (&hGlareShader);
}
}
#endif
}
int CreateSphereShader (void)
{
int bOk;
if (!(gameStates.ogl.bShadersOk && gameStates.ogl.bPerPixelLightingOk)) {
gameStates.render.bPerPixelLighting = 0;
return 0;
}
if (sphereShaderProg)
return 1;
PrintLog ("building sphere shader program\n");
if (!sphereShaderProg) {
bOk = CreateShaderProg (&sphereShaderProg) &&
CreateShaderFunc (&sphereShaderProg, &sphereFS, &sphereVS, pszSphereFS, pszSphereVS, 1) &&
LinkShaderProg (&sphereShaderProg);
if (!bOk) {
gameStates.ogl.bPerPixelLightingOk = 0;
gameStates.render.bPerPixelLighting = 0;
return -1;
}
}
return 1;
}
void InitLightmapShaders (void)
{
int i;
if (!gameStates.ogl.bShadersOk)
gameStates.render.color.bLightMapsOk = 0;
if (gameStates.render.color.bLightMapsOk) {
LogErr ("building lightmap shader programs\n");
for (i = 0; i < 2; i++) {
if (lmShaderProgs [i])
DeleteShaderProg (lmShaderProgs + i);
gameStates.render.color.bLightMapsOk =
CreateShaderProg (lmShaderProgs + i) &&
CreateShaderFunc (lmShaderProgs + i, lmFS + i, lmVS + i, lightMapFS [i], lightMapVS [i], 1) &&
LinkShaderProg (lmShaderProgs + i);
if (!gameStates.render.color.bLightMapsOk) {
while (i)
DeleteShaderProg (lmShaderProgs + --i);
break;
}
}
}
}
void InitGlareShader (void)
{
int bOk;
ogl.m_states.bDepthBlending = 0;
#if SHADER_SOFT_CORONAS
PrintLog ("building corona blending shader program\n");
DeleteShaderProg (NULL);
if (ogl.m_states.bRender2TextureOk && ogl.m_states.bShadersOk) {
ogl.m_states.bDepthBlending = 1;
if (hGlareShader)
DeleteShaderProg (&hGlareShader);
bOk = CreateShaderProg (&hGlareShader) &&
CreateShaderFunc (&hGlareShader, &hGlareFS, &hGlareVS, glareFS, glareVS, 1) &&
LinkShaderProg (&hGlareShader);
if (!bOk) {
ogl.m_states.bDepthBlending = 0;
DeleteShaderProg (&hGlareShader);
return;
}
ogl.ClearError (0);
}
#endif
}
int CreateShaderFunc (GLhandleARB *progP, GLhandleARB *fsP, GLhandleARB *vsP,
const char *fsName, const char *vsName, int bFromFile)
{
GLhandleARB fs, vs;
GLint bFragCompiled, bVertCompiled;
if (!gameStates.ogl.bShadersOk)
return 0;
if (!CreateShaderProg (progP))
return 0;
if (*fsP) {
glDeleteObject (*fsP);
*fsP = 0;
}
if (*vsP) {
glDeleteObject (*vsP);
*vsP = 0;
}
if (!(vs = glCreateShaderObject (GL_VERTEX_SHADER)))
return 0;
if (!(fs = glCreateShaderObject (GL_FRAGMENT_SHADER))) {
glDeleteObject (vs);
return 0;
}
#if DBG_SHADERS
if (bFromFile) {
vsName = LoadShader (vsName);
fsName = LoadShader (fsName);
if (!vsName || !fsName)
return 0;
}
#endif
glShaderSource (vs, 1, reinterpret_cast<const GLcharARB **> (&vsName), NULL);
glShaderSource (fs, 1, reinterpret_cast<const GLcharARB **> (&fsName), NULL);
#if DBG_SHADERS
if (bFromFile) {
delete[] vsName;
delete[] fsName;
}
#endif
glCompileShader (vs);
glCompileShader (fs);
glGetObjectParameteriv (vs, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled);
glGetObjectParameteriv (fs, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled);
if (!bVertCompiled || !bFragCompiled) {
if (!bVertCompiled) {
PrintLog (" Couldn't compile vertex shader\n \"%s\"\n", vsName);
PrintShaderInfoLog (vs, 0);
}
if (!bFragCompiled) {
PrintLog (" Couldn't compile fragment shader\n \"%s\"\n", fsName);
PrintShaderInfoLog (fs, 0);
}
return 0;
}
glAttachObject (*progP, vs);
glAttachObject (*progP, fs);
*fsP = fs;
*vsP = vs;
return 1;
}
