Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Spiele programmieren mit C++ SDL2 OpenGL ES für Android- hilfe

Werbeanzeige

Patty1991

Frischling

  • »Patty1991« ist der Autor dieses Themas

Beiträge: 61

  • Private Nachricht senden

1

02.08.2014, 17:15

Spiele programmieren mit C++ SDL2 OpenGL ES für Android- hilfe

Hallo allerseits,

Ich möchte euch mal was erzählen ...und weis nicht ob ich hier richtig bin

Da ich 3D-Gamestudio Nutzr bin und es noch keinen
Support für Android gibt, habe ich mich mal schau gemacht
wie man überhaupt erstmal was auf android darstellt - weil ich immer schomal Programme
zum "Mitnehmen" schreiben wollte

Immer und immer wieder bin ich nur auf Tutorials gestoßen die zeigen
wie man mit Eclipse (Compiler) ,Java (Programmiersprache), dem NDK (Andriod tool Kit für Eclipse)
und sehr sehr viel code und ganz kompliziert wenige sachen darstellt

-> z.b. hello world

zufällig habe ich gesehn, oder ehr danach gesucht, ob es einen C/C++ Compiler für Android gibt
denn es gibt ja schließlich auch ein 3D-Gamestudio c++ plugin oder so - warum nicht das eine mit dem anderen
versuchen zu verschmelzen... (geht leider nicht) aber...

ja sowas gibs !

C4droid heist die App (Kostet so 3-4€ im PlayStore)
CC Tools - kostenlos, fast unbrauchbar weil man makefiles und so bearbeiten muss via terminal ect...
sehr umständlich zu bedienn

_________________________________________
das besondere an diesem C4Droid Compiler:
__________________________________________

-man öffnet ihn und kann sofort los programmieren

-einfach plugins (gcc,sdl,qt,nativActivity) installieren und loslegen (keine includes,keine libs,keine links manuel verbinden )

-drückt man auf export so wird eine Apk erzeugt :) :)

-sehr einfach zu bedinen...

-man kann sogar einstellen ob man ein steuerkreuz in der app haben möchte, muss diese dann normal mit
SDL via input bestimmen (key: _links, _rechts, _oben, _unten) zusäzlich kann man 6 knöpfe einbinden und diese
dann auch simulieren(a-z,enter,space...)- man programmiert bei der steuerung wie auf PC

updates alle paar monate
_____________________________________________________
...Tja nur.. wie programmiert man spiele in c/c++ ?
_____________________________________________________

später fand ich ein plugin names "SDL" <- was auch immer das sein mochte ...

und wiederum später fand ich mithilfe von Google, diversen Foren heraus, dass
es sich hierbei um eine Grafikbibleothek handelt ( SDL1.2 oder SDL2.0 )

ich enschied mich für 1.2(was ich noch berreuen sollte...)

*das LazyFoo Tutorial kann ich euch nicht empfelen,da hier vielzuviel code benutzt wird - (400 zeilen für ein bild ?...)

Mit ganz vielen Tutorials, Videos und eingendlich recht raschen verstehn habe ich es geschafft
innerhalb von 4 monaten ein 2D Space Shooter zu programmieren mit: Menus,Sounds,Feinde,Scroe,Leben,Schuss,
der auf Android als App sofort ausführbar ist

und das nur mit C++/SDL !!!

-> sdl erlaubt mir auf Android mausevents als touchscreen_event zu "emulieren"
so kann man mit einbisschen Logik auch eigende Buttons programmieren,
indem man über eine kollisionsabfrage fragt ob die "maus"(surface) über den button ist
und man gleichzeitig maus_left drückt (doppelt auf dem bildschirm tippen)

so jetzt kann ich meine eigende Apps programmieren und hab folgendes erlernt:

-Bilder darstellen
-Buttons machen die man drücken kann
-Menüs mit pfeil am rand , (der immer wieder wenn ganz unten ist, nach oben springt - sowie umgekehrt)
-Kollisionen
-Ton ausgeben
-"touchscreen" benutzen- mithilfe von SDL_mouse events

______________________________________________________________________________________________________

Schön und gut, aber ... alles halt nur in 2D ..aber 3D ???
______________________________________________________________________________________________________

Da ich gelesen habe, dass SDL nur 2d kann war ich echt entäuscht... alles umsonst erlernt oder wie ?

In Youtube habe ich gesehn wie jemand mit SDL und OpenGL ein OpenGL Dreieck darstellt mit ganz wenig Code
Das besondere: OpenGl kann 3D und lässt sich mithilfe von SDL 1.2 sowie 2.0 ganz einfach intigrieren
- also kann SDL indereckt auch 3D :-)

Ich wollte das ganze dann schnell nachmachen aufen Tablet, Ausgeführt und ...

Error - gl.h not found
Error - glut.h not found

_______________________________________________________________________________________________________

Das ganze habe ich dann mal in CodeBlocks ausgeführt,und siehe da..
es funtioniert...nur nicht auf Tablet :(

Im Ordner Example wird auch gezeigt vie man mit NativActivity ein 3D Cube darstellt und ihn dreht
-> der Code dazu ist spagetti code extrem, der irgendwie ins Java übergeht (komische include und defines)

_________________________________________________________________________
Ich will doch nur ein OpenGL dreieck auf ein Android gerät darstellen...
_________________________________________________________________________

Auch 3 Wochen dannach hab ich es immer nochnicht geschafft den Fehler zu beheben und
wollte alles schon übern haufen werfen...

Als ich aus Ablenkung nochmal im Playstore war und ein Spiel runterladen wollte,
hat mir dieser alle was von CCTools gezeigt und irgendwie hab ich dann zufällig auf
ccTools SDL plugin getippt und was bekomm ich zusehn ???

Ein Regenbogen Farbender 3D Würfel und andere sdL examples !!!

-> SOFORT HAB ICH MIR CCTOOLS und das plugin runtergeladen..
nachdem ich nach 3 tagen endlich rausgefunden habe wie man damit ein example öffnet oder auch nicht:/
über makefiles und dann noch hochkomplizirt verdreht
___________________________________________________________________________

irgendwann habe ich mich beim ganzen hin und her vertan und folgendes gemacht,
ohne mir gedanken darüber zu machen:

- ich hab c4droid geöffnet
- auf open gedrückt
- cctools/SDL example/glesexample
- und hab auf run gedrückt ... EIN 3D REGENBOGEN WÜRFEL
____________________________________________________________________________
MAN KANN ALLE SDL EXAMPLES VON CCTOOLS mit C4Droid öffnen und ausführen !!!
____________________________________________________________________________


So nach dem ich mir das ganze mal angeschaut habe,
habe ich versucht mithilfe eines OpenGl tutorials ein Dreieck darzustellen ...
hmm das hat leider nicht functioniert -> ist ja auch OpenGL Es


Das ist der Code des Würfels

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

/*
  CCTools SDL plugin GLES example
 
  Derived from SDL testgles sources:
 
  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
 
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
 
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include <SDL2/SDL.h>
#include <SDL2/SDL_opengles.h>
 
static SDL_Window *window;
static SDL_GLContext context;
 
static void
AspectAdjust(int w, int h)
{
    float aspectAdjust;
 
    aspectAdjust = (4.0f / 3.0f) / ((float)w / h);
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrthof(-2.0, 2.0, -2.0 * aspectAdjust, 2.0 * aspectAdjust, -20.0, 20.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glShadeModel(GL_SMOOTH);
}
 
static void
Render()
{
    static GLubyte color[8][4] = { {255, 0, 0, 0},
    {255, 0, 0, 255},
    {0, 255, 0, 255},
    {0, 255, 0, 255},
    {0, 255, 0, 255},
    {255, 255, 255, 255},
    {255, 0, 255, 255},
    {0, 0, 255, 255}
    };
    static GLfloat cube[8][3] = { {0.5, 0.5, -0.5},
    {0.5f, -0.5f, -0.5f},
    {-0.5f, -0.5f, -0.5f},
    {-0.5f, 0.5f, -0.5f},
    {-0.5f, 0.5f, 0.5f},
    {0.5f, 0.5f, 0.5f},
    {0.5f, -0.5f, 0.5f},
    {-0.5f, -0.5f, 0.5f}
    };
    static GLubyte indices[36] = { 0, 3, 4,
        4, 5, 0,
        0, 5, 6,
        6, 1, 0,
       
        6, 7, 2,
        2, 1, 6,
        7, 4, 3,
       
        3, 2, 7,
        5, 4, 7,
        7, 6, 5,
       
        2, 3, 1,
        3, 0, 1
    };
 
 
    /* Do our drawing, too. */
    glClearColor(0.0, 0.0, 0.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    /* Draw the cube */
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, color);
    glEnableClientState(GL_COLOR_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, cube);
    glEnableClientState(GL_VERTEX_ARRAY);
    glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, indices);
 
    glMatrixMode(GL_MODELVIEW);
    glRotatef(5.0, 1.0, 1.0, 1.0);
}
 
int
main(int argc, char *argv[])
{
    int done;
    SDL_DisplayMode mode;
    SDL_Event event;
    Uint32 then, now, frames;
 
    if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { /* Initialize SDL's Video subsystem */
        SDL_Log("Unable to initialize SDL");
        return 1;
    }
 
    SDL_GetDesktopDisplayMode(0, &mode);
 
    SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 16);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
 
    // Create our window centered
    window = SDL_CreateWindow("GLES example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
    mode.w, mode.h, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN);
    if (!window) {
    // Die if creation failed
    SDL_Log("Unable to create window");
    return 1;
    }
 
    // Create our opengl context and attach it to our window
    context = SDL_GL_CreateContext(window);
    if (!context) {
    SDL_Log("Unable to create GL context");
    return 1;
    }
 
    SDL_GL_MakeCurrent(window, context);
 
    SDL_GL_SetSwapInterval(1);
 
    SDL_Log("Screen bpp: %d\n", SDL_BITSPERPIXEL(mode.format));
    SDL_Log("\n");
    SDL_Log("Vendor     : %s\n", glGetString(GL_VENDOR));
    SDL_Log("Renderer   : %s\n", glGetString(GL_RENDERER));
    SDL_Log("Version    : %s\n", glGetString(GL_VERSION));
    SDL_Log("Extensions : %s\n", glGetString(GL_EXTENSIONS));
    SDL_Log("\n");
 
    AspectAdjust(mode.w, mode.h);
 
    /* Main render loop */
    frames = 0;
    then = SDL_GetTicks();
    done = 0;
    while (!done) {
        /* Check for events */
        ++frames;
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
            case SDL_KEYDOWN:
                if (event.key.keysym.scancode == SDL_SCANCODE_AC_BACK) {
                    done = 1;
                }
                break;
            case SDL_WINDOWEVENT:
                switch (event.window.event) {
                    case SDL_WINDOWEVENT_RESIZED:
                        /* Change view port to the new window dimensions */
                        AspectAdjust(event.window.data1, event.window.data2);
                        /* Update window content */
                        Render();
                        SDL_GL_SwapWindow(window);
                        break;
                }
            }
        }
 
        Render();
        SDL_GL_SwapWindow(window);
    }
 
    /* Print out some timing information */
    now = SDL_GetTicks();
    if (now > then) {
        SDL_Log("%2.2f frames per second\n",
               ((double) frames * 1000) / (now - then));
    }
 
    SDL_GL_DeleteContext(context);
    SDL_DestroyWindow(window);
    SDL_Quit();
 
    return 0;
}



irgendwie habe ich trotzdem jetz eine quadratische Fläche ...

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include <SDL2/SDL.h>
#include <SDL2/SDL_opengles.h>
 
 
 
static SDL_Window *window;
static SDL_GLContext context;
int move_me;
 
 
 
static void AspectAdjust(int w, int h)
{
    float aspectAdjust;
 
    aspectAdjust = (4.0f / 3.0f) / ((float)w / h);
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrthof(-2.0, 2.0, -2.0 * aspectAdjust, 2.0 * aspectAdjust, -20.0, 20.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glShadeModel(GL_SMOOTH);
}
 
static void Render()
{
    static GLubyte color[8][4] =
    {
    {0, 0, 255, 0},
    {2, 0, 0, 255},
    {0, 255, 0, 255},
    {0, 255, 0, 255},
    {0, 255, 0, 255},
    {255, 255, 255, 255},
    {255, 0, 255, 255},
    {0, 0, 255, 255},
    };
   
   
   static GLfloat trangleVectiles[8][4]  =
   {
    {0.5f, 0.5f, -0.5f},
    {0.5f, -0.5f, -0.5f},
    {0.0f, -0.5f, -0.5f},
    {-0.5f, 0.5f, 0.0f},
    {-0.5f, 0.5f, 0.5f},
    };
   
   
    static GLubyte indices[36] =
   
      {  
        0, 1, 2,
        2, 3, 0
      };
         
 
       
   
     
 
    /* Do our drawing, too. */
    glClearColor(0.0, 0.0, 0.0, 0.5);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    /* Draw the cube */
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, color);
    glEnableClientState(GL_COLOR_ARRAY);
   
    glVertexPointer(3, GL_FLOAT, 0, trangleVectiles);
    glEnableClientState(GL_VERTEX_ARRAY);
   
    glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, indices);
 
    glMatrixMode(GL_MODELVIEW);
    glRotatef(1.0, 0.0, 1.0, 0.0);
}
 
int main(int argc, char *argv[])
{
    int done;
    SDL_DisplayMode mode;
    SDL_Event event;
 
    if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { /* Initialize SDL's Video subsystem */
        SDL_Log("Unable to initialize SDL");
        return 1;
    }
 
    SDL_GetDesktopDisplayMode(0, &mode);
 
    SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
 
    // Create our window centered
    window = SDL_CreateWindow("GLES example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
    mode.w, mode.h, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN);
   
    // Create our opengl context and attach it to our window
    context = SDL_GL_CreateContext(window);
   
    SDL_GL_MakeCurrent(window, context);
 
    SDL_GL_SetSwapInterval(1);
 
    AspectAdjust(mode.w, mode.h);
 
    done = 0;
    while (!done) {
        /* Check for events */
       
        while (SDL_PollEvent(&event))
        {
         if ( event.type == SDL_MOUSEBUTTONDOWN )
         {
          if (event.button.button == SDL_BUTTON_LEFT )
            {
             if (event.type == SDL_MOUSEMOTION)
             {
              move_me  = event.motion.x;
             }}
  //  cursorPosition.y  = event.motion.y;
   }
           
                  switch (event.type) {
            case SDL_KEYDOWN:
                if (event.key.keysym.scancode == SDL_SCANCODE_AC_BACK) {
                    done = 1;
                }
                break;
            case SDL_WINDOWEVENT:
                switch (event.window.event) {
                    case SDL_WINDOWEVENT_RESIZED:
                        /* Change view port to the new window dimensions */
                        AspectAdjust(event.window.data1, event.window.data2);
                        /* Update window content */
                        Render();
                        SDL_GL_SwapWindow(window);
                        break;
                }
                  }
        }
 
        Render();
        SDL_GL_SwapWindow(window);
    }
 
 
    SDL_GL_DeleteContext(context);
    SDL_DestroyWindow(window);
    SDL_Quit();
 
    return 0;
}



leider lassen sich openGL ES programme nicht ohne weiteres Ausführen auf PC, ich hoffe ihr könnt dennoch helfen:

-> kann mir wer helfen und zeigen wie man ein 2ten würfel neben den würfel dastellt - es gibt ja kein glBegin und glEnd mehr ?
-> was haben die arrays [8][3] aufsich ?
-> wie functionieren indices ?
-> wie kann ich ein Surface zusätzlich darstellen
-> gibt es wo Tutorials dazu , die mir helfen (ohne JAVA !)

und da das ganze leider nur auf SDL2 laüft muss ich mit SDL nochmal neu anfanen, weil es ganz anders functioniert

iSmokiieZz

Treue Seele

Beiträge: 364

  • Private Nachricht senden

2

02.08.2014, 19:30

Zitat

-> kann mir wer helfen und zeigen wie man ein 2ten würfel neben den würfel dastellt - es gibt ja kein glBegin und glEnd mehr ?
Indem du entweder die Indices Liste erweiterst (siehe auch die andere Frage), oder einen weiteren "Index Buffer" anlegst.

Zitat

-> was haben die arrays [8][3] aufsich ?
Das sind mehrdimensionale Arrays. Du kannst dir genanntes Array vorstellen, wie ein Raster mit 8x3 Zellen. In diesem Fall wird es dafür benutzt, um jeweils 3 Farbkanäle (Rot, Grün, Blau) pro Vertex zu beschreiben.

Zitat

-> wie functionieren indices ?
*funktionieren
Indices sind Zahlen, die auf den Index eines Vertex im Vertex-Buffer-Object (VBO) zeigen, somit die Reihenfolge der Vertices beschreiben und damit das Polygon bilden.
Beispiel:
Nehmen wir an, der VBO sieht folgendermaßen aus:

C-/C++-Quelltext

 
1
2
3
4
5
6

SVertex vertices[3] =
{
SVertex( 0.0f, 1.0f, 2.0f);
SVertex( 0.5f, 0.0f, 2.0f);
SVertex(-0.5f, 0.0f, 2.0f);
};
... dann hat der erste Vertex einen Index von 0, der zweite von 1 und so weiter. Die Vertices sind in der Form eines Dreiecks. Nun legen wir die Indices für dieses Dreieck fest:

C-/C++-Quelltext

 
1

unsigned int indices[3] = { 1, 0, 2 };
Damit kann opengl nun ein Dreieck zeichnen. Für ein Rechteck brauchst du dann eben 4 Vertices und 4 Indices. Für einen Würfel 8 Vertices und (von Problemen mit Texturkoordinaten abgesehen) pro Seite 6 (pro Dreieck 3), also 36 Indices.

Zitat

-> wie kann ich ein Surface zusätzlich darstellen
Zum Beispiel, indem du mit SDL_CreateRGBSurface eine neue Surface erstellst und in die renderst.
Siehe https://wiki.libsdl.org/SDL_CreateRGBSurface

Zitat

-> gibt es wo Tutorials dazu , die mir helfen (ohne JAVA !)

http://www.opengl-tutorial.org/beginners-tutorials/
http://www.opengl.org/wiki/Tutorial1:_Cr…in_SDL_(C_/_SDL)
http://qt-project.org/doc/qt-4.8/opengl-cube.html
http://www.google.com
EnvisionGame(); EnableGame(); AchieveGame(); - Visionen kann man viele haben. Sie umzusetzen und auf das Ergebnis stolz zu sein ist die eigentliche Kunst.

Patty1991

Frischling

  • »Patty1991« ist der Autor dieses Themas

Beiträge: 61

  • Private Nachricht senden

3

04.08.2014, 01:53

boa ! erstmal danke für soviel info

eine bitte noch: kannst du mir zeigen wie man 2 würfel darstellt ?

ich hab versucht 2 flächen darzustellen aber da passirt nichts,
wenn ich die multi array verändere ,wird das nur komisch gefaltet

das ganze ist für mich ehr Origami statt OpenGL :D

hier mein versuch:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

static void Render()
{
    static GLubyte color[8][4] =
    {
    {0, 0, 255, 0},
    {2, 0, 0, 255},
    {0, 255, 0, 255},
    {0, 255, 0, 255},
    {0, 255, 0, 255},
    {255, 255, 255, 255},
    {255, 0, 255, 255},
    {0, 0, 255, 255},
    };
   
   
   static GLfloat trangleVecties[8][4]  =
   {
    {0.5f, 0.5f, -0.5f},
    {0.5f, -0.5f, -0.5f},
    {0.0f, -0.5f, -0.5f},
    {-0.5f, 0.5f, 0.0f},
    {-0.5f, 0.5f, 0.5f},
    };
   
   
   static GLfloat trangleVecties2[8][4]  =
   {
    {0.5f, 0.5f, -0.5f},
    {0.5f, -0.5f, -0.5f},
    {0.0f, -0.5f, -0.5f},
    {-0.5f, 0.5f, 0.0f},
    {-0.5f, 0.5f, 0.5f},
    };
    static GLubyte indices[36] =
   
      {  
        0, 1, 2,
        2, 3, 0
      };
   
   static GLubyte indices2[36] =
      {  
        5, 4, 7,
        7, 6, 5,
      };
        
    /* Do our drawing, too. */
    glClearColor(0.0, 0.0, 0.0, 0.5);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    /* Draw the cube */
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, color);
    glEnableClientState(GL_COLOR_ARRAY);
   
    glVertexPointer(3, GL_FLOAT, 0, trangleVectiles);
    glEnableClientState(GL_VERTEX_ARRAY);
    glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, indices);
  
    glVertexPointer(3, GL_FLOAT, 0, trangleVectiles2);     
    glEnableClientState(GL_VERTEX_ARRAY);  
    glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, indices2);
 
    glMatrixMode(GL_MODELVIEW);
    glRotatef(1.0, 0.0, 1.0, 0.0);
}

iSmokiieZz

Treue Seele

Beiträge: 364

  • Private Nachricht senden

4

04.08.2014, 02:18

Eine Fläche setzt sich aus zwei Dreiecken zusammen. Ein Würfel hat 6 Seiten, also brauchst du 12 Dreiecke. Pro Dreieck 3 Indizes machen 36 Indices. Dein Index Array ist doch schon 36 Indices groß. Wozu dann ein weiteres? Warum nutzt du das Array nicht einfach, um alle 12 Dreiecke für den Würfel zu definieren? Im Moment hast du nur 4 Dreiecke und somit nur zwei Flächen. Die restlichen 4 Seiten wirst du auch noch schaffen ;)

Die vertices geben die Position der eckpunkte an und verzerren somit auch den "Körper". Wenn der nur aus zwei Flächen besteht ist es logisch, dass sich diese "falten".


Du solltest dir wirklich die Grundlagen erstmal aneignen. Das nützt sonst garnichts hier.
David hat ein gutes Buch geschrieben, in dem ein Großteil an Grundlagen übermittelt wird, wenn auch der Rest mit directx Zutun hat. Auch im Microsoft press Verlag gab es mal ein Buch, indem auch die Grundlagen verständlich dargeboten wurden. Ich bin mir sicher, du wirst sowas auch für opengl, vielleicht sogar gezielt für mobile Endgerät finden.
EnvisionGame(); EnableGame(); AchieveGame(); - Visionen kann man viele haben. Sie umzusetzen und auf das Ergebnis stolz zu sein ist die eigentliche Kunst.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »iSmokiieZz« (04.08.2014, 02:23)

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

5

04.08.2014, 07:13

Zitat von »iSmokiieZz«

David hat ein gutes Buch geschrieben, in dem ein Großteil an Grundlagen übermittelt wird, wenn auch der Rest mit directx Zutun hat.
Jein. Davids Buch richtet sich an Einsteiger in der Spiele-Entwicklung. Allerdings nicht an Programmier-Einsteiger. Wollte das nur nochmal klar stellen.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

Werbeanzeige

Ähnliche Themen