Primitive Drawing & Input Handler

Function

Nama : Nur Qalbi Mentari Usmayda

Kelas : 2 D4 Teknik Komputer B
NRP : 3220600045
Dosen : Dewi Mutiara sari, S.ST., M.Sc.

Mata Kuliah : Workshop Grafika Komputer

Tgl Praktikum : 16 Maret 2022

 Primitive Drawing & Input Handler Function
Segitiga Hijau
Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>

int main() {
//start GL context and OS Windows using GLFW lib
if (!glfwInit()) {
fprintf(stderr, "ERROR : could not start GLFW3\n");
return 1;
}

GLFWwindow* window = glfwCreateWindow(640, 480, "Hello Triangle", NULL,

NULL);
if (!window) {
fprintf(stderr, "ERROR : could not open windows with GLFW3\n");
return 1;
}

glfwMakeContextCurrent(window);

//start GLEW extension handler

glewExperimental = GL_TRUE;
glewInit();

//get version info

const GLubyte* renderer = glGetString(GL_RENDERER);
const GLubyte* version = glGetString(GL_VERSION);
printf_s("Renderer : %s\n", renderer);
printf_s("OpenGL version supported %s\n", version);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

float points[] = {
0.0f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f,
};

//create vector buffer object

GLuint vbo;
glGenBuffers(1, &vbo);

//allocate space and upload from CPU to GPU

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

//VAO setting
GLuint vao = 0;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
 //RECALL SHADERS
const char* vertex_shader =
"#version 400\n"
"in vec3 vp;"
"void main() {"
"gl_Position = vec4(vp, 1.0);"
"}";

const char* fragment_shader =

"#version 400\n"
"out vec4 frag_colour;"
"void main() {"
"frag_colour = vec4(0, 1.0, 0, 1.0);"
"}";

//shaders attach
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vertex_shader, NULL);
glCompileShader(vs);
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragment_shader, NULL);
glCompileShader(fs);

GLuint shader_progamme = glCreateProgram();

glAttachShader(shader_progamme, fs);
glAttachShader(shader_progamme, vs);
glLinkProgram(shader_progamme);

while (!glfwWindowShouldClose(window))
{
//wipe drawing or clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shader_progamme);
glBindVertexArray(vao);
//draw point
glDrawArrays(GL_TRIANGLES, 0, 3);
glPointSize(15.0);
//update event
glfwPollEvents();
//put drawing
glfwSwapBuffers(window);
}
}
Capture Output :
Segitiga Dot
Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>

int main() {
//start GL context and OS Windows using GLFW lib
if (!glfwInit()) {
fprintf(stderr, "ERROR : could not start GLFW3\n");
return 1;
}

GLFWwindow* window = glfwCreateWindow(640, 480, "Hello Triangle", NULL,

NULL);
if (!window) {
fprintf(stderr, "ERROR : could not open windows with GLFW3\n");
return 1;
}

glfwMakeContextCurrent(window);

//start GLEW extension handler

glewExperimental = GL_TRUE;
glewInit();

//get version info

const GLubyte* renderer = glGetString(GL_RENDERER);
const GLubyte* version = glGetString(GL_VERSION);
printf_s("Renderer : %s\n", renderer);
printf_s("OpenGL version supported %s\n", version);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

float points[] = {
0.0f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f,
};
 //create vector buffer object
GLuint vbo;
glGenBuffers(1, &vbo);

//allocate space and upload from CPU to GPU

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

//VAO setting
GLuint vao = 0;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

//RECALL SHADERS
const char* vertex_shader =
"#version 400\n"
"in vec3 vp;"
"void main() {"
"gl_Position = vec4(vp, 1.0);"
"}";

const char* fragment_shader =

"#version 400\n"
"out vec4 frag_colour;"
"void main() {"
" frag_colour = vec4(0.5, 0.0, 0.5, 1.0);"
"}";

//shaders attach
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vertex_shader, NULL);
glCompileShader(vs);
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragment_shader, NULL);
glCompileShader(fs);

GLuint shader_progamme = glCreateProgram();

glAttachShader(shader_progamme, fs);
glAttachShader(shader_progamme, vs);
glLinkProgram(shader_progamme);

while (!glfwWindowShouldClose(window))
{
//wipe drawing or clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shader_progamme);
glBindVertexArray(vao);
//draw point
glDrawArrays(GL_POINTS, 0, 3);
glPointSize(15.0);
//update event
glfwPollEvents();
//put drawing
glfwSwapBuffers(window);
}
}
Capture Output :
Input Handler Function Keyboard Spasi
Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

using namespace std;

void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);

int main(void)
{
GLFWwindow* window;

if (!glfwInit())
{
return -1;
}

window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World", NULL,

NULL);

int screenWidth, screenHeight;

glfwGetFramebufferSize(window, &screenWidth, &screenHeight);

if (!window)
{
glfwTerminate();
return -1;
}

glfwMakeContextCurrent(window);

glfwSetKeyCallback(window, keyCallback);
 glfwSetInputMode(window, GLFW_STICKY_KEYS, 1);

glViewport(0.0f, 0.0f, screenWidth, screenHeight);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, screenWidth, 0, screenHeight, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(window);
glfwPollEvents();
}

glfwTerminate();
return 0;

void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
{
std::cout << "Space Key Pressed" << std::endl;
}
}
Capture Output :

Input Handler Function Mouse Posisi 1

Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480
static void cursorPositionCallback(GLFWwindow* window, double xpos, double ypos);
int main(void) {
GLFWwindow* window;
if (!glfwInit())
{
return -1;
}
window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World", NULL,
NULL);
glfwSetCursorPosCallback(window, cursorPositionCallback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);

while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwTerminate();
return 0;
}

static void cursorPositionCallback(GLFWwindow* window, double xpos, double ypos) {

std::cout << xpos << " : " << ypos << std::endl;
}
Capture Output :
Input Handler Function Mouse Posisi 2
Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

void cursorEnterCallback(GLFWwindow* window, int entered);

int main(void) {

GLFWwindow* window;

if (!glfwInit())
{
return -1;
}

window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World", NULL,

NULL);

glfwSetCursorEnterCallback(window, cursorEnterCallback);

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);

int screenWidth, screenHeight;

glfwGetFramebufferSize(window, &screenWidth, &screenHeight);

while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);

glfwSwapBuffers(window);

glfwPollEvents();
}

glfwTerminate();

return 0;
}

static void cursorEnterCallback(GLFWwindow* window, int entered) {

 if (entered)
{
std::cout << "Entered Window" << std::endl;
}
else
{
std::cout << "Left Window" << std::endl;
}
}
Capture Output :

TUGAS
Assignment 1
1. Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>

int main() {
//start GL context and OS Windows using GLFW lib
if (!glfwInit()) {
fprintf(stderr, "ERROR : could not start GLFW3\n");
return 1;
}

GLFWwindow* window = glfwCreateWindow(640, 480, "Hello Triangle", NULL,

NULL);
if (!window) {
fprintf(stderr, "ERROR : could not open windows with GLFW3\n");
return 1;
}
glfwMakeContextCurrent(window);

//start GLEW extension handler

glewExperimental = GL_TRUE;
glewInit();

//get version info

const GLubyte* renderer = glGetString(GL_RENDERER);
const GLubyte* version = glGetString(GL_VERSION);
printf_s("Renderer : %s\n", renderer);
printf_s("OpenGL version supported %s\n", version);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

float points[] = {
0.5f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f, 0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f

};

//create vector buffer object

GLuint vbo;
glGenBuffers(1, &vbo);

//allocate space and upload from CPU to GPU

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

//VAO setting
GLuint vao = 0;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

//RECALL SHADERS
const char* vertex_shader =
"#version 400\n"
"in vec3 vp;"
"void main() {"
"gl_Position = vec4(vp, 1.0);"
"}";

const char* fragment_shader =

"#version 400\n"
 "out vec4 frag_colour;"
"void main() {"
" frag_colour = vec4(0.5, 0.0, 0.5, 1.0);"
"}";

//shaders attach
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vertex_shader, NULL);
glCompileShader(vs);

GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragment_shader, NULL);
glCompileShader(fs);

GLuint shader_progamme = glCreateProgram();

glAttachShader(shader_progamme, fs);
glAttachShader(shader_progamme, vs);
glLinkProgram(shader_progamme);

while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shader_progamme);
glBindVertexArray(vao);

glDrawArrays(GL_LINES, 0, 8);
glPointSize(38.0);

glfwPollEvents();
glfwSwapBuffers(window);

}
Capture Output :
 Analisa :
Pada praktikum di assignment 1.1 kali ini yaitu membuat garis yang akan
membentuk persegi. Pertama membuat output window dengan ukuran 640 dan 480.
Selanjutnya membuat variable konstanta untuk menampilkan renderer graphic yang
dipakai dan versi opengl yang dipakai, selanjutnya membuat float points untuk garis
yang akan dimunculkan nanti, Menggunakan perintah buffer untuk memproses float
pointnya, membuat variable untuk shader dan fragment untuk posisi dan warnanya,
kemudian memasukanprogram untuk memproses shader dan fragment. Selanjutnya
membuat fungsi while untuk menampilkan hasilnya dengan memanggil fungsi shader,
array dari variable vao, perintah gldrawarray untuk menggambarkan hasil prosesnya
yang berisi fungsi GL_LINES untuk menampilkan garis yang sudah diproses dan
point size untuk menentukan ukuran dari gambarnya. Hasilnya akan muncul gambar
persegi Panjang yang terbentuk dari garis – garis yang sudah di proses tadi.

2. Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>

int main() {
if (!glfwInit()) {
fprintf(stderr, "ERROR : could not start GLFW3\n");
return 1;
}

GLFWwindow* window = glfwCreateWindow(640, 480, "Hello Triangle",

NULL, NULL);

if (!window) {
fprintf(stderr, "ERROR : could not open windows with GLFW3\n");
glfwTerminate();
return 1;
}

glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
glewInit();

const GLubyte* renderer = glGetString(GL_RENDERER);

const GLubyte* version = glGetString(GL_VERSION);

printf("Renderer : %s\n", renderer);

printf("OpenGL version supported %s\n", version);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

float points[] = {
0.5f, 0.5f, 0.0f,
0.5f,-0.5f, 0.0f,
-0.5f,-0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f, 0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
0.5f,-0.5f, 0.0f,
-0.5f,-0.5f, 0.0f,
};

GLuint vbo;
glGenBuffers(1, &vbo);

glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

GLuint vao = 0;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);

const char* vertex_shader =

"#version 400\n"
"in vec3 vp;"
"void main() {"
" gl_Position = vec4(vp, 1.0);"
"}";

const char* fragment_shader =

"#version 400\n"
"out vec4 frag_colour;"
"void main() {"
" frag_colour = vec4(0.5, 0.0, 0.5, 1.0);"
"}";

GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vertex_shader, NULL);
glCompileShader(vs);
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragment_shader, NULL);
glCompileShader(fs);

GLuint shader_progamme = glCreateProgram();

glAttachShader(shader_progamme, fs);
 glAttachShader(shader_progamme, vs);
glLinkProgram(shader_progamme);

while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(shader_progamme);
glBindVertexArray(vao);

glDrawArrays(GL_LINE_LOOP, 0, 4);

glfwPollEvents();
glfwSwapBuffers(window);
}
}
Capture Output :

Analisa :
Pada praktikum kali ini yaitu membuat perulangan garis yang akan
membentuk persegi Panjang. Pertama membuat output window dengan ukuran 640
dan 480. Selanjutnya membuat variable konstanta untuk menampilkan renderer
graphic yang dipakai dan versi opengl yang dipakai, selanjutnya membuat float points
untuk garis yang akan dimunculkan nanti, Menggunakan perintah buffer untuk
memproses float pointnya, membuat variable untuk shader dan fragment untuk posisi
dan warnanya, kemudian memasukanprogram untuk memproses shader dan fragment.
Selanjutnya membuat fungsi while untuk menampilkan hasilnya dengan memanggil
fungsi shader, array dari variable vao, perintah gldrawarray untuk menggambarkan
hasil prosesnya yang berisi fungsi GL_LINE_LOOP untuk menampilkan garis secara
berulang dan point size untuk menentukan ukuran dari gambarnya. Hasilnya akan
muncul gambar persegi Panjang yang terbentuk dari garis – garis yang sudah di
proses tadi.
Assignment 2
1. Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

void keyCallBack(GLFWwindow* window, int key, int scancode, int action, int
mods) {
std::cout << key << std::endl;

if (key == GLFW_KEY_SPACE && action == GLFW_REPEAT) {

std::cout << "Space Key Pressed" << std::endl;
}
}

int main(void) {
GLFWwindow* window;

if (!glfwInit()) {
return -1;
}

window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World",

NULL, NULL);

int screenWidth, screecHeight;

glfwGetFramebufferSize(window, &screenWidth, &screecHeight);
if (!window) {
glfwTerminate();
return -1;
}

glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, keyCallBack);
glfwSetInputMode(window, GLFW_STICKY_KEYS, 1);

glViewport(0.0f, 0.0f, screenWidth, screecHeight);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(window);
glfwPollEvents();
}
 glfwTerminate();

return 0;
}

Capture Output :

Analisa :
Pada program keyboard yang pertama, fungsi keyCallback menggunakan fungsi input
GLFW_KEY_SPACE dan GLFW_PRESS. Outputnya adalah jika kita menekan
space, akan muncul teks “Space Key Pressed”. Sedangkan pada program keyboard
assignment 2(1) menggunakan fungsi input GLFW_REPEAT. Perbedaan dari fungsi
sebelumnya yang menggunakan GLFW_PRESS yaitu pada GLFW_REPEAT, saat
menekan tombol space pada keyboard harus ditekan lebih lama agar tulisan “Space
Key Pressed” muncul.
2. Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

void keyCallBack(GLFWwindow* window, int key, int scancode, int action, int
mods) {
std::cout << key << std::endl;
 if (key == GLFW_KEY_L && action == GLFW_PRESS) {
std::cout << "L Key Pressed" << std::endl;
}
}

int main(void) {
GLFWwindow* window;

if (!glfwInit()) {
return -1;
}

window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World",

NULL, NULL);

int screenWidth, screecHeight;

glfwGetFramebufferSize(window, &screenWidth, &screecHeight);
if (!window) {
glfwTerminate();
return -1;
}

glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, keyCallBack);
glfwSetInputMode(window, GLFW_STICKY_KEYS, 1);

glViewport(0.0f, 0.0f, screenWidth, screecHeight);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(window);
glfwPollEvents();
}

glfwTerminate();

return 0;
}
Capture Output :
 Analisa :
Pada percobaan praktikum assignment 2(2) menggunakan program yang sama
dengan program keyboard. Namun, pada fungsi keyCallback pada parameter if,
bagian key dan action diganti dengan key L dan GLFW_REPEAT. Pada parameter if,
nilai key diganti menjadi GLFW_KEY_L agar saat tombol L ditekan, program akan
memberikan callback dan mencetak “L key pressed”. Bila key selain L ditekan, maka
tidak akan mencetak tulisan apapun. Namun, karena menggunakan GLFW_REPEAT,
maka tombol L harus ditekan terus menerus untuk mencetak tulisan “L Key Pressed”.
Bila tombol L hanya ditekan kemudian dilepaskan, maka tulisan tidak akan tercetak.

Assignment 3
1. Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

void mouseButtonCallback(GLFWwindow* window, int button, int action, int

mods);

int main(void) {

GLFWwindow* window;

if (!glfwInit())
{
return -1;
}

window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World",

NULL, NULL);

int screenWidth, screenHeight;

glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
 if (!window) {
glfwTerminate();
return -1;
}

glfwMakeContextCurrent(window);
glfwSetMouseButtonCallback(window, mouseButtonCallback);
glfwSetInputMode(window, GLFW_STICKY_MOUSE_BUTTONS, GLFW_TRUE);

glViewport(0.0f, 0.0f, screenWidth, screenHeight);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);

glfwSwapBuffers(window);

glfwPollEvents();
}

glfwTerminate();

return 0;
}

static void mouseButtonCallback(GLFWwindow* window, int button, int

action, int mods) {
if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS)
{
std::cout << "Right Button Pressed" << std::endl;
}
if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
{
std::cout << "Left Button Pressed" << std::endl;
}
}
Capture Output :
Analisa :
Pada mouse program di module, saat kursor berada dalam window Hello
World, maka akan muncul teks “Entered Window”. Saat kursor di luar window Hello
World, akan muncul teks “Left Window”. Dengan fungsi cursorEnterCallback, hanya
dengan menggeser kursor ke arah window atau keluar window, kita bisa
memunculkan tulisan tersebut. Sedangkan dalam program assignment 3,
perbedaannya adalah kita harus menekan klik kanan pada mouse, lalu akan muncul
tulisan “Right Button Pressed”. Hal itu bisa dilakukan dengan membuat fungsi
mouseButtonCallback yang didalamnya terdapat
GLFW_MOUSE_BUTTON_RIGHT untuk klik kanan dan action GLFW_PRESS
untuk bisa menampilkan action saat mouse ditekan, yaitu memunculkan tulisan
“Right Button Pressed”. Dan GLFW_MOUSE_BUTTON_LEFT untuk klik kiri dan
action GLFW_PRESS untuk menampilkan action saat mouse ditekan dan
menampilkan tulisan “Left Button Pressed”.
2. Sintaks Code :
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
#include <math.h>
#include <iostream>

#define SCREEN_WIDTH 640

#define SCREEN_HEIGHT 480

void scrollCallback(GLFWwindow* window, double xoffset, double yoffset);

int main(void) {

GLFWwindow* window;

if (!glfwInit())
{
return -1;
}

window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Hello World",

NULL, NULL);

int screenWidth, screenHeight;

glfwGetFramebufferSize(window, &screenWidth, &screenHeight);

if (!window) {
glfwTerminate();
return -1;
}

glfwMakeContextCurrent(window);
glfwSetScrollCallback(window, scrollCallback);
glfwSetInputMode(window, GLFW_STICKY_MOUSE_BUTTONS, GLFW_TRUE);

glViewport(0.0f, 0.0f, screenWidth, screenHeight);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, SCREEN_WIDTH, 0, SCREEN_HEIGHT, 0, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

while (!glfwWindowShouldClose(window))
{
glClear(GL_COLOR_BUFFER_BIT);

glfwSwapBuffers(window);

glfwPollEvents();
}

glfwTerminate();

return 0;
}

static void scrollCallback(GLFWwindow* window, double xoffset, double

yoffset) {
if (yoffset < 0)
{
yoffset = -1;
std::cout << "Scrolling : X[" << xoffset << "] Y[" << yoffset
 << "]" << std::endl;
}
else
{
yoffset = 1;
std::cout << "Scrolling : X[" << xoffset << "] Y[" << yoffset
<< "]" << std::endl;
}
}

Capture Output :

Analisa :
Output program mouse assignment 3(2) adalah jika kita melakukan scroll up pada
mouse, akan keluar nilai 1 pada sumbu y, dan jika kita melakukan scroll down pada mouse,
akan keluar nilai -1 pada sumbu y. Perbedaan dari program sebelumnya adalah pada program
sebelumnya kita harus mengklik kanan atau kiri pada mouse terlebih dahulu baru muncul
output “Right button pressed” atau “Left button pressed”, sedangkan program ini hanya perlu
menscroll ke atas atau ke bawah saja untuk menampilkan nilai pada Y apakah 1 atau -1.