A. Pendahuluan
Objek 3D pada open GL merupakan objek yang lebih hidup dibandingkan objek 2D. Namun permukaan objek 3D yang polos membuat 3D cenderung kurang menarik dan kaku. Untuk membuat objek yang lebih hidup pada OpenGL diperlukan suatu texture mapping. Mapping ialah sebuah bentuk kegiatan untuk melakukan pewarnaan atau memetakan permukaan geometri pada objek 3D. Sedangkan Maps adalah bentuk gambar atau warna yang digunakan untuk melapisi objek 3D pada saat dilakukan mapping. Dengan kata lain pemetaan texture merupakan pemberian sebuah gambar pada permukaan objek sehingga objek akan tampak realistis. Texture mapping memungkinkan untuk menaruh gambar pada geometric primitive tersebut dan sekaligus mengikuti transformasi yang diterapkan kepada objek. Contohnya apabila sebuah objek kubus tanpa gambar diberi texture bebatuan pada permukaannya, maka objek tersebut akan tampak memiliki tekstur kasar seperti batu. Texture pada permukaan objek dapat dilihat dari berbagai
perspective yang berbeda. Beberapa contoh texture pada objek sebagai berikut: Texture 1 dimensi
Texture 2 dimensi
Texture 3 dimensi
Filter pembesaran texture berpengaruh pada bagaimana OpenGL melakukan proses rasterisasi texture saat texture ditampilkan pada jumlah pixel yang lebih besar atau lebih kecil dari ukuran sebenarnya. Pada Nearest Filtered
Texture, texture yang ditampilkan merupakan hasil pemilihan nilai pixel pada posisi terdekat. Sedangkan dengan Linear Interpolation Texture (LPT), texture yang ditampilkan merupakan hasil interpolasi linear antara pixel-pixel disekitarnya. Pada Mipmapped Texture(MPT), interpolasi linear dilakukan pada awal secara offline sehingga dihasilkan banyak texture dengan ukuran dari yang kecil hingga yang besar.LPT dan MPT akan menghasilkan kira-kira hasil yang sama dengan LPT akan sedikit lebih lambat dari MPT walaupun memori yang digunakan jauh lebih kecil.
Namun terkadang efek texture yang diinginkan dapat diperoleh dengan mencampur lebih dari satu texture. Proses pencampuran lebih dari satu texture disebut dengan istilah blending. Salah satu efek blending yang paling sederhana adalah dengan memblending texture dengan warna. Fungsi yang digunakan pada proses blending adalah glEnable(GL_BLEND).
Implementasi texture pada objek grafika computer terdapat pada, animasi seperti toy story maupun game animasi.
B. Konsep Texture Mapping
Texture mapping merupakan teknik pemetaan sebuah tekstur pada pola gambar wireframe, dimana wireframe yang telah dibuat akan ditampilkan memiliki kulit luar seperti
tekstur yang diinginkan. Beberapa hal yang perlu diperhatikan dalam pemberian tekstur, diantaranya: Menentukan tekstur
1. Membaca atau membangkitkan tekstur 2. Menandai tekstur
3. Mengenablekan tekstur
Menandai koordinat tekstur pada vertek Menentukan parameter tekstur
C. Teknik-teknik Realisme dalam Kompuer Grafik
1. . Tekstur-Maps
Maps berwujud gambar tekstur 2D yang dituangkan ke permukaan geometri/objek untuk membuat penampilan objek tersebut tampak halus untuk detail permukaannya. Pada pengembangan grafik realisme tingkat tinggi diperlukan lebih banyak lapisan tekstur, agar hasil mapping mendekati kesempurnaan. Sebuah tekstur maps yang diterapkan (dipetakan) biasanya dipakai untuk permukaan bentuk objek polygon, proses ini mirip dengan menerapkan texture pada kertas berpola kotak putih yang polos.Kegiatan texture mapping untuk texture maps dapat didefinisikan sebagai sebuah metode untuk menambahkan detail tekstur permukaan (bitmap atau raster image), atau warna yang dihasilkan komputer grafis atau model 3D. Penerapannya pada grafis 3D dirintis oleh Dr Edwin Catmull pada proyek Ph.D tesisnya tahun 1974.
2. Environment-Maps
Environtment-Maps ialah maps yang memiliki pewarnaan dengan banyak gambar (tekstur) yang merekam refleksi global dan pencahayaan pada objek. Gambar-gambar ini difungsikan sebagai resampled selama proses rendering, dengan tujuan untuk mengekstrak, dan melihat informasi spesifik yang kemudian diterapkan sebagai tekstur objek pada permukaan geometri. Maps ini sering disebut reflection yang berarti tekstur pencahayaan dari benda-benda luar di sekitar objek, maps jenis ini sangat cocok untuk benda-benda yang memiliki tingkat refleksi yang sangat tinggi, seperti kaca, dan lain sebagainya.Environmet mapping pada maps ini memiliki definisi yaitu metode yang efisien untuk simulasi kompleks permukaan bercermin melalui suatu gambar tekstur. Tekstur yang digunakan bekerja untuk menyimpan gambar dari lingkungan sekitar objek yang diberikan. Ada beberapa cara untuk menyimpan tekstur lingkungan sekitar objek, salah satu metode yang paling umum adalah metode Spherical Environment Mapping, di mana dalam metode ini suatu tekstur yang berisi citra lingkungan sekitar akan direfleksikan sebagai bola cermin, dan kemudian dimasukkan sebagai tekstur objek yang diberi maps.
3. Bump-Maps
Bump maps adalah maps yang memfokuskan permukaan tekstur pada objek, dengan menggunakan maps ini, permukaan geometri/objek akan terlihat berbeda dan unik, tidak seperti objek-objek yang memiliki permukaan normal pada umumnya. Rumus pekerjaan dari maps ini akan menerapkan bidang untuk intensitas dalam maps yang menunjukkan tingkat rendah tingginya suatu permukaan objek, fungsi maps ini akan mengacaukan permukaan objek yang normal, sehingga menimbulkan kesan unik ketika hasilnya sudah di-render.Untuk kegiatannya, bump mapping adalah sebuah teknik grafis komputer di mana pada setiap pixel untuk permukaan normal objek, akan diberikan efek tidak halus dan diterapkan sebelum melakukan perhitungan iluminasi. Hasilnya, objek yang diberi maps akan lebih kaya, serta lebih rinci untuk representasi permukaan objek dan lebih mirip pada permukaan alam. 4. Normal-Maps
Maps ini serupa dengan bump-maps, perbedaannya adalah fungsionalitas yang ada pada normal maps, maps ini secara alami akan menghasilkan bentuk permukaan yang tidak halus tanpa menggunakan lebih banyak penambahan atau pengurangan poligon pada objek.Dalam dunia grafik komputer 3D, normal mapping pada maps ini bisa disebut "
Dot3 bump mapping ", definisinya adalah sebuah teknik yang digunakan untuk ”berpura-pura” menambahkan efek tidak halus pada permukaan objek. Kenapa disebut ”berpura-pura”
? Hal ini disebabkan karena mapping ini bekerja dengan menambahkan rincian tidak halus pada permukaan objek tanpa menggunakan poligon. Normal mapping biasanya diakurasi sebagai sebuah gambar RGB yang berhubungan dengan koordinat X, Y, dan Z dari permukaan normal suatu objek. Penggunaan umum teknik ini adalah untuk lebih meningkatkan tampilan dan detail dari model poligon rendah dengan menghasilkan peta normal dari model poligon yang tinggi.
5. Shadow-Maps
Shadow maps yaitu maps yang menghasilkan suatu bayangan tekstur pada objek dengan menangkap siluet objek tersebut dari sumber cahaya yang terlihat. Maps ini sangat sering dipakai oleh pengembang grafik 3D, karena efek yang dihasilkan seolah-olah menunjukkan objek tersebut sangat realistis, dan disebabkan adanya bayangan dari sumber cahaya yang ada.Fungsi kerjanya yang berkonsep shadow mapping adalah proses di mana bayang-bayang ditambahkan ke grafik komputer 3D. Konsep ini diperkenalkan oleh Lance Williams pada tahun 1978, dalam sebuah makalah yang berjudul "Casting curved shadows on curved surfaces". Sejak
saat itu, teknik ini telah digunakan baik dalam pra-render adegan, dipakai secara realtime, atau bahkan diterapkan ke banyak konsol dan PC high-end game.
D. Teknik-teknik dalam Geometri
1. Texture- Mapping.
Sebuah metode untuk menambahkan detail, tekstur permukaan (bitmap atau raster image), atau warna yang dihasilkan komputer grafis atau model 3D. Penerapannya pada grafis 3D dirintis oleh Dr Edwin Catmull di gelar Ph.D. tesis 1974.
2. Poligonization.
Dengan merubah bentuk asli objek, namun, ini membutuhkan resource hardware yang besar. 3. Splines.
Merupakan teknik yang menggunakan representasi permukaan matematis (polynomial), tanpa menggunakan polygon sama sekali.
4. Implicit surface (Blobbies).
Teknik ini didasarkan pada fungsi x,y, dan z. 5. Subdivision Surfaces.
Membagi objek menjadi segitiga yang bertumpuk. 6. Degradasi tingkat detail.
Mengganti poligon pada objek yang berada pada posisi yang jauh, menghemat waktu render. 7. Mesh decimation.
Mengurangi poligon pada suatu objek untuk menghemat waktu rendering.
Tekstur merupakan sebuah wadah dari sebuah gambar atau lebih. Namun, tekstur tidak menyimpan gambar begitu saja, gambar tekstur memiliki konfigurasi tertentu. Ada tiga karakteristik untuk mendefinisikan tekstur, karakteristik tersebut adalah: jenis tekstur, ukuran tekstur, dan format gambar yang digunakan tekstur. Jenis tekstur mendefinisikan susunan gambar dalam tekstur, ukuran mendefinisikan ukuran gambar dalam tekstur, dan format gambar mendefinisikan format gambar yang digunakan dalam tekstur.
Berikut ini adalah macam-macam tekstur:
GL_TEXTURE_1D: semua gambar dalam tekstur ini 1- dimensi. Memiliki lebar, tapi tidak memiliki ketinggian atau kedalaman.
GL_TEXTURE_2D: semua gambar dalam tekstur ini 2- dimensi. Memiliki lebar dan tinggi, namun tidak punya kedalaman.
GL_TEXTURE_RECTANGLE: Gambar dalam tekstur ini (hanya satu gambar pada mipmapping) 2-dimensi. Koordinat tekstur yang digunakan untuk tekstur ini tidak dinormalisasi.
GL_TEXTURE_BUFFER: Gambar dalam tekstur ini (Hanya satu gambar ada mipmapping) 1-dimensi. Penyimpanan data berasal dari Buffer Object.
GL_TEXTURE_CUBE_MAP: terdapat 6 set gambar 2D berbeda, dengan ukuran yang sama. Berbentuk seperti 6 sisi kubus.
GL_TEXTURE_1D_ARRAY: Gambar dalam tekstur ini semua 1-dimensi. Namun, berisi beberapa set gambar
1-dimensi, semua dalam satu tekstur. Panjang array bagian dari ukuran tekstur itu.
GL_TEXTURE_2D_ARRAY: Gambar dalam tekstur ini semua adalah 2-dimensi. Namun, mengandung beberapa set gambar 2 dimensi, semua dalam satu tekstur. Panjang array bagian dari ukuran tekstur itu.
GL_TEXTURE_CUBE_MAP_ARRAY: Gambar dalam tekstur ini merupakan pemetaan kubus. Berisi beberapa set peta kubus yang kesemuanya berada dalam sebuah tekstur. Panjang Array * 6 (jumlah sisi kubus) merupakan bagian dari ukuran tekstur.
GL_TEXTURE_2D_MULTISAMPLE: Gambar dalam tekstur ini (hanya satu gambar ada mipmapping) adalah 2-dimensi. Setiap pixel dalam gambar ini berisi beberapa sampel bukan hanya satu nilai.
GL_TEXTURE_2D_MULTISAMPLE_ARRAY: Menggabungkan 2D array dan jenis multisample 2D. Tidak ada mipmapping.
Ukuran tekstur memiliki batas dalam implementasinya di open GL. Untuk tekstur 1D dan 2D (dan setiap jenis tekstur yang menggunakan dimensi yang sama, seperti cubemaps) ukuran maksimalnya adalah GL_MAX_TEXTURE_SIZE. Untuk tekstur array, panjang maksimum array adalah GL_MAX_ARRAY_TEXTURE_LAYERS. Untuk tekstur 3D, dimensi tidak boleh lebih besar dari GL_MAX_3D_TEXTURE_SIZE dalam ukuran. Dalam batas-batas ini, ukuran tekstur dapat bernilai berapapun. Disarankan bagaimanapun, Anda harus tetap mangacu pada pangkat dua untuk ukuran tekstur, kecuali Anda memiliki kebutuhan yang signifikan untuk menggunakan ukuran tertentu.
E. Mip maps
Ketika tekstur secara langsung diterapkan ke permukaan, berapa banyak piksel tekstur yang (biasa disebut
"texels") digunakan tergantung pada sudut di mana permukaan akan dirender. Sebuah tekstur dipetakan ke gambar pesawat yang hampir di tepi kamera hanya akan menggunakan sebagian kecil dari pixel tekstur. Demikian pula, melihat langsung ke bawah pada tekstur dari jauh akan menunjukkan texels lebih sedikit daripada melihat dari dekat. Masalahnya adalah dengan animasi. Ketika Anda perlahan- lahan melakukan zoom out pada tekstur, Anda akan mulai melihat bentuk asing muncul. Ini disebabkan oleh pengambilan sampel yang lebih sedikit dari semua texels, pilihan texel mana yang yang akan dijadikan sample berubah berdasarkan frame yang berbeda pada animasi. Bahkan dengan linear filtering (lihat di bawah), bentuk akan muncul seperti kamera di-zoom out.
Untuk mengatasi masalah ini, kita dapat
menggunakan mip maps.metode ini adalah menyusut versi gambar berukuran penuh. Setiap mipmap adalah setengah ukuran dari sebelumnya dalam rangkaian, menggunakan dimensi terbesar gambar. Jadi 2D tekstur 64x16 dapat memiliki 6 mip-map: 32x8, 16x4, 8x2, 4x1, 2x1, dan 1x1. OpenGL tidak mengharuskan rantai mipmap selesai, Anda dapat menentukan apa yang rentang mipmaps dalam tekstur yang tersedia.
Beberapa jenis tekstur memiliki beberapa set independen mipmaps. Setiap sisi cubemap memiliki pemetaan mipmaps sendiri, seperti halnya setiap entri dalam tekstur array. Namun, tekstur secara keseluruhan hanya memiliki satu pengaturan yang mipmaps tertentu. Jadi jika tekstur sudah diatur sedemikian rupa sehingga hanya bagian top 4 levels mipmaps, Anda harus memiliki rangkaian bagian mipmaps tersebut dalam sebuah tekstur.
Ketika melakukan sampel tekstur, implementasi secara otomatis akan memilih mipmap yang digunakan untuk sudut pandang, ukuran tekstur, dan berbagai faktor lainnya. Bila menggunakan ukuran tekstur yang tidak pangkat dua, setengah ukuran mipmaps lebih rendah dibulatkan ke bawah. Jadi tekstur 63x63 memiliki tingkat terendah berikutnya:
31x31. Dan seterusnya.
Tingkat dasar rantai mipmap adalah yang terbesar. Hal ini juga salah satu yang mendefinisikan ukuran penuh tekstur. Nomor OpenGL ini tingkat mipmap sebagai 0, tingkat mipmap terbesar berikutnya adalah 1, dan seterusnya. Tingkat dasar tekstur tidak harus di-load. Selama Anda menentukan rentang mipmaps dengan benar, Anda dapat meninggalkan setiap tingkat mipmap yang Anda inginkan.
CG
Obye
byek
Obyek
CG
Obye
k CG
Proses texture mapping (2)G. Object Texture
Diagram konten objek tekstur
Tekstur dalam OpenGL adalah objek OpenGL, dan mengikuti konvensi standar tersebut. Tekstur memiliki standar glGenTextures, glBindTexture.Target parameter lBindTexture sesuai dengan jenis tekstur itu. Jadi, ketika Anda menggunakan nama tekstur baru yang dihasilkan, rangkaian pertama akan menentukan jenis tekstur. Anda tidak dapat memasukkan objek pada target dengan tipe yang berbeda. Jadi, jika Anda membuat tekstur sebagai GL_TEXTURE_1D, maka Anda harus terus menggunakan tipe itu.
Seperti jenis objek lain di OpenGL, kita dapat
menggunakan target dengan tipe yang berbeda. Sehingga Anda dapat memiliki GL_TEXTURE_1D dan GL_TEXTURE_2D_ARRAY.
Contoh program
/* Program evaluasi untuk mengevaluasi kurva
* permukaan secara otomatis menentukan koorditan texture */ #include <GL/glut.h> #include <stdlib.h> #include <math.h> GLfloat ctrlpoints[4][4][3] = { {{ -1.5, -1.5,4.0}, { -0.5, -1.5,2.0}, {0.5, -1.5, -1.0}, {1.5, -1.5,2.0}}, {{ -1.5, -0.5,1.0}, { -0.5, -0.5,3.0}, {0.5, -0.5,0.0}, {1.5, -0.5, -1.0}}, {{ -1.5,0.5,4.0}, { -0.5,0.5,0.0}, {0.5,0.5,3.0}, {1.5,0.5,4.0}}, {{ -1.5,1.5, -2.0}, { -0.5,1.5, -2.0}, {0.5,1.5,0.0}, {1.5,1.5, -1.0}} }; GLfloat texpts[2][2][2] = {{{0.0,0.0}, {0.0,1.0}}, {{1.0,0.0}, {1.0,1.0}}}; void display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glColor3f(1.0,1.0,1.0); glEvalMesh2(GL_FILL,0,20,0,20); glFlush(); } #define imageWidth 64 #define imageHeight 64
GLubyte image[3*imageWidth*imageHeight];
void makeImage(void)
{
int i, j; float ti, tj;
for (i =0; i < imageWidth; i++) { ti =2.0*3.14159265*i/imageWidth;
for (j =0; j < imageHeight; j++) { tj =2.0*3.14159265*j/imageHeight;
image[3*(imageHeight*i+j)] = (GLubyte)127*(1.0+sin(ti)); image[3*(imageHeight*i+j)+1] = (GLubyte)127*(1.0+cos(2*tj)); image[3*(imageHeight*i+j)+2] = (GLubyte)127*(1.0+cos(ti+tj)); } } } void init(void) { glMap2f(GL_MAP2_VERTEX_3,0,1,3,4, 0,1,12,4, &ctrlpoints[0][0][0]); glMap2f(GL_MAP2_TEXTURE_COORD_2,0,1,2,2, 0,1,4,2, &texpts[0][0][0]); glEnable(GL_MAP2_TEXTURE_COORD_2); glEnable(GL_MAP2_VERTEX_3); glMapGrid2f(20,0.0,1.0,20,0.0,1.0); makeImage();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 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_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D,0, GL_RGB, imageWidth, imageHeight,0, GL_RGB,
GL_UNSIGNED_BYTE, image); glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST); glShadeModel (GL_FLAT); }
void reshape(int w, int h)
{
glViewport(0,0, (GLsizei) w, (GLsizei) h); glMatrixMode(GL_PROJECTION); glLoadIdentity();
if (w <= h)
glOrtho(-4.0,4.0, -4.0*(GLfloat)h/(GLfloat)w,4.0*(GLfloat)h/(GLfloat)w, -4.0,4.0);
else
glOrtho(-4.0*(GLfloat)w/(GLfloat)h,4.0*(GLfloat)w/(GLfloat)h, -4.0,4.0, -4.0,4.0); glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(85.0,1.0,1.0,1.0); }
void keyboard(unsigned char key, int x, int y)
{
switch (key) { case27:
exit(0);
} }
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize (500,500); glutInitWindowPosition (100,100); glutCreateWindow (argv[0]); init (); glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keyboard); glutMainLoop(); return0; }
