PRAKTIKUM GRAFIKA KOMPUTER

Pertemuan ke-10 (Bayangan)

Dadan Ahmad Badar Muttaqin

2006116

JURUSAN ILMU KOMPUTER

PROGRAM STUDI TEKNIK INFORMATIKA
INSTITUT TEKNOLOGI GARUT
Jl. Mayor Syamsu No. 1 Jayaraga Garut 44151 Indonesia

1
 I. PENDAHULUAN
Grafika komputer merupakan cabang ilmu yang terus berkembang pesat,
memberikan daya cipta manusia untuk menciptakan dunia visual yang semakin mendekati
realitas. Dalam pengembangan grafika komputer, salah satu aspek yang krusial adalah
pemahaman dan pengimplementasian bayangan. Bayangan bukan hanya sekadar
representasi visual, namun juga kunci untuk mencapai tingkat realisme yang tinggi dalam
penggambaran objek dan scene.

Bayangan dalam konteks grafika komputer adalah hasil dari kompleksitas interaksi
antara sumber cahaya, objek, dan mata pengamat. Materi ini akan menjelaskan aspek-aspek
kunci yang terlibat dalam pembentukan bayangan, dari pencahayaan hingga teknik
pemodelan yang digunakan untuk menciptakan gambar yang meyakinkan. Pemahaman
mendalam tentang bayangan diperlukan untuk memberikan dimensi dan kedalaman pada
objek yang dirender, sehingga memungkinkan para desainer dan pengembang grafis untuk
menciptakan pengalaman visual yang lebih kaya.

Saya akan menjelajahi konsep-konsep dasar seperti jenis pencahayaan, tipe

bayangan, dan teknik pemodelan seperti shadow mapping dan ray tracing. Selain itu,
pemrosesan warna, efek spesifik seperti pantulan dan pembiasan, serta teknik lanjutan
seperti soft shadows dan global illumination akan menjadi fokus dalam pemahaman
mendalam tentang bayangan dalam dunia grafika komputer.

Dengan menguasai konsep-konsep ini, para pengembang grafis dapat menciptakan

simulasi visual yang lebih realistis, menggiring pengalaman pengguna ke tingkat yang lebih
tinggi. Oleh karena itu, pemahaman tentang bayangan dalam grafika komputer menjadi
langkah esensial menuju pencapaian representasi visual yang semakin mendekati keaslian
objek dan lingkungan yang dirender.

1
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

II. PEMBAHASAN

A. Source Code

Bayangan
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>

double rx = 0.0;
double ry = 0.0;
float l[] = { 0.0, 80.0, 0.0 }; // koordinat sumber cahaya
float n[] = { 0.0, -1.0, 0.0 };
float e[] = { 0.0, -60.0, 0.0 };

void help(); // obyek yang akan digambar

void draw(){
glutSolidCube(50.0);
}

// membuat proyeksi bayangan

void glShadowProjection(float* l, float* e, float* n) {
float d, c;
float mat[16];

d = n[0] * l[0] + n[1] * l[1] + n[2] * l[2];

c = e[0] * n[0] + e[1] * n[1] + e[2] * n[2] - d;

// membuat matriks. OpenGL menggunakan kolom matriks

mat[0] = l[0] * n[0] + c;
mat[4] = n[1] * l[0];
mat[8] = n[2] * l[0];
mat[12] = -l[0] * c - l[0] * d;
mat[1] = n[0] * l[1];
mat[5] = l[1] * n[1] + c;
mat[9] = n[2] * l[1];
mat[13] = -l[1] * c - l[1] * d;
mat[2] = n[0] * l[2];
mat[6] = n[1] * l[2];
mat[10] = l[2] * n[2] + c;
mat[14] = -l[2] * c - l[2] * d;
mat[3] = n[0];
mat[7] = n[1];
mat[11] = n[2];
mat[15] = -d;

2
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

// kalikan matriks
glMultMatrixf(mat);
}

// render
void render() {
glClearColor(0.0, 0.6, 0.9, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLightfv(GL_LIGHT0, GL_POSITION, l);
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);

glColor3f(1.0, 1.0, 0.0);

glBegin(GL_POINTS);
glVertex3f(l[0], l[1], l[2]);
glEnd();

glColor3f(0.8, 0.8, 0.8);

glBegin(GL_QUADS);
glNormal3f(0.0, 1.0, 0.0);
glVertex3f(-1300.0, e[1] - 0.1, 1300.0);
glVertex3f(1300.0, e[1] - 0.1, 1300.0);
glVertex3f(1300.0, e[1] - 0.1, -1300.0);
glVertex3f(-1300.0, e[1] - 0.1, -1300.0);
glEnd();

// gambar bayangan
glPushMatrix();
glRotatef(ry, 0, 1, 0);
glRotatef(rx, 1, 0, 0);
glEnable(GL_LIGHTING);
glColor3f(0.0, 0.0, 0.8);
draw();
glPopMatrix();

// sekarang gambar bayangan yang muncul

glPushMatrix();
glShadowProjection(l, e, n);
glRotatef(ry, 0, 1, 0);
glRotatef(rx, 1, 0, 0);
glDisable(GL_LIGHTING);
glColor3f(0.4, 0.4, 0.4);
draw();
glPopMatrix();

glutSwapBuffers();
}

void keypress(unsigned char c, int a, int b) {

3
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

if (c == 27)
exit(0);
else if (c == 's')
l[1] -= 5.0;
else if (c == 'w')
l[1] += 5.0;
else if (c == 'a')
l[0] -= 5.0;
else if (c == 'd')
l[0] += 5.0;
else if (c == 'q')
l[2] -= 5.0;
else if (c == 'e')
l[2] += 5.0;
else if (c == '?')
help();
}

void help() {

printf("==================================================\n");
printf("proyeksi contoh bayangan sebuah obyek cube\n");
printf("----------------------------------------------------------------\n");
printf("s/w memindahkan sumber cahaya naik/turun\n");
printf("a/d memindahkan sumber cahaya kekanan/kekiri\n");
printf("q/e memindahkan sumber cahaya ke depan atau ke
belakang\n");
printf("? ini adalah contoh\n");

printf("==================================================\n");
}

void idle() {
rx += 0.4;
ry += 0.7;
render();
}

void resize(int w, int h) {

glViewport(0, 0, w, h);
}

int main(int argc, char* argv[]) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutCreateWindow("2006116 - Dadan Ahmad Badar Muttaqin");
glutReshapeFunc(resize);
glutReshapeWindow(400, 400);
glutKeyboardFunc(keypress);

4
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

glutDisplayFunc(render);
glutIdleFunc(idle);

glEnable(GL_NORMALIZE);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHT0);
glEnable(GL_TEXTURE_2D);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, 1.0, 1.0, 400.0); // Reset koordinat sebelum
dimodifikasi/diubah

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -150.0);

help();

glutMainLoop();
return 0;
}

5
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

B. Output

C. Penjelasan
Kode program di atas merupakan implementasi proyeksi bayangan untuk objek kubus
menggunakan OpenGL dan GLUT dalam bahasa pemrograman C. Dalam program ini, beberapa
variabel global seperti `rx`, `ry`, `l`, `n`, dan `e` dideklarasikan untuk mengontrol rotasi, posisi
sumber cahaya, dan vektor normal.
Fungsi `help()` menampilkan pesan bantuan di konsol, dan fungsi `draw()` menggunakan
fungsi `glutSolidCube()` untuk menggambar objek kubus. Proyeksi bayangan diimplementasikan
dalam fungsi `glShadowProjection`, yang serupa dengan versi sebelumnya.
Fungsi `render()` mengatur proses rendering, termasuk pengaturan tampilan dan warna latar
belakang, pencahayaan, serta menggambar objek kubus dan bayangannya. Fungsi input keyboard
`keypress()` memberikan respons terhadap input pengguna, memungkinkan pergerakan sumber
cahaya dalam berbagai arah.Fungsi `idle()` memberikan efek animasi pada objek dan bayangannya
dengan memanggil fungsi `render()` secara terus-menerus. Fungsi `resize()` mengatur viewport
OpenGL ketika ukuran jendela berubah.
Dalam fungsi `main()`, inisialisasi OpenGL dan GLUT dilakukan, termasuk pengaturan
proyeksi perspektif, pencahayaan, dan inisialisasi jendela GLUT. Beberapa pengaturan OpenGL
diaktifkan seperti normalisasi vektor normal, pencahayaan, uji kedalaman, dan penggunaan lampu.
Seluruh setup modelview dan proyeksi dilakukan di bagian akhir fungsi `main()`. Program
ini memberikan pemahaman praktis tentang proyeksi bayangan dalam konteks grafika komputer
dan memberikan interaktivitas dengan pengguna melalui input keyboard.

6
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

7
Praktikum Grafika Komputer
Pertemuan ke-2 Primitive Drawing

III. Kesimpulan

Secara keseluruhan, kode program tersebut adalah implementasi proyeksi bayangan untuk
objek kubus menggunakan OpenGL dan GLUT dalam bahasa pemrograman C. Program ini
memanfaatkan variabel global untuk mengontrol posisi dan rotasi sumber cahaya, serta vektor
normal. Fungsi-fungsi seperti `help()`, `draw()`, dan `glShadowProjection()` berkontribusi dalam
menampilkan pesan bantuan, menggambar objek kubus, dan mengimplementasikan proyeksi
bayangan.
Fungsi `render()` mengatur seluruh proses rendering, termasuk pencahayaan, pengaturan
tampilan, dan menggambar objek kubus beserta bayangannya. Pengguna dapat berinteraksi dengan
program melalui input keyboard yang diatur oleh fungsi `keypress()`, memungkinkan pergerakan
sumber cahaya dalam berbagai arah. Animasi objek dan bayangan dicapai melalui fungsi `idle()` yang
dipanggil secara berulang.
Melalui fungsi `resize()`, program dapat menanggapi perubahan ukuran jendela dengan
mengatur viewport OpenGL. Dengan inisialisasi OpenGL dan GLUT di dalam fungsi `main()`,
program mempersiapkan lingkungan grafis yang memungkinkan visualisasi proyeksi bayangan objek
kubus secara interaktif. Keseluruhan, program ini memberikan pengalaman praktis dalam
pengembangan grafika komputer sederhana, dengan fokus pada konsep proyeksi bayangan dan
interaksi pengguna.