void ofAppGLFWWindow::setupOpenGL(int w, int h, int screenMode){
requestedWidth = w;
requestedHeight = h;
if(!glfwInit( )){
ofLog(OF_LOG_ERROR,"cannot init GLFW");
return;
}
windowMode = screenMode;
glfwOpenWindowHint( GLFW_FSAA_SAMPLES, samples );
// targets default
// GLFW_REFRESH_RATE 0
// GLFW_ACCUM_RED_BITS; 0
// GLFW_ACCUM_GREEN_BITS; 0
// GLFW_ACCUM_BLUE_BITS; 0
// GLFW_ACCUM_ALPHA_BITS; 0
// GLFW_AUX_BUFFERS; 0
// GLFW_STEREO; 0
// GLFW_WINDOW_NO_RESIZE; 0
// GLFW_FSAA_SAMPLES; 0
if (windowMode == OF_WINDOW){
glfwOpenWindow(
w, h, // Width and height of window
8, 8, 8, // Number of red, green, and blue bits for color buffer
8, // Number of bits for alpha buffer
24, // Number of bits for depth buffer (Z-buffer)
0, // Number of bits for stencil buffer
GLFW_WINDOW // We want a desktop window (could be GLFW_FULLSCREEN)
);
}else if(windowMode == OF_FULLSCREEN){
glfwOpenWindow(
getScreenSize().x, getScreenSize().y, // Width and height of window
8, 8, 8, // Number of red, green, and blue bits for color buffer
8, // Number of bits for alpha buffer
24, // Number of bits for depth buffer (Z-buffer)
0, // Number of bits for stencil buffer
GLFW_FULLSCREEN // We want a desktop window (could be GLFW_FULLSCREEN)
);
showCursor();
}else if(windowMode == OF_GAME_MODE){
glfwOpenWindow(
w, h, // Width and height of window
8, 8, 8, // Number of red, green, and blue bits for color buffer
8, // Number of bits for alpha buffer
24, // Number of bits for depth buffer (Z-buffer)
0, // Number of bits for stencil buffer
GLFW_FULLSCREEN // We want a desktop window (could be GLFW_FULLSCREEN)
);
showCursor();
}
setVerticalSync(false);
// Set window title
glfwSetWindowTitle( " " );
glfwEnable( GLFW_KEY_REPEAT );
ofBackground(200,200,200); // default bg color
ofSetColor(0xFFFFFF); // default draw color
// used to be black, but
// black + texture = black
// so maybe grey bg
// and "white" fg color
// as default works the best...
requestedHeight = requestedHeight < 1 ? 1 : requestedHeight;
glfwGetWindowSize( &requestedWidth, &requestedHeight );
nonFullScreenW = ofGetWidth();
nonFullScreenH = ofGetHeight();
setWindowPosition(50, 50);
}
int main(int argc, char **args)
{
if (!glfwInit()) {
std::cerr << "Failed to initialize GLFW" << std::endl;
exit(EXIT_FAILURE);
}
int depth_bits = 16;
if (!glfwOpenWindow(640, 480, 0, 0, 0, 0, depth_bits, 0, GLFW_WINDOW)) {
std::cerr << "Failed to open GLFW window" << std::endl;
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwGetWindowSize(&screen_width, &screen_height);
glfwSetWindowTitle("Teapot");
glfwEnable(GLFW_STICKY_KEYS);
glfwSwapInterval(1);
shader_program_t shader_program;
shader_program_t::build(shader_program, "diffuse.vs", "diffuse.fs");
mesh_t teapot;
if (! mesh_t::read_from_file("teapot.ctm", teapot)) {
std::cerr << "Failed to read ctm file" << std::endl;
glfwTerminate();
exit(EXIT_FAILURE);
}
teapot.load_to_buffers();
projection_matrix = glm::perspective(camera_fovy, (float) screen_width / (float) screen_height, 1.0f, 30.0f);
glm::vec3 camera_position(0.0f, 0.0f, 3.0f);
glm::vec3 camera_center(0.0f, 0.0f, 0.0f);
glm::vec3 camera_up(0.0f, 1.0f, 0.0f);
view_matrix = glm::lookAt(camera_position, camera_center, camera_up); // from world to camera
normal_matrix = glm::mat3(glm::transpose(glm::inverse(view_matrix)));
light_direction = glm::vec3(0.0, -1.0, 0.0);
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
do {
{
glCullFace(GL_BACK);
glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, screen_width, screen_height);
shader_program.bind();
shader_program.set_uniform_value("light_direction", light_direction);
shader_program.set_uniform_value("projection_matrix", projection_matrix);
shader_program.set_uniform_value("model_view_matrix", view_matrix);
shader_program.set_uniform_value("normal_matrix", normal_matrix);
teapot.render(shader_program);
shader_program.release();
}
glfwSwapBuffers();
}
while (glfwGetKey(GLFW_KEY_ESC) != GLFW_PRESS && glfwGetWindowParam(GLFW_OPENED));
glfwTerminate();
return 0;
}
int main( int argc, char **argv )
{
int width = 1024, height=768;
float widthf = (float) width, heightf = (float) height;
double t;
float fps = 0.f;
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
exit( EXIT_FAILURE );
}
// Force core profile on Mac OSX
#ifdef __APPLE__
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#endif
// Open a window and create its OpenGL context
if( !glfwOpenWindow( width, height, 0,0,0,0, 24, 0, GLFW_WINDOW ) )
{
fprintf( stderr, "Failed to open GLFW window\n" );
glfwTerminate();
exit( EXIT_FAILURE );
}
glfwSetWindowTitle( "002_forward_a" );
// Core profile is flagged as experimental in glew
#ifdef __APPLE__
glewExperimental = GL_TRUE;
#endif
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
exit( EXIT_FAILURE );
}
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Enable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
GLenum glerr = GL_NO_ERROR;
glerr = glGetError();
if (!imguiRenderGLInit(DroidSans_ttf, DroidSans_ttf_len))
{
fprintf(stderr, "Could not init GUI renderer.\n");
exit(EXIT_FAILURE);
}
// Init viewer structures
Camera camera;
camera_defaults(camera);
GUIStates guiStates;
init_gui_states(guiStates);
// GUI
float intensity = 1.0;
// Load images and upload textures
GLuint textures[3];
glGenTextures(3, textures);
int x;
int y;
int comp;
unsigned char * diffuse = stbi_load("textures/spnza_bricks_a_diff.tga", &x, &y, &comp, 3);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, x, y, 0, GL_RGB, GL_UNSIGNED_BYTE, diffuse);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Diffuse %dx%d:%d\n", x, y, comp);
unsigned char * spec = stbi_load("textures/spnza_bricks_a_spec.tga", &x, &y, &comp, 1);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, x, y, 0, GL_RED, GL_UNSIGNED_BYTE, spec);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
fprintf(stderr, "Spec %dx%d:%d\n", x, y, comp);
// Try to load and compile shader
ShaderGLSL shader;
const char * shaderFile = "002/1.glsl";
//int status = load_shader_from_file(shader, shaderFile, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER | ShaderGLSL::GEOMETRY_SHADER);
int status = load_shader_from_file(shader, shaderFile, ShaderGLSL::VERTEX_SHADER | ShaderGLSL::FRAGMENT_SHADER);
if ( status == -1 )
{
fprintf(stderr, "Error on loading %s\n", shaderFile);
exit( EXIT_FAILURE );
}
// Apply shader
GLuint program = shader.program;
glUseProgram(program);
GLuint projectionLocation = glGetUniformLocation(program, "Projection");
GLuint viewLocation = glGetUniformLocation(program, "View");
GLuint objectLocation = glGetUniformLocation(program, "Object");
GLuint timeLocation = glGetUniformLocation(program, "Time");
GLuint diffuseLocation = glGetUniformLocation(program, "Diffuse");
GLuint specLocation = glGetUniformLocation(program, "Spec");
GLuint intensityLocation = glGetUniformLocation(program, "Intensity");
GLuint cameraPositionLocation = glGetUniformLocation(program, "CameraPosition");
GLuint lightPositionLocation = glGetUniformLocation(program, "LightPosition");
GLuint lightIntensityLocation = glGetUniformLocation(program, "LightIntensity");
GLuint diffuseColorLocation = glGetUniformLocation(program, "DiffuseColor");
GLuint specularColorLocation = glGetUniformLocation(program, "SpecularColor");
GLuint specularFactorLocation = glGetUniformLocation(program, "SpecularFactor");
GLuint lightPositionLocation2 = glGetUniformLocation(program, "LightPosition2");
GLuint lightIntensityLocation2 = glGetUniformLocation(program, "LightIntensity2");
GLuint diffuseColorLocation2 = glGetUniformLocation(program, "DiffuseColor2");
GLuint specularColorLocation2 = glGetUniformLocation(program, "SpecularColor2");
GLuint specularFactorLocation2 = glGetUniformLocation(program, "SpecularFactor2");
GLuint spotLightExternalAngleLocation = glGetUniformLocation(program, "SpotLightExternalAngle");
GLuint spotLightInternalAngleLocation = glGetUniformLocation(program, "SpotLightInternalAngle");
// Load geometry
int cube_triangleCount = 12;
int cube_triangleList[] = {0, 1, 2, 2, 1, 3, 4, 5, 6, 6, 5, 7, 8, 9, 10, 10, 9, 11, 12, 13, 14, 14, 13, 15, 16, 17, 18, 19, 17, 20, 21, 22, 23, 24, 25, 26, };
float cube_uvs[] = {0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 0.f, 0.f, 0.f, 1.f, 1.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f, 1.f, 1.f, 0.f, 0.f, 0.f, 0.f, 1.f, 1.f, 1.f, 0.f, };
float cube_vertices[] = {-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5 };
float cube_normals[] = {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, };
int plane_triangleCount = 2;
int plane_triangleList[] = {0, 1, 2, 2, 1, 3};
float plane_uvs[] = {0.f, 0.f, 0.f, 10.f, 10.f, 0.f, 10.f, 10.f};
float plane_vertices[] = {-50.0, -1.0, 50.0, 50.0, -1.0, 50.0, -50.0, -1.0, -50.0, 50.0, -1.0, -50.0};
float plane_normals[] = {0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0};
// Vertex Array Object
GLuint vao[2];
glGenVertexArrays(2, vao);
// Vertex Buffer Objects
GLuint vbo[8];
glGenBuffers(8, vbo);
// Cube
glBindVertexArray(vao[0]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_triangleList), cube_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_normals), cube_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_uvs), cube_uvs, GL_STATIC_DRAW);
// Plane
glBindVertexArray(vao[1]);
// Bind indices and upload data
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[4]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(plane_triangleList), plane_triangleList, GL_STATIC_DRAW);
// Bind vertices and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[5]);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_vertices), plane_vertices, GL_STATIC_DRAW);
// Bind normals and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[6]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*3, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_normals), plane_normals, GL_STATIC_DRAW);
// Bind uv coords and upload data
glBindBuffer(GL_ARRAY_BUFFER, vbo[7]);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(GL_FLOAT)*2, (void*)0);
glBufferData(GL_ARRAY_BUFFER, sizeof(plane_uvs), plane_uvs, GL_STATIC_DRAW);
// Unbind everything. Potentially illegal on some implementations
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Viewport
glViewport( 0, 0, width, height );
// Default states
glm::vec3 lightPosition(0.0, 1.0, 10);
float lightIntensity = 1.0f;
glm::vec3 diffuseColor(1.0, 1.0, 1.0);
glm::vec3 specularColor(1.0, 1.0, 1.0);
float specularFactor = 100.f;
glm::vec3 lightPosition2(1.0, 0.0, 10);
float lightIntensity2 = 1.0f;
glm::vec3 diffuseColor2(1.0, 0.0, 0.0);
glm::vec3 specularColor2(1.0, 1.0, 1.0);
float specularFactor2 = 100.f;
float spotLightInternal = M_PI/32;
float spotLightExternal = M_PI/16;
bool checkedLight1 = true;
bool checkedLight2 = false;
bool checkedLight3 = false;
do
{
t = glfwGetTime();
glEnable(GL_DEPTH_TEST);
// Mouse states
int leftButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_LEFT );
int rightButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_RIGHT );
int middleButton = glfwGetMouseButton( GLFW_MOUSE_BUTTON_MIDDLE );
if( leftButton == GLFW_PRESS )
guiStates.turnLock = true;
else
guiStates.turnLock = false;
if( rightButton == GLFW_PRESS )
guiStates.zoomLock = true;
else
guiStates.zoomLock = false;
if( middleButton == GLFW_PRESS )
guiStates.panLock = true;
else
guiStates.panLock = false;
// Camera movements
int altPressed = glfwGetKey(GLFW_KEY_LSHIFT);
if (!altPressed && (leftButton == GLFW_PRESS || rightButton == GLFW_PRESS || middleButton == GLFW_PRESS))
{
int x; int y;
glfwGetMousePos(&x, &y);
guiStates.lockPositionX = x;
guiStates.lockPositionY = y;
}
if (altPressed == GLFW_PRESS)
{
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
int diffLockPositionX = mousex - guiStates.lockPositionX;
int diffLockPositionY = mousey - guiStates.lockPositionY;
if (guiStates.zoomLock)
{
float zoomDir = 0.0;
if (diffLockPositionX > 0)
zoomDir = -1.f;
else if (diffLockPositionX < 0 )
zoomDir = 1.f;
camera_zoom(camera, zoomDir * GUIStates::MOUSE_ZOOM_SPEED);
}
else if (guiStates.turnLock)
{
camera_turn(camera, diffLockPositionY * GUIStates::MOUSE_TURN_SPEED,
diffLockPositionX * GUIStates::MOUSE_TURN_SPEED);
}
else if (guiStates.panLock)
{
camera_pan(camera, diffLockPositionX * GUIStates::MOUSE_PAN_SPEED,
diffLockPositionY * GUIStates::MOUSE_PAN_SPEED);
}
guiStates.lockPositionX = mousex;
guiStates.lockPositionY = mousey;
}
// Get camera matrices
glm::mat4 projection = glm::perspective(45.0f, widthf / heightf, 0.1f, 100.f);
glm::mat4 worldToView = glm::lookAt(camera.eye, camera.o, camera.up);
glm::mat4 objectToWorld;
// Clear the front buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Bind textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textures[1]);
// Bind shader
glUseProgram(program);
// Upload uniforms
glUniformMatrix4fv(projectionLocation, 1, 0, glm::value_ptr(projection));
glUniformMatrix4fv(viewLocation, 1, 0, glm::value_ptr(worldToView));
glUniformMatrix4fv(objectLocation, 1, 0, glm::value_ptr(objectToWorld));
glUniform1f(timeLocation, t);
glUniform3fv(cameraPositionLocation, 1, glm::value_ptr(camera.eye));
glUniform1f(intensityLocation, intensity);
glUniform1i(diffuseLocation, 0);
glUniform1i(specLocation, 1);
glUniform3fv(lightPositionLocation, 1, glm::value_ptr(lightPosition));
glUniform1f(lightIntensityLocation, lightIntensity);
glUniform3fv(diffuseColorLocation, 1, glm::value_ptr(diffuseColor));
glUniform3fv(specularColorLocation, 1, glm::value_ptr(specularColor));
glUniform1f(specularFactorLocation, specularFactor);
glUniform3fv(lightPositionLocation2, 1, glm::value_ptr(lightPosition2));
glUniform1f(lightIntensityLocation2, lightIntensity2);
glUniform3fv(diffuseColorLocation2, 1, glm::value_ptr(diffuseColor2));
glUniform3fv(specularColorLocation2, 1, glm::value_ptr(specularColor2));
glUniform1f(specularFactorLocation2, specularFactor2);
glUniform1f(spotLightInternalAngleLocation, spotLightInternal);
glUniform1f(spotLightExternalAngleLocation, spotLightExternal);
// Render vaos
glBindVertexArray(vao[0]);
glDrawElementsInstanced(GL_TRIANGLES, cube_triangleCount * 3, GL_UNSIGNED_INT, (void*)0, 4);
glBindVertexArray(vao[1]);
glDrawElements(GL_TRIANGLES, plane_triangleCount * 3, GL_UNSIGNED_INT, (void*)0);
#if 1
// Draw UI
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, width, height);
unsigned char mbut = 0;
int mscroll = 0;
int mousex; int mousey;
glfwGetMousePos(&mousex, &mousey);
mousey = height - mousey;
if( leftButton == GLFW_PRESS )
mbut |= IMGUI_MBUT_LEFT;
imguiBeginFrame(mousex, mousey, mbut, mscroll);
int logScroll = 0;
char lineBuffer[512];
imguiBeginScrollArea("001", 0, 0, 200, height, &logScroll);
sprintf(lineBuffer, "FPS %f", fps);
imguiLabel(lineBuffer);
int toggle = 0;
toggle = imguiCollapse("Light1", "", checkedLight1);
if(checkedLight1)
{
imguiIndent();
imguiIndent();
imguiLabel("Light Position");
imguiIndent();
imguiSlider("x", &lightPosition.x, -10, 10, 0.01);
imguiSlider("y", &lightPosition.y, -10, 10, 0.01);
imguiSlider("z", &lightPosition.z, -10, 10, 0.01);
imguiUnindent();
imguiSlider("Light Intensity", &lightIntensity, 0, 3, 0.01);
imguiLabel("Diffuse Color");
imguiIndent();
imguiSlider("r", &diffuseColor.x, 0, 1, 0.001);
imguiSlider("g", &diffuseColor.y, 0, 1, 0.001);
imguiSlider("b", &diffuseColor.z, 0, 1, 0.001);
imguiUnindent();
imguiLabel("Specular Color");
imguiIndent();
imguiSlider("r", &specularColor.x, 0, 1, 0.001);
imguiSlider("g", &specularColor.y, 0, 1, 0.001);
imguiSlider("b", &specularColor.z, 0, 1, 0.001);
imguiUnindent();
imguiSlider("Specular Intensity", &specularFactor, 0, 100, 1);
imguiUnindent();
imguiUnindent();
}
if (toggle)
{
checkedLight1 = !checkedLight1;
}
toggle = imguiCollapse("Light2", "", checkedLight2);
if(checkedLight2)
{
imguiIndent();
imguiIndent();
imguiLabel("Light Position");
imguiIndent();
imguiSlider("x", &lightPosition2.x, -10, 10, 0.01);
imguiSlider("y", &lightPosition2.y, -10, 10, 0.01);
imguiSlider("z", &lightPosition2.z, -10, 10, 0.01);
imguiUnindent();
imguiSlider("Light Intensity", &lightIntensity2, 0, 3, 0.01);
imguiLabel("Diffuse Color");
imguiIndent();
imguiSlider("r", &diffuseColor2.x, 0, 1, 0.001);
imguiSlider("g", &diffuseColor2.y, 0, 1, 0.001);
imguiSlider("b", &diffuseColor2.z, 0, 1, 0.001);
imguiUnindent();
imguiLabel("Specular Color");
imguiIndent();
imguiSlider("r", &specularColor2.x, 0, 1, 0.001);
imguiSlider("g", &specularColor2.y, 0, 1, 0.001);
imguiSlider("b", &specularColor2.z, 0, 1, 0.001);
imguiUnindent();
imguiSlider("Specular Intensity", &specularFactor2, 0, 100, 1);
imguiUnindent();
imguiUnindent();
}
if (toggle)
{
checkedLight2 = !checkedLight2;
}
toggle = imguiCollapse("SpotLight", "", checkedLight3);
if(checkedLight3)
{
imguiIndent();
imguiIndent();
imguiSlider("External Angle", &spotLightExternal, 0, 2, 0.01);
imguiSlider("Internal Angle", &spotLightInternal, 0, 2, 0.01);
imguiUnindent();
imguiUnindent();
}
if (toggle)
{
checkedLight3 = !checkedLight3;
}
imguiEndScrollArea();
imguiEndFrame();
imguiRenderGLDraw(width, height);
glDisable(GL_BLEND);
#endif
// Check for errors
GLenum err = glGetError();
if(err != GL_NO_ERROR)
{
fprintf(stderr, "OpenGL Error : %s\n", gluErrorString(err));
}
// Swap buffers
glfwSwapBuffers();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Clean UI
imguiRenderGLDestroy();
// Close OpenGL window and terminate GLFW
glfwTerminate();
exit( EXIT_SUCCESS );
}
vector<int*> outPut::choosePoints()
{
glfwEnable( GLFW_KEY_REPEAT );
_points.clear();
TwBar *b_points = TwNewBar("Points stratégiques");
coords<int> curPoint((float)_dimensions.x/2.0, (float)_dimensions.y/2.0);
bool done(false), addCurrent(false), addRandom(false);
coords3d<float> vertex(0,0,0);
TwAddVarRW(b_points, "x", TW_TYPE_INT32, &(curPoint.x), "keyincr = RIGHT keydecr = LEFT" );
TwAddVarRW(b_points, "y", TW_TYPE_INT32, &(curPoint.y), "keyincr = UP keydecr = DOWN" );
TwAddVarRW(b_points, "Fini", TW_TYPE_BOOLCPP, &(done), "key = RETURN" );
TwAddVarRW(b_points, "Ajouter courant", TW_TYPE_BOOLCPP, &(addCurrent), "key = SPACE" );
TwAddVarRW(b_points, "Ajouter au hasard", TW_TYPE_BOOLCPP, &(addRandom), "key = 'r'" );
TwAddVarRW(b_points, "Pente max", TW_TYPE_INT32, &(_status.maxDiff), "keyincr=o keydecr=l");
while((!done || _points.size() < 2) && _status.running)
{
setScene();
drawScene();
glDisable(GL_DEPTH_TEST);
glUseProgram(_sNolight.getProgramID());
curPoint.x = clamp(curPoint.x, 1, _dimensions.x-1);
curPoint.y = clamp(curPoint.y, 1, _dimensions.y-1);
vertex = getVertex<float>(curPoint.x,curPoint.y);
_scene3d.focus.x = curPoint.x;
_scene3d.focus.y = curPoint.y;
if(addRandom)
{
addCurrent = true;
addRandom = false;
curPoint.x = rand()%(_dimensions.x-1);
curPoint.y = rand()%(_dimensions.y-1);
}
if(addCurrent)
{
_points.push_back(curPoint);
addCurrent = false;
}
glBegin(GL_POINTS);
glColor3ub(0,255,0);
glVertex3d(vertex.x, vertex.y, vertex.z);
glEnd();
display();
}
unsigned int n = _points.size();
std::cout << "nb de bombes : " << n << std::endl;
vector<int*> bombList(n, NULL);
for(unsigned int i = 0; i<n;i++)
{
bombList[i] = new int[n+2];
for(unsigned int j = 0; j < n+2; ++j)
{
bombList[i][j] = 0;
}
bombList[i][n+2-2] = _points[i].x;
bombList[i][n+2-1] = _points[i].y;
}
TwDeleteBar(b_points);
TwDefine(" Scene/x keyincr = RIGHT keydecr = LEFT");
TwDefine(" Scene/y keyincr = UP keydecr = DOWN");
return bombList;
}
int main(int argc, _TCHAR* argv[])
{
int width, height, running, frames;
double t, t0, fps;
char titlestr[ 200 ];
int p=0;
printf("BLUntrl written 2009, 2010 by Sven Killig <*****@*****.**>\n");
printf("BLUntrl.exe [ VfWDeviceNo | MonitorNo (-1=all) Brightness (0-100%) ]\n");
//printf("argc=%i\n", argc);
if(argc==3) {
TAPP.setBrightness(atoi((char*)argv[1]),atoi((char*)argv[2]));
return 0;
} else if(argc==2) {
// all doesn't work?!
//printf("argv[1]='%s'\n", argv[1]);
//p=StrToInt(argv[1]);
/*if(StrToIntEx(argv[1], STIF_DEFAULT, &p)) printf("StrToIntEx=true\n");
else printf("StrToIntEx=false\n");*/
p=atoi((char*)argv[1]);
//printf("p=%i\n", p);
}
// Initialise GLFW
glfwInit();
// Open OpenGL window
if (!glfwOpenWindow(160,120, // Open window
24, 24, 24, // Red, green, and blue bits for color buffer
24, // Bits for alpha buffer
24, // Bits for depth buffer (Z-buffer)
24, // Bits for stencil buffer
GLFW_WINDOW)){
glfwTerminate();
return 0;
}
glfwSetKeyCallback( keyfun );
glfwSetMouseWheelCallback( mousewheelfun );
glfwSetWindowSizeCallback( windowsizefun );
TAPP.init(p);
glfwEnable( GLFW_STICKY_KEYS );
glfwDisable( GLFW_AUTO_POLL_EVENTS );
// Disable vertical sync (on cards that support it)
glfwSwapInterval( 1 );
// Main loop
running = GL_TRUE;
frames = 0;
t0 = glfwGetTime();
int i=0;
while( running ){
i++;
// Get time and mouse position
t = glfwGetTime();
//glfwGetMousePos( &x, &y );
if(TAPP.idle() && !glfwGetWindowParam(GLFW_ICONIFIED)) {
frames ++;
// Get window size (may be different than the requested size)
glfwGetWindowSize( &width, &height );
height = height > 0 ? height : 1;
// Set viewport
glViewport( 0, 0, width, height );
// Clear color buffer
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
glClear( GL_COLOR_BUFFER_BIT );
TAPP.draw();
// Swap buffers
glfwSwapBuffers();
// Calculate and display FPS (frames per second)
//if( (t-t0) > 1.0 || frames == 0 )
{
fps = (double)frames / (t-t0);
sprintf( titlestr, "BLUntrl (%.1f FPS); %i", fps, i );
glfwSetWindowTitle( titlestr );
t0 = t;
frames = 0;
}
} else Sleep(1000/30);
glfwPollEvents();
// Check if the ESC key was pressed or the window was closed
running = !glfwGetKey( GLFW_KEY_ESC ) /*&&
glfwGetWindowParam( GLFW_OPENED )*/;
}
// Close OpenGL window and terminate GLFW
glfwTerminate();
return 0;
}
