src/main_test.cpp

#include "glux_engine/engine.h"
using namespace std;

//FPS
unsigned cycle = 0;                     //drawn cycles in one second 
unsigned fps;

//scene
TScene *s;          
char msg[32];
bool wire = false;                    //wireframe rendering flag
int fsaa;
float anim = 0.0;
TVector lpos1(-30.0,45.0,5.0),lpos2(0.0,1.0,0.0);

//*****************************************************************************
//Initialize OpenGL settings for scene
bool InitScene(int resx, int resy)
{ 
  s = new TScene();
  if(!s->PreInit(resx, resy, 0.1, 1000.0, 45.0, 0)) 
    return false;

                        //toggle HDR
                        s->UseHDR(true);

                        //prepare render to texture
                        s->CreateRenderTarget();

                //position camera
                s->MoveCamera(1.0,-3.0,-24.0);
                s->RotateCamera(5.0, A_X);
                s->RotateCamera(60.0, A_Y);

                        //lights
                        s->AddLight(0,grey,white,white,lpos1);
                        s->AddLight(1,grey,silver,grey,TVector(-20.0,20.0,10.0));
                        s->SetShadow(0,4096);

                        s->LoadScene("data/obj/scenes/chata.3ds");
                        //additional materials&textures
                        s->AddMaterial("mat_sky",white,white,white,0.0,0.0,0.0,NONE);
                        s->AddTexture("matleaf","data/tex/alpha/leafs4.tga",ALPHA);
                        s->AddTexture("matgrass","data/tex/alpha/grass.tga",ALPHA);
                        s->AddTexture("matroad","data/tex/dirtroad.tga",BASE,MODULATE,1.0,1.0,1.0,true,true);
                        s->AddTexture("matroad","data/tex/normal/bump.tga",BUMP,MODULATE,1.0,1.0,1.0,true,true);
                        s->AddTexture("matroof","data/tex/roof.tga",BASE,MODULATE,1.0,1.0,1.0,true,true);
                        const char *cubemap[] = { "data/tex/cubemaps/sky/posx.tga", "data/tex/cubemaps/sky/negx.tga",
                                                                                                                                "data/tex/cubemaps/sky/posy.tga", "data/tex/cubemaps/sky/negy.tga",
                                                                                                                                "data/tex/cubemaps/sky/posz.tga", "data/tex/cubemaps/sky/negz.tga" };
                        s->AddTexture("mat_sky",cubemap);
                        //load objects
                        s->AddObject("sky",SPHERE,200.0,0.0,8,8);

                        //set materials
                        s->SetMaterial("sky","mat_sky");

                        //cast/receive shadows
                        s->CastShadow("sky",false);
                        s->CastShadow("ground",false);
                        s->ReceiveShadow("mat_sky",false);

                        //General HDR settings
                        s->SetUniform("mat_bloom_hdr","THRESHOLD",0.0);
                        s->SetUniform("mat_tonemap","exposure",1.0);
                        s->SetUniform("mat_tonemap","bloomFactor",1.0);
                        s->SetUniform("mat_tonemap","brightMax",1.2);

                        //blur
                        s->SetUniform("mat_blur_horiz","kernel_size",9);
                        s->SetUniform("mat_blur_horiz","blur_radius",0.003);
                        s->SetUniform("mat_blur_vert","kernel_size",9);
                        s->SetUniform("mat_blur_vert","blur_radius",0.003);

  return s->PostInit();
}

string name;
//*****************************************************************************
//Main drawing function
void Redraw()
{
        //move light
        lpos1.z = 50.0 * sin(anim);
        lpos1.y = 30.0 * abs(cos(anim)) + 10.0;
        s->MoveLight(0,lpos1);
        s->SetUniform("mat_tonemap","exposure",abs(cos(anim)) + 0.05);

  s->Redraw();
  cycle++;                          //increment draw counter 

  //FPS info
  sprintf(msg,"%d fps",fps);
  s->DrawScreenText(msg,50.0,1.0,1.0);           

        //meminfo
        int meminfo[4];
        glGetIntegerv(GL_TEXTURE_FREE_MEMORY_ATI,meminfo);
        sprintf(msg,"VRAM used: %d MB",1024 - meminfo[0]/1024);
  s->DrawScreenText(msg,10.0,1.0,1.0); 
}

//*****************************************************************************
//Keyboard input
const float INC = 0.5;
bool use_ssao = true;
void KeyInput(SDLKey key)
{
        lpos1 = s->GetLightPos(0);
  switch(key)
  {     
    case SDLK_x:         //X - wireframe
        wire = !wire;
        if(wire) glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
        else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
        break;

    //main light movement
    case SDLK_w: lpos1.z -= INC; s->MoveLight(0,lpos1); break;
    case SDLK_s: lpos1.z += INC; s->MoveLight(0,lpos1); break;
    case SDLK_a: lpos1.x -= INC; s->MoveLight(0,lpos1); break;
    case SDLK_d: lpos1.x += INC; s->MoveLight(0,lpos1); break;
    case SDLK_q: lpos1.y += INC; s->MoveLight(0,lpos1); break;
    case SDLK_e: lpos1.y -= INC; s->MoveLight(0,lpos1); break;

                case SDLK_c: s->UseShadows(true); break;
                case SDLK_v: s->UseShadows(false); break;
                case SDLK_b: s->UseHDR(true); break;
                case SDLK_n: s->UseHDR(false); break;

    case SDLK_ESCAPE:        //ESCAPE - quit
        SDL_Quit();
        exit(0);
        break;
    default:
        break;
  }
        cout<<lpos1.x<<","<<lpos1.y<<","<<lpos1.z<<endl;
}

int status;                                     //which button?
void MouseClick(SDL_Event event)
{ 
  if(event.button.state = SDL_RELEASED) 
    status = 0;
  else
    status = event.button.button;
}

void MouseMotion(SDL_Event event)
{
  int x = event.motion.xrel;
  int y = event.motion.yrel;

  if(status == SDL_BUTTON_LEFT)   //rotate
  {
    s->RotateCamera(y, A_X);
    s->RotateCamera(x, A_Y);
  }
  else if(status == /* wtf??? proc nefuguje??SDL_BUTTON_RIGHT */ 4)  //zoom
    s->MoveCamera(0.0,0.0, x/10.0 );
  else if(status == SDL_BUTTON_MIDDLE)  //position
    s->MoveCamera( x/10.0, -y/10.0, 0.0);
  
  //print out camera position
  //s->PrintCamera();
}

void WrongParams()
{
  cout<<"Wrong parameters.\n"
    "Usage: gluxEngine.exe [-w|-f resX resY][-aa value]\n"
    "Parameters:\n"
    "-w,-f: windowed/fullscreen mode\n"
    "resX, resY: screen resolution in pixels\n"
    "-aa: antialiasing strength (0,1 = off)\n";
  exit(1);
}


//********************************* MAIN ********************************************************//
int main(int argc, char **argv)
{
  //application settings
  string param;
  int fsaa = 1;
  bool fullscreen = false;
  int resx = 1024, resy = 640;

  //parse parameters
  for(int i=1; i<argc; i++)
  {
    param = argv[i];
    //fullscreen/windowed mode
    if(param == "-w" || param == "-f")
    {
      if(param == "-w")
        fullscreen = false;
      else if(param == "-f")
        fullscreen = true;
      //display resolution
      if(i+2 < argc)
      {
        resx = atoi(argv[i+1]);
        resy = atoi(argv[i+2]);
        i += 2;
      }
      else
        WrongParams();
    }
    //antialiasing
    else if(param == "-aa")
    {
      if(i+1 < argc)
      {
        fsaa = atoi(argv[i+1]);
        i++;
      }
      else
        WrongParams();
    }
    //error
    else
      WrongParams();
  }

  //initialize SDL video
  if(SDL_Init(SDL_INIT_VIDEO) < 0) exit(1);

  //request an opengl 3.2 context. If isn't supported, fall back to 3.1 or 3.0
  if(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3) == -1)
  {
    ShowMessage("OpenGL 3.0 not supported :(\n",false);
    SDL_Quit();
    exit(1);
  }

  if(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2) == -1)
  {
    cout<<"OpenGL 3.2 not supported, falling back to 3.1\n";
    if(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1) == -1)
    {
      cout<<"OpenGL 3.1 not supported, falling back to 3.0\n";
      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
    }
  }

  //enable double buffering with a 24bit Z buffer.
  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

  //enable multisampling
  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
  SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fsaa);

  SDL_WM_SetCaption("gluxEngine", 0);

  //set video mode
  int mode = SDL_OPENGL;
  if(fullscreen)
    mode |= SDL_FULLSCREEN;
  if(SDL_SetVideoMode(resx, resy, 32, mode) == NULL)
  {
    ShowMessage("Display mode not supported!\n");
    SDL_Quit();
    return 1;
  }

        //init GLEW
        if(glewInit() != GLEW_OK)
        {
    ShowMessage("GLEW initialization failed!\n");
    SDL_Quit();
    return 1;
        }

  //init scene
  if(!InitScene(resx,resy)) exit(1);

  //Main loop
        SDLKey key;
        bool keypress = false;
  SDL_Event event;
  int time_now, time_nextMS, time_nextS, last_keypress;
  time_now = time_nextMS = time_nextS = SDL_GetTicks();
  while(true)
  {
    //measure time
    time_now = SDL_GetTicks();

    if(time_now >= time_nextMS) //increment animation after 10ms
    {
      anim += 0.01;
      time_nextMS += 10;
    }
    if(time_now >= time_nextS) //increment time after one second
    {
      time_nextS += 1000;
      //save FPS
      fps = cycle;
      cycle = 0;
    }

    //handle events with SDL
    if(SDL_PollEvent(&event))
    {
      if(event.type == SDL_QUIT)
        break;
      //keyboard events
      else if(event.type == SDL_KEYDOWN)
                        {
        keypress = true;
                                last_keypress = time_now;
                                key = event.key.keysym.sym;             //store pressed key
                        }
      else if(event.type == SDL_KEYUP)
        keypress = false;
      //mouse events
      else if(event.type == SDL_MOUSEMOTION)
      {
        MouseMotion(event);
        MouseClick(event);
      }
    }

                //call keyboard handle when key pressed
                if(keypress && (time_now - last_keypress > 150 || last_keypress == time_now) ) 
                        KeyInput(key);

    //call drawing function
    Redraw();
    SDL_GL_SwapBuffers();
  }

  //deinitialize SDL
  SDL_Quit();
  return 0;
}

---