PRAKTIKUM GRAFIKA KOMPUTER

Pertemuan ke-10 (Bayangan)

Gea Davids Khalik

2206013

Jurusan Ilmu Komputer

Program Studi Teknik Informatika
Institut Teknologi Garut
Jl. Mayor Syamsu No. 1 Jayaraga Garut 44151 Indonesia

I. PENDAHULUAN

Dalam dunia grafika komputer, bayangan (shadow) memiliki peran sentral dalam
menciptakan pengalaman visual yang realistis dan mendalam. Pada dasarnya, bayangan memberikan
dimensi tambahan kepada objek 3D, menunjukkan adanya interaksi antara objek tersebut dengan
sumber cahaya di dalam suatu ruang tiga dimensi. Dalam konteks pengembangan aplikasi grafis
menggunakan OpenGL, konsep bayangan menjadi kritis karena dapat memberikan detail dan
kompleksitas yang diperlukan untuk meningkatkan kualitas visual.

Proses rendering bayangan di dalam OpenGL seringkali merupakan tantangan, melibatkan

perhitungan cahaya dan kompleksitas interaksi antara objek dan sumber cahaya. Salah satu teknik
yang sering digunakan untuk mencapai efek bayangan adalah "shadow mapping." Teknik ini
memanfaatkan informasi kedalaman (depth information) dari sudut pandang sumber cahaya untuk
mensimulasikan bayangan dengan tepat.

Teknik bayangan lainnya yang juga umum digunakan melibatkan "shadow volumes" dan
"shadow masks," masing-masing dengan pendekatan yang unik untuk mencapai hasil visual yang
diinginkan. Pemahaman mendalam terhadap prinsip-prinsip dasar di balik teknik-teknik ini sangat
penting agar dapat mengimplementasikannya secara efektif dalam pengembangan aplikasi berbasis
OpenGL.

Pentingnya integrasi bayangan dalam pengembangan aplikasi OpenGL tidak hanya terbatas
pada aspek estetika visual semata. Bayangan juga memberikan informasi kontekstual tentang
hubungan spasial antara objek, menambahkan tingkat realisme dan detail yang diperlukan untuk
menciptakan pengalaman pengguna yang memukau. Oleh karena itu, pembahasan dan pemahaman
lebih lanjut mengenai konsep bayangan dalam konteks OpenGL akan memberikan wawasan yang
lebih mendalam tentang cara meningkatkan kualitas grafis suatu aplikasi.

1
Praktikum Grafika Komputer
Pertemuan ke-10 Bayangan

II. PEMBAHASAN

A. Source Code

#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>
using namespace std;

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()
{
glutSolidCone(40, 20, 15, 50);
}

//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 matrik. OpenGL menggunakan kolom matrik
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;
// kalikan matrik
glMultMatrixf(mat);
}

2
Praktikum Grafika Komputer
Pertemuan ke-10 Bayangan

/*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)

{
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();
}

3
Praktikum Grafika Komputer
Pertemuan ke-10 Bayangan

void help()
{
cout<<"=================================================="<<endl;
cout<<"=================================================="<<endl;
cout<<"Proyeksi Contoh Bayangan Sebuah Obyek Teapot"<<endl;
cout<<"\t\tGea Davids Khalik\t\t"<<endl;
cout<<"\t\t 2206013\t\t"<<endl;
cout<<"=================================================="<<endl;
cout<<endl;
cout<<"=================================================="<<endl;
cout<<"s : Memindahkan sumber cahaya naik"<<endl;
cout<<"w : Memindahkan sumber cahaya turun"<<endl;
cout<<"a : Memindahkan sumber cahaya ke kanan"<<endl;
cout<<"d : Memindahkan sumber cahaya ke kiri"<<endl;
cout<<"q : Memindahkan sumber cahaya ke depan"<<endl;
cout<<"e : Memindahkan sumber cahaya ke belakang"<<endl;
cout<<"=================================================="<<endl;
cout<<"=================================================="<<endl;
}

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("2206013_Gea Davids Khalik");
glutReshapeFunc(resize);
glutReshapeWindow(400,400);
glutKeyboardFunc(keypress);
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);

4
Praktikum Grafika Komputer
Pertemuan ke-10 Bayangan

glLoadIdentity();
glTranslatef(0.0, 0.0, -150.0);
help();
glutMainLoop();
return 0;
}

Output :

B. Penjelasan

Program tersebut adalah contoh implementasi proyeksi bayangan menggunakan OpenGL. Berikut adalah
penjelasan singkat dari beberapa bagian utama dalam program:

1 Inisialisasi Variabel
• `rx` dan `ry` menyimpan nilai rotasi pada sumbu-x dan sumbu-y.
• `l` adalah koordinat sumber cahaya.
• `n` adalah vektor normal permukaan bayangan.
• `e` adalah posisi mata/pemirsa.

2 Fungsi `draw`
• Membuat obyek yang akan digambar menggunakan fungsi `glutSolidCone`.

3 Fungsi `glShadowProjection`
• Membuat proyeksi bayangan dengan menghitung matriks transformasi dan mengalikannya pada
matriks model-view.

5
Praktikum Grafika Komputer
Pertemuan ke-10 Bayangan

4 Fungsi `render`
• Mengatur tampilan, warna latar belakang, dan pencahayaan.
• Gambar lantai sebagai bayangan.
• Gambar obyek dan bayangannya dengan memanfaatkan proyeksi bayangan.

5 Fungsi `keypress`
• Mengatur respons terhadap input keyboard.
• Mengubah posisi sumber cahaya berdasarkan input.

6 Fungsi `help`
• Menampilkan pesan bantuan yang menjelaskan fungsi dari setiap tombol keyboard yang dapat
digunakan.

7 Fungsi `idle`
• Mengatur rotasi obyek secara terus-menerus untuk memberikan efek dinamis.

8 Fungsi `resize`
• Mengatur ulang viewport ketika ukuran jendela berubah.

9 Fungsi `main`
• Inisialisasi GLUT dan menyiapkan jendela.
• Mengatur fungsi-fungsi callback.
• Mengaktifkan beberapa fitur OpenGL seperti pencahayaan, material warna, dan depth testing.
• Menjalankan loop utama GLUT.

6
Praktikum Grafika Komputer
Pertemuan ke-10 Bayangan

III. Kesimpulan

Dalam program proyeksi bayangan menggunakan OpenGL ini, konsep dasar grafika
komputer diimplementasikan untuk menciptakan tampilan 3D dengan efek proyeksi bayangan.
Program ini menggunakan GLUT dan OpenGL untuk membuat jendela grafis, mengatur
pencahayaan, dan merender obyek 3D. Pada intinya, proyeksi bayangan dihasilkan dengan
menghitung transformasi matriks yang memodifikasi tampilan obyek sesuai dengan posisi dan arah
sumber cahaya. Pengguna dapat berinteraksi dengan program melalui input keyboard untuk
mengubah posisi sumber cahaya. Keseluruhan, program ini memberikan pemahaman praktis terhadap
konsep-konsep dasar dalam grafika komputer, seperti transformasi matriks, pencahayaan, dan
proyeksi bayangan.