3D und 2D Darstellung zugleich...WIE ???

[pseudopat]

Guten Tag,

ich möchte folgendes machen:

Ein Button den ich anklicken kann und in einen 3D Fester soll dann z.b. ein würfel erscheinen und sich drehen
aber da beisst sich die Katze irgendwie in Schwanz...

schon seit sehr langen suche ich eine Möglichkeit recht "einfach"
Apps zu entwickeln.
Das problem dabei ist folgendes:

-Will ich eine 2D App entwickeln benötige ich SDL2
-Will ich eine 3D App entwickeln benötige ich OpenGL ES

OpenGL ES ist jedoch sehr kompliziet und kann KEIN 2D darstellen.
(Doch! dafür muss das Surface vorher irgendwie als eine Textur convertiert werden)

- OpenGL ES ist nicht vergleichbar mit OpenGL

-Auch funktionieren geschichten wie GLUT nicht ! heisst:
will man z.b. eine 3D Kamera schreiben,so muss man die ganze Matrix bewegen und son quatsch
-x,y,z werden als Float-Transformation und Rotation bezeichnet (0.5f,0.0f,0.1f)
-es gibt auch kein Object Loader ..
-jede OpenGL ES version funtioniert wiederum anders als die davor


alles muss selbst geschrieben werden und exampels aus dem Netz funkionierten meist auch nicht
da sie nur als endloslange klassen und verkettungen dargestellt beschrieben werden (wie in Java)

ich bekomm nen klos im hals wenn ich daran schon Denke und das sehe...

ich bin nicht Dumm aber das hier ist ne ganz andere Hausnummer als wie ich progrmmieren
gelernt habe.

Meiner meinung nach muss/sollte ein programmierer nicht noch die komplette Graffik-darstellung
und 3D Umgebung programmieren müssen... wofür gibst denn so sachen wie SDL2,OpenGL, graffik libs ect...



--------------------------------

Gibt es alternativen hierzu ?

Ich habe viel mit 3D Gamestudio für Pc gearbeitet, leider hat GameStudio von Hause aus kein
Android Support wesswegen ich mich hiermit befasse

eigendlich dürfte es meiner meinung nach keine 3D Spiele für Android geben,so kompliziert wie der ganze Kack ist
ich bin echt sauer dass ich seid mehreren jahren nicht mehr weiter komme ... ich habs ehrlich gesagt aufgegeben !

HILFE !

 

[Kardroid]

Hallo pseudopat,

was genau möchtest du denn machen? Möchtest du ein Spiel programmieren oder eine App? Was wäre denn mit WebGL? Vielleicht kannst du dein 3D auch in JavaScript erstellen und es über ne WebView ausgeben lassen? three.js - Javascript 3D library
Auf einem Handy ist die Performance natürlich nicht ganz so gut...

 

[keen]

Helfen nicht Game-Engines wie zb Unity bei genau solchen Problemen?

 

[pseudopat]

ich benutze den C4Droid Compiler für Android. Die Codes laufen (copy,paste and run)

Probleme habe ich mit der Surface function in OpenGL ES:

So wird ein Bild dargestellt in SDL2:

...
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
...

int main( int argc, char *argv[] )
{
 SDL_Surface *imageSurface = NULL;
 SDL_Surface *windowSurface = NULL;


 if ( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
 {
  std::cout << "SDL could not initialize! SDL Error: " << SDL_GetError( ) << std::endl;
 }

 SDL_Window *window = SDL_CreateWindow( "SDL2", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WIDTH, HEIGHT, SDL_WINDOW_ALLOW_HIGHDPI );
windowSurface = SDL_GetWindowSurface( window );

if ( NULL == window )
 {
  std::cout << "Could not create window: " << SDL_GetError( ) << std::endl;
  return EXIT_FAILURE;
 }

 SDL_Event windowEvent;

 imageSurface = SDL_LoadBMP( "hello_world.bmp" );


 while ( true )
 {
  if ( SDL_PollEvent( &windowEvent ) )
  {
   if ( SDL_QUIT == windowEvent.type )
   {
    break;
   }
  }

 SDL_BlitSurface( imageSurface, NULL, windowSurface, NULL );

//Update the surface
SDL_UpdateWindowSurface( window );

}
SDL_FreeSurface( imageSurface );
SDL_FreeSurface( windowSurface );

imageSurface = NULL;
windowSurface = NULL;

SDL_DestroyWindow( window );

SDL_Quit( );
return EXIT_SUCCESS;
}

und so wird OpenGL ES dargestellt -> ein 5x5x5 Voxel ..+ versuchter Camera

#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);
}
// camera code
double  DegToRad(double angleDeg)
{
 return (M_PI * angleDeg / 180.0);
}
struct index
{
  float orientation[2];
  float position[2];
};
float linearSpeed = 0.5f;
void SetCamera()
{
   struct index CameraX;
  //  float linearSpeed = 0.5f;
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
              glRotatef(CameraX.orientation[0], 1,0,0);
              glRotatef(CameraX.orientation[1], 0,1,0);
              glRotatef(CameraX.orientation[2], 0,0,1);
              glTranslatef(-CameraX.position[0],-CameraX.position[1],CameraX.position[2]);
}
/*
   void checkKeyPresses() {
   if (GetAsyncKeyState(VK_LEFT) ) { CAMERA_X.position[0] +=
   sin(DEGTORAD(CAMERA_X.orientation[1]-90)) * linearSpeed;
   CAMERA_X.position[2] += cos(DEGTORAD(CAMERA_X.orientation[1]-90)) *
   linearSpeed; }
   if (GetAsyncKeyState(VK_RIGHT)) { CAMERA_X.position[0] +=
   sin(DEGTORAD(CAMERA_X.orientation[1]+90)) * linearSpeed;
   CAMERA_X.position[2] += cos(DEGTORAD(CAMERA_X.orientation[1]+90)) *
   linearSpeed; }
   if (GetAsyncKeyState(VK_UP)) { CAMERA_X.position[0] +=
   sin(DEGTORAD(CAMERA_X.orientation[1])) * linearSpeed; CAMERA_X.position[2]
   += cos(DEGTORAD(CAMERA_X.orientation[1])) * linearSpeed; }
   if (GetAsyncKeyState(VK_DOWN) ) { CAMERA_X.position[0] -=
   sin(DEGTORAD(CAMERA_X.orientation[1])) * linearSpeed; CAMERA_X.position[2]
   -= cos(DEGTORAD(CAMERA_X.orientation[1])) * linearSpeed; }
   if (GetAsyncKeyState(VK_INSERT)) { linearSpeed += .1; angularSpeed += .1; }
ß
   if (GetAsyncKeyState(VK_DELETE)) { if (!(linearSpeed < 0)) linearSpeed -=
     .1; if (!(angularSpeed < 0)) angularSpeed -= .1; } }
*/
static void cube()
{
   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.125, 0.125, -0.125},
       {0.125f, -0.125f, -0.125f},
       {-0.125f, -0.125f, -0.125f},
       {-0.125f, 0.125f, -0.125f},
       {-0.125f, 0.125f, 0.125f},
       {0.125f, 0.125f, 0.125f},
       {0.125f, -0.125f, 0.125f},
       {-0.125f, -0.125f, 0.125f}
   };
   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
   };
   // glRotatef(27.0f,1.0f,1.0f,1.0f);
   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);
}
int chunk_x = 15;
int chunk_y = 15;
int chunk_z = 15;
float B_SIZE = 0.25f;
void Render(Uint32 time)
{
   glClearColor(0.0, 0.0, 0.0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   // glTranslatef(cam_x*0.05f,cam_y*0.05f,cam_z*0.06f);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   int i, j, k;
   for (i = 0; i < chunk_x; i++)
   {
       for (j = 0; j < chunk_y; j++)
       {
           for (k = 0; k < chunk_z; k++)
           {
               glPushMatrix();
               glTranslatef(j * B_SIZE, i * B_SIZE, k * B_SIZE);
               cube();
               glPopMatrix();
           }
       }
   }
   SetCamera();
}
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);
   // 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);
       struct index CameraX;
   // rotation
    CameraX.orientation[0] = 4.0f; // angle -x
    CameraX.orientation[1] = 3.0f; // angle y
    CameraX.orientation[2] = 2.0f; // angle-z
   // translation
    CameraX.position[0] = -2.5f; // x  - left/right
    CameraX.position[1] = -2.5f; // y  - font/back
    CameraX.position[2] = 2.5f; // z  - up/down
    float linearSpeed = 0.5f;
   /* Main render loop */
   frames = 0;
   then = SDL_GetTicks();
   done = 0;
   int i;
   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_MOUSEBUTTONDOWN:
               {
               //   cam_rot--;
               CameraX.position[0] += sin(DegToRad(CameraX.orientation[1]-90)) * linearSpeed;
                        CameraX.position[2] += cos(DegToRad(CameraX.orientation[1]-90)) * linearSpeed;
               }
               break;
           case SDL_MOUSEBUTTONUP:
               {
                   //cam_rot = 0.1f;
               }
               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_GetTicks());
                   SDL_GL_SwapWindow(window);
                   break;
               }
           }
       }
       Render(SDL_GetTicks());
       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;
}

und ich versuche die ganze zeit nix anderes als dass ich ein bild in OpenGL ES darstellen kann

-> am besten wie bei SDL_IMAGE ..
aber es will nicht functionieren
[doublepost=1517995008,1517991537][/doublepost]Ich schaue mir gerade tutorials an über Unity.. joa.. sieht sehr nach gamestudio aus

 

[swa00]

Hallo Pseudo,

ich denke , dass Dein Ansatz nicht mehr so ganz aktuell ist.
OpenGL solltest du auch mit einem aktuellen Tool umsetzen - also in dem Falle AndroidStudio 3.x -
und einen SurfaceView benutzen.

Und eine entsprechende Vorgehensweise gibt es in der API-Dokumentation
Displaying Graphics with OpenGL ES | Android Developers
OpenGL ES | Android Developers

P.S Unity ist ein Baukasten und schränkt das Native ein.

 

[pseudopat]

ich glaube ich hab was
OpenGL - Textures
https://open.gl/content/code/c3_multitexture.txt

ach..f* ist wieder nur GL nicht GL ES

 

[swa00]

Und wo ist in beiden Beispielen der SurfaceView ?

Beide Beipiele zeigen das ganz normale Desktop Rendering, nicht unter Android

 

[pseudopat]

meinst du das ?

 imageSurface = SDL_LoadBMP( "hello_world.bmp" );
...
 SDL_BlitSurface( imageSurface, NULL, windowSurface, NULL );
...
 SDL_FreeSurface( imageSurface );

wie gesagt - ich gibs auf , das geht nicht in opengl es :/


und die "how to make" tutorials da kann ich nix mit anfangen weil das so komisch verkettet ist -> function (GL10 gl.ka.was.punkt.verkettung ...und.nochmehr) und dann tuts das nicht

weis der geier wie...

 

[swa00]

und die "how to make" tutorials da kann ich nix mit anfangen weil das so komisch verkettet ist -> function (GL10 gl.ka.was.punkt.verkettung ...und.nochmehr) und dann tuts das nicht

Und das ist genau der Punkt und ich hatte es schon vermutet.

Du wirst nicht drumrum kommen, das Programmieren von Java unter Android zu erlernen

ODER

dich auf Unity zu stürzen - damit wird Dir die Programmierarbeit abgenommen.

Du hast jetzt seit mehreren Tagen versucht, eine Desktoptechnik auf Android umzusetzen
das konnte nicht klappen

 

[pseudopat]

HAB DA WAS GEFUNDEN !

Drawing 2D Sprite Using OpenGl with SDL - GaanZa

jetzt mal schauen wie und ob ich es in OpenGL ES umsetzen kann
sieht viel versprechend aus

scheint wohl als hätten mehrere Leute Probleme damit.

ich will ja nicht auf das neuste Pferd setzen was die programmiersprache angeht, sondern es geht mir in erster
linie darum, OB es möglich ist so auf Android zu Programmieren wie auf PC
und JA das geht anscheind doch

mit dem C4Droid Compiler und SDL2 habe ich schon ein Komplettes 2D-Space Shooter Spiel geschrieben
welches mit Touch Score,Lives, Musik , ton und scroll_screen funktioniert (voll geil)

dann wollte ich wissen ob man mit SDL2 auch 3D darstellen kann - JOP !

es wunderte mich nur, weil SDL2 eine OPENGL ES schnittstelle besitzt ohne wirkliche
examples -> den Cube Code hat mit mal Irgendwer so umgestellt wie oben angegeben (der wat auch erst so verdreht programmiert)