Java OpenGL[JoGL] poruszanie się pojazdem po terenie.

0

Witam, zwracam się uprzejmie w kwestii pomocy. Napisałem programik w JOGLu, który przedstawia poniższy kod:

KLASA 1.

 package org.yourorghere;

import com.sun.opengl.util.Animator;
import com.sun.opengl.util.texture.Texture;
import com.sun.opengl.util.texture.TextureIO;
import java.awt.Frame;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
import javax.swing.JOptionPane;

public class JOGLLab6 implements GLEventListener {

    //statyczne pola określające rotację wokół osi X i Y
    private static float xrot = 0.0f, yrot = 0.0f, zrot = 0.0f;
    static BufferedImage image1 = null, image2 = null;
    static Texture t1 = null, t2 = null;

    public static void main(String[] args) {
        Frame frame = new Frame("Simple JOGL Application");
        GLCanvas canvas = new GLCanvas();
        canvas.addGLEventListener(new JOGLLab6());
        frame.add(canvas);
        frame.setSize(640, 480);
        final Animator animator = new Animator(canvas);
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // Run this on another thread than the AWT event queue to
                // make sure the call to Animator.stop() completes before // exiting
                new Thread(new Runnable() {
                    public void run() {
                        animator.stop();
                        System.exit(0);
                    }
                }).start();
            }
        });

        //Obsługa klawiszy strzałek
        frame.addKeyListener(new KeyListener() {
            public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_UP) {
                    xrot -= 10.0f;
                }
                if (e.getKeyCode() == KeyEvent.VK_DOWN) {
                    xrot += 10.0f;
                }
                if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
                    yrot += 10.0f;
                }
                if (e.getKeyCode() == KeyEvent.VK_LEFT) {
                    yrot -= 10.0f;
                }
                if (e.getKeyCode() == KeyEvent.VK_Z) {
                    zrot += 10.0f;
                }
                if (e.getKeyCode() == KeyEvent.VK_X) {
                    zrot -= 10.0f;
                }
            }

            public void keyReleased(KeyEvent e) {
            }

            public void keyTyped(KeyEvent e) {
            }
        });

        // Center frame
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        animator.start();
    }

    public void init(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        System.err.println("INIT GL IS: " + gl.getClass().getName());
        gl.setSwapInterval(1);

        //wartości składowe oświetlenia i koordynaty źródła światła
        float ambientLight[] = {0.3f, 0.3f, 0.3f, 1.0f};//swiatło otaczające
        float diffuseLight[] = {0.7f, 0.7f, 0.7f, 1.0f};//światło rozproszone
        float specular[] = {1.0f, 1.0f, 1.0f, 1.0f}; //światło odbite
        float lightPos[] = {0.0f, 150.0f, 150.0f, 1.0f};//pozycja światła
        //(czwarty parametr określa odległość źródła:
        //0.0f-nieskończona; 1.0f-określona przez pozostałe parametry)
        gl.glEnable(GL.GL_LIGHTING); //uaktywnienie oświetlenia
        //ustawienie parametrów źródła światła nr. 0
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, ambientLight, 0); //swiatło otaczające
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuseLight, 0); //światło rozproszone
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, specular, 0); //światło odbite
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, lightPos, 0); //pozycja światła
        gl.glEnable(GL.GL_LIGHT0); //uaktywnienie źródła światła nr. 0
        gl.glEnable(GL.GL_COLOR_MATERIAL); //uaktywnienie śledzenia kolorów
        //kolory będą ustalane za pomocą glColor
        gl.glColorMaterial(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE);
        gl.glEnable(GL.GL_DEPTH_TEST);
        // Setup the drawing area and shading mode
        gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        gl.glShadeModel(GL.GL_SMOOTH);
        try {
            image1 = ImageIO.read(new File("kurczak.jpg"));
            image2 = ImageIO.read(new File("krolik.jpg"));
        } catch (Exception exc) {
            JOptionPane.showMessageDialog(null, exc.toString());
            return;
        }

        t1 = TextureIO.newTexture(image1, false);
        t2 = TextureIO.newTexture(image2, false);

        gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_BLEND | GL.GL_MODULATE);
        gl.glEnable(GL.GL_TEXTURE_2D);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
    }

    public void reshape(GLAutoDrawable drawable, int x, int y, int width,
            int height) {
        GL gl = drawable.getGL();
        GLU glu = new GLU();
        if (height <= 0) { // avoid a divide by zero error!

            height = 1;
        }
        final float h = (float) width / (float) height;
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluPerspective(45.0f, h, 1.0, 20.0);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
    }

    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();
        // Clear the drawing area
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
        // Reset the current matrix to the "identity"
        gl.glLoadIdentity();
        gl.glTranslatef(0.0f, 0.0f, -6.0f); //przesunięcie o 6 jednostek
        gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f); //rotacja wokół osi X
        gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f); //rotacja wokół osi Y
        gl.glRotatef(zrot, 0.0f, 0.0f, 1.0f); //rotacja wokół osi Z

        gl.glBindTexture(GL.GL_TEXTURE_2D, t1.getTextureObject());
        gl.glBegin(GL.GL_TRIANGLES);

        gl.glTexCoord2f(1.0f, 1.0f);
        gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(0.0f, 0.0f, 0.0f);
        gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
        gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, -1.0f);

        gl.glTexCoord2f(1.0f, 1.0f);
        gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(0.0f, 0.0f, 0.0f);
        gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
        gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, -1.0f);

        gl.glTexCoord2f(1.0f, 1.0f);
        gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(0.0f, 0.0f, 0.0f);
        gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, -1.0f);
        gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(1.0f, -1.0f, 1.0f);

        gl.glEnd();

        gl.glBindTexture(GL.GL_TEXTURE_2D, t2.getTextureObject());

        gl.glBegin(GL.GL_QUADS);
        gl.glTexCoord2f(1.0f, 1.0f);
        gl.glVertex3f(1.0f, -1.0f, 1.0f);
        gl.glTexCoord2f(0.0f, 1.0f);
        gl.glVertex3f(1.0f, -1.0f, -1.0f);
        gl.glTexCoord2f(0.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, -1.0f);
        gl.glTexCoord2f(1.0f, 0.0f);
        gl.glVertex3f(-1.0f, -1.0f, 1.0f);
        gl.glEnd();
        gl.glFlush();

    }

    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged,
            boolean deviceChanged) {
    }
}

KLASA 2:

 
package org.yourorghere;
import javax.media.opengl.*;



public class Auto {
    
    public float kat0; //cale ramie lewo-prawo
    public float kat1; //cale ramie gora-gol
    public float kat2; //gorne ramie
    public float kat3; //lyzka
    
    public float x;
    public float y;
    public float z;
    public float rot;
    
    public void Rysuj(GL gl)
    {   
        //Podwozie
        gl.glTranslatef(0.0f+x,0.0f+y,0.0f+z);
        gl.glColor3f(0.0f,0.0f,0.0f);
        Prostopadloscian(gl,-2.0f,-1.0f,-1.0f,4.0f,1.0f,2.0f);
        //Koła
        //kolor kół
        gl.glColor3f(0.15f,0.15f,0.15f);
        Walec(gl,0.5f,0.5f,-1.5f,-1.0f,-1.25f);
        Walec(gl,0.5f,0.5f,-1.5f,-1.0f,0.75f);
        Walec(gl,0.5f,0.5f,1.5f,-1.0f,-1.25f);
        Walec(gl,0.5f,0.5f,1.5f,-1.0f,0.75f);
        //Nadwozie
        //kolor nadwozia
        
        gl.glRotatef(0.0f+rot,1.0f,1.0f,1.0f);
        
        gl.glColor3f(0.0f,0.0f,1.0f);
        Prostopadloscian(gl,-0.5f,0.0f,-1.0f,0.1f,1.0f,0.1f);
        gl.glColor3f(1.0f,0.0f,1.0f);
        Prostopadloscian(gl,-0.5f,0.0f,0.9f,0.1f,1.0f,0.1f);
        //czarny
        gl.glColor3f(0.0f,0.0f,0.0f);
        Prostopadloscian(gl,1.4f,0.0f,-1.0f,0.1f,1.0f,0.1f);
        //pomarańczowy
        gl.glColor3f(1.0f,0.5f,0.0f);
        Prostopadloscian(gl,1.4f,0.0f,0.9f,0.1f,1.0f,0.1f);
        gl.glColor3f(0.2f,0.5f,0.5f);
        Prostopadloscian(gl,-0.5f,1.0f,-1.0f,2.0f,0.1f,2.0f);
    }

    private void Prostopadloscian(GL gl, float x0, float y0, float z0,
    float dx, float dy, float dz)
        {
        float x1=x0+dx;
        float y1=y0+dy;
        float z1=z0+dz;
        gl.glBegin(GL.GL_QUADS);
        //sciana przednia
        gl.glNormal3f(0.0f,0.0f,1.0f);
        gl.glVertex3f(x0,y0,z1);
        gl.glVertex3f(x1,y0,z1);
        gl.glVertex3f(x1,y1,z1);
        gl.glVertex3f(x0,y1,z1);
        //sciana tylnia
        gl.glNormal3f(0.0f,0.0f,-1.0f);
        gl.glVertex3f(x0,y1,z0);
        gl.glVertex3f(x1,y1,z0);
        gl.glVertex3f(x1,y0,z0);
        gl.glVertex3f(x0,y0,z0);
        //sciana lewa
        gl.glNormal3f(-1.0f,0.0f,0.0f);
        gl.glVertex3f(x0,y0,z0);
        gl.glVertex3f(x0,y0,z1);
        gl.glVertex3f(x0,y1,z1);
        gl.glVertex3f(x0,y1,z0);
        //sciana prawa
        gl.glNormal3f(1.0f,0.0f,0.0f);
        gl.glVertex3f(x1,y1,z0);
        gl.glVertex3f(x1,y1,z1);
        gl.glVertex3f(x1,y0,z1);
        gl.glVertex3f(x1,y0,z0);
        //sciana dolna
        gl.glNormal3f(0.0f,-1.0f,0.0f);
        gl.glVertex3f(x0,y0,z1);
        gl.glVertex3f(x0,y0,z0);
        gl.glVertex3f(x1,y0,z0);
        gl.glVertex3f(x1,y0,z1);
        //sciana gorna
        gl.glNormal3f(0.0f,1.0f,0.0f);
        gl.glVertex3f(x1,y1,z1);
        gl.glVertex3f(x1,y1,z0);
        gl.glVertex3f(x0,y1,z0);
        gl.glVertex3f(x0,y1,z1);
        gl.glEnd();
    }

    private void Walec(GL gl, float promien, float dlugosc,
    float px, float py, float pz)
    {
        float x=0.0f,y=0.0f,kat=0.0f;
        gl.glBegin(GL.GL_QUAD_STRIP);
        for(kat = 0.0f; kat < (2.0f*Math.PI); kat += (Math.PI/32.0f))
        {
            x = px + promien*(float)Math.sin(kat);
            y = py + promien*(float)Math.cos(kat);
            gl.glNormal3f((float)Math.sin(kat),(float)Math.cos(kat),0.0f);
            gl.glVertex3f(x, y, pz);
            gl.glVertex3f(x, y, pz+dlugosc);
        }
        gl.glEnd();
        gl.glNormal3f(0.0f,0.0f,-1.0f);
        x=y=kat=0.0f;
        gl.glBegin(GL.GL_TRIANGLE_FAN);
        gl.glVertex3f(px, py, pz); //srodek kola
        for(kat = 0.0f; kat < (2.0f*Math.PI); kat += (Math.PI/32.0f))
        {
            x = px + promien*(float)Math.sin(kat);
            y = py + promien*(float)Math.cos(kat);
            gl.glVertex3f(x, y, pz);
        }
        gl.glEnd();
        gl.glNormal3f(0.0f,0.0f,1.0f);
        x=y=kat=0.0f;
        gl.glBegin(GL.GL_TRIANGLE_FAN);
        gl.glVertex3f(px, py, pz+dlugosc); //srodek kola
        for(kat = 2.0f*(float)Math.PI; kat > 0.0f ; kat -= (Math.PI/32.0f))
        {
            x = px + promien*(float)Math.sin(kat);
            y = py + promien*(float)Math.cos(kat);
            gl.glVertex3f(x, y, pz+dlugosc);
        }
        gl.glEnd();
    }

    private void Lyzka(GL gl)
    {
        gl.glDisable(GL.GL_CULL_FACE);
        gl.glBegin(GL.GL_TRIANGLES);
        gl.glNormal3f(0.0f,0.0f,1.0f);
        gl.glVertex3f(0.0f,0.0f,0.5f);
        gl.glVertex3f(0.5f,0.5f,0.5f);
        gl.glVertex3f(0.0f,0.5f,0.5f);
        gl.glNormal3f(0.0f,0.0f,-1.0f);
        gl.glVertex3f(0.0f,0.0f,-0.2f);
        gl.glVertex3f(0.0f,0.5f,-0.2f);
        gl.glVertex3f(0.5f,0.5f,-0.2f);
        gl.glEnd();
        gl.glDisable(GL.GL_CULL_FACE);
        gl.glBegin(GL.GL_QUADS);
        gl.glNormal3f(-1.0f,0.0f,0.0f);
        gl.glVertex3f(0.0f,0.0f,0.5f);
        gl.glVertex3f(0.0f,0.5f,0.5f);
        gl.glVertex3f(0.0f,0.5f,-0.2f);
        gl.glVertex3f(0.0f,0.0f,-0.2f);
        gl.glNormal3f(0.0f,1.0f,0.0f);
        gl.glVertex3f(0.0f,0.5f,0.5f);
        gl.glVertex3f(0.5f,0.5f,0.5f);
        gl.glVertex3f(0.5f,0.5f,-0.2f);
        gl.glVertex3f(0.0f,0.5f,-0.2f);
        gl.glEnd();
        gl.glEnable(GL.GL_CULL_FACE);
    }
}

i tutaj chciałbym się dowiedzieć jak zrobić by ten pojazd zamiast kręcić się w koło zaczął jeździć po tej nieznanej nikomu pustej przestrzeni. Tyle napisałem i stanąłem w miejscu.
Tutoriali mało do JOGLa jest i tu ból.

Z góry dzięki za podpowiedzi.

1

W obsłudze klawiszy zamiast zmieniać rotację, przesuwaj obiekt (inkrementuj/dekrementuj pozycję pojazdu). Żeby pojazd miał nowe położenie musisz zrobić glTranslated przed wyświetleniem pojazdu, jako argumenty glTranslate wpisujesz pozycję.

0

:* serdeczne dzięki, postaram się wykonać tak jak kolega poradził :)

0

Oto odpowiedź na moje pytanie:

 if (e.getKeyCode() == KeyEvent.VK_S) {
                    if (autko.x < 10.0f) {
                        autko.x += 1.0f;
                    }
                }
                if (e.getKeyCode() == KeyEvent.VK_W) {
                    if (autko.x > -10.0f) {
                        autko.x -= 1.0f;
                    }
                }
                if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
                    if (autko.y > -10.0f) {
                        autko.y -= 1.0f;
                    }
                }
                if (e.getKeyCode() == KeyEvent.VK_SPACE) {
                    if (autko.y < 10.0f) {
                        autko.y += 1.0f;
                    }
                }
                if (e.getKeyCode() == KeyEvent.VK_A) {
                    if (autko.z > -10.0f) {
                        autko.z -= 1.0f;
                    }
                }
                if (e.getKeyCode() == KeyEvent.VK_D) {
                    if (autko.z < 10.0f) {
                        autko.z += 1.0f;
                    }
                }

  public void Rysuj(GL gl)
    {   
        //Podwozie
        gl.glTranslatef(0.0f+x,0.0f+y,0.0f+z);
        gl.glColor3f(0.0f,0.0f,0.0f);
        Prostopadloscian(gl,-2.0f,-1.0f,-1.0f,4.0f,1.0f,2.0f);

Może się to komuś kiedyś przyda :P

0

Mam jeszcze pytanie odnośnie tego, jak zabrać się za teksturowanie brył przestrzennych. Chodzi mi o wstawienie obrazka na przykładowo prostopadłościan. Da się to zrobić, żeby nie bawić się w rysowanie quadów i ich teksturowanie, tylko od razu teksturę wylać na cały prostopadłościan?

Jeśli tak to proszę o wskazówkę...
Dziękuję

1

OpenGL jest niskopoziomową biblioteką. Musisz mu dokładnie opisać w jaki sposób chcesz rysować swój kształt. Możesz narysować kulę, dysk i walec z użyciem kwadryk (z biblioteki glu), tam jest opcja automatycznego teksturowania. http://www.tjhsst.edu/~rlatimer/opengl/quadrics.html http://nehe.gamedev.net/tutorial/quadrics/20001/

0

Dzięki zaraz obadam temat ;P

Java OpenGL[JoGL] poruszanie się pojazdem po terenie.

1 użytkowników online, w tym zalogowanych: 0, gości: 1

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami