Java OpenGL, objektumok elhelyezése gömbbe

Java OpenGL, objektumok elhelyezése gömbbe
2011-10-22T15:01:27+02:00
2011-10-29T16:53:20+02:00
2022-11-23T12:35:37+01:00
adam21.
Üdv.

Próbáltam már mindenhogy, de sehogy sem sikerült. Adott egy gömb:

public void display(GLAutoDrawable drawable) { if (!animator.isAnimating()) { return; } final GL gl = drawable.getGL(); gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); setCamera(gl, glu, 30); gl.glColor3f(0.3f, 0.5f, 1f); GLUquadric star = glu.gluNewQuadric(); glu.gluQuadricDrawStyle(star, GLU.GLU_FILL); glu.gluQuadricNormals(star, GLU.GLU_FLAT); glu.gluQuadricOrientation(star, GLU.GLU_OUTSIDE); final float radius = 26.378f; final int slices = 16; final int stacks = 16; glu.gluSphere(star, radius, slices, stacks); glu.gluDeleteQuadric(star); }


Elsősorban ebbe a gömbbe szeretnék elhelyezni már meglévő objektumokat és a program lefutásakor alapesetben a gömbben lévő dolgokat lássam. Valamint ennek a gömbnek a belső falára egy képet szeretnék tenni(nem nyújtva):

public void init(GLAutoDrawable drawable) { final GL gl = drawable.getGL(); drawable.setGL(new DebugGL(drawable.getGL())); System.err.println("INIT GL IS: " + gl.getClass().getName()); gl.glEnable(GL.GL_DEPTH_TEST); gl.glDepthFunc(GL.GL_LEQUAL); gl.glShadeModel(GL.GL_SMOOTH); gl.glClearColor(0f, 0f, 0f, 0f); gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); glu = new GLU(); try { InputStream stream = getClass().getResourceAsStream("csillagok.png"); TextureData data = TextureIO.newTextureData(stream, false, "png"); starTexture = TextureIO.newTexture(data); } catch (IOException exc) { exc.printStackTrace(); System.exit(0); } animator = new FPSAnimator(this, fps); animator.start(); }

Hogyan lehet ezt megoldani? Köszönöm előre is.
Mutasd a teljes hozzászólást!
1. Amit az előbb linkeltem ott az objektumoknak az alját lehet látni, én viszont azt szeretném, ha teljesen oldalról tudnám nézni. Próbáltam a glRotated utolsó 3 paraméterét állítani, de azzal nem sikerült. Úgy gondolom valahogy a nézőpontot kellene állítani, de úgy hogy az egész objektumra vonatkozzon.


Keress valami oktatóanyagot, mert úgy látszik, az alapok sincsenek meg. Ha a nézet már be van állítva, a glTranslate, glRotate és glScale függvényekkel tudod az objektumaidat pozícionálni.

2. Azt vettem észre, hogy a fel, le, balra, jobbra nyilak lenyomásával nem reagál. Pedig ugyanúgy van mint a korábbi fájlba, ahol működött is. Próbáltam úgy, hogy a main metódust amibe van az eseménykezelő a program legelejére tenni, de úgy sem volt jó.


Továbbra se értek az AWT-hez, de amikor az én változatomban a canvasra raktam a KeyListenert, és nem a frame-re, akkor elkezdtek működni a billentyűk.

3. A későbbiekben nem fog hátrányt jelenteni, ha mozogni lehet majd az objektumok között és ,,ki fogok,, menni a kockából?


Most írom le harmadszor, hogy a kockát mindig pontosan a kamera köré kell rajzolni, így aztán kimenni se tudsz belőle. Pont az a lényeg, hogy akárhogy mozogsz a világban, a skybox kockának mindig a közepén marad a kamera.

Megpróbáltam azt is megcsinálni, hogy a camera metódusba egy glTranslate-et vagy egy glRotated-et betenni amivel a pozíciót betudnám állítani, hogy honnan nézze az objektumokat, de azzal sem sikerült...


Hát ez szomorú. Ha forráskódot nem tudsz mutatni, akkor együttérzésen kívül mással nem tudok segíteni...
Mutasd a teljes hozzászólást!

  • Google és "skybox rendering opengl"...
    Mutasd a teljes hozzászólást!
  • És erről a Skybox-ról nincs valami konkrét leírásod? Hogyan kell használni? Hogyan kapcsolódik a javahoz? Nem használtam még, ezért így nem sokat mond nekem. Valami olyasmi lehet, hogy egy modell ,,dobozt,, lehet vele létrehozni, amin belül lehet elhelyezni objektumokat. Köszi a választ!
    Mutasd a teljes hozzászólást!
  • Nem kapcsolódik Java-hoz semennyire, ez egy általános módszer, amivel a "távoli tájat" szimulálod a jelenetben.
    A skyBOX név ellenére, nem csak "dobozzal" működik, hanem pl. gömbbel is (bármilyen befoglaló alakzattal).
    Van egy olyan érzésem, hogy nem sok linket olvastál el a találatok közül, mert az elsők közt vannak olyan egyértelmű leírások is, amik még a renderelés sorrendjét is leirják...
    Mutasd a teljes hozzászólást!
  • Akkor viszont végkép nem értem, hogy ha nem kapcsolódik a javahoz, akkor hogyan tudom megvalósítani azt amit leírtam.

    Keresgéltem, és ezt találtam hozzá:

    Skybox tutorial - Sidvind

    Mutasd a teljes hozzászólást!
  • Ez a 3d grafikáhozhoz kapcsolódik, nem nyelvhez, nem API-hoz.
    Ugyanúgy csinálod, mint D3D-ben, mint C++, vagy bármi másban.
    Mutasd a teljes hozzászólást!
  • Csak ezzel a Skybox-al lehet ezt megoldani? Sose hallottam még róla, neten sincs használható alap amiből ki tudnék indulni. Mindenhol vagy c++ fájlokat találok, vagy csak pár sor szöveget róla, ami számomra nem sokat mond.
    Mutasd a teljes hozzászólást!
  • Technikailag egy nagy kocka, aminek a belső lapjai textúrázottak és statikus, tehát nem mozgó objektum. Tehát java-ban definiálsz egy textúrázott kockát, amiben gondolom a megfelelő GL utasítások ugyanazok, mint más nyelvben is.
    Mutasd a teljes hozzászólást!
  • Az talán félrevezető, hogy nem mozog a skybox. A kamerához képest nem változik a helye, de a helyzete igen. (Az, hogy a kamera forog őbenne, vagy ő forog a kamera körül, az már viszonyítás kérdése ugye.)

    @adam21:
    A skybox egy, a kamera köré rajzolt kocka, ahogy Daniell is írta. Az a trükkje, hogy a kirajzolás előtt kikapcsolod a z-buffert, aztán rajzolás után üríted és visszakapcsolod. Ennek az lesz az eredménye, hogy a kocka nem takar el semmit, hanem minden más mögött látszik. Mivel a kamera mindig a középpontjában van a kockának, a kocka mérete igazából lényegtelen. A z-bufferes trükközés miatt pedig nem kell aggódni, hogy a tereptárgyaid valóban a kockán belül helyezkedjenek el, mivel a látvány szempontjából a kocka lapjai végtelen messze vannak. Már csak egy jó textúra kell rá, ami a kocka éleinél szépen egymásba folyik, így a szemlélő egyáltalán nem veszi észre a kocka éleit, csak egy folytonos látképet lát.
    Mutasd a teljes hozzászólást!
  • Köszönöm, ezen azt hiszem el tudok indulni. Szóval létrehoztam egy kockát így:

    public void display(GLAutoDrawable drawable) { GL gl = drawable.getGL(); gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); gl.glLoadIdentity(); gl.glTranslatef(-1.5f, 0.0f, -6.0f); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glEnd(); }

    Következő lépésként említetted, hogy kapcsoljam ki a Z-buffert(rajzolás előtt), majd ürítem és visszakapcsolom.
    Ez lenne az?
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    Köszi a segítséget előre is!
    Mutasd a teljes hozzászólást!
  • A Z-buffert így tudod kikapcsolni:
    gl.glDisable(GL.GL_DEPTH_TEST);

    Ez után jöhet a kocka rajzolása.

    A kocka rajzolása után üríted a Z-buffert, aztán visszakapcsolod:
    gl.glClear(GL.GL_DEPTH_BUFFER_BIT); gl.glEnable(GL.GL_DEPTH_TEST);

    A color buffer ürítése szükségtelen a kocka rajzolása előtt, mivel a kocka mindenképp le fogja fedni az egész látóteret.

    A másik probléma, hogy az a glTranslatef hívás oda nagyon nem kéne. Pont az a lényeg, hogy a kamera a kocka középpontjában maradjon. Helyette majd egy glRotatef fog kelleni, ami gondoskodik róla, hogy a skybox a világ maradékával együtt forogjon.

    Ja és ha nem lenne világos, a skyboxot a világ maradék része előtt kell kirajzolni
    Mutasd a teljes hozzászólást!
  • Köszi, haladok ahogy írtad.

    Szóval kikapcsoltam, ürítettem majd visszakapcsoltam a Z-buffert. Kiszedtem onnan a glTranslatef() metódust, viszont így már nem jelenik meg a létrehozott kocka(előtte színes volt), nem tudom ez mennyire hátrány a későbbiekben. Ezután a kocka belső textúráját kellene megoldani? Szóval egy képet ráilleszteni minden egyes oldalára?(az egész dolog egy naprendszerről szólna, szóval a kocka oldalaira egy olyan képet tennék amin csillagok vannak) Így ha szerencsém van akkor nem fog látszódni hogy a világűr egy kocka belsejében van. Előbb akkor ezt csinálnám meg(a képet a kocka belsejébe helyezni) aztán pedig a már korábban megírt objektumokat helyezném el bennük.

    Az alap programomba(amiben vannak az objektumaim, nevezetesen a bolygók) a gömbökre ilyen eljárással tettem képet:

    try { InputStream stream = getClass().getResourceAsStream("earth.png"); TextureData data = TextureIO.newTextureData(stream, false, "png"); earthTexture = TextureIO.newTexture(data); } catch (IOException exc) { exc.printStackTrace(); System.exit(1); }

    Ez a külsejére fedi a paraméterben megadott képet. Kérdésem az lenne, hogy hasonló eljárással kell a kocka belső oldalaira vasalni a képet?
    Mutasd a teljes hozzászólást!
  • A JOGL-hez nem értek, de ami kódot bemásoltál, az csak a textúra betöltésének tűnik.

    Most rákerestem Google-ön, és a Texture példány bind() metódusa fog kelleni neked. A legegyszerűbb az, ha minden lap egy-egy külön textúra lesz. (A csillagos égboltnál talán csalhatsz kicsit, és rakhatod minden lapra ugyanazt a textúrát.) Mielőtt az adott lapot kirajzolnád, meghívod a megfelelő textúra bind() metódusát, hogy az adott laphoz azt a textúrát használja az OpenGL.

    (Persze ha nincs bekapcsolva a textúrázás, előtte nem árt bekapcsolni egy glEnable(GL.GL_TEXTURE_2D) hívással.)
    Mutasd a teljes hozzászólást!
  • Nos így néz ki a kód:

    public void display(GLAutoDrawable drawable) { GL gl = drawable.getGL(); gl.glEnable(GL.GL_TEXTURE_2D); gl.glLoadIdentity(); gl.glDisable(GL.GL_DEPTH_TEST); glu.gluLookAt(0, 8, 4, 0, 0, 0, 0, 1, 0); starTexture.enable(); starTexture.bind(); gl.glTranslatef(-1.5f, 0.0f, -6.0f); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glEnd(); gl.glClear(GL.GL_DEPTH_BUFFER_BIT); gl.glEnable(GL.GL_DEPTH_TEST); }

    Betettem egy gluLookAt()-et is hogy beállítsam milyen szögből nézem a kockát.
    Így a textúra beolvasás:


    public void init(GLAutoDrawable drawable) { GL gl = drawable.getGL(); try { InputStream stream = getClass().getResourceAsStream("csillagok.png"); TextureData data = TextureIO.newTextureData(stream, false, "png"); starTexture = TextureIO.newTexture(data); } catch (IOException exc) { exc.printStackTrace(); System.exit(1); } }

    Lefuttatva ráteszi a lapokra a png képet, egyszer hívtam meg a bind(), és az enable();-t és így az összes lapra ráteszi a képet de kívülre, én ugyebár meg belülre szeretném tenni. Erre milyen módszer létezik?
    Mutasd a teljes hozzászólást!
  • Most órajárással ellentétes irányban definiálod a quad-okat, ezt fordítsd meg, igy nem kifelé, hanem befelé néznek majd, ergo a normáljuk megfordul (ha a culling be van kapcsolva, akkor addig forditsd meg a front face irányát).
    Egyébként nem kell minden quad-hoz glBegin/glEnd...
    Mutasd a teljes hozzászólást!
  • Itt egész pontosan le van írva hogyan kell.

    Továbblépés: A begin-end páros már elavult, nem is tudom hol lehet ezt még egyáltalán használni manapság. Mindenesetre lassúnak lassú. A glVertexPointer és glDrawArrays-nek érdemes utána nézni.
    Mutasd a teljes hozzászólást!
  • Igen ez alapján csinálom én is. Illetve az itt szerzett infók mellé még ezt is nézem.
    Mutasd a teljes hozzászólást!
  • glBindTexture(GL_TEXTURE_2D, _skybox[0]);

    Ebben a sorban a _skybox[0] tömb mit határozza meg? Tesztelgettem a jelenlegi programba, hogy ha 1-est írok akkor látom a négyzet külsején a képet, ha 1-től nagyobbat akkor viszont nem(fehér lesz az adott négyzet oldala), ebből ezt a következtetést vettem le.
    A paraméter megnevezés szerint a textúra nevét várja oda, viszont int típusként.
    Mutasd a teljes hozzászólást!
  • Igen, a textúra neve OpenGL szóhasználatban egy egész szám, talán szerencsésebb lett volna az azonosító szó. A glGenTextures generál neked valahány nevet. Ezeket a neveket aztán felhasználhatod a glTexImage2D függvényben a textúra pixeleinek kitöltéséhez, és a glBindTexture függvényben az aktuális textúra kiválasztásához.

    A példában nem írták ki, csak sugallták, hogy a _skybox egy int tömb, amibe már betöltöttek hat textúranevet, valamint ezekbe a textúrákba már betöltötték a megfelelő lap pixeleit.

    Ezt az azonosítós trükközést elfedi előled a Texture osztály. A leírása alapján a létrehozásakor elintézi a glGenTextures és glTexImage2D hívását, a bind() metódusa pedig a glBindTexture-t hívja a háttérben.
    Mutasd a teljes hozzászólást!
  • Akkor is kell a glGenTexture ha én csak egy képet akarok felhasználni vagy csak elég egyszer használni?
    Itt van ahol beolvasom a textúrát:
    try { InputStream stream = getClass().getResourceAsStream("csillagok.png"); TextureData data = TextureIO.newTextureData(stream, false, "png"); starTexture = TextureIO.newTexture(data); } catch (IOException exc) { exc.printStackTrace(); System.exit(1); }


    aztán:


    public void display(GLAutoDrawable drawable) { GL gl = drawable.getGL(); int i; for(i=0; i<6; i++){ skybox[i] = gl.glGenTextures(1, starTexture); } gl.glLoadIdentity(); gl.glDisable(GL.GL_DEPTH_TEST); starTexture.enable(); starTexture.bind(); glu.gluLookAt(0, 6, 4, 0, 0, 0, 0, 1, 0); gl.glEnable(GL.GL_TEXTURE_2D); gl.glBindTexture(GL.GL_TEXTURE_2D, skybox[0]); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBindTexture(GL.GL_TEXTURE_2D, skybox[1]); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBindTexture(GL.GL_TEXTURE_2D, skybox[2]); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBindTexture(GL.GL_TEXTURE_2D, skybox[3]); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBindTexture(GL.GL_TEXTURE_2D, skybox[4]); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBindTexture(GL.GL_TEXTURE_2D, skybox[5]); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glEnd(); gl.glClear(GL.GL_DEPTH_BUFFER_BIT); gl.glEnable(GL.GL_DEPTH_TEST); }

    Nem tudom, hogy ez mennyire jó megoldás. Bár eléggé belegabalyodtam már:S
    Mutasd a teljes hozzászólást!
  • Szerintem is belegabalyodtál már

    Ahogy írtam előbb, a starTexture létrehozáskor a JOGL már elintézte a glGenTextures-t és a glTexImage2D-t. A starTexture.bind() pedig elintézi a glBindTexture-t. Így ezeket kézzel nem kell meghívnod sehol.

    Még ha kézzel is akarnád ezeket a metódusokat használni, akkor sem célszerű minden rajzolási menetben újra létrehozni őket. Az egész akkor lesz hatékony, ha a rajzolás előtt betöltöd az összes szükséges textúrát, és rajzolás közben csak váltogatsz közöttük.

    Egyáltalán lefordul ez neked?
    skybox[i] = gl.glGenTextures(1, starTexture);
    Mert ami doksit én találtam, abban csak void visszatérési értékű glGenTextures van...
    Mutasd a teljes hozzászólást!
  • A glGenTexture csak akkor kell, ha új OpenGL objektumot hozol létre, amit te itt
    InputStream stream = getClass().getResourceAsStream("csillagok.png"); TextureData data = TextureIO.newTextureData(stream, false, "png"); starTexture = TextureIO.newTexture(data);
    meg is teszel. A display-ben nem kell a Gen, semmi értelme.
    Ha egy textúrát szeretnél használni az összes lapra, akkor az első lap rajzolása előtt bind-eled, és utána, amig másik textúrát nem "kapcsolsz be", vagy a textúrázást ki, addig az is marad.
    Mutasd a teljes hozzászólást!

  • Akkor így marad ezek szerint a kód, így megjeleníti a a textúrákat a kocka külső oldalán.
    public void display(GLAutoDrawable drawable) { GL gl = drawable.getGL(); gl.glLoadIdentity(); gl.glDisable(GL.GL_DEPTH_TEST); starTexture.enable(); starTexture.bind(); glu.gluLookAt(0, 6, 4, 0, 0, 0, 0, 1, 0); gl.glEnable(GL.GL_TEXTURE_2D); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, 0.5f, -0.5f ); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, 0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, 0.5f, -0.5f ); gl.glEnd(); gl.glBegin(gl.GL_QUADS); gl.glTexCoord2f(0, 0); gl.glVertex3f( -0.5f, -0.5f, -0.5f ); gl.glTexCoord2f(0, 1); gl.glVertex3f( -0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 1); gl.glVertex3f( 0.5f, -0.5f, 0.5f ); gl.glTexCoord2f(1, 0); gl.glVertex3f( 0.5f, -0.5f, -0.5f ); gl.glEnd(); gl.glClear(GL.GL_DEPTH_BUFFER_BIT); gl.glEnable(GL.GL_DEPTH_TEST); }

    Most már csak azt kellene megcsinálni, hogy a kocka belső lapjain legyenek a textúrák, jari_jari javasolta, hogy a koordinátákkal játsszak úgy hogy a rajzolást ellentétesen oldom meg és ezáltal befelé fog nézni a kép. Igaz?
    Ezután meg jöhet a meglévő objektumok és ez a kocka összefésülése. Gondolom, hogy a kamerát a kockán belül kell elhelyezni, kérdésem még az lenne, hogy mekkorának kell lennie a kockának, hogy minden elférjen benne?
    Mutasd a teljes hozzászólást!
  • Amilyen nagy, akkora, csak a távoli vágósík elé tedd be...
    Mutasd a teljes hozzászólást!
  • Ezután meg jöhet a meglévő objektumok és ez a kocka összefésülése. Gondolom, hogy a kamerát a kockán belül kell elhelyezni, kérdésem még az lenne, hogy mekkorának kell lennie a kockának, hogy minden elférjen benne?


    Nem olvastad elég figyelmesen a 16:19-es hozzászólásomat. Az egész GL_DEPTH_TEST-es trükközésnek az a lényege, hogy a kocka méretét lényegtelené tegye. A kocka semmit sem takar el, tehát effektíve végtelen távol van, minden más dolog mögött. A lényeg csak az, hogy a kocka mindig pontosan a kamera köré legyen rajzolva, a többi dolog meg a szokásos módon.

    Ez utóbbit úgy a legegyszerűbb elérni, ha a kamera helye és nézési iránya már eleve külön van tárolva a kódodban. A skybox rajzolásánál csak az irányt veszed figyelembe glRotate-tel, a világ maradék részénél pedig a helyet is, glTranslate-tel.
    Mutasd a teljes hozzászólást!
  • Na ezeket megemésztem aztán majd folytatom, köszönöm mindenkinek a segítséget. Ha valahol elakadtam akkor írok, de remélem nem lesz rá szükség.
    Mutasd a teljes hozzászólást!
  • Üdv megint! Próbálgattam a skyboxot, viszont a kocka helyett áttértem a gömbre. Nem akartam egyből a jelenlegi programba bemásolni, előbb tesztelgettem egy külön file-ba. Szóval létrehoztam egy gömböt, textúra beolvasása, ahogyan kell majd kikapcsoltam a z-buffert(GL.GL_DEPTH_TEST), GL_DEPTH_TEST -et is, aztán engedélyeztem a gl.GL_TEXTURE_2D. Eztuán jött a kirajzolás, ahol kikapcsoltam a backfacecullingot(gl.GL_CULL_FACE). A kirjaazolás után pedig vissza kapcsoltam ezket.

    Íme a kód:

    public void display(GLAutoDrawable drawable) { GL gl = drawable.getGL(); gl.glLoadIdentity(); gl.glClearColor(5, 6, 7, 10); gl.glClear(gl.GL_COLOR_BUFFER_BIT); gl.glDisable(GL.GL_DEPTH_TEST); starTexture.enable(); starTexture.bind(); glu.gluLookAt(2, 22, 0, 0, 0, 0, 0, 1, 0); gl.glEnable(GL.GL_TEXTURE_2D); GLUquadric star = glu.gluNewQuadric(); glu.gluQuadricTexture(star, true); glu.gluQuadricDrawStyle(star, GLU.GLU_FILL); glu.gluQuadricNormals(star, GLU.GLU_FLAT); glu.gluQuadricOrientation(star, GLU.GLU_INSIDE); final float radius = 0.9f; final int slices = 16; final int stacks = 16; gl.glDisable(gl.GL_CULL_FACE); glu.gluSphere(star, radius, slices, stacks); glu.gluDeleteQuadric(star); gl.glDisable(gl.GL_TEXTURE_2D); gl.glEnable(gl.GL_DEPTH_TEST); gl.glEnable(gl.GL_CULL_FACE); gl.glClear(GL.GL_DEPTH_BUFFER_BIT); }

    Ha elindítom és a megfelelő szögből nézem a gluLookAt-el(glu.gluLookAt(2, 22, 0, 0, 0, 0, 0, 1, 0);), akkor látható a gömb külseje, rajta a textúrával, viszont ha belemegyek a gömb belsejébe gluLookAt(0, 0, 0, 0, 0, 0, 0, 1, 0); -el akkor nem látni maga a textúrát, hanem csak a fehér hátteret Mit ronthattam el?
    Mutasd a teljes hozzászólást!
  • Először is: én csak kockával próbálkoznék gömb előtt. Először működjön az egyszerű eset, aztán lehet variálni. Másodszor: egyelőre hagyd ki teljesen a gluLookAt-et, mert szerintem most az kavar be neked.
    Mutasd a teljes hozzászólást!
  • Hmm.. úgy gondoltam egy gömbbel egyszerűbb lesz a dolog
    Mutasd a teljes hozzászólást!
  • És ezt miből gondoltad?
    Mutasd a teljes hozzászólást!
Tetszett amit olvastál? Szeretnél a jövőben is értesülni a hasonló érdekességekről?
abcd