Membuat Objek Bola Dengan C++ OpenGL Membuat Objek Bola Dengan C++ OpenGL

Membuat Objek Bola Dengan C++ OpenGL

Translasi Bola Dengan C++ OpenGL – Halo teman teman, berjumpa lagi dengan saya, kali ini kita akan membahas tentang translasi pada objek bola. Apa itu translasi dan apa itu bola. Baiklah sebelum ke program kita bahas dulu ya. Translasi adalah perpindahan atau gerak obejk bola yang berpindah dari sumbu koordinat ke sumbu koordinat lainnya, misalnya dari sumbu x berpindah ke sumbu y.

Sedangkan bola adalah yang sering disepak oleh anak anak kalau lagi dilapangan, ops iya benar, Bola emang sering di sepak oleh anak anak, Tapi bola yang dimaksud adalh objek bola lingakaran berupa gambar 3D. Nah intinya bola yang dimaksud adalah gambar bola, bukan bola yang masu disepak gol ke kiper.

Nah, langsung saja berikut ini coding programnya, ingat harus udah terinstal OpenGLnya ya.

1. Coding Membuat Objek Bola C++ OpenGL

#include<stdlib.h>
#include<glut.h>
float w=480,h=480;
float sudut=0,sx=0,sy=0,sz=0,z=-320;
void sphere (){
glColor3d(1,1,1); glutWireSphere(100,150,150);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0,0,z);
glRotatef(sudut,sx,sy,sz);
sphere();
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 init(){
glClearColor(0.0,0.0,0.0,1.0);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.,(GLdouble)w/(GLdouble)h,1.,300.);
glMatrixMode(GL_MODELVIEW);
}
void myKeyboard(unsigned char key, int x, int y){
if(key=='y'){
sy=1;
sudut+=10;
}
}
void update(int value){
glutPostRedisplay();
glutTimerFunc(50,update,0);
}
void main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_DEPTH | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(w,h);
glutCreateWindow("Objek 3D");
glutDisplayFunc(display);
glutReshapeFunc(resize);
init();
glutTimerFunc(50,update,0);
glutKeyboardFunc(myKeyboard);
glutMainLoop();
}

Jika kode diatas tidak jalan, bisa mencoba kode dibawah

2. Contoh Coding Bola C++ OpenGL

#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>
 
// Variabel
GLfloat xrot = 0.0f;
GLfloat yrot = 0.0f;
GLfloat xdiff = 0.0f;
GLfloat ydiff = 0.0f;
bool mouseDown = false;
int isActiveMouse = 0;

// Fungsi untuk menggambar bola
void Draw_Ball()
{
    GLfloat x,y,z,angle;
    GLfloat radius = 0.5f;
 
    glBegin(GL_TRIANGLE_FAN);
    glNormal3f(0.0f,0.0f,1.0f);
    glVertex3f(0.0f,0.0f,radius);
 
    for(angle=0.0f;angle<(2.0f*3.14159);angle+=0.2f)
    {
        x = radius * sin(angle);
        y = radius * cos(angle);

3. Membuat Lingkaran C++ OpenGL

//Inisialisasi
float x = 0.0f;
float y = 0.0f;
float radius = 0.2f;

//Deklarasi Fungsi
void lingkaran(){
    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x, y);
        int numSegments = 50;
        float angle;
        for (int i = 0; i <= numSegments; i++) {
            angle = i * 2.0f * PI / numSegments;
            glVertex2f(x + (cos(angle) * radius), y + (sin(angle) * radius));
        }
    glEnd();
}

//Pemanggilan Fungsi
lingkaran();

Code lain

// Berikut ini adalah cara untuk membuat lingkaran dengan OpenGL C++:

// 1. Pertama, Anda harus menginclude library yang diperlukan.
#include <GL/glut.h>
#include <math.h>
 
// 2. Membuat variabel untuk menyimpan jari-jari, x, dan y posisi lingkaran
float radius = 0.5f;
float xPos = 0.0f;
float yPos = 0.0f;
 
// 3. Buat variabel untuk menyimpan jumlah titik yang dibutuhkan untuk membuat lingkaran
int numPoints = 1000;
 
// 4. Buat fungsi untuk menggambar lingkaran
void drawCircle()
{
    // 5. Tentukan titik awal
    glBegin(GL_LINE_LOOP);
 
    // 6. Buat loop untuk membuat titik-titik lingkaran
    for (int i =1; i <= numPoints; i++)
    {
        // 7. Tentukan sudut untuk setiap titik
        float angle = i * 2.0f * 3.1416f / numPoints;
 
        // 8. Tentukan posisi x dan y dari setiap titik
        float x = xPos + radius * cos(angle);
        float y = yPos + radius * sin(angle);
 
        // 9. Gambar setiap titik
        glVertex2f(x, y);
    }
 
    // 10. Tutup loop
    glEnd();
}

Code lain

#include <GL/glut.h> 
#include <math.h> 
  
#define PI 3.14159265358979323846 
  
// fungsi untuk menampilkan lingkaran 
void drawCircle(GLfloat x, GLfloat y, GLfloat radius) 
{ 
    GLfloat twicePi = 2.0f * PI; 
  
    glBegin(GL_TRIANGLE_FAN); 
        glVertex2f(x, y); // senter of circle 
        for (int i = 0; i <= 20; i++)  
        { 
            glVertex2f ( 
                (x + (radius * cos(i *  twicePi / 20))), 
                (y + (radius * sin(i * twicePi / 20))) 
            ); 
        } 
    glEnd(); 
} 

// fungsi display
void Display(void) 
{ 
    glClear(GL_COLOR_BUFFER_BIT); 
    glColor3f(0.0, 0.0, 0.0); 
    drawCircle(0.0, 0.0, 0.5); 
    glFlush(); 
} 

// fungsi main
int main(int argc, char** argv) 
{ 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); 
    glutInitWindowPosition(50, 100); 
    glutInitWindowSize(400, 300); 
    glutCreateWindow("Membuat Lingkaran"); 
    glClearColor(1.0, 1.0, 1.0, 0.0); 
    gluOrtho2D(-1.0, 1.0, -1.0, 1.0); 
    glutDisplayFunc(Display); 
    glutMainLoop(); 
    return 0; 
}

Baiklah teman teman, sampai disini dulu ya pembahasan artikel kita tentang membuat translasi pada bola menggunakan C++ dan OpenGL, semoga artikel ini bisa bermanfaat buat kita semua.

Baca Juga :   Siklus Proyek (Project Cycle)

Langkah-langkah Membuat Objek Bola Dengan C++ OpenGL

Langkah pertama dalam membuat objek bola adalah membuat jendela OpenGL. Untuk itu, kamu dapat menggunakan library GLFW (Graphics Library Framework) yang menyediakan fungsi-fungsi untuk membuat jendela OpenGL dengan mudah.

#include 

int main() {
    // Inisialisasi GLFW
    if (!glfwInit()) {
        return -1;
    }

    // Membuat jendela
    GLFWwindow* window = glfwCreateWindow(800, 600, "Objek Bola", NULL, NULL);
    if (!window) {
        glfwTerminate();
        return -1;
    }

    // Mengatur konteks OpenGL
    glfwMakeContextCurrent(window);

    // Loop utama
    while (!glfwWindowShouldClose(window)) {
        // Menggambar objek bola
        // ...

        // Mengecek input pengguna
        glfwPollEvents();
    }

    // Menghancurkan jendela dan menghentikan GLFW
    glfwDestroyWindow(window);
    glfwTerminate();

    return 0;
}

Membuat Objek Bola

Setelah kita memiliki jendela OpenGL, kita dapat mulai membuat objek bola. Untuk membuat bola, kita akan menggunakan primitif dasar yaitu titik, garis, dan segitiga.

Langkah pertama adalah mendefinisikan titik-titik yang membentuk bola. Kita dapat menggunakan persamaan matematika untuk menghasilkan titik-titik tersebut. Selanjutnya, kita dapat menghubungkan titik-titik tersebut dengan garis-garis dan membentuk segitiga-segitiga.

// Mendefinisikan titik-titik yang membentuk bola
float radius = 0.5f;
int sectorCount = 36;
int stackCount = 18;

std::vector vertices;
std::vector indices;

float x, y, z, xy;
float sectorStep = 2 * M_PI / sectorCount;
float stackStep = M_PI / stackCount;
float sectorAngle, stackAngle;

for (int i = 0; i <= stackCount; ++i) {
    stackAngle = M_PI / 2 - i * stackStep;
    xy = radius * cosf(stackAngle);
    z = radius * sinf(stackAngle);

    for (int j = 0; j <= sectorCount; ++j) {
        sectorAngle = j * sectorStep;

        x = xy * cosf(sectorAngle);
        y = xy * sinf(sectorAngle);

        vertices.push_back(x);
        vertices.push_back(y);
        vertices.push_back(z);
    }
}

// Menghubungkan titik-titik dengan garis-garis
for (int i = 0; i < stackCount; ++i) {
    int k1 = i * (sectorCount + 1);
    int k2 = k1 + sectorCount + 1;

    for (int j = 0; j < sectorCount; ++j, ++k1, ++k2) {
        if (i != 0) {
            indices.push_back(k1);
            indices.push_back(k2);
            indices.push_back(k1 + 1);
        }

        if (i != (stackCount - 1)) {
            indices.push_back(k1 + 1);
            indices.push_back(k2);
            indices.push_back(k2 + 1);
        }
    }
}

Menggambar Objek Bola

Setelah kita memiliki titik-titik dan indeks yang membentuk bola, kita dapat mulai menggambar objek bola pada jendela OpenGL yang telah kita buat sebelumnya. Untuk menggambar objek bola, kita dapat menggunakan fungsi-fungsi OpenGL seperti glBegin, glVertex3f, dan glEnd.

while (!glfwWindowShouldClose(window)) {
    // Menghapus buffer layar
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Mengatur warna objek
    glColor3f(1.0f, 0.0f, 0.0f);

    // Menggambar objek bola
    glBegin(GL_TRIANGLES);
    for (unsigned int i = 0; i < indices.size(); ++i) {
        unsigned int index = indices[i];
        glVertex3f(vertices[3 * index], vertices[3 * index + 1], vertices[3 * index + 2]);
    }
    glEnd();

    // Mengecek input pengguna
    glfwPollEvents();

    // Menukar buffer layar
    glfwSwapBuffers(window);
}

Code yang ada di artikel ini dirangkum dari berbagai sumber

  1. wah… aku baru tahu ada aplikasi pendukung dalam bermain C++, saya kemaren ada tugas untuk membuat sebuah bentuk dengan menggunakan C++ dan saya izin ambil script untuk menyelesaikan tugas, terimakasih.

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *