Mercurial > sdl-ios-xcode
changeset 4708:f3f65cb6a382
Added egl headers so we can use eglMakeCurrent()
| author | Paul Hunkin <paul@bieh.net> |
|---|---|
| date | Fri, 18 Jun 2010 01:28:39 +1200 |
| parents | 8b109f0dcd2f |
| children | 6dc26b9d8368 |
| files | android/testproject/jni/Android.mk android/testproject/jni/app-android.c android/testproject/jni/egl.h android/testproject/jni/eglnatives.h android/testproject/jni/egltypes.h android/testproject/jni/lesson05.c |
| diffstat | 6 files changed, 1108 insertions(+), 3 deletions(-) [+] |
line wrap: on
line diff
--- a/android/testproject/jni/Android.mk Fri Jun 18 00:03:09 2010 +1200 +++ b/android/testproject/jni/Android.mk Fri Jun 18 01:28:39 2010 +1200 @@ -4,13 +4,17 @@ 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)
--- a/android/testproject/jni/app-android.c Fri Jun 18 00:03:09 2010 +1200 +++ b/android/testproject/jni/app-android.c Fri Jun 18 01:28:39 2010 +1200 @@ -14,6 +14,7 @@ #include <pthread.h> #include "importgl.h" +#include "egl.h" /******************************************************************************* Globals @@ -31,7 +32,17 @@ } +/******************************************************************************* + 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 @@ 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 @@ __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 @@ { //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"); + }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/android/testproject/jni/egl.h Fri Jun 18 01:28:39 2010 +1200 @@ -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*/ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/android/testproject/jni/eglnatives.h Fri Jun 18 01:28:39 2010 +1200 @@ -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 */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/android/testproject/jni/egltypes.h Fri Jun 18 01:28:39 2010 +1200 @@ -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 */ +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/android/testproject/jni/lesson05.c Fri Jun 18 01:28:39 2010 +1200 @@ -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 ); +} + +