bool Screen::cursorPosCallbackEvent(double x, double y) {
Vector2i p((int) x, (int) y);
bool ret = false;
mLastInteraction = glfwGetTime();
try {
if (mDragActive) {
ret = mDragWidget->mouseDragEvent(
p - mDragWidget->parent()->absolutePosition(), p - mMousePos,
mMouseState, mModifiers);
} else {
Widget *widget = findWidget(mMousePos);
if (widget != nullptr && widget->cursor() != mCursor) {
mCursor = widget->cursor();
glfwSetCursor(mGLFWWindow, mCursors[(int) mCursor]);
}
}
if (!ret)
ret = mouseMotionEvent(p, p - mMousePos, mMouseState, mModifiers);
mMousePos = p;
return ret;
} catch (const std::exception &e) {
std::cerr << "Caught exception in event handler: " << e.what() << std::endl;
abort();
}
return false;
}
GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
{
_GLFWcursor* cursor = (_GLFWcursor*) handle;
_GLFW_REQUIRE_INIT();
if (cursor == NULL)
return;
// Make sure the cursor is not being used by any window
{
_GLFWwindow* window;
for (window = _glfw.windowListHead; window; window = window->next)
{
if (window->cursor == cursor)
glfwSetCursor((GLFWwindow*) window, NULL);
}
}
_glfwPlatformDestroyCursor(cursor);
// Unlink cursor from global linked list
{
_GLFWcursor** prev = &_glfw.cursorListHead;
while (*prev != cursor)
prev = &((*prev)->next);
*prev = cursor->next;
}
free(cursor);
}
JNIEXPORT void JNICALL Java_com_badlogic_jglfw_Glfw_glfwSetCursor(JNIEnv* env, jclass clazz, jlong window, jlong cursor) {
//@line:931
glfwSetCursor((GLFWwindow*)window, (GLFWcursor*)cursor);
}
bool Screen::mouseButtonCallbackEvent(int button, int action, int modifiers) {
mModifiers = modifiers;
mLastInteraction = glfwGetTime();
try {
if (mFocusPath.size() > 1) {
const Window *window =
dynamic_cast<Window *>(mFocusPath[mFocusPath.size() - 2]);
if (window && window->modal()) {
if (!window->contains(mMousePos))
return false;
}
}
if (action == GLFW_PRESS)
mMouseState |= 1 << button;
else
mMouseState &= ~(1 << button);
auto dropWidget = findWidget(mMousePos);
if (mDragActive && action == GLFW_RELEASE &&
dropWidget != mDragWidget)
mDragWidget->mouseButtonEvent(
mMousePos - mDragWidget->parent()->absolutePosition(), button,
false, mModifiers);
if (dropWidget != nullptr && dropWidget->cursor() != mCursor) {
mCursor = dropWidget->cursor();
glfwSetCursor(mGLFWWindow, mCursors[(int) mCursor]);
}
if (action == GLFW_PRESS && button == GLFW_MOUSE_BUTTON_1) {
mDragWidget = findWidget(mMousePos);
if (mDragWidget == this)
mDragWidget = nullptr;
mDragActive = mDragWidget != nullptr;
if (!mDragActive)
updateFocus(nullptr);
} else {
mDragActive = false;
mDragWidget = nullptr;
}
return mouseButtonEvent(mMousePos, button, action == GLFW_PRESS,
mModifiers);
} catch (const std::exception &e) {
std::cerr << "Caught exception in event handler: " << e.what() << std::endl;
abort();
}
return false;
}
void createWindow() {
glfwSetErrorCallback([](int, const char* desc) { cout << desc << endl; });
std::stringstream title;
title << "NEWorld " << MAJOR_VERSION << MINOR_VERSION << EXT_VERSION;
if (Multisample != 0) glfwWindowHint(GLFW_SAMPLES, Multisample);
MainWindow = glfwCreateWindow(windowwidth, windowheight, title.str().c_str(), NULL, NULL);
MouseCursor = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
glfwMakeContextCurrent(MainWindow);
glfwSetCursor(MainWindow, MouseCursor);
glfwSetInputMode(MainWindow, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
glfwSetWindowSizeCallback(MainWindow, &WindowSizeFunc);
glfwSetMouseButtonCallback(MainWindow, &MouseButtonFunc);
glfwSetScrollCallback(MainWindow, &MouseScrollFunc);
glfwSetCharCallback(MainWindow, &CharInputFunc);
if (ppistretch) GUI::InitStretch();
}
static void ImGui_ImplGlfw_UpdateMouseCursor()
{
ImGuiIO& io = ImGui::GetIO();
if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(g_Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
return;
ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
}
else
{
// Show OS mouse cursor
// FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
glfwSetCursor(g_Window, g_MouseCursors[imgui_cursor] ? g_MouseCursors[imgui_cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]);
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
}
}
int main(void)
{
int i;
GLFWwindow* window;
GLFWcursor* star_cursors[CURSOR_FRAME_COUNT];
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
for (i = 0; i < CURSOR_FRAME_COUNT; i++)
{
star_cursors[i] = create_cursor_frame(i / (float) CURSOR_FRAME_COUNT);
if (!star_cursors[i])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
}
for (i = 0; i < sizeof(standard_cursors) / sizeof(standard_cursors[0]); i++)
{
const int shapes[] = {
GLFW_ARROW_CURSOR,
GLFW_IBEAM_CURSOR,
GLFW_CROSSHAIR_CURSOR,
GLFW_HAND_CURSOR,
GLFW_HRESIZE_CURSOR,
GLFW_VRESIZE_CURSOR
};
standard_cursors[i] = glfwCreateStandardCursor(shapes[i]);
if (!standard_cursors[i])
{
glfwTerminate();
exit(EXIT_FAILURE);
}
}
window = glfwCreateWindow(640, 480, "Cursor Test", NULL, NULL);
if (!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwGetCursorPos(window, &cursor_x, &cursor_y);
printf("Cursor position: %f %f\n", cursor_x, cursor_y);
glfwSetCursorPosCallback(window, cursor_position_callback);
glfwSetKeyCallback(window, key_callback);
while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);
if (track_cursor)
{
int wnd_width, wnd_height, fb_width, fb_height;
float scale;
glfwGetWindowSize(window, &wnd_width, &wnd_height);
glfwGetFramebufferSize(window, &fb_width, &fb_height);
scale = (float) fb_width / (float) wnd_width;
glViewport(0, 0, fb_width, fb_height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.f, fb_width, 0.f, fb_height, 0.f, 1.f);
glBegin(GL_LINES);
glVertex2f(0.f, (GLfloat) (fb_height - cursor_y * scale));
glVertex2f((GLfloat) fb_width, (GLfloat) (fb_height - cursor_y * scale));
glVertex2f((GLfloat) cursor_x * scale, 0.f);
glVertex2f((GLfloat) cursor_x * scale, (GLfloat) fb_height);
glEnd();
}
glfwSwapBuffers(window);
if (animate_cursor)
{
const int i = (int) (glfwGetTime() * 30.0) % CURSOR_FRAME_COUNT;
glfwSetCursor(window, star_cursors[i]);
}
if (wait_events)
glfwWaitEvents();
else
glfwPollEvents();
// Workaround for an issue with msvcrt and mintty
fflush(stdout);
}
glfwDestroyWindow(window);
for (i = 0; i < CURSOR_FRAME_COUNT; i++)
glfwDestroyCursor(star_cursors[i]);
for (i = 0; i < sizeof(standard_cursors) / sizeof(standard_cursors[0]); i++)
glfwDestroyCursor(standard_cursors[i]);
glfwTerminate();
exit(EXIT_SUCCESS);
}
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (action != GLFW_PRESS)
return;
switch (key)
{
case GLFW_KEY_A:
{
animate_cursor = !animate_cursor;
if (!animate_cursor)
glfwSetCursor(window, NULL);
break;
}
case GLFW_KEY_ESCAPE:
{
if (glfwGetInputMode(window, GLFW_CURSOR) != GLFW_CURSOR_DISABLED)
{
glfwSetWindowShouldClose(window, GL_TRUE);
break;
}
/* FALLTHROUGH */
}
case GLFW_KEY_N:
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
printf("(( cursor is normal ))\n");
break;
case GLFW_KEY_D:
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
printf("(( cursor is disabled ))\n");
break;
case GLFW_KEY_H:
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
printf("(( cursor is hidden ))\n");
break;
case GLFW_KEY_SPACE:
swap_interval = 1 - swap_interval;
printf("(( swap interval: %i ))\n", swap_interval);
glfwSwapInterval(swap_interval);
break;
case GLFW_KEY_W:
wait_events = !wait_events;
printf("(( %sing for events ))\n", wait_events ? "wait" : "poll");
break;
case GLFW_KEY_T:
track_cursor = !track_cursor;
break;
case GLFW_KEY_0:
glfwSetCursor(window, NULL);
break;
case GLFW_KEY_1:
glfwSetCursor(window, standard_cursors[0]);
break;
case GLFW_KEY_2:
glfwSetCursor(window, standard_cursors[1]);
break;
case GLFW_KEY_3:
glfwSetCursor(window, standard_cursors[2]);
break;
case GLFW_KEY_4:
glfwSetCursor(window, standard_cursors[3]);
break;
case GLFW_KEY_5:
glfwSetCursor(window, standard_cursors[4]);
break;
case GLFW_KEY_6:
glfwSetCursor(window, standard_cursors[5]);
break;
}
}
void ImGui_ImplGlfwGL2_NewFrame()
{
if (!g_FontTexture)
ImGui_ImplGlfwGL2_CreateDeviceObjects();
ImGuiIO& io = ImGui::GetIO();
// Setup display size (every frame to accommodate for window resizing)
int w, h;
int display_w, display_h;
glfwGetWindowSize(g_Window, &w, &h);
glfwGetFramebufferSize(g_Window, &display_w, &display_h);
io.DisplaySize = ImVec2((float)w, (float)h);
io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0);
// Setup time step
double current_time = glfwGetTime();
io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
g_Time = current_time;
// Setup inputs
// (we already got mouse wheel, keyboard keys & characters from glfw callbacks polled in glfwPollEvents())
if (glfwGetWindowAttrib(g_Window, GLFW_FOCUSED))
{
// Set OS mouse position if requested (only used when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if (io.WantSetMousePos)
{
glfwSetCursorPos(g_Window, (double)io.MousePos.x, (double)io.MousePos.y);
}
else
{
double mouse_x, mouse_y;
glfwGetCursorPos(g_Window, &mouse_x, &mouse_y);
io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);
}
}
else
{
io.MousePos = ImVec2(-FLT_MAX,-FLT_MAX);
}
for (int i = 0; i < 3; i++)
{
// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
io.MouseDown[i] = g_MouseJustPressed[i] || glfwGetMouseButton(g_Window, i) != 0;
g_MouseJustPressed[i] = false;
}
// Update OS/hardware mouse cursor if imgui isn't drawing a software cursor
if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) == 0 && glfwGetInputMode(g_Window, GLFW_CURSOR) != GLFW_CURSOR_DISABLED)
{
ImGuiMouseCursor cursor = ImGui::GetMouseCursor();
if (io.MouseDrawCursor || cursor == ImGuiMouseCursor_None)
{
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
}
else
{
glfwSetCursor(g_Window, g_MouseCursors[cursor] ? g_MouseCursors[cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]);
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
}
}
// Start the frame. This call will update the io.WantCaptureMouse, io.WantCaptureKeyboard flag that you can use to dispatch inputs (or not) to your application.
ImGui::NewFrame();
}
int main( void )
{
GLFWwindow *window;
// Initialize the library
if ( !glfwInit( ) )
{
return -1;
}
// Create a windowed mode window and its OpenGL context
window = glfwCreateWindow( SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World", NULL, NULL );
glfwSetCursorPosCallback( window, cursorPositionCallback );
glfwSetInputMode( window, GLFW_CURSOR, GLFW_CURSOR_NORMAL );
glfwSetCursorEnterCallback( window, cursorEnterCallback );
glfwSetMouseButtonCallback( window, mouseButtonCallback );
glfwSetInputMode( window, GLFW_STICKY_MOUSE_BUTTONS, 1 );
glfwSetScrollCallback( window, scrollCallback );
unsigned char pixels[16 * 16 * 4];
memset( pixels, 0xff, sizeof( pixels ) );
GLFWimage image;
image.width = 16;
image.height = 16;
image.pixels = pixels;
GLFWcursor *cursor = glfwCreateCursor( &image, 0, 0 );
glfwSetCursor( window, cursor ); // set to null to reset cursor
int screenWidth, screenHeight;
glfwGetFramebufferSize( window, &screenWidth, &screenHeight );
if ( !window )
{
glfwTerminate( );
return -1;
}
// Make the window's context current
glfwMakeContextCurrent( window );
glViewport( 0.0f, 0.0f, screenWidth, screenHeight ); // specifies the part of the window to which OpenGL will draw (in pixels), convert from normalised to pixels
glMatrixMode( GL_PROJECTION ); // projection matrix defines the properties of the camera that views the objects in the world coordinate frame. Here you typically set the zoom factor, aspect ratio and the near and far clipping planes
glLoadIdentity( ); // replace the current matrix with the identity matrix and starts us a fresh because matrix transforms such as glOrpho and glRotate cumulate, basically puts us at (0, 0, 0)
glOrtho( 0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1 ); // essentially set coordinate system
glMatrixMode( GL_MODELVIEW ); // (default matrix mode) modelview matrix defines how your objects are transformed (meaning translation, rotation and scaling) in your world
glLoadIdentity( ); // same as above comment
// Loop until the user closes the window
while ( !glfwWindowShouldClose( window ) )
{
glClear( GL_COLOR_BUFFER_BIT );
// Render OpenGL here
double xpos, ypos;
glfwGetCursorPos( window, &xpos, &ypos );
// Swap front and back buffers
glfwSwapBuffers( window );
// Poll for and process events
glfwPollEvents( );
}
glfwTerminate( );
return 0;
}
static void command_callback(int key)
{
switch (key)
{
case GLFW_KEY_H:
{
printf("H: show this help\n");
printf("C: call glfwCreateCursor()\n");
printf("D: call glfwDestroyCursor()\n");
printf("S: call glfwSetCursor()\n");
printf("N: call glfwSetCursor() with NULL\n");
printf("1: set GLFW_CURSOR_NORMAL\n");
printf("2: set GLFW_CURSOR_HIDDEN\n");
printf("3: set GLFW_CURSOR_DISABLED\n");
printf("T: enable 3s delay for all previous commands\n");
}
break;
case GLFW_KEY_C:
{
int x, y;
GLFWimage image;
unsigned char* pixels;
if (cursor)
break;
image.width = cursorSize[currentSize].w;
image.height = cursorSize[currentSize].h;
pixels = malloc(4 * image.width * image.height);
image.pixels = pixels;
for (y = 0; y < image.height; y++)
{
for (x = 0; x < image.width; x++)
{
*pixels++ = 0xff;
*pixels++ = 0;
*pixels++ = 255 * y / image.height;
*pixels++ = 255 * x / image.width;
}
}
cursor = glfwCreateCursor(&image, image.width / 2, image.height / 2);
currentSize = (currentSize + 1) % SizeCount;
free(image.pixels);
break;
}
case GLFW_KEY_D:
{
if (cursor != NULL)
{
glfwDestroyCursor(cursor);
cursor = NULL;
}
break;
}
case GLFW_KEY_S:
{
if (cursor != NULL)
glfwSetCursor(activeWindow, cursor);
else
printf("The cursor is not created\n");
break;
}
case GLFW_KEY_N:
glfwSetCursor(activeWindow, NULL);
break;
case GLFW_KEY_1:
glfwSetInputMode(activeWindow, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
break;
case GLFW_KEY_2:
glfwSetInputMode(activeWindow, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
break;
case GLFW_KEY_3:
glfwSetInputMode(activeWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
break;
}
}
void ImGui_ImplGlfwGL3_NewFrame()
{
if (!g_FontTexture)
ImGui_ImplGlfwGL3_CreateDeviceObjects();
ImGuiIO& io = ImGui::GetIO();
// Setup display size (every frame to accommodate for window resizing)
int w, h;
int display_w, display_h;
glfwGetWindowSize(g_Window, &w, &h);
glfwGetFramebufferSize(g_Window, &display_w, &display_h);
io.DisplaySize = ImVec2((float)w, (float)h);
io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0);
// Setup time step
double current_time = glfwGetTime();
io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
g_Time = current_time;
// Setup inputs
// (we already got mouse wheel, keyboard keys & characters from glfw callbacks polled in glfwPollEvents())
if (glfwGetWindowAttrib(g_Window, GLFW_FOCUSED))
{
// Set OS mouse position if requested (only used when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if (io.WantSetMousePos)
{
glfwSetCursorPos(g_Window, (double)io.MousePos.x, (double)io.MousePos.y);
}
else
{
double mouse_x, mouse_y;
glfwGetCursorPos(g_Window, &mouse_x, &mouse_y);
io.MousePos = ImVec2((float)mouse_x, (float)mouse_y);
}
}
else
{
io.MousePos = ImVec2(-FLT_MAX,-FLT_MAX);
}
for (int i = 0; i < 3; i++)
{
// If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
io.MouseDown[i] = g_MouseJustPressed[i] || glfwGetMouseButton(g_Window, i) != 0;
g_MouseJustPressed[i] = false;
}
// Update OS/hardware mouse cursor if imgui isn't drawing a software cursor
if ((io.ConfigFlags & ImGuiConfigFlags_NoSetMouseCursor) == 0 && glfwGetInputMode(g_Window, GLFW_CURSOR) != GLFW_CURSOR_DISABLED)
{
ImGuiMouseCursor cursor = ImGui::GetMouseCursor();
if (io.MouseDrawCursor || cursor == ImGuiMouseCursor_None)
{
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
}
else
{
glfwSetCursor(g_Window, g_MouseCursors[cursor] ? g_MouseCursors[cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]);
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
}
}
// Gamepad navigation mapping [BETA]
memset(io.NavInputs, 0, sizeof(io.NavInputs));
if (io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad)
{
// Update gamepad inputs
#define MAP_BUTTON(NAV_NO, BUTTON_NO) { if (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS) io.NavInputs[NAV_NO] = 1.0f; }
#define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); if (v > 1.0f) v = 1.0f; if (io.NavInputs[NAV_NO] < v) io.NavInputs[NAV_NO] = v; }
int axes_count = 0, buttons_count = 0;
const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
MAP_BUTTON(ImGuiNavInput_Activate, 0); // Cross / A
MAP_BUTTON(ImGuiNavInput_Cancel, 1); // Circle / B
MAP_BUTTON(ImGuiNavInput_Menu, 2); // Square / X
MAP_BUTTON(ImGuiNavInput_Input, 3); // Triangle / Y
MAP_BUTTON(ImGuiNavInput_DpadLeft, 13); // D-Pad Left
MAP_BUTTON(ImGuiNavInput_DpadRight, 11); // D-Pad Right
MAP_BUTTON(ImGuiNavInput_DpadUp, 10); // D-Pad Up
MAP_BUTTON(ImGuiNavInput_DpadDown, 12); // D-Pad Down
MAP_BUTTON(ImGuiNavInput_FocusPrev, 4); // L1 / LB
MAP_BUTTON(ImGuiNavInput_FocusNext, 5); // R1 / RB
MAP_BUTTON(ImGuiNavInput_TweakSlow, 4); // L1 / LB
MAP_BUTTON(ImGuiNavInput_TweakFast, 5); // R1 / RB
MAP_ANALOG(ImGuiNavInput_LStickLeft, 0, -0.3f, -0.9f);
MAP_ANALOG(ImGuiNavInput_LStickRight,0, +0.3f, +0.9f);
MAP_ANALOG(ImGuiNavInput_LStickUp, 1, +0.3f, +0.9f);
MAP_ANALOG(ImGuiNavInput_LStickDown, 1, -0.3f, -0.9f);
#undef MAP_BUTTON
#undef MAP_ANALOG
if (axes_count > 0 && buttons_count > 0)
io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
else
io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
}
// Start the frame. This call will update the io.WantCaptureMouse, io.WantCaptureKeyboard flag that you can use to dispatch inputs (or not) to your application.
ImGui::NewFrame();
}
int main(void) {
// for application time calculations
static GLfloat last = 0;
GLfloat timer = glfwGetTime();
GLfloat start;
start = timer;
last = timer;
// array of circles
Circle circles[CIRCLE_NUM];
int length = CIRCLE_NUM;
int i;
int currentCircleIndex;
// time to wait before moving the circle
GLfloat sleep = 0.01;
// total running time
GLfloat total = TOTAL_TIME * 60; // 1 minutes has 60 seconds
// output file name
char text[] = "output.txt";
// output stream
FILE * out = fopen(text, "w");
globalOut = out;
//initialize the global variable
chosenCircleIndex = 0;
currentCircleIndex = chosenCircleIndex;
currentCircle = &circles[currentCircleIndex];
srand(time(NULL));
initCircleArray(circles, length);
glfwSetErrorCallback(error);
if (!glfwInit() || out == NULL) {
return -1;
}
window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "two_co", NULL, NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glViewport(0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
glfwSetCursor( window, cursor ); // set to null to reset cursor
glfwSetKeyCallback(window, key_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
while (timer - start < total
&& !glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT);
timer = glfwGetTime();
writeToFile(out, circles[currentCircleIndex], timer, window);
// whether we should change the color
if (currentCircleIndex != chosenCircleIndex) {
currentCircleIndex = chosenCircleIndex;
// set all circle to blue
for (i = 0; i < length; i++) {
circles[i].colour[0] = 0;
circles[i].colour[1] = 0;
circles[i].colour[2] = 255;
}
// set green color to the chosen circle
circles[currentCircleIndex].colour[0] = 0;
circles[currentCircleIndex].colour[1] = 255;
circles[currentCircleIndex].colour[2] = 0;
currentCircle = &circles[currentCircleIndex];
}
// whether we should move the circle
if (timer - last > sleep) {
last = timer;
for (i = 0; i < length; i++) {
moves(circles, length, i);
drawCircle(circles[i]);
}
} else {
for (i = 0; i < length; i++) {
drawCircle(circles[i]);
}
}
glfwSwapBuffers(window);
glfwPollEvents();
}
fclose(out);
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
int main( void )
{
// application time
static GLfloat last = 0;
GLfloat delta;
GLfloat timer = glfwGetTime();
last = timer;
// circle position and other attribute
GLfloat x = SCREEN_WIDTH / 3;
GLfloat y = SCREEN_HEIGHT / 2;
GLfloat xStep = 3;
GLfloat yStep = 3;
GLfloat radius = 65.0;
GLfloat lambda = SCREEN_HEIGHT / 4;
// time to wait before moving the cirle
GLfloat sleep = 0.03;
char text[] = "output.txt";
FILE * out = fopen(text, "w");
// temporary position of cursor
double xpos;
double ypos;
// current position of cursor
double cX;
double cY;
GLfloat distance;
glfwSetErrorCallback(error);
if ( !glfwInit( )
|| out == NULL)
{
return -1;
}
window = glfwCreateWindow( SCREEN_WIDTH, SCREEN_HEIGHT, "fx", NULL, NULL );
if ( !window )
{
glfwTerminate( );
return -1;
}
glfwMakeContextCurrent( window );
glViewport( 0.0f, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
glOrtho( 0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
cursor = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
glfwSetCursor( window, cursor ); // set to null to reset cursor
glfwGetCursorPos(window, &cX, &cY);
glfwSetKeyCallback(window, key_callback);
while ( !glfwWindowShouldClose( window ) )
{
glClear( GL_COLOR_BUFFER_BIT );
timer = glfwGetTime();
// whether we should move the circle
if (timer - last > sleep) {
last = timer;
// edge detection
if (x + radius > SCREEN_WIDTH ||
x - radius < 0.0) {
xStep *= -1;
}
if (//y + radius > 3 * SCREEN_HEIGHT / 4 <-- if top/bottom bounds are desired
//|| y - radius < SCREEN_HEIGHT / 4 <-- if top/bottom bounds are desired
x + radius > SCREEN_WIDTH ||
x - radius < 0.0) {
yStep *= -1;
}
// change position of circle-center, i.e. we move the circle
x += xStep;
y += yStep * (2 * sin(2 * M_PI * x / lambda)) * 3;
}
drawCircle( x, y, 0, radius, 36);
//update cursor position
glfwGetCursorPos(window, &xpos, &ypos);
cX = xpos;
cY = SCREEN_HEIGHT - ypos;
distance = sqrt((cX - x) * (cX - x) + (cY - y) * (cY - y));
writeData(out, x, y, radius, cX, cY, timer, distance);
glfwSwapBuffers( window );
glfwPollEvents( );
}
fclose(out);
glfwDestroyWindow(window);
glfwDestroyCursor(cursor);
glfwTerminate( );
return 0;
}
void ctx_cursor(struct context *ctx, cursor_t *c)
{
glfwSetCursor(ctx->win, c);
}