bool handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
{
switch(ea.getEventType())
{
case osgGA::GUIEventAdapter::KEYDOWN:
switch(ea.getKey())
{
case osgGA::GUIEventAdapter::KEY_Space:
*bRotate = !(*bRotate);
return false;
case '1':
loadTextureImage(strokeTex, "../data/strokeNoise.png");
return false;
case '2':
loadTextureImage(strokeTex, "../data/strokeDiag.png");
return false;
default:
return false;
}
default:
return false;
}
}
void Target_init() {
loadTextureImage();
glEnableClientState(GL_VERTEX_ARRAY);
Shell_mainLoop();
}
QImage* Texture::getTextureImage()
{
if (!imageLoaded) {
loadTextureImage();
}
return &textureImage;
}
static void cycleTextures(int direction) {
textureIndex += direction;
if (textureIndex < 0) {
textureIndex += NUM_TEXTURES;
} else if (textureIndex >= NUM_TEXTURES) {
textureIndex -= NUM_TEXTURES;
}
loadTextureImage();
Shell_redisplay();
}
void Texture::generateTexture()
{
if (fileName != "" && textVertexArray != 0) {
// bind texture to image
loadTextureImage();
releaseTexture();
// generate id
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexImage2D(GL_TEXTURE_2D, 0, 4,//GL_RGBA,
textureImage.width(), textureImage.height(),
0, GL_RGBA, GL_UNSIGNED_BYTE, textureImage.bits());
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
}
}
/**
* Initialisiert das Programm (inkl. I/O und OpenGL) und startet die
* Ereignisbehandlung.
* @param title Beschriftung des Fensters
* @param width Breite des Fensters
* @param height Hoehe des Fensters
* @return ID des erzeugten Fensters, 0 im Fehlerfall
*/
int initAndStartIO (char *title, int width, int height)
{
int windowID = 0;
/* Kommandozeile immitieren */
int argc = 1;
char *argv = "cmd";
G_Width = width;
G_Height = height;
G_NearPlane = 0.1;
G_FarPlane = 1000;
/* Glut initialisieren */
glutInit (&argc, &argv);
/* FensterInitialisierung */
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
/* FensterGröße */
glutInitWindowSize (G_Width, G_Height);
/* FensterPosition */
glutInitWindowPosition (0, 0);
windowID = glutCreateWindow (title);
if (windowID)
{
/* Hintergrund und so werden initialisiert (Farben) */
if (initScene ())
{
G_ShaderID = loadShaders("waterVertexShader.vert", "waterFragmentShader.frag");
G_ShaderTerrain = loadShaders("textureVertexShader.vert", "textureFragmentShader.frag");
G_ShaderColor = loadShaders("colorVertexShader.vert", "colorFragmentShader.frag");
G_ShaderDepth = loadShaders("textureVertexShader.vert", "textureDepthFragmentShader2.frag");
registerCallBacks ();
allocateMemoryStuffDepth(&G_TexCamera, &G_TexCameraDepth, &G_fboCam);
G_sampler2dLoc = glGetUniformLocation(G_ShaderID, "texsampler");
G_samplerDepth2dLoc = glGetUniformLocation(G_ShaderID, "texsamplerDepth");
Image * imageSand, * imageGrass, * imageRocks, * imageSnow, * imageForest, * imageTundra;
imageSand = malloc(sizeof(Image));
imageGrass = malloc(sizeof(Image));
imageRocks = malloc(sizeof(Image));
imageSnow = malloc(sizeof(Image));
imageForest = malloc(sizeof(Image));
imageTundra = malloc(sizeof(Image));
loadTextureImage(imageSand, "sand1.bmp", &G_TexImageSand );
loadTextureImage(imageGrass, "gras2.bmp", &G_TexImageGrass);
loadTextureImage(imageRocks, "rocks.bmp", &G_TexImageRocks);
loadTextureImage(imageSnow, "snow.bmp", &G_TexImageSnow);
loadTextureImage(imageForest, "forest.bmp", &G_TexImageForest);
loadTextureImage(imageTundra, "tundra.bmp", &G_TexImageTundra);
/* Wasser */
glGenBuffers (1, &G_WaterBuffer);
glBindBuffer (GL_ARRAY_BUFFER, G_WaterBuffer);
glBufferData (GL_ARRAY_BUFFER, sizeof(*getWaterList())*WORLD_SIZE*WORLD_SIZE, getWaterList(), GL_STREAM_DRAW);
glBindBuffer (GL_ARRAY_BUFFER, 0);
glGenBuffers (1, &G_WaterBufferIndex);
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, G_WaterBufferIndex);
glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof(*getWaterIndices())*WORLD_SIZE*WORLD_SIZE*3*2, getWaterIndices(), GL_STREAM_DRAW);
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
/* Terrain */
glGenBuffers (1, &G_TerrainBuffer);
glBindBuffer (GL_ARRAY_BUFFER, G_TerrainBuffer);
glBufferData (GL_ARRAY_BUFFER, sizeof(*getTerrainList())*TERRAIN_SIZE*TERRAIN_SIZE, getTerrainList(), GL_STATIC_DRAW);
glBindBuffer (GL_ARRAY_BUFFER, 0);
glGenBuffers (1, &G_TerrainBufferIndex);
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, G_TerrainBufferIndex);
glBufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof(*getTerrainIndices())*TERRAIN_SIZE*TERRAIN_SIZE*3*2, getTerrainIndices(), GL_STATIC_DRAW);
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0.0, 1.0, 1.0, 0.0);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Die Endlosschleife wird angestoßen */
glutMainLoop ();
windowID = 0;
glDeleteFramebuffers(1, &G_fboCam);
glDeleteTextures(1, &G_TexCamera);
glDeleteTextures(1, &G_TexCameraDepth);
}
else
{
glutDestroyWindow (windowID);
windowID = 0;
}
}
return windowID;
}
int main()
{
osg::Node *mesh;
osg::Group *root;
osgViewer::Viewer viewer;
osg::Texture2D *strokeTex;
osg::Texture2D *backTex;
osg::Texture2D *renTex;
osg::ref_ptr<osg::Geode> quadGeode;
osg::ref_ptr<osg::Camera> texCamera;
osg::ref_ptr<osg::Camera> screenCamera;
osg::Vec3 meshPos;
osg::PositionAttitudeTransform *meshTrans;
bool bRotate = false;
float width = 800;
float height = 600;
mesh = osgDB::readNodeFile("../data/woman.3ds");
// preprocess effect - applies shaders
SketchPre *effSketchPre = new SketchPre();
// postprocess effect - applies shaders
SketchPost *effSketchPost = new SketchPost();
// prepare the base of scene graph
root = new osg::Group();
meshTrans = new osg::PositionAttitudeTransform();
meshTrans->addChild(mesh);
strokeTex = setupStrokeTexture();
loadTextureImage(strokeTex, "../data/strokeNoise.png");
backTex = setupBackTexture();
loadTextureImage(backTex, "../data/paper.png");
renTex = setupRenTexture(width, height);
quadGeode = setupRenQuad(width, height, renTex, strokeTex, backTex);
texCamera = setupTexCamera(width, height, renTex);
screenCamera = setupScreenCamera(width, height);
// prepare the rest of the scene graph
// first rendering scene to texture
// second rendering the resulting texture to screen
texCamera->addChild(effSketchPre);
effSketchPre->addChild(meshTrans);
screenCamera->addChild(effSketchPost);
effSketchPost->addChild(quadGeode.get());
root->addChild(texCamera.get());
root->addChild(screenCamera.get());
// setup keyboard handler
KeyEventHandler *keyHandler = new KeyEventHandler(&bRotate, strokeTex);
viewer.addEventHandler(keyHandler);
// we would like a windowed application
viewer.setUpViewInWindow(0, 0, width, height);
viewer.setSceneData(root);
viewer.realize();
// position the object proprly so we can see it
meshPos.set(0, 0, -10);
meshTrans->setPosition(meshPos);
// and rotate it a little bit
osg::Quat quat;
float angle = 0.5;
quat.makeRotate(angle, 0.0, 1.0, 0.0);
meshTrans->setAttitude(quat);
float timeLast, timeCur = viewer.getFrameStamp()->getReferenceTime();
while(!viewer.done())
{
timeLast = timeCur;
timeCur = viewer.getFrameStamp()->getReferenceTime();
if (bRotate)
{
// rotate the object according to elapsed time
// from previous frame
angle += (timeCur-timeLast) * 0.2;
quat.makeRotate(angle, 0.0, 1.0, 0.0);
meshTrans->setAttitude(quat);
}
viewer.frame();
}
return 0;
}
static void toggleAutoMipmap() {
autoMipmap = !autoMipmap;
loadTextureImage();
Shell_redisplay();
}
/**
* Initializes the program (including io and OpenGL) and starts the
* event handling.
*/
int initAndStartIO (char *title, int width, int height)
{
int windowID = 0;
G_Width = width;
G_Height = height;
G_WindowTitle = title;
int argc = 1;
char *argv = "cmd";
G_NearPlane = 0.5;
G_FarPlane = 50.0;
/* initialize GLUT */
glutInit (&argc, &argv);
/* initialize window */
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
/* window size */
glutInitWindowSize (G_Width, G_Height);
/* window position */
glutInitWindowPosition (0, 0);
windowID = glutCreateWindow (G_WindowTitle);
if (windowID)
{
/* Background color and other stuff initialization */
if (initScene ())
{
printf ("--> Load shaders...\n"); fflush(stdout);
registerCallBacks ();
/*
* Load shaders from file
*/
G_ShaderTexture = loadShaders("textureVertexShader.vert", "textureFragmentShader.frag");
G_ShaderColor = loadShaders("colorVertexShader.vert", "colorFragmentShader.frag");
G_ShaderPosColor = loadShaders("posColorVertexShader.vert", "colorFragmentShader.frag");
G_ShaderDepthTexture = loadShaders("textureVertexShader.vert", "textureDepthFragmentShader.frag");
printf ("--> Shaders are loaded.\n"); fflush(stdout);
/*
* Load texture from file
*/
Image * imageRocks;
imageRocks = malloc(sizeof(Image));
loadTextureImage(imageRocks, "sunset-red.bmp", &G_TexImageRocks);
/*
* Create buffer for the object we want to draw.
*/
glGenBuffers(1, &G_ObjectsBuffer);
glBindBuffer(GL_ARRAY_BUFFER, G_ObjectsBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(G_Objects)*sizeof(GLfloat), G_Objects, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
allocateMemoryStuffDepth(&G_TexCamera, &G_TexCameraDepth, &G_fboCam);
printf ("--> Finished Initialization.\n"); fflush(stdout);
/* Endless loop is started. */
glutMainLoop ();
windowID = 0;
} else {
glutDestroyWindow (windowID);
return 0;
}
} else {
return 0;
}
glutDestroyWindow (windowID);
return 1;
}
