Membuat Rumah 3D Dengan OpenGL

Membuat Rumah 3D Dengan OpenGL

Membuat Rumah 3D Dengan OpenGL

Membuat Rumah 3D dengan OpenGL sama seperti postingan saya yang sebelumnya kita membuat rumah 2D menggunakan OpenGL bedanya ya 3D dan 2D. Kita sudah belajar tentang yang 2D oleh karena itu kita akan meningkatkan skil kita lagi teman-teman, dengan membuat rumah 3D. Bedanya dimana sih ?

Langsung saja siapkan tools yang kalian gunakan kemudian copy script dibawah ini : 

#include "stdlib.h"
#include "gl/glut.h"

int w=600, h=600, z=0;
int x1=0, y1=0, sudut=0, z1=0;
float skalaX=1, skalaY=1, skalaZ=1;
int cx, cy;

void myKeyboard(unsigned char key, int x, int y){
if (key =='a') z+=5;
else if (key == 'd') z-=5;
else if (key == 'q') skalaX+=0.5;
else if (key == 'w') skalaX-=0.5;
else if (key == 'e') skalaY+=0.5;
else if (key == 'r') skalaY-=0.5;
else if (key == 't') skalaZ+=0.5;
else if (key == 'u') skalaZ-=0.5;
else if (key == 'x') {
x1=1;
y1=0;
z1=0;
sudut+=10;
}
else if (key == 'y') {
y1=1;
x1=0;
z1=0;
sudut+=-10;
}
else if (key == 'z') {
y1=0;
x1=0;
z1=1;
sudut+=-10;
}
}

void init(){
GLfloat LightPosition[] = {10.0f, 10.0f, 20.0f, 0.0f};
GLfloat LightAmbient[] = {0.0f, 1.0f, 0.0f, 1.0f};
GLfloat LightDiffuse[] = {0.7f, 0.7f, 0.7f, 1.0f};
GLfloat LightSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f};
GLfloat Shine[] = { 80 };

glShadeModel(GL_SMOOTH);
glClearColor(0.0f,0.0f,0.0f,0.5f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

glMaterialfv(GL_FRONT, GL_SPECULAR, LightSpecular);
glMaterialfv(GL_FRONT, GL_SHININESS, Shine);

glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
return;

}

void pagar(){
//pagar
glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glTranslatef(3,-1,1);
glColor3f(0,0,0);

glPushMatrix();
glTranslatef(-1,0.2,0);
glScalef(5.4,0.2,0.1);
glutSolidCube(1);
glPopMatrix();

glPushMatrix();
glTranslatef(-1,-0.2,0);
glScalef(5.4,0.2,0.1);
glutSolidCube(1);
glPopMatrix();

glScalef(0.2,1,0.1);
//glutSolidCube(1);
glTranslatef(2,0,0);
glutSolidCube(1);
glTranslatef(2,0,0);
glutSolidCube(1);
glTranslatef(2,0,0);
glutSolidCube(1);
glTranslatef(2,0,0);
//glutSolidCube(1);
glTranslatef(2,0,0);
//glutSolidCube(1);
glTranslatef(2,0,0);
//glutSolidCube(1);
glTranslatef(2,0,0);
//glutSolidCube(1);
glTranslatef(-12,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);
glTranslatef(-2,0,0);
glutSolidCube(1);

glDisable(GL_COLOR_MATERIAL);
glPopMatrix();

}

void renderScene(void){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(1,1,1,1);

glLoadIdentity();
glTranslatef(0,0,z);
glRotatef(sudut,x1,y1,z1);
glScalef(skalaX, skalaY, skalaZ);

//tembok
glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0,0,0.5);
glRotatef(50,0,1,0);
glutSolidCube(3);
glDisable(GL_COLOR_MATERIAL);

//pagar
glPushMatrix();
glTranslatef(-2,0,1.5);
pagar();
glPopMatrix();

glPushMatrix();
glTranslatef(-2,0,-3.5);
pagar();
glPopMatrix();

glPushMatrix();
glRotatef(-90,0,1,0);
glTranslatef(-2,0,1.5);
pagar();
glPopMatrix();

glPushMatrix();
glRotatef(-90,0,1,0);
glTranslatef(-2,0,-3.5);

pagar();
glPopMatrix();

//pintu
glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.5,0.8,0);
glTranslatef(-0.6,-1,1.46);
glScalef(7,10,1);
glutSolidCube(0.1);
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();

//jendela
glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.5,0.8,0);
glTranslatef(0.5,0.1,1.46);
glScalef(3,3,1);
glutSolidCube(0.1);
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();

glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.5,0.8,0);
glTranslatef(0.9,0.1,1.46);
glScalef(3,3,1);
glutSolidCube(0.1);
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();

glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.5,0.8,0);
glTranslatef(0.9,-0.3,1.46);
glScalef(3,3,1);
glutSolidCube(0.1);
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();

glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.5,0.8,0);
glTranslatef(0.5,-0.3,1.46);
glScalef(3,3,1);
glutSolidCube(0.1);
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();

glPopMatrix();


//atap
glPushMatrix();
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.8,0,0);
glRotatef(5,0,1,0);
glTranslatef(0,1.5,0);
glScalef(3,1.3,3);
glutSolidOctahedron();
glDisable(GL_COLOR_MATERIAL);
glPopMatrix();


glutSwapBuffers();
}

void resize(int w1, int h1){
glViewport(0,0,w1,h1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0,(float) w1/(float) h1, 1.0,300.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void timer(int value){
glutPostRedisplay();
glutTimerFunc(50,timer,0);
}

void main (int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(w,h);
glutCreateWindow("Rumah");
glutDisplayFunc(renderScene);
glutReshapeFunc(resize);
glutKeyboardFunc(myKeyboard);
glutTimerFunc(1,timer,0);
init();
glutMainLoop();
}


Jika kita jalankan script di atas makan hasilnya akan seperti gambar dibawah ini :

Membuat Rumah 3D Dengan OpenGL
Gambar Demo

Nah itu dia teman-teman tutorial tentang Cara Membuat Rumah 3D Dengan OpenGL. Silahkan teman-teman pakai scriptnya dengan gratis. Jika ada pertanyaan silahkan komentar di kolom bawah ya.
Membuat Rumah Menggunakan OpenGL

Membuat Rumah Menggunakan OpenGL

Membuat Rumah Menggunakan OpenGL

Halo teman-teman semua, pada kesempatan kali ini malasupload.com akan membagikan sedikti trik dan source untuk membuat rumah menggunakan OpenGL. Kita akan memuat rumah dengan desain 2D menggunakan OpenGL, cukup sulit juga sih tetapi disini malasupload.com sudah sediakan source gratis untuk teman-teman semua ya.

Oke langsung saja, daripada banyak basa-basi silahlkan teman-teman buka tools yang akan kalian gunakan dan copy script dibawah ini :

#include<Windows.h>       // for MS Windows
#include<GL\glut.h> // GLUT, include glu.h and gl.h
//Note: GLglut.h path depending on the system in use
void init()
{
// Set display window color to as glClearColor(R,G,B,Alpha)
glClearColor(0.5, 0.9, 0.4, 0.0);
// Set projection parameters.
glMatrixMode(GL_PROJECTION);
// Set 2D Transformation as gluOrtho2D(Min Width, Max Width, Min Height, Max Height)
gluOrtho2D(0.0, 800, 0.0, 600);
}
void home()
{
//Roof
glClear(GL_COLOR_BUFFER_BIT); // Clear display window
// Set line segment color as glColor3f(R,G,B)
glColor3f(0.3, 0.5, 0.8);
glBegin(GL_POLYGON);
glVertex2i(200, 500);
glVertex2i(600, 500);
glVertex2i(700, 350);
glVertex2i(300, 350);
glEnd();
// Top of Front Wall
glColor3f(0.1, 0.5, 0.0);
glBegin(GL_TRIANGLES);
glVertex2i(200, 500);
glVertex2i(100, 350);
glVertex2i(300, 350);
glEnd();
// Front Wall
glColor3f(0.7, 0.2, 0.3);
glBegin(GL_POLYGON);
glVertex2i(100, 350);
glVertex2i(300, 350);
glVertex2i(300, 100);
glVertex2i(100, 100);
glEnd();
// Front Door
glColor3f(0.7, 0.2, 0.9);
glBegin(GL_POLYGON);
glVertex2i(150, 250);
glVertex2i(250, 250);
glVertex2i(250, 100);
glVertex2i(150, 100);
glEnd();

// Front Door Lock
glColor3f(0.3, 0.7, 0.9);
glPointSize(15);
glBegin(GL_POINTS);
glVertex2i(170, 170);
glEnd();

//side Wall
glColor3f(0.1, 0.2, 0.3);
glBegin(GL_POLYGON);
glVertex2i(300, 350);
glVertex2i(700, 350);
glVertex2i(700, 100);
glVertex2i(300, 100);
glEnd();
// window one
glColor3f(0.2, 0.4, 0.3);
glBegin(GL_POLYGON);
glVertex2i(330, 320);
glVertex2i(450, 320);
glVertex2i(450, 230);
glVertex2i(330, 230);
glEnd();
// line of window one
glColor3f(0.1, 0.7, 0.5);
glLineWidth(5);
glBegin(GL_LINES);
glVertex2i(390, 320);
glVertex2i(390, 230);
glVertex2i(330, 273);
glVertex2i(450, 273);
glEnd();
// window two
glColor3f(0.2, 0.4, 0.3);
glBegin(GL_POLYGON);
glVertex2i(530, 320);
glVertex2i(650, 320);
glVertex2i(650, 230);
glVertex2i(530, 230);
glEnd();
// lines of window two
glColor3f(0.1, 0.7, 0.5);
glLineWidth(5);
glBegin(GL_LINES);
glVertex2i(590, 320);
glVertex2i(590, 230);
glVertex2i(530, 273);
glVertex2i(650, 273);
glEnd();

// Entrance Path
glColor3f(0.3, 0.5, 0.7);
glLineWidth(3);
glBegin(GL_POLYGON);
glVertex2i(150, 100);
glVertex2i(250, 100);
glVertex2i(210, 0);
glVertex2i(40, 0);
glEnd();
// Process all OpenGL routine s as quickly as possible
glFlush();
}
int main(int argc, char ** argv)
{
// Initialize GLUT
glutInit(&argc, argv);
// Set display mode
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
// Set top - left display window position.
glutInitWindowPosition(100, 100);
// Set display window width and height
glutInitWindowSize(500, 500);
// Create display window with the given title
glutCreateWindow("2D House in OpenGL ");
// Execute initialization procedure
init();
// Send graphics to display window
glutDisplayFunc(home);
// Display everything and wait.
glutMainLoop();
}

Jika kita jalankan maka hasilnya akan seperti gambar dibawah ini :

Membuat Rumah Menggunakan OpenGL
Gambar Demo

Oke teman-teman kurang lebih seperti itu ya untuk tutorial Membuat Rumah Menggunakan OpenGL, jika ada yang masih bingung silahkan tinggalka komentar dibawah. Admin malasupload akan segera membalasnya, terimakasih.
Cara Membuat Linkaran Menggunakan OpenGL

Cara Membuat Linkaran Menggunakan OpenGL

Membuat Lingkaran Menggunakan OpenGL

Pada kesempatan kali ini kita akan Membuat Linkaran Menggunakan OpenGL, Seperti biasanya malasupload.com hanya akan membaikan source code gratis saja tanpa ada penjelasan. Silahkan teman-teman cari di Google.co.id untuk mendaptkan penjelasan yang lebih detail.

Oke teman-teman langsung saja ya, tidak perlu banyak basa-basi. Silahkan siapkan tools yang akan kalian gunakan kemudian copy source code dibawah ini :

#include <gl/glut.h>
#include <windows.h>
#include <math.h>

const double PI = 3.141592653589793;
int i,radius,jumlah_titik,x_tengah,y_tengah;
void Draw() {
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);

glBegin(GL_LINE_LOOP);
radius=40;
jumlah_titik=20;
x_tengah=50;
y_tengah=50;
for (i=0;i<=360;i++){
float sudut=i*(2*PI/jumlah_titik);
float x=x_tengah+radius*cos(sudut);
float y=y_tengah+radius*sin(sudut);
glVertex2f(x/100,y/100);


}
glEnd();


glFlush();
}

void Initialize() {
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

int main(int iArgc, char** cppArgv) {
glutInit(&iArgc, cppArgv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(250, 250);
glutInitWindowPosition(200, 200);
glutCreateWindow("Lingkaran");
Initialize();
glutDisplayFunc(Draw);
glutMainLoop();
return 0;
}
Jika program diatas kita jalankan maka akan tempil seperti gambar dibawah ini:

Cara Membuat Linkaran Menggunakan OpenGL
Gambar Demo

Kemudian jika teman-teman ingin membuat sedikit variasi di lingkaran tersebut, teman-teman bisa copy source code dibawah ini :

#include <gl/glut.h>
#include <windows.h>
#include <math.h>

const double PI = 3.141592653589793;
int i,radius,jumlah_titik,x_tengah,y_tengah;
void Draw() {
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);

glBegin(GL_LINE_LOOP);
radius=40;
jumlah_titik=20;
x_tengah=50;
y_tengah=50;
for (i=0;i<=360;i++){
float sudut=i*(2*PI/jumlah_titik);
float x=x_tengah+radius*cos(sudut);
float y=y_tengah+radius*sin(sudut);
glVertex2f(x/100,y/100);


}
glEnd();

glBegin(GL_TRIANGLE_FAN);
radius=5;
jumlah_titik=20;
x_tengah=30;
y_tengah=60;
for (i=0;i<=jumlah_titik;i++){
float sudut=i*(2*PI/jumlah_titik);
float x=x_tengah+radius*cos(sudut);
float y=y_tengah+radius*sin(sudut);
glVertex2f(x/100,y/100);


}
glEnd();

glBegin(GL_TRIANGLE_FAN);
radius=5;
jumlah_titik=20;
x_tengah=70;
y_tengah=60;
for (i=0;i<=jumlah_titik;i++){
float sudut=i*(2*PI/jumlah_titik);
float x=x_tengah+radius*cos(sudut);
float y=y_tengah+radius*sin(sudut);
glVertex2f(x/100,y/100);


}
glEnd();

glBegin(GL_LINE_LOOP);
glVertex2f(0.5,0.6);
glVertex2f(0.4,0.5);
glVertex2f(0.6,0.5);
glEnd();

glBegin(GL_LINE_LOOP);
radius=20;
jumlah_titik=180;
x_tengah=50;
y_tengah=40;
for (i=90;i<=jumlah_titik;i++){
float sudut=i*(2*PI/jumlah_titik);
float x=x_tengah+radius*cos(sudut);
float y=y_tengah+radius*sin(sudut);
glVertex2f(x/100,y/100);


}
glEnd();
glFlush();
}

void Initialize() {
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

int main(int iArgc, char** cppArgv) {
glutInit(&iArgc, cppArgv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(250, 250);
glutInitWindowPosition(200, 200);
glutCreateWindow("Lingkaran senyum");
Initialize();
glutDisplayFunc(Draw);
glutMainLoop();
return 0;
}
Jika program tersebut kita jalankan, maka akan tampil seperti gambar dibawah ini :

Lingkaran senyum openGL
Gambar Demo

Oke teman-teman itu dia sedikit trik dalam membuat lingkaran sederhana dan variasi menggunakan OpenGL. Semoga dengan adanya artikel ini dapat membantu teman-teman semua dalam mengerjakan tugasnya.