pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added egl headers so we can use eglMakeCurrent()

Browse source
This commit is contained in:
Paul Hunkin 2010-06-18 01:28:39 +12:00
parent c67e5f7bcb
commit d4cfca1cdb
6 changed files with 1108 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

8
android/testproject/jni/Android.mk
View file

@ -4,13 +4,17 @@ include $(CLEAR_VARS)
LOCAL_MODULE := sanangeles
SDL := /home/paul/Projects/gsoc/SDL-gsoc2010_android/
LOCAL_CFLAGS := -DANDROID_NDK \
-DDISABLE_IMPORTGL
-DDISABLE_IMPORTGL \
-I$(SDL)/include
LOCAL_SRC_FILES := \
importgl.c \
app-android.c \
lesson05.c \
LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog
LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lSDL -lEGL -lgcc -L$(SDL) -L$(SDL)/build-scripts/android_libs/
include $(BUILD_SHARED_LIBRARY)

40
android/testproject/jni/app-android.c
View file

@ -14,6 +14,7 @@
#include <pthread.h>
#include "importgl.h"
#include "egl.h"
/*******************************************************************************
Globals
@ -31,7 +32,17 @@ static long _getTime(void){
}
/*******************************************************************************
Things used by libsdl
*******************************************************************************/
pthread_mutex_t mSDLRenderMutex;
pthread_cond_t mSDLRenderCondition;
EGLContext mContext;
EGLDisplay mDisplay;
EGLSurface mRead;
EGLSurface mDraw;
/*******************************************************************************
SDL thread
*******************************************************************************/
@ -39,7 +50,13 @@ pthread_t mSDLThread = 0;
void* sdlThreadProc(void* args){
__android_log_print(ANDROID_LOG_INFO, "SDL", "Thread Entry");
return 0;
if(!eglMakeCurrent(mDisplay, mDraw, mRead, mContext)){
__android_log_print(ANDROID_LOG_INFO, "SDL", "Couldn't make current: 0x%x", eglGetError());
return NULL;
}
return (void *)SDL_main();
}
/*******************************************************************************
@ -54,6 +71,21 @@ void Java_org_libsdl_android_TestRenderer_nativeInit( JNIEnv* env )
__android_log_print(ANDROID_LOG_INFO, "SDL", "Entry point");
pthread_mutex_init(&mSDLRenderMutex, NULL);
pthread_cond_init (&mSDLRenderCondition, NULL);
//Get some egl stuff we need
mContext = eglGetCurrentContext();
mDisplay = eglGetCurrentDisplay();
mRead = eglGetCurrentSurface(EGL_READ);
mDraw = eglGetCurrentSurface(EGL_DRAW);
//We need to abandon our context so SDL can have it
if(!eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)){
__android_log_print(ANDROID_LOG_INFO, "SDL", "Couldn't abandon context: 0x%x", eglGetError());
return NULL;
}
//Spin up the SDL thread
int r = pthread_create(&mSDLThread, NULL, sdlThreadProc, NULL);
@ -115,4 +147,10 @@ void Java_org_libsdl_android_TestRenderer_nativeRender( JNIEnv* env )
{
//TODO: Render here
pthread_mutex_lock(&mSDLRenderMutex);
pthread_cond_signal(&mSDLRenderCondition); //wake up the SDL thread
pthread_mutex_unlock(&mSDLRenderMutex);
//__android_log_print(ANDROID_LOG_INFO, "SDL", "Unlocked");
}

269
android/testproject/jni/egl.h Normal file
View file

@ -0,0 +1,269 @@
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_EGL_H
#define ANDROID_EGL_H
#include <GLES/gl.h>
#include <egltypes.h>
#include <eglnatives.h>
#ifdef __cplusplus
extern "C" {
#endif
#define EGL_VERSION_1_0 1
#define EGL_VERSION_1_1 1
#define EGL_VERSION_1_2 1
#define EGL_FALSE 0
#define EGL_TRUE 1
/* Errors */
#define EGL_SUCCESS 0x3000
#define EGL_NOT_INITIALIZED 0x3001
#define EGL_BAD_ACCESS 0x3002
#define EGL_BAD_ALLOC 0x3003
#define EGL_BAD_ATTRIBUTE 0x3004
#define EGL_BAD_CONFIG 0x3005
#define EGL_BAD_CONTEXT 0x3006
#define EGL_BAD_CURRENT_SURFACE 0x3007
#define EGL_BAD_DISPLAY 0x3008
#define EGL_BAD_MATCH 0x3009
#define EGL_BAD_NATIVE_PIXMAP 0x300A
#define EGL_BAD_NATIVE_WINDOW 0x300B
#define EGL_BAD_PARAMETER 0x300C
#define EGL_BAD_SURFACE 0x300D
#define EGL_CONTEXT_LOST 0x300E
/* Config attributes */
#define EGL_BUFFER_SIZE 0x3020
#define EGL_ALPHA_SIZE 0x3021
#define EGL_BLUE_SIZE 0x3022
#define EGL_GREEN_SIZE 0x3023
#define EGL_RED_SIZE 0x3024
#define EGL_DEPTH_SIZE 0x3025
#define EGL_STENCIL_SIZE 0x3026
#define EGL_CONFIG_CAVEAT 0x3027
#define EGL_CONFIG_ID 0x3028
#define EGL_LEVEL 0x3029
#define EGL_MAX_PBUFFER_HEIGHT 0x302A
#define EGL_MAX_PBUFFER_PIXELS 0x302B
#define EGL_MAX_PBUFFER_WIDTH 0x302C
#define EGL_NATIVE_RENDERABLE 0x302D
#define EGL_NATIVE_VISUAL_ID 0x302E
#define EGL_NATIVE_VISUAL_TYPE 0x302F
#define EGL_SAMPLES 0x3031
#define EGL_SAMPLE_BUFFERS 0x3032
#define EGL_SURFACE_TYPE 0x3033
#define EGL_TRANSPARENT_TYPE 0x3034
#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
#define EGL_TRANSPARENT_RED_VALUE 0x3037
#define EGL_NONE 0x3038
#define EGL_BIND_TO_TEXTURE_RGB 0x3039
#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
#define EGL_MIN_SWAP_INTERVAL 0x303B
#define EGL_MAX_SWAP_INTERVAL 0x303C
#define EGL_LUMINANCE_SIZE 0x303D
#define EGL_ALPHA_MASK_SIZE 0x303E
#define EGL_COLOR_BUFFER_TYPE 0x303F
#define EGL_RENDERABLE_TYPE 0x3040
/* Config values */
#define EGL_DONT_CARE ((EGLint)-1)
#define EGL_SLOW_CONFIG 0x3050
#define EGL_NON_CONFORMANT_CONFIG 0x3051
#define EGL_TRANSPARENT_RGB 0x3052
#define EGL_NO_TEXTURE 0x305C
#define EGL_TEXTURE_RGB 0x305D
#define EGL_TEXTURE_RGBA 0x305E
#define EGL_TEXTURE_2D 0x305F
#define EGL_RGB_BUFFER 0x308E
#define EGL_LUMINANCE_BUFFER 0x308F
/* Config attribute mask bits */
#define EGL_PBUFFER_BIT 0x01
#define EGL_PIXMAP_BIT 0x02
#define EGL_WINDOW_BIT 0x04
#define EGL_OPENGL_ES_BIT 0x01
#define EGL_OPENVG_BIT 0x02
/* String names */
#define EGL_VENDOR 0x3053
#define EGL_VERSION 0x3054
#define EGL_EXTENSIONS 0x3055
#define EGL_CLIENT_APIS 0x308D
/* Surface attributes */
#define EGL_HEIGHT 0x3056
#define EGL_WIDTH 0x3057
#define EGL_LARGEST_PBUFFER 0x3058
#define EGL_TEXTURE_FORMAT 0x3080
#define EGL_TEXTURE_TARGET 0x3081
#define EGL_MIPMAP_TEXTURE 0x3082
#define EGL_MIPMAP_LEVEL 0x3083
#define EGL_RENDER_BUFFER 0x3086
#define EGL_COLORSPACE 0x3087
#define EGL_ALPHA_FORMAT 0x3088
#define EGL_HORIZONTAL_RESOLUTION 0x3090
#define EGL_VERTICAL_RESOLUTION 0x3091
#define EGL_PIXEL_ASPECT_RATIO 0x3092
#define EGL_SWAP_BEHAVIOR 0x3093
#define EGL_BACK_BUFFER 0x3084
#define EGL_SINGLE_BUFFER 0x3085
#define EGL_DISPLAY_SCALING 10000
#define EGL_UNKNOWN ((EGLint)-1)
/* Back buffer swap behaviors */
#define EGL_BUFFER_PRESERVED 0x3094
#define EGL_BUFFER_DESTROYED 0x3095
/* CreatePbufferFromClientBuffer buffer types */
#define EGL_OPENVG_IMAGE 0x3096
/* QueryContext targets */
#define EGL_CONTEXT_CLIENT_TYPE 0x3097
/* BindAPI/QueryAPI targets */
#define EGL_OPENGL_ES_API 0x30A0
#define EGL_OPENVG_API 0x30A1
/* WaitNative engines */
#define EGL_CORE_NATIVE_ENGINE 0x305B
/* Current surfaces */
#define EGL_DRAW 0x3059
#define EGL_READ 0x305A
EGLDisplay eglGetDisplay(NativeDisplayType display);
EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLBoolean eglTerminate(EGLDisplay dpy);
EGLBoolean eglGetConfigs( EGLDisplay dpy,
EGLConfig *configs,
EGLint config_size, EGLint *num_config);
EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
EGLConfig *configs, EGLint config_size,
EGLint *num_config);
EGLBoolean eglGetConfigAttrib( EGLDisplay dpy, EGLConfig config,
EGLint attribute, EGLint *value);
EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
NativeWindowType window,
const EGLint *attrib_list);
EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config,
NativePixmapType pixmap,
const EGLint *attrib_list);
EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
const EGLint *attrib_list);
EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface surface,
EGLint attribute, EGLint *value);
EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,
EGLContext share_list, const EGLint *attrib_list);
EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
EGLSurface read, EGLContext ctx);
EGLContext eglGetCurrentContext(void);
EGLSurface eglGetCurrentSurface(EGLint readdraw);
EGLDisplay eglGetCurrentDisplay(void);
EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx,
EGLint attribute, EGLint *value);
EGLBoolean eglWaitGL(void);
EGLBoolean eglWaitNative(EGLint engine);
EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw);
EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface,
NativePixmapType target);
EGLint eglGetError(void);
const char* eglQueryString(EGLDisplay dpy, EGLint name);
void (*eglGetProcAddress (const char *procname))();
/* ----------------------------------------------------------------------------
* EGL 1.1
* ----------------------------------------------------------------------------
*/
EGLBoolean eglSurfaceAttrib(
EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLBoolean eglBindTexImage(
EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean eglReleaseTexImage(
EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval);
/* ----------------------------------------------------------------------------
* EGL 1.2
* ----------------------------------------------------------------------------
*/
EGLBoolean eglBindAPI(EGLenum api);
EGLenum eglQueryAPI(void);
EGLBoolean eglWaitClient(void);
EGLBoolean eglReleaseThread(void);
EGLSurface eglCreatePbufferFromClientBuffer(
EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
EGLConfig config, const EGLint *attrib_list);
/* ----------------------------------------------------------------------------
* Android extentions
* ----------------------------------------------------------------------------
*/
EGLBoolean eglSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw,
EGLint l, EGLint t, EGLint w, EGLint h);
EGLBoolean eglCopyFrontToBackANDROID(EGLDisplay dpy,
EGLSurface surface,
EGLint l, EGLint t, EGLint w, EGLint h);
const char* eglQueryStringConfigANDROID(
EGLDisplay dpy, EGLConfig config, EGLint name);
void* eglGetRenderBufferAddressANDROID(EGLDisplay dpy, EGLSurface surface);
EGLBoolean eglCopyBitsANDROID(EGLDisplay dpy,
NativeWindowType draw, EGLint x, EGLint y,
NativeWindowType read,
EGLint crop_x, EGLint crop_y, EGLint crop_w, EGLint crop_h,
EGLint flags);
#ifdef __cplusplus
}
#endif
#endif /*ANDROID_EGL_H*/

277
android/testproject/jni/eglnatives.h Normal file
View file

@ -0,0 +1,277 @@
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_EGLNATIVES_H
#define ANDROID_EGLNATIVES_H
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
/*****************************************************************************/
struct egl_native_window_t;
struct egl_native_pixmap_t;
typedef struct egl_native_window_t* NativeWindowType;
typedef struct egl_native_pixmap_t* NativePixmapType;
typedef void* NativeDisplayType;
/*
* This a conveniance function to create a NativeWindowType surface
* that maps to the whole screen
* This function is actually implemented in libui.so
*/
NativeWindowType android_createDisplaySurface();
/* flags returned from swapBuffer */
#define EGL_NATIVES_FLAG_SIZE_CHANGED 0x00000001
/* surface flags */
#define EGL_NATIVES_FLAG_DESTROY_BACKBUFFER 0x00000001
enum native_pixel_format_t
{
NATIVE_PIXEL_FORMAT_RGBA_8888 = 1,
NATIVE_PIXEL_FORMAT_RGB_565 = 4,
NATIVE_PIXEL_FORMAT_RGBA_5551 = 6,
NATIVE_PIXEL_FORMAT_RGBA_4444 = 7,
NATIVE_PIXEL_FORMAT_YCbCr_422_SP= 0x10,
NATIVE_PIXEL_FORMAT_YCbCr_420_SP= 0x11,
};
enum native_memory_type_t
{
NATIVE_MEMORY_TYPE_PMEM = 0,
NATIVE_MEMORY_TYPE_GPU = 1,
NATIVE_MEMORY_TYPE_FB = 2,
NATIVE_MEMORY_TYPE_HEAP = 128
};
struct egl_native_window_t
{
/*
* magic must be set to 0x600913
*/
uint32_t magic;
/*
* must be sizeof(egl_native_window_t)
*/
uint32_t version;
/*
* ident is reserved for the Android platform
*/
uint32_t ident;
/*
* width, height and stride of the window in pixels
* Any of these value can be nul in which case GL commands are
* accepted and processed as usual, but not rendering occurs.
*/
int width; // w=h=0 is legal
int height;
int stride;
/*
* format of the native window (see ui/PixelFormat.h)
*/
int format;
/*
* Offset of the bits in the VRAM
*/
intptr_t offset;
/*
* flags describing some attributes of this surface
* EGL_NATIVES_FLAG_DESTROY_BACKBUFFER: backbuffer not preserved after
* eglSwapBuffers
*/
uint32_t flags;
/*
* horizontal and vertical resolution in DPI
*/
float xdpi;
float ydpi;
/*
* refresh rate in frames per second (Hz)
*/
float fps;
/*
* Base memory virtual address of the surface in the CPU side
*/
intptr_t base;
/*
* Heap the offset above is based from
*/
int fd;
/*
* Memory type the surface resides into
*/
uint8_t memory_type;
/*
* Reserved for future use. MUST BE ZERO.
*/
uint8_t reserved_pad[3];
int reserved[8];
/*
* Vertical stride (only relevant with planar formats)
*/
int vstride;
/*
* Hook called by EGL to hold a reference on this structure
*/
void (*incRef)(NativeWindowType window);
/*
* Hook called by EGL to release a reference on this structure
*/
void (*decRef)(NativeWindowType window);
/*
* Hook called by EGL to perform a page flip. This function
* may update the size attributes above, in which case it returns
* the EGL_NATIVES_FLAG_SIZE_CHANGED bit set.
*/
uint32_t (*swapBuffers)(NativeWindowType window);
/*
* Hook called by EGL to set the swap rectangle. this hook can be
* null (operation not supported)
*/
void (*setSwapRectangle)(NativeWindowType window, int l, int t, int w, int h);
/*
* Reserved for future use. MUST BE ZERO.
*/
void (*reserved_proc_0)(void);
/*
* Hook called by EGL to retrieve the next buffer to render into.
* This call updates this structure.
*/
uint32_t (*nextBuffer)(NativeWindowType window);
/*
* Hook called by EGL when the native surface is associated to EGL
* (eglCreateWindowSurface). Can be NULL.
*/
void (*connect)(NativeWindowType window);
/*
* Hook called by EGL when eglDestroySurface is called. Can be NULL.
*/
void (*disconnect)(NativeWindowType window);
/*
* Reserved for future use. MUST BE ZERO.
*/
void (*reserved_proc[11])(void);
/*
* Some storage reserved for the oem driver.
*/
intptr_t oem[4];
};
struct egl_native_pixmap_t
{
int32_t version; /* must be 32 */
int32_t width;
int32_t height;
int32_t stride;
uint8_t* data;
uint8_t format;
uint8_t rfu[3];
union {
uint32_t compressedFormat;
int32_t vstride;
};
int32_t reserved;
};
/*****************************************************************************/
/*
* OEM's egl's library (libhgl.so) must imlement these hooks to allocate
* the GPU memory they need
*/
typedef struct
{
// for internal use
void* user;
// virtual address of this area
void* base;
// size of this area in bytes
size_t size;
// physical address of this area
void* phys;
// offset in this area available to the GPU
size_t offset;
// fd of this area
int fd;
} gpu_area_t;
typedef struct
{
// area where GPU registers are mapped
gpu_area_t regs;
// number of extra areas (currently limited to 2)
int32_t count;
// extra GPU areas (currently limited to 2)
gpu_area_t gpu[2];
} request_gpu_t;
typedef request_gpu_t* (*OEM_EGL_acquire_gpu_t)(void* user);
typedef int (*OEM_EGL_release_gpu_t)(void* user, request_gpu_t* handle);
typedef void (*register_gpu_t)
(void* user, OEM_EGL_acquire_gpu_t, OEM_EGL_release_gpu_t);
void oem_register_gpu(
void* user,
OEM_EGL_acquire_gpu_t acquire,
OEM_EGL_release_gpu_t release);
/*****************************************************************************/
#ifdef __cplusplus
}
#endif
#endif /* ANDROID_EGLNATIVES_H */

48
android/testproject/jni/egltypes.h Normal file
View file

@ -0,0 +1,48 @@
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_EGL_TYPES_H
#define ANDROID_EGL_TYPES_H
#include <sys/types.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef unsigned int EGLBoolean;
typedef int32_t EGLint;
typedef int EGLenum;
typedef void *EGLDisplay;
typedef void *EGLConfig;
typedef void *EGLSurface;
typedef void *EGLContext;
typedef void *EGLClientBuffer;
#define EGL_DEFAULT_DISPLAY ((NativeDisplayType)0)
#define EGL_NO_CONTEXT ((EGLContext)0)
#define EGL_NO_DISPLAY ((EGLDisplay)0)
#define EGL_NO_SURFACE ((EGLSurface)0)
#ifdef __cplusplus
}
#endif
#endif /* ANDROID_EGL_TYPES_H */

469
android/testproject/jni/lesson05.c Normal file
View file

@ -0,0 +1,469 @@
/*
* This code was created by Jeff Molofee '99
* (ported to Linux/SDL by Ti Leggett '01)
*
* If you've found this code useful, please let me know.
*
* Visit Jeff at http://nehe.gamedev.net/
*
* or for port-specific comments, questions, bugreports etc.
* email to leggett@eecs.tulane.edu
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <android/log.h>
#ifdef ANDROID
#include <GLES/gl.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#include "SDL.h"
/* screen width, height, and bit depth */
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 480
#define SCREEN_BPP 16
/* Define our booleans */
#define TRUE 1
#define FALSE 0
/* This is our SDL surface */
SDL_Surface *surface;
/**************************************
gluperspective implementation
**************************************/
void gluPerspective(double fovy, double aspect, double zNear, double zFar){
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
double xmin, xmax, ymin, ymax;
ymax = zNear * tan(fovy * M_PI / 360.0);
ymin = -ymax;
xmin = ymin * aspect;
xmax = ymax * aspect;
glFrustumf(xmin, xmax, ymin, ymax, zNear, zFar);
}
/**************************************
glulookat implementation
**************************************/
void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez,
GLfloat centerx, GLfloat centery, GLfloat centerz,
GLfloat upx, GLfloat upy, GLfloat upz)
{
GLfloat m[16];
GLfloat x[3], y[3], z[3];
GLfloat mag;
/* Make rotation matrix */
/* Z vector */
z[0] = eyex - centerx;
z[1] = eyey - centery;
z[2] = eyez - centerz;
mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
if (mag) { /* mpichler, 19950515 */
z[0] /= mag;
z[1] /= mag;
z[2] /= mag;
}
/* Y vector */
y[0] = upx;
y[1] = upy;
y[2] = upz;
/* X vector = Y cross Z */
x[0] = y[1] * z[2] - y[2] * z[1];
x[1] = -y[0] * z[2] + y[2] * z[0];
x[2] = y[0] * z[1] - y[1] * z[0];
/* Recompute Y = Z cross X */
y[0] = z[1] * x[2] - z[2] * x[1];
y[1] = -z[0] * x[2] + z[2] * x[0];
y[2] = z[0] * x[1] - z[1] * x[0];
/* mpichler, 19950515 */
/* cross product gives area of parallelogram, which is < 1.0 for
* non-perpendicular unit-length vectors; so normalize x, y here
*/
mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
if (mag) {
x[0] /= mag;
x[1] /= mag;
x[2] /= mag;
}
mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
if (mag) {
y[0] /= mag;
y[1] /= mag;
y[2] /= mag;
}
#define M(row,col) m[col*4+row]
M(0, 0) = x[0];
M(0, 1) = x[1];
M(0, 2) = x[2];
M(0, 3) = 0.0;
M(1, 0) = y[0];
M(1, 1) = y[1];
M(1, 2) = y[2];
M(1, 3) = 0.0;
M(2, 0) = z[0];
M(2, 1) = z[1];
M(2, 2) = z[2];
M(2, 3) = 0.0;
M(3, 0) = 0.0;
M(3, 1) = 0.0;
M(3, 2) = 0.0;
M(3, 3) = 1.0;
#undef M
glMultMatrixf(m);
/* Translate Eye to Origin */
glTranslatef(-eyex, -eyey, -eyez);
}
/* function to release/destroy our resources and restoring the old desktop */
void Quit( int returnCode )
{
/* clean up the window */
SDL_Quit( );
/* and exit appropriately */
exit( returnCode );
}
/* function to reset our viewport after a window resize */
int resizeWindow( int width, int height )
{
/* Height / width ration */
GLfloat ratio;
/* Protect against a divide by zero */
if ( height == 0 )
height = 1;
ratio = ( GLfloat )width / ( GLfloat )height;
/* Setup our viewport. */
glViewport( 0, 0, ( GLsizei )width, ( GLsizei )height );
/* change to the projection matrix and set our viewing volume. */
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
/* Set our perspective */
gluPerspective( 45.0f, ratio, 0.1f, 100.0f );
/* Make sure we're chaning the model view and not the projection */
glMatrixMode( GL_MODELVIEW );
/* Reset The View */
glLoadIdentity( );
return( TRUE );
}
/* function to handle key press events */
void handleKeyPress( SDL_keysym *keysym )
{
switch ( keysym->sym )
{
case SDLK_ESCAPE:
/* ESC key was pressed */
Quit( 0 );
break;
case SDLK_F1:
/* F1 key was pressed
* this toggles fullscreen mode
*/
SDL_WM_ToggleFullScreen( surface );
break;
default:
break;
}
return;
}
/* general OpenGL initialization function */
int initGL( GLvoid )
{
/* Enable smooth shading */
glShadeModel( GL_SMOOTH );
/* Set the background black */
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
/* Depth buffer setup */
//glClearDepth( 1.0f );
/* Enables Depth Testing */
glEnable( GL_DEPTH_TEST );
/* The Type Of Depth Test To Do */
glDepthFunc( GL_LEQUAL );
/* Really Nice Perspective Calculations */
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
return( TRUE );
}
/* Here goes our drawing code */
int drawGLScene( GLvoid )
{
static int Frames = 0;
static int T0 = 0;
glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
glClearColorx(0,0,Frames,255);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45, (float)SCREEN_WIDTH / SCREEN_HEIGHT, 0.5f, 150);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//Camera
gluLookAt(0,0,5, 0,0,0, 0,1,0);
//Draw a triangle
//glRotatef(iRot, 0, 1, 0);
glRotatef( Frames % 360, 0.0f, 1.0f, 0.0f );
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_COLOR_ARRAY);
/* Rotate The Triangle On The Y axis ( NEW ) */
glRotatef( Frames % 360, 0.0f, 1.0f, 0.0f );
/* GLES variant of drawing a triangle */
const GLfloat triVertices[][9] = {
{ /* Front Triangle */
0.0f, 1.0f, 0.0f, /* Top Of Triangle */
-1.0f, -1.0f, 1.0f, /* Left Of Triangle */
1.0f, -1.0f, 1.0f /* Right Of Triangle */
}, { /* Right Triangle */
0.0f, 1.0f, 0.0f, /* Top Of Triangle */
1.0f, -1.0f, 1.0f, /* Left Of Triangle */
1.0f, -1.0f, -1.0f /* Right Of Triangle */
}, { /* Back Triangle */
0.0f, 1.0f, 0.0f, /* Top Of Triangle */
1.0f, -1.0f, -1.0f, /* Left Of Triangle */
-1.0f, -1.0f, -1.0f /* Right Of Triangle */
}, { /* Left Triangle */
0.0f, 1.0f, 0.0f, /* Top Of Triangle */
-1.0f, -1.0f, -1.0f, /* Left Of Triangle */
-1.0f, -1.0f, 1.0f /* Right Of Triangle */
}
};
/* unlike GL, GLES does not support RGB. We have to use RGBA instead */
const GLfloat triColors[][12] = {
{ /* Front triangle */
1.0f, 0.0f, 0.0f, 1.0f, /* Red */
0.0f, 1.0f, 0.0f, 1.0f, /* Green */
0.0f, 0.0f, 1.0f, 1.0f /* Blue */
}, { /* Right triangle */
1.0f, 0.0f, 0.0f, 1.0f, /* Red */
0.0f, 0.0f, 1.0f, 1.0f, /* Blue */
0.0f, 1.0f, 0.0f, 1.0f /* Green */
}, { /* Back triangle */
1.0f, 0.0f, 0.0f, 1.0f, /* Red */
0.0f, 1.0f, 0.0f, 1.0f, /* Green */
0.0f, 0.0f, 1.0f, 1.0f /* Blue */
}, { /* Left triangle */
1.0f, 0.0f, 0.0f, 1.0f, /* Red */
0.0f, 0.0f, 1.0f, 1.0f, /* Blue */
0.0f, 1.0f, 0.0f, 1.0f /* Green */
}
};
glEnableClientState(GL_COLOR_ARRAY);
int tri=0;
/* Loop through all Triangles */
for(tri=0;tri<sizeof(triVertices)/(9*sizeof(GLfloat));tri++)
{
glVertexPointer(3, GL_FLOAT, 0, triVertices[tri]);
glColorPointer(4, GL_FLOAT, 0, triColors[tri]);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 3);
}
//__android_log_print(ANDROID_LOG_INFO, "SDL", "render %d", Frames++);
/* Draw it to the screen */
SDL_GL_SwapBuffers( );
/* Gather our frames per second */
Frames++;
{
GLint t = SDL_GetTicks();
if (t - T0 >= 5000) {
GLfloat seconds = (t - T0) / 1000.0;
GLfloat fps = Frames / seconds;
__android_log_print(ANDROID_LOG_INFO, "SDL","%d frames in %g seconds = %g FPS\n", Frames, seconds, fps);
T0 = t;
Frames = 0;
}
}
return( TRUE );
}
int SDL_main( int argc, char **argv )
{
__android_log_print(ANDROID_LOG_INFO, "SDL","entry\n");
/* Flags to pass to SDL_SetVideoMode */
int videoFlags;
/* main loop variable */
int done = FALSE;
/* used to collect events */
SDL_Event event;
/* this holds some info about our display */
const SDL_VideoInfo *videoInfo;
/* whether or not the window is active */
int isActive = TRUE;
/* initialize SDL */
if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
{
__android_log_print(ANDROID_LOG_INFO, "SDL", "Video initialization failed: %s\n",
SDL_GetError( ) );
Quit( 1 );
}
/* Fetch the video info */
videoInfo = SDL_GetVideoInfo( );
if ( !videoInfo )
{
__android_log_print(ANDROID_LOG_INFO, "SDL", "Video query failed: %s\n",
SDL_GetError( ) );
Quit( 1 );
}
/* the flags to pass to SDL_SetVideoMode */
videoFlags = SDL_OPENGL; /* Enable OpenGL in SDL */
videoFlags |= SDL_GL_DOUBLEBUFFER; /* Enable double buffering */
videoFlags |= SDL_HWPALETTE; /* Store the palette in hardware */
videoFlags |= SDL_RESIZABLE; /* Enable window resizing */
/* This checks to see if surfaces can be stored in memory */
if ( videoInfo->hw_available )
videoFlags |= SDL_HWSURFACE;
else
videoFlags |= SDL_SWSURFACE;
/* This checks if hardware blits can be done */
if ( videoInfo->blit_hw )
videoFlags |= SDL_HWACCEL;
/* Sets up OpenGL double buffering */
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
/* get a SDL surface */
surface = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP,
videoFlags );
/* Verify there is a surface */
if ( !surface )
{
__android_log_print(ANDROID_LOG_INFO, "SDL", "Video mode set failed: %s\n", SDL_GetError( ) );
Quit( 1 );
}
__android_log_print(ANDROID_LOG_INFO, "SDL","Made a video mode!\n");
/* initialize OpenGL */
initGL( );
/* resize the initial window */
resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT );
/* wait for events */
while ( !done )
{
/* handle the events in the queue */
while ( SDL_PollEvent( &event ) )
{
switch( event.type )
{
case SDL_ACTIVEEVENT:
/* Something's happend with our focus
* If we lost focus or we are iconified, we
* shouldn't draw the screen
*/
if ( event.active.gain == 0 )
isActive = FALSE;
else
isActive = TRUE;
break;
case SDL_VIDEORESIZE:
/* handle resize event */
surface = SDL_SetVideoMode( event.resize.w,
event.resize.h,
16, videoFlags );
if ( !surface )
{
__android_log_print(ANDROID_LOG_INFO, "SDL","Could not get a surface after resize: %s\n", SDL_GetError( ) );
Quit( 1 );
}
resizeWindow( event.resize.w, event.resize.h );
break;
case SDL_KEYDOWN:
/* handle key presses */
handleKeyPress( &event.key.keysym );
break;
case SDL_QUIT:
/* handle quit requests */
done = TRUE;
break;
default:
break;
}
}
/* draw the scene */
if ( isActive )
drawGLScene( );
}
/* clean ourselves up and exit */
Quit( 0 );
/* Should never get here */
return( 0 );
}