Membuat Rumah Menggunakan C++ OpenGL

Assalamualaikum wr.wb hallo sahabat semuanya, bisssaaaa gak, ini merupakan coding untuk membuat rumah menggunakan visual studio, Semoga Bermanfaat Buat Kalian

Program Membuat Rumah Menggunakan C++ OpenGL

Disini kita akan membuat objek rumah menggunakan C++ OpenGL, terdapat beberapa contoh coding yang bisa kalian coba.

1. Contoh Coding Rumah Menggunakan C++ dan OpenGL

#include <GL/glut.h>

void myInit(void) {
    glClearColor(1.0, 1.0, 1.0, 0.0); // latar belakang putih
    glColor3f(0.0f, 0.0f, 0.f); // warna gambar hitam
    glPointSize(4.0); // ukuran titik 4 x 4 pixel
    glLineWidth(4.0f);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0.0, 500.0, 0.0, 300.0);
}

void myDisplay(void) {
    glClear(GL_COLOR_BUFFER_BIT); // hapus layar

    // Tembok
    glColor3f(1.0, 1.0, 1.0);
    glBegin(GL_POLYGON); // tembok depan
    glVertex2i(100, 100);
    glVertex2i(100, 200);
    glVertex2i(200, 200);
    glVertex2i(200, 100);
    glEnd();

    glBegin(GL_POLYGON); // tembok belakang
    glVertex2i(200, 100);
    glVertex2i(200, 200);
    glVertex2i(400, 200);
    glVertex2i(400, 100);
    glEnd();

    // Pintu
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_POLYGON);
    glVertex2i(130, 100);
    glVertex2i(130, 150);
    glVertex2i(160, 150);
    glVertex2i(160, 100);
    glEnd();

    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_POINTS);
    glVertex2i(135, 130); // handle pintu
    glEnd();

    // Atap
    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex2i(100, 200); // atap depan
    glVertex2i(150, 250);
    glVertex2i(200, 200);
    glEnd();

    glBegin(GL_POLYGON); // atap belakang
    glVertex2i(200, 200);
    glVertex2i(150, 250);
    glVertex2i(350, 250);
    glVertex2i(400, 200);
    glEnd();

    // Jendela
    glColor3f(1.0, 1.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex2i(275, 125); // jendela kiri bawah
    glVertex2i(275, 150);
    glVertex2i(300, 150);
    glVertex2i(300, 125);
    glEnd();

    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex2i(275, 150); // jendela kiri atas
    glVertex2i(275, 175);
    glVertex2i(300, 175);
    glVertex2i(300, 150);
    glEnd();

    glColor3f(1.0, 1.0, 1.0);
    glBegin(GL_POLYGON);
    glVertex2i(300, 125); // jendela kanan bawah
    glVertex2i(300, 150);
    glVertex2i(325, 150);
    glVertex2i(325, 125);
    glEnd();

    glColor3f(1.0, 0.0, 0.0);
    glBegin(GL_POLYGON);
    glVertex2i(300, 150); // jendela kanan atas
    glVertex2i(300, 175);
    glVertex2i(325, 175);
    glVertex2i(325, 150);
    glEnd();

    // Garis
    glColor3f(0.0f, 0.0f, .0f);
    glBegin(GL_LINE_LOOP);
    glVertex2i(100, 100); // garis tembok depan
    glVertex2i(100, 200);
    glVertex2i(200, 200);
    glVertex2i(200, 100);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(130, 100); // garis pintu
    glVertex2i(130, 150);
    glVertex2i(160, 150);
    glVertex2i(160, 100);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(200, 100); // garis tembok belakang
    glVertex2i(200, 200);
    glVertex2i(400, 200);
    glVertex2i(400, 100);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(100, 200); // garis atap depan
    glVertex2i(150, 250);
    glVertex2i(200, 200);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(200, 200); // garis atap belakang
    glVertex2i(150, 250);
    glVertex2i(350, 250);
    glVertex2i(400, 200);
    glEnd();

    // Garis jendela
    glColor3f(0.0f, 0.0f, 0.0f);
    glBegin(GL_LINE_LOOP);
    glVertex2i(275, 125); // jendela kiri bawah
    glVertex2i(275, 150);
    glVertex2i(300, 150);
    glVertex2i(300, 125);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(275, 150); // jendela kiri atas
    glVertex2i(275, 175);
    glVertex2i(300, 175);
    glVertex2i(300, 150);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(300, 125); // jendela kanan bawah
    glVertex2i(300, 150);
    glVertex2i(325, 150);
    glVertex2i(325, 125);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2i(300, 150); // jendela kanan atas
    glVertex2i(300, 175);
    glVertex2i(325, 175);
    glVertex2i(325, 150);
    glEnd();

    glFlush(); // mengirim semua output ke layar
}

int main(int argc, char** argv) {
    glutInit(&argc, argv); // inisialisasi toolkit
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // set modus display
    glutInitWindowSize(450, 300); // set ukuran window
    glutInitWindowPosition(100, 150); // set posisi window di layar
    glutCreateWindow("

Penjelasan:

Kode di atas akan menggambar bentuk rumah sederhana. Setelah program dijalankan, akan membuat jendela dengan judul “Rumah” yang menampilkan rumah sederhana dengan tembok, pintu, atap, dan jendela.

Elemen yang digambarkan dalam jendela termasuk:

• Tembok Depan dan Belakang: Dilambangkan dengan GL_POLYGON untuk membuat dua bidang persegi empat yang mewakili tembok bagian depan dan belakang rumah.
• Pintu: Diberikan warna merah dan diilustrasikan sebagai bidang persegi empat yang mewakili pintu rumah.
• Atap Depan dan Belakang: Terdiri dari dua bidang segitiga yang mewakili bagian atap depan dan belakang rumah.
• Jendela Kiri dan Kanan: Masing-masing terdiri dari dua bidang persegi yang merepresentasikan jendela kiri dan kanan di rumah.

Selain itu, terdapat juga penggunaan GL_POINTS dan GL_LINE_LOOP untuk membuat detail-detail tambahan seperti handle pintu, garis tepi tembok, dan garis tepi jendela.

Warna-warna yang digunakan dalam kode tersebut telah didefinisikan dalam bentuk RGB. Program ini menggunakan mode single-buffered GLUT dengan RGB color dan tata letak koordinat yang terbatas pada layar dengan ukuran 450×300 piksel.

Keseluruhan tampilan gambar adalah representasi visual sederhana dari sebuah rumah dengan elemen-elemen dasar yang digambarkan menggunakan primitif-primitif yang disediakan oleh OpenGL.

2. Program Membuat Objek Rumah C++ OpenGL

#include <GL/glut.h>
#include <GL/gl.h>
#include <iostream>

using namespace std;

void init() {
    glClearColor(1.0, 1.0, 1.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    gluOrtho2D(0.0, 640.0, 0.0, 480.0);
}

void drawHouse() {
    glClear(GL_COLOR_BUFFER_BIT);

    // Badan Rumah
    glColor3f(0.137255, 0.556863, 0.137255);
    glBegin(GL_POLYGON);
    glVertex2i(150, 150);
    glVertex2i(150, 300);
    glVertex2i(450, 300);
    glVertex2i(450, 150);
    glEnd();

    // Atap Rumah
    glColor3f(0.854902, 0.647059, 0.12549);
    glBegin(GL_TRIANGLES);
    glVertex2i(300, 400);
    glVertex2i(150, 300);
    glVertex2i(450, 300);
    glEnd();

    // Pintu
    glColor3f(0.137255, 0.556863, 0.419608);
    glBegin(GL_POLYGON);
    glVertex2i(250, 150);
    glVertex2i(250, 250);
    glVertex2i(350, 250);
    glVertex2i(350, 150);
    glEnd();

    // Jendela
    glColor3f(0.137255, 0.556863, 0.419608);
    glBegin(GL_POLYGON);
    glVertex2i(200, 200);
    glVertex2i(200, 250);
    glVertex2i(300, 250);
    glVertex2i(300, 200);
    glEnd();

    glFlush();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(640, 480);
    glutCreateWindow("Membuat Rumah Menggunakan C++ OpenGL");
    init();
    glutDisplayFunc(drawHouse);
    glutMainLoop();
}

Kode tersebut adalah program sederhana yang menggunakan OpenGL untuk menggambar sebuah rumah.

Saat dieksekusi, program akan membuat jendela dengan judul “Membuat Rumah Menggunakan C++ OpenGL” dan menampilkan gambar rumah yang terdiri dari badan rumah dengan warna hijau, atap rumah berwarna kuning keemasan, pintu dengan warna hijau gelap, dan jendela dengan warna hijau gelap.

3. Cara Membuat Rumah Menggunakan C++ dan OpenGL

Sebelum memulai proyek, pastikan Anda telah menginstal C++ dan OpenGL di komputer Anda. Anda juga akan membutuhkan sebuah Integrated Development Environment (IDE) seperti Code::Blocks atau Visual Studio untuk menulis dan mengompilasi kode.

1. Membuat Jendela

Pertama-tama, kita akan membuat jendela tempat objek 3D kita akan ditampilkan. Dalam proyek ini, kita akan menggunakan library GLUT (OpenGL Utility Toolkit) untuk membuat jendela.

Berikut adalah contoh kode untuk membuat jendela:

#include 

void display() {
    // Kode untuk menggambar objek 3D
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Rumah 3D");
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

Pada contoh kode di atas, kita menginisialisasi GLUT dengan menggunakan fungsi glutInit(). Kemudian, kita mengatur mode tampilan GLUT dengan menggunakan glutInitDisplayMode() untuk mengatur mode tampilan menjadi RGB dan menggunakan double buffering.

Selanjutnya, kita mengatur ukuran jendela dengan menggunakan glutInitWindowSize() dan membuat jendela dengan menggunakan glutCreateWindow().

Terakhir, kita menggunakan glutDisplayFunc() untuk mengatur fungsi display yang akan dipanggil untuk menggambar objek 3D.

2. Menggambar Rumah

Sekarang, kita akan mulai menggambar rumah. Dalam proyek ini, kita akan menggunakan primitif-primitif dasar seperti titik, garis, dan poligon untuk menggambar rumah.

Berikut adalah contoh kode untuk menggambar rumah:

void display() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.7, 0.7, 0.7);

    // Menggambar atap
    glBegin(GL_TRIANGLES);
    glVertex2f(-0.5, 0.0);
    glVertex2f(0.5, 0.0);
    glVertex2f(0.0, 0.5);
    glEnd();

    // Menggambar dinding
    glBegin(GL_QUADS);
    glVertex2f(-0.5, 0.0);
    glVertex2f(-0.5, -0.5);
    glVertex2f(0.5, -0.5);
    glVertex2f(0.5, 0.0);
    glEnd();

    // Menggambar pintu
    glColor3f(0.3, 0.2, 0.1);
    glBegin(GL_QUADS);
    glVertex2f(-0.2, -0.5);
    glVertex2f(-0.2, -0.3);
    glVertex2f(0.2, -0.3);
    glVertex2f(0.2, -0.5);
    glEnd();

    // Menggambar jendela
    glColor3f(0.8, 0.8, 0.8);
    glBegin(GL_QUADS);
    glVertex2f(-0.4, -0.4);
    glVertex2f(-0.4, -0.2);
    glVertex2f(-0.1, -0.2);
    glVertex2f(-0.1, -0.4);
    glEnd();

    // Menggambar jendela
    glBegin(GL_QUADS);
    glVertex2f(0.1, -0.4);
    glVertex2f(0.1, -0.2);
    glVertex2f(0.4, -0.2);
    glVertex2f(0.4, -0.4);
    glEnd();

    glFlush();
    glutSwapBuffers();
}

Pada contoh kode di atas, kita menggunakan fungsi glBegin() untuk memulai menggambar primitif-primitif dasar seperti titik, garis, dan poligon. Setiap primitif diakhiri dengan fungsi glEnd().

Fungsi glVertex2f() digunakan untuk mengatur koordinat titik-titik yang membentuk primitif. Kita juga menggunakan fungsi glColor3f() untuk mengatur warna primitif.

3. Menjalankan Program

Setelah selesai menulis kode, kita dapat menjalankan program dengan mengompilasi dan mengeksekusi kode menggunakan IDE yang kita gunakan.

Jika semuanya berjalan dengan baik, Anda akan melihat sebuah jendela dengan gambar rumah yang telah kita buat.

Sampai disini artikel kita kali ini teman teman, jangan lupa kasih sarannya ya lewat komentar.