spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

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

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

static SDL_Window *window;
static SDL_GLContext context;
int move_me;

float posX = 0, posY = 0;
float rotX = 0,  rotY = 0;


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);
}

// sphere function - from google search (copy-paste)
void renderSphere(float cx, float cy, float cz, float r, int p)
{
    float theta1 = 0.0, theta2 = 0.0, theta3 = 0.0;
    float ex = 0.0f, ey = 0.0f, ez = 0.0f;
    float px = 0.0f, py = 0.0f, pz = 0.0f;
    GLfloat vertices[p*6+6], normals[p*6+6], texCoords[p*4+4];
    
    if( r < 0 )
        r = -r;
    
    if( p < 0 )
        p = -p;
    
    for(int i = 0; i < p/2; ++i)
    {
        theta1 = i * (M_PI*2) / p - M_PI_2;
        theta2 = (i + 1) * (M_PI*2) / p - M_PI_2;
        
        for(int j = 0; j <= p; ++j)
        {
            theta3 = j * (M_PI*2) / p;
            
            ex = cosf(theta2) * cosf(theta3);
            ey = sinf(theta2);
            ez = cosf(theta2) * sinf(theta3);
            px = cx + r * ex;
            py = cy + r * ey;
            pz = cz + r * ez;
            
            vertices[(6*j)+(0%6)] = px;
            vertices[(6*j)+(1%6)] = py;
            vertices[(6*j)+(2%6)] = pz;
            
            normals[(6*j)+(0%6)] = ex;
            normals[(6*j)+(1%6)] = ey;
            normals[(6*j)+(2%6)] = ez;
            
            texCoords[(4*j)+(0%4)] = -(j/(float)p);
            texCoords[(4*j)+(1%4)] = 2*(i+1)/(float)p;
            
            
            ex = cosf(theta1) * cosf(theta3);
            ey = sinf(theta1);
            ez = cosf(theta1) * sinf(theta3);
            px = cx + r * ex;
            py = cy + r * ey;
            pz = cz + r * ez;
            
            vertices[(6*j)+(3%6)] = px;
            vertices[(6*j)+(4%6)] = py;
            vertices[(6*j)+(5%6)] = pz;
            
            normals[(6*j)+(3%6)] = ex;
            normals[(6*j)+(4%6)] = ey;
            normals[(6*j)+(5%6)] = ez;
            
            texCoords[(4*j)+(2%4)] = -(j/(float)p);
            texCoords[(4*j)+(3%4)] = 2*i/(float)p;
        }
        glVertexPointer(3, GL_FLOAT, 0, vertices);
        glNormalPointer(GL_FLOAT, 0, normals);
        glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, (p+1)*2);
    }
}

static void Render()
{
    static GLubyte color[] = {
    120, 120, 120, 0,
    };

    /* Do our drawing, too. */
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glColorPointer(4, GL_UNSIGNED_BYTE, 0, color);
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    
    // draw the sphere
    renderSphere(0.0f, 0.0f, 0.0f, 0.5f, 50);

    glMatrixMode(GL_MODELVIEW);
    glRotatef(rotX, -0.5 ,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)
    {                   
        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);
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);

    // 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);

     bool run = true;
                
         
    while (run)
    {
        /* Check for events */
        while (SDL_PollEvent(&event))
        {   
        /*
         if (event.type == SDL_MOUSEMOTION)
          {
           posX  = event.motion.x ;
          }
       */           
        switch (event.type)
          {
           case SDL_QUIT:
           run = false;
           break;
            
            // touch the screen , rotate the object
              case SDL_MOUSEBUTTONDOWN: 
            {
                rotX = 0.5;
              }
              break;
       
             case SDL_MOUSEBUTTONUP: 
             {
              rotX = 0;
             }  
            break;
           //--------------------------------------
           
            case SDL_KEYDOWN:  // exit
             if (event.key.keysym.scancode == SDL_SCANCODE_AC_BACK)
             {
              done = false;
             }
            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;
                }
            }
        }
        
        // Main loop    
            
        Render();

        SDL_RenderPresent(renderer);
        SDL_GL_SwapWindow(window);
    }


    SDL_GL_DeleteContext(context);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

C-/C++-Quelltext

/*
 if (event.type == SDL_MOUSEMOTION)
 {
  posX  = event.motion.x ;
  }
*/

C-/C++-Quelltext

    //glColorPointer(4, GL_UNSIGNED_BYTE, 0, color);
    //glEnableClientState(GL_COLOR_ARRAY);