Leahnaya/SDL
1
0
Fork 0
mirror of https://github.com/yawut/SDL.git synced 2026-08-23 09:15:18 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed obsolete test project

Browse Source
This commit is contained in:
Sam Lantinga
2010-08-19 00:21:20 -07:00
parent faaae689b9
commit b03ba1321d
19 changed files with 0 additions and 2289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
android/testproject/AndroidManifest.xml
View File

@@ -1,15 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.libsdl.android"
android:versionCode="1"
android:versionName="1.0">
<application android:label="@string/app_name" android:icon="@drawable/icon">
<activity android:name="SDLActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

17
android/testproject/build.properties
View File

@@ -1,17 +0,0 @@
# This file is used to override default values used by the Ant build system.
#
# This file must be checked in Version Control Systems, as it is
# integral to the build system of your project.
# This file is only used by the Ant script.
# You can use this to override default values such as
# 'source.dir' for the location of your java source folder and
# 'out.dir' for the location of your output folder.
# You can also use it define how the release builds are signed by declaring
# the following properties:
# 'key.store' for the location of your keystore and
# 'key.alias' for the name of the key to use.
# The password will be asked during the build when you use the 'release' target.

67
android/testproject/build.xml
View File

@@ -1,67 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project name="Test" default="help">
<!-- The local.properties file is created and updated by the 'android' tool.
It contains the path to the SDK. It should *NOT* be checked in in Version
Control Systems. -->
<property file="local.properties" />
<!-- The build.properties file can be created by you and is never touched
by the 'android' tool. This is the place to change some of the default property values
used by the Ant rules.
Here are some properties you may want to change/update:
application.package
the name of your application package as defined in the manifest. Used by the
'uninstall' rule.
source.dir
the name of the source directory. Default is 'src'.
out.dir
the name of the output directory. Default is 'bin'.
Properties related to the SDK location or the project target should be updated
using the 'android' tool with the 'update' action.
This file is an integral part of the build system for your application and
should be checked in in Version Control Systems.
-->
<property file="build.properties" />
<!-- The default.properties file is created and updated by the 'android' tool, as well
as ADT.
This file is an integral part of the build system for your application and
should be checked in in Version Control Systems. -->
<property file="default.properties" />
<!-- Custom Android task to deal with the project target, and import the proper rules.
This requires ant 1.6.0 or above. -->
<path id="android.antlibs">
<pathelement path="${sdk.dir}/tools/lib/anttasks.jar" />
<pathelement path="${sdk.dir}/tools/lib/sdklib.jar" />
<pathelement path="${sdk.dir}/tools/lib/androidprefs.jar" />
<pathelement path="${sdk.dir}/tools/lib/apkbuilder.jar" />
<pathelement path="${sdk.dir}/tools/lib/jarutils.jar" />
</path>
<taskdef name="setup"
classname="com.android.ant.SetupTask"
classpathref="android.antlibs" />
<!-- Execute the Android Setup task that will setup some properties specific to the target,
and import the build rules files.
The rules file is imported from
<SDK>/platforms/<target_platform>/templates/android_rules.xml
To customize some build steps for your project:
- copy the content of the main node <project> from android_rules.xml
- paste it in this build.xml below the <setup /> task.
- disable the import by changing the setup task below to <setup import="false" />
This will ensure that the properties are setup correctly but that your customized
build steps are used.
-->
<setup />
</project>

11
android/testproject/default.properties
View File

@@ -1,11 +0,0 @@
# This file is automatically generated by Android Tools.
# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
#
# This file must be checked in Version Control Systems.
#
# To customize properties used by the Ant build system use,
# "build.properties", and override values to adapt the script to your
# project structure.
# Project target.
target=Google Inc.:Google APIs:7

20
android/testproject/jni/Android.mk
View File

@@ -1,20 +0,0 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := sdltest
SDL := /home/paul/Projects/gsoc/SDL-gsoc2010_android/
LOCAL_CFLAGS := -DANDROID_NDK \
-DDISABLE_IMPORTGL \
-I$(SDL)/include
LOCAL_SRC_FILES := \
importgl.cpp \
app-android.cpp \
lesson05.c \
LOCAL_LDLIBS := -lGLESv1_CM -ldl -llog -lSDL -lEGL -lgcc -L$(SDL) -L$(SDL)/build-scripts/android_libs/
include $(BUILD_SHARED_LIBRARY)

236
android/testproject/jni/app-android.cpp
View File

@@ -1,236 +0,0 @@
/*******************************************************************************
Headers
*******************************************************************************/
#include <jni.h>
#include <sys/time.h>
#include <time.h>
#include <android/log.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <pthread.h>
//#include "importgl.h"
//#include "egl.h"
/*******************************************************************************
Globals
*******************************************************************************/
static long _getTime(void){
struct timeval now;
gettimeofday(&now, NULL);
return (long)(now.tv_sec*1000 + now.tv_usec/1000);
}
JNIEnv* mEnv = NULL;
JNIEnv* mAudioThreadEnv = NULL; //See the note below for why this is necessary
JavaVM* mVM = NULL;
//Main activity
jclass mActivityInstance;
//method signatures
jmethodID midCreateGLContext;
jmethodID midFlipBuffers;
jmethodID midEnableFeature;
jmethodID midUpdateAudio;
extern "C" int SDL_main();
extern "C" int Android_OnKeyDown(int keycode);
extern "C" int Android_OnKeyUp(int keycode);
extern "C" void Android_SetScreenResolution(int width, int height);
extern "C" void Android_OnResize(int width, int height, int format);
extern "C" int SDL_SendQuit();
extern "C" void Android_EnableFeature(int featureid, bool enabled);
//If we're not the active app, don't try to render
bool bRenderingEnabled = false;
//Feature IDs
static const int FEATURE_AUDIO = 1;
static const int FEATURE_ACCEL = 2;
//Accelerometer data storage
float fLastAccelerometer[3];
/*******************************************************************************
Functions called by JNI
*******************************************************************************/
//Library init
extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved){
JNIEnv* env = NULL;
jint result = -1;
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
return result;
}
mEnv = env;
__android_log_print(ANDROID_LOG_INFO, "SDL", "JNI: OnLoad");
jclass cls = mEnv->FindClass ("org/libsdl/android/SDLActivity");
mActivityInstance = cls;
midCreateGLContext = mEnv->GetStaticMethodID(cls,"createGLContext","()V");
midFlipBuffers = mEnv->GetStaticMethodID(cls,"flipBuffers","()V");
midEnableFeature = mEnv->GetStaticMethodID(cls,"enableFeature","(II)V");
midUpdateAudio = mEnv->GetStaticMethodID(cls,"updateAudio","([B)V");
if(!midCreateGLContext || !midFlipBuffers || !midEnableFeature ||
!midUpdateAudio){
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: Bad mids\n");
}else{
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: Good mids\n");
}
return JNI_VERSION_1_4;
}
//Start up the SDL app
extern "C" void Java_org_libsdl_android_SDLActivity_nativeInit( JNIEnv* env,
jobject obj ){
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: Native Init");
mEnv = env;
bRenderingEnabled = true;
Android_EnableFeature(FEATURE_ACCEL, true);
SDL_main();
}
//Keydown
extern "C" void Java_org_libsdl_android_SDLActivity_onNativeKeyDown(JNIEnv* env,
jobject obj, jint keycode){
int r = Android_OnKeyDown(keycode);
__android_log_print(ANDROID_LOG_INFO, "SDL",
"SDL: native key down %d, %d\n", keycode, r);
}
//Keyup
extern "C" void Java_org_libsdl_android_SDLActivity_onNativeKeyUp(JNIEnv* env,
jobject obj, jint keycode){
int r = Android_OnKeyUp(keycode);
__android_log_print(ANDROID_LOG_INFO, "SDL",
"SDL: native key up %d, %d\n", keycode, r);
}
//Touch
extern "C" void Java_org_libsdl_android_SDLActivity_onNativeTouch(JNIEnv* env,
jobject obj, jint action, jfloat x, jfloat y, jfloat p){
__android_log_print(ANDROID_LOG_INFO, "SDL",
"SDL: native touch event %d @ %f/%f, pressure %f\n",
action, x, y, p);
//TODO: Pass this off to the SDL multitouch stuff
}
//Quit
extern "C" void Java_org_libsdl_android_SDLActivity_nativeQuit( JNIEnv* env,
jobject obj ){
//Stop rendering as we're no longer in the foreground
bRenderingEnabled = false;
//Inject a SDL_QUIT event
int r = SDL_SendQuit();
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: Native quit %d", r);
}
//Screen size
extern "C" void Java_org_libsdl_android_SDLActivity_nativeSetScreenSize(
JNIEnv* env, jobject obj, jint width, jint height){
__android_log_print(ANDROID_LOG_INFO, "SDL",
"SDL: Set screen size on init: %d/%d\n", width, height);
Android_SetScreenResolution(width, height);
}
//Resize
extern "C" void Java_org_libsdl_android_SDLActivity_onNativeResize(
JNIEnv* env, jobject obj, jint width,
jint height, jint format){
Android_OnResize(width, height, format);
}
extern "C" void Java_org_libsdl_android_SDLActivity_onNativeAccel(
JNIEnv* env, jobject obj,
jfloat x, jfloat y, jfloat z){
fLastAccelerometer[0] = x;
fLastAccelerometer[1] = y;
fLastAccelerometer[2] = z;
}
/*******************************************************************************
Functions called by SDL into Java
*******************************************************************************/
extern "C" void Android_CreateContext(){
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: sdl_create_context()\n");
bRenderingEnabled = true;
mEnv->CallStaticVoidMethod(mActivityInstance, midCreateGLContext );
}
extern "C" void Android_Render(){
if(!bRenderingEnabled){
return;
}
//When we get here, we've accumulated a full frame
mEnv->CallStaticVoidMethod(mActivityInstance, midFlipBuffers );
}
extern "C" void Android_EnableFeature(int featureid, bool enabled){
mEnv->CallStaticVoidMethod(mActivityInstance, midEnableFeature,
featureid, (int)enabled);
}
extern "C" void Android_UpdateAudioBuffer(unsigned char *buf, int len){
//Annoyingly we can't just call into Java from any thread. Because the audio
//callback is dispatched from the SDL audio thread (that wasn't made from
//java, we have to do some magic here to let the JVM know about the thread.
//Because everything it touches on the Java side is static anyway, it's
//not a big deal, just annoying.
if(!mAudioThreadEnv){
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: Need to set up audio thread env\n");
mJVM->AttachCurrentThread(&mAudioThreadEnv, NULL);
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: ok\n");
}
jbyteArray arr = mAudioThreadEnv->NewByteArray(len);
//blah. We probably should rework this so we avoid the copy.
mAudioThreadEnv->SetByteArrayRegion(arr, 0, len, (jbyte *)buf);
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: copied\n");
mAudioThreadEnv->CallStaticVoidMethod( mActivityInstance,
midUpdateAudio, arr );
__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL: invoked\n");
}

269
android/testproject/jni/egl.h
View File

@@ -1,269 +0,0 @@
/*
* 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
View File

@@ -1,277 +0,0 @@
/*
* 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
View File

@@ -1,48 +0,0 @@
/*
* 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 */

168
android/testproject/jni/importgl.cpp
View File

@@ -1,168 +0,0 @@
/* San Angeles Observation OpenGL ES version example
* Copyright 2004-2005 Jetro Lauha
* All rights reserved.
* Web: http://iki.fi/jetro/
*
* This source is free software; you can redistribute it and/or
* modify it under the terms of EITHER:
* (1) The GNU Lesser General Public License as published by the Free
* Software Foundation; either version 2.1 of the License, or (at
* your option) any later version. The text of the GNU Lesser
* General Public License is included with this source in the
* file LICENSE-LGPL.txt.
* (2) The BSD-style license that is included with this source in
* the file LICENSE-BSD.txt.
*
* This source is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
* LICENSE-LGPL.txt and LICENSE-BSD.txt for more details.
*
* $Id: importgl.c,v 1.4 2005/02/08 18:42:55 tonic Exp $
* $Revision: 1.4 $
*/
#undef WIN32
#undef LINUX
#ifdef _MSC_VER
// Desktop or mobile Win32 environment:
#define WIN32
#else
// Linux environment:
#define LINUX
#endif
#ifndef DISABLE_IMPORTGL
#if defined(WIN32)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tchar.h>
static HMODULE sGLESDLL = NULL;
#endif // WIN32
#ifdef LINUX
#include <stdlib.h>
#include <dlfcn.h>
static void *sGLESSO = NULL;
#endif // LINUX
#endif /* DISABLE_IMPORTGL */
#define IMPORTGL_NO_FNPTR_DEFS
#define IMPORTGL_API
#define IMPORTGL_FNPTRINIT = NULL
#include "importgl.h"
/* Imports function pointers to selected function calls in OpenGL ES Common
* or Common Lite profile DLL or shared object. The function pointers are
* stored as global symbols with equivalent function name but prefixed with
* "funcPtr_". Standard gl/egl calls are redirected to the function pointers
* with preprocessor macros (see importgl.h).
*/
int importGLInit()
{
int result = 1;
#ifndef DISABLE_IMPORTGL
#undef IMPORT_FUNC
#ifdef WIN32
sGLESDLL = LoadLibrary(_T("libGLES_CM.dll"));
if (sGLESDLL == NULL)
sGLESDLL = LoadLibrary(_T("libGLES_CL.dll"));
if (sGLESDLL == NULL)
return 0; // Cannot find OpenGL ES Common or Common Lite DLL.
/* The following fetches address to each egl & gl function call
* and stores it to the related function pointer. Casting through
* void * results in warnings with VC warning level 4, which
* could be fixed by casting to the true type for each fetch.
*/
#define IMPORT_FUNC(funcName) do { \
void *procAddress = (void *)GetProcAddress(sGLESDLL, _T(#funcName)); \
if (procAddress == NULL) result = 0; \
*((void **)&FNPTR(funcName)) = procAddress; } while (0)
#endif // WIN32
#ifdef LINUX
#ifdef ANDROID_NDK
sGLESSO = dlopen("libGLESv1_CM.so", RTLD_NOW);
#else /* !ANDROID_NDK */
sGLESSO = dlopen("libGLES_CM.so", RTLD_NOW);
if (sGLESSO == NULL)
sGLESSO = dlopen("libGLES_CL.so", RTLD_NOW);
#endif /* !ANDROID_NDK */
if (sGLESSO == NULL)
return 0; // Cannot find OpenGL ES Common or Common Lite SO.
#define IMPORT_FUNC(funcName) do { \
void *procAddress = (void *)dlsym(sGLESSO, #funcName); \
if (procAddress == NULL) result = 0; \
*((void **)&FNPTR(funcName)) = procAddress; } while (0)
#endif // LINUX
#ifndef ANDROID_NDK
IMPORT_FUNC(eglChooseConfig);
IMPORT_FUNC(eglCreateContext);
IMPORT_FUNC(eglCreateWindowSurface);
IMPORT_FUNC(eglDestroyContext);
IMPORT_FUNC(eglDestroySurface);
IMPORT_FUNC(eglGetConfigAttrib);
IMPORT_FUNC(eglGetConfigs);
IMPORT_FUNC(eglGetDisplay);
IMPORT_FUNC(eglGetError);
IMPORT_FUNC(eglInitialize);
IMPORT_FUNC(eglMakeCurrent);
IMPORT_FUNC(eglSwapBuffers);
IMPORT_FUNC(eglTerminate);
#endif /* !ANDROID_NDK */
IMPORT_FUNC(glBlendFunc);
IMPORT_FUNC(glClear);
IMPORT_FUNC(glClearColorx);
IMPORT_FUNC(glColor4x);
IMPORT_FUNC(glColorPointer);
IMPORT_FUNC(glDisable);
IMPORT_FUNC(glDisableClientState);
IMPORT_FUNC(glDrawArrays);
IMPORT_FUNC(glEnable);
IMPORT_FUNC(glEnableClientState);
IMPORT_FUNC(glFrustumx);
IMPORT_FUNC(glGetError);
IMPORT_FUNC(glLightxv);
IMPORT_FUNC(glLoadIdentity);
IMPORT_FUNC(glMaterialx);
IMPORT_FUNC(glMaterialxv);
IMPORT_FUNC(glMatrixMode);
IMPORT_FUNC(glMultMatrixx);
IMPORT_FUNC(glNormalPointer);
IMPORT_FUNC(glPopMatrix);
IMPORT_FUNC(glPushMatrix);
IMPORT_FUNC(glRotatex);
IMPORT_FUNC(glScalex);
IMPORT_FUNC(glShadeModel);
IMPORT_FUNC(glTranslatex);
IMPORT_FUNC(glVertexPointer);
IMPORT_FUNC(glViewport);
#endif /* DISABLE_IMPORTGL */
return result;
}
void importGLDeinit()
{
#ifndef DISABLE_IMPORTGL
#ifdef WIN32
FreeLibrary(sGLESDLL);
#endif
#ifdef LINUX
dlclose(sGLESSO);
#endif
#endif /* DISABLE_IMPORTGL */
}

172
android/testproject/jni/importgl.h
View File

@@ -1,172 +0,0 @@
/* San Angeles Observation OpenGL ES version example
* Copyright 2004-2005 Jetro Lauha
* All rights reserved.
* Web: http://iki.fi/jetro/
*
* This source is free software; you can redistribute it and/or
* modify it under the terms of EITHER:
* (1) The GNU Lesser General Public License as published by the Free
* Software Foundation; either version 2.1 of the License, or (at
* your option) any later version. The text of the GNU Lesser
* General Public License is included with this source in the
* file LICENSE-LGPL.txt.
* (2) The BSD-style license that is included with this source in
* the file LICENSE-BSD.txt.
*
* This source is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
* LICENSE-LGPL.txt and LICENSE-BSD.txt for more details.
*
* $Id: importgl.h,v 1.4 2005/02/24 20:29:33 tonic Exp $
* $Revision: 1.4 $
*/
#ifndef IMPORTGL_H_INCLUDED
#define IMPORTGL_H_INCLUDED
#ifdef __cplusplus
extern "C" {
#endif
#include <GLES/gl.h>
#ifndef ANDROID_NDK
#include <GLES/egl.h>
#endif /* !ANDROID_NDK */
/* Use DISABLE_IMPORTGL if you want to link the OpenGL ES at
* compile/link time and not import it dynamically runtime.
*/
#ifndef DISABLE_IMPORTGL
/* Dynamically fetches pointers to the egl & gl functions.
* Should be called once on application initialization.
* Returns non-zero on success and 0 on failure.
*/
extern int importGLInit();
/* Frees the handle to egl & gl functions library.
*/
extern void importGLDeinit();
#ifndef IMPORTGL_API
#define IMPORTGL_API extern
#endif
#ifndef IMPORTGL_FNPTRINIT
#define IMPORTGL_FNPTRINIT
#endif
#define FNDEF(retType, funcName, args) IMPORTGL_API retType (*funcPtr_##funcName) args IMPORTGL_FNPTRINIT
#ifndef ANDROID_NDK
FNDEF(EGLBoolean, eglChooseConfig, (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config));
FNDEF(EGLContext, eglCreateContext, (EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list));
FNDEF(EGLSurface, eglCreateWindowSurface, (EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list));
FNDEF(EGLBoolean, eglDestroyContext, (EGLDisplay dpy, EGLContext ctx));
FNDEF(EGLBoolean, eglDestroySurface, (EGLDisplay dpy, EGLSurface surface));
FNDEF(EGLBoolean, eglGetConfigAttrib, (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value));
FNDEF(EGLBoolean, eglGetConfigs, (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config));
FNDEF(EGLDisplay, eglGetDisplay, (NativeDisplayType display));
FNDEF(EGLint, eglGetError, (void));
FNDEF(EGLBoolean, eglInitialize, (EGLDisplay dpy, EGLint *major, EGLint *minor));
FNDEF(EGLBoolean, eglMakeCurrent, (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx));
FNDEF(EGLBoolean, eglSwapBuffers, (EGLDisplay dpy, EGLSurface draw));
FNDEF(EGLBoolean, eglTerminate, (EGLDisplay dpy));
#endif /* !ANDROID_NDK */
FNDEF(void, glBlendFunc, (GLenum sfactor, GLenum dfactor));
FNDEF(void, glClear, (GLbitfield mask));
FNDEF(void, glClearColorx, (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha));
FNDEF(void, glColor4x, (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha));
FNDEF(void, glColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer));
FNDEF(void, glDisable, (GLenum cap));
FNDEF(void, glDisableClientState, (GLenum array));
FNDEF(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count));
FNDEF(void, glEnable, (GLenum cap));
FNDEF(void, glEnableClientState, (GLenum array));
FNDEF(void, glFrustumx, (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar));
FNDEF(GLenum, glGetError, (void));
FNDEF(void, glLightxv, (GLenum light, GLenum pname, const GLfixed *params));
FNDEF(void, glLoadIdentity, (void));
FNDEF(void, glMaterialx, (GLenum face, GLenum pname, GLfixed param));
FNDEF(void, glMaterialxv, (GLenum face, GLenum pname, const GLfixed *params));
FNDEF(void, glMatrixMode, (GLenum mode));
FNDEF(void, glMultMatrixx, (const GLfixed *m));
FNDEF(void, glNormalPointer, (GLenum type, GLsizei stride, const GLvoid *pointer));
FNDEF(void, glPopMatrix, (void));
FNDEF(void, glPushMatrix, (void));
FNDEF(void, glRotatex, (GLfixed angle, GLfixed x, GLfixed y, GLfixed z));
FNDEF(void, glScalex, (GLfixed x, GLfixed y, GLfixed z));
FNDEF(void, glShadeModel, (GLenum mode));
FNDEF(void, glTranslatex, (GLfixed x, GLfixed y, GLfixed z));
FNDEF(void, glVertexPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer));
FNDEF(void, glViewport, (GLint x, GLint y, GLsizei width, GLsizei height));
#undef FN
#define FNPTR(name) funcPtr_##name
#ifndef IMPORTGL_NO_FNPTR_DEFS
// Redirect egl* and gl* function calls to funcPtr_egl* and funcPtr_gl*.
#ifndef ANDROID_NDK
#define eglChooseConfig FNPTR(eglChooseConfig)
#define eglCreateContext FNPTR(eglCreateContext)
#define eglCreateWindowSurface FNPTR(eglCreateWindowSurface)
#define eglDestroyContext FNPTR(eglDestroyContext)
#define eglDestroySurface FNPTR(eglDestroySurface)
#define eglGetConfigAttrib FNPTR(eglGetConfigAttrib)
#define eglGetConfigs FNPTR(eglGetConfigs)
#define eglGetDisplay FNPTR(eglGetDisplay)
#define eglGetError FNPTR(eglGetError)
#define eglInitialize FNPTR(eglInitialize)
#define eglMakeCurrent FNPTR(eglMakeCurrent)
#define eglSwapBuffers FNPTR(eglSwapBuffers)
#define eglTerminate FNPTR(eglTerminate)
#endif /* !ANDROID_NDK */
#define glBlendFunc FNPTR(glBlendFunc)
#define glClear FNPTR(glClear)
#define glClearColorx FNPTR(glClearColorx)
#define glColor4x FNPTR(glColor4x)
#define glColorPointer FNPTR(glColorPointer)
#define glDisable FNPTR(glDisable)
#define glDisableClientState FNPTR(glDisableClientState)
#define glDrawArrays FNPTR(glDrawArrays)
#define glEnable FNPTR(glEnable)
#define glEnableClientState FNPTR(glEnableClientState)
#define glFrustumx FNPTR(glFrustumx)
#define glGetError FNPTR(glGetError)
#define glLightxv FNPTR(glLightxv)
#define glLoadIdentity FNPTR(glLoadIdentity)
#define glMaterialx FNPTR(glMaterialx)
#define glMaterialxv FNPTR(glMaterialxv)
#define glMatrixMode FNPTR(glMatrixMode)
#define glMultMatrixx FNPTR(glMultMatrixx)
#define glNormalPointer FNPTR(glNormalPointer)
#define glPopMatrix FNPTR(glPopMatrix)
#define glPushMatrix FNPTR(glPushMatrix)
#define glRotatex FNPTR(glRotatex)
#define glScalex FNPTR(glScalex)
#define glShadeModel FNPTR(glShadeModel)
#define glTranslatex FNPTR(glTranslatex)
#define glVertexPointer FNPTR(glVertexPointer)
#define glViewport FNPTR(glViewport)
#endif // !IMPORTGL_NO_FNPTR_DEFS
#endif // !DISABLE_IMPORTGL
#ifdef __cplusplus
}
#endif
#endif // !IMPORTGL_H_INCLUDED

574
android/testproject/jni/lesson05.c
View File

@@ -1,574 +0,0 @@
/*
* 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 <signal.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 430
#define SCREEN_BPP 16
/* Define our booleans */
#define TRUE 1
#define FALSE 0
/* This is our SDL surface */
SDL_Surface *surface;
int rotation = 0;
/**************************************
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;
case SDLK_LEFT:
rotation -= 30;
break;
case SDLK_RIGHT:
rotation += 30;
break;
default:
break;
}
__android_log_print(ANDROID_LOG_INFO, "SDL","Keycode: %d, %d, %d\n", keysym->sym, SDLK_LEFT, SDLK_RIGHT);
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,0,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( rotation, 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;
}
}
rotation++;
return( TRUE );
}
struct
{
SDL_AudioSpec spec;
Uint8 *sound; /* Pointer to wave data */
Uint32 soundlen; /* Length of wave data */
int soundpos; /* Current play position */
} wave;
void SDLCALL
fillerup(void *unused, Uint8 * stream, int len)
{
__android_log_print(ANDROID_LOG_INFO, "SDL","FILLERUP\n");
Uint8 *waveptr;
int waveleft;
/* Set up the pointers */
waveptr = wave.sound + wave.soundpos;
waveleft = wave.soundlen - wave.soundpos;
/* Go! */
while (waveleft <= len) {
SDL_memcpy(stream, waveptr, waveleft);
stream += waveleft;
len -= waveleft;
waveptr = wave.sound;
waveleft = wave.soundlen;
wave.soundpos = 0;
}
SDL_memcpy(stream, waveptr, len);
wave.soundpos += len;
}
void testAudio(){
const char *file = "/sdcard/sample.wav";
/* Load the SDL library */
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
__android_log_print(ANDROID_LOG_INFO, "SDL","Couldn't initialize SDL Audio: %s\n", SDL_GetError());
return;
}else{
__android_log_print(ANDROID_LOG_INFO, "SDL","Init audio ok\n");
}
/* Load the wave file into memory */
if (SDL_LoadWAV(file, &wave.spec, &wave.sound, &wave.soundlen) == NULL) {
__android_log_print(ANDROID_LOG_INFO, "SDL", "Couldn't load %s: %s\n", file, SDL_GetError());
return;
}
wave.spec.callback = fillerup;
__android_log_print(ANDROID_LOG_INFO, "SDL","Loaded: %d\n", wave.soundlen);
/* Initialize fillerup() variables */
if (SDL_OpenAudio(&wave.spec, NULL) < 0) {
__android_log_print(ANDROID_LOG_INFO, "SDL", "Couldn't open audio: %s\n", SDL_GetError());
SDL_FreeWAV(wave.sound);
return;
}
__android_log_print(ANDROID_LOG_INFO, "SDL","Using audio driver: %s\n", SDL_GetCurrentAudioDriver());
/* Let the audio run */
SDL_PauseAudio(0);
__android_log_print(ANDROID_LOG_INFO, "SDL","Playing\n");
while (SDL_GetAudioStatus() == SDL_AUDIO_PLAYING){
//__android_log_print(ANDROID_LOG_INFO, "SDL","Still playing\n");
SDL_Delay(100);
}
__android_log_print(ANDROID_LOG_INFO, "SDL","Closing down\n");
/* Clean up on signal */
SDL_CloseAudio();
SDL_FreeWAV(wave.sound);
}
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 );
testAudio();
/* 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;
__android_log_print(ANDROID_LOG_INFO, "SDL","App is shutting down\n");
break;
default:
break;
}
}
/* draw the scene */
if ( isActive )
drawGLScene( );
}
/* clean ourselves up and exit */
Quit( 0 );
/* Should never get here */
return( 0 );
}

10
android/testproject/local.properties
View File

@@ -1,10 +0,0 @@
# This file is automatically generated by Android Tools.
# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
#
# This file must *NOT* be checked in Version Control Systems,
# as it contains information specific to your local configuration.
# location of the SDK. This is only used by Ant
# For customization when using a Version Control System, please read the
# header note.
sdk.dir=/home/paul/Projects/gsoc/sdk/android-sdk-linux_86

BIN
android/testproject/res/drawable-hdpi/icon.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.0 KiB

BIN
android/testproject/res/drawable-ldpi/icon.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.7 KiB

BIN
android/testproject/res/drawable-mdpi/icon.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.5 KiB

13
android/testproject/res/layout/main.xml
View File

@@ -1,13 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Hello World, TestActivity"
/>
</LinearLayout>

4
android/testproject/res/values/strings.xml
View File

@@ -1,4 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">TestActivity</string>
</resources>

388
android/testproject/src/org/libsdl/android/SDLActivity.java
View File

@@ -1,388 +0,0 @@
package org.libsdl.android;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import javax.microedition.khronos.egl.*;
import android.app.*;
import android.content.*;
import android.view.*;
import android.os.*;
import android.util.Log;
import android.graphics.*;
import android.text.method.*;
import android.text.*;
import android.media.*;
import android.hardware.*;
import android.content.*;
import java.lang.*;
/**
SDL Activity
*/
public class SDLActivity extends Activity {
//Main components
private static SDLActivity mSingleton;
private static SDLSurface mSurface;
//Audio
private static AudioTrack mAudioTrack;
private static boolean bAudioIsEnabled;
//Sensors
private static boolean bAccelIsEnabled;
//feature IDs. Must match up on the C side as well.
private static int FEATURE_AUDIO = 1;
private static int FEATURE_ACCEL = 2;
//Load the .so
static {
System.loadLibrary("sdltest");
}
//Setup
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//So we can call stuff from static callbacks
mSingleton = this;
//Set up the surface
mSurface = new SDLSurface(getApplication());
setContentView(mSurface);
SurfaceHolder holder = mSurface.getHolder();
holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
}
//Audio
public static boolean initAudio(){
//blah. Hardcoded things are bad. FIXME when we have more sound stuff
//working properly.
mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
11025,
AudioFormat.CHANNEL_CONFIGURATION_MONO,
AudioFormat.ENCODING_PCM_8BIT,
2048,
AudioTrack.MODE_STREAM);
bAudioIsEnabled = true;
return true;
}
//Accel
public static boolean initAccel(){
mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true);
bAccelIsEnabled = true;
return true;
}
public static boolean closeAccel(){
mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, false);
bAccelIsEnabled = false;
return true;
}
//Events
protected void onPause() {
super.onPause();
}
protected void onResume() {
super.onResume();
}
//C functions we call
public static native void nativeInit();
public static native void nativeQuit();
public static native void nativeSetScreenSize(int width, int height);
public static native void onNativeKeyDown(int keycode);
public static native void onNativeKeyUp(int keycode);
public static native void onNativeTouch(int action, float x,
float y, float p);
public static native void onNativeResize(int x, int y, int format);
public static native void onNativeAccel(float x, float y, float z);
//Java functions called from C
private static void createGLContext(){
mSurface.initEGL();
}
public static void flipBuffers(){
mSurface.flipEGL();
}
public static void updateAudio(byte [] buf){
if(mAudioTrack == null){
return;
}
mAudioTrack.write(buf, 0, buf.length);
mAudioTrack.play();
Log.v("SDL","Played some audio");
}
public static void enableFeature(int featureid, int enabled){
Log.v("SDL","Feature " + featureid + " = " + enabled);
//Yuck. This is all horribly inelegent. If it gets to more than a few
//'features' I'll rip this out and make something nicer, I promise :)
if(featureid == FEATURE_AUDIO){
if(enabled == 1){
initAudio();
}else{
//We don't have one of these yet...
//closeAudio();
}
}
else if(featureid == FEATURE_ACCEL){
if(enabled == 1){
initAccel();
}else{
closeAccel();
}
}
}
}
/**
Simple nativeInit() runnable
*/
class SDLRunner implements Runnable{
public void run(){
//SDLActivity.initAudio();
//Runs SDL_main()
SDLActivity.nativeInit();
Log.v("SDL","SDL thread terminated");
}
}
/**
SDLSurface. This is what we draw on, so we need to know when it's created
in order to do anything useful.
Because of this, that's where we set up the SDL thread
*/
class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
View.OnKeyListener, View.OnTouchListener, SensorEventListener {
//This is what SDL runs in. It invokes SDL_main(), eventually
private Thread mSDLThread;
//EGL private objects
private EGLContext mEGLContext;
private EGLSurface mEGLSurface;
private EGLDisplay mEGLDisplay;
//Sensors
private static SensorManager mSensorManager;
//Startup
public SDLSurface(Context context) {
super(context);
getHolder().addCallback(this);
setFocusable(true);
setFocusableInTouchMode(true);
requestFocus();
setOnKeyListener(this);
setOnTouchListener(this);
mSensorManager = (SensorManager)context.getSystemService("sensor");
}
//Called when we have a valid drawing surface
public void surfaceCreated(SurfaceHolder holder) {
Log.v("SDL","Surface created");
int width = getWidth();
int height = getHeight();
//Set the width and height variables in C before we start SDL so we have
//it available on init
SDLActivity.nativeSetScreenSize(width, height);
//Now start up the C app thread
mSDLThread = new Thread(new SDLRunner(), "SDLThread");
mSDLThread.start();
}
//Called when we lose the surface
public void surfaceDestroyed(SurfaceHolder holder) {
Log.v("SDL","Surface destroyed");
SDLActivity.nativeQuit();
//Now wait for the SDL thread to quit
try{
mSDLThread.wait();
}catch(Exception e){
Log.v("SDL","Problem stopping thread: " + e);
}
}
//Called when the surface is resized
public void surfaceChanged(SurfaceHolder holder, int format,
int width, int height) {
Log.v("SDL","Surface resized");
SDLActivity.onNativeResize(width, height, format);
}
//unused
public void onDraw(Canvas canvas) {}
//EGL functions
public boolean initEGL(){
Log.v("SDL","Starting up");
try{
EGL10 egl = (EGL10)EGLContext.getEGL();
EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
egl.eglInitialize(dpy, version);
int[] configSpec = {
//EGL10.EGL_DEPTH_SIZE, 16,
EGL10.EGL_NONE
};
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config);
EGLConfig config = configs[0];
EGLContext ctx = egl.eglCreateContext(dpy, config, EGL10.EGL_NO_CONTEXT, null);
EGLSurface surface = egl.eglCreateWindowSurface(dpy, config, this, null);
egl.eglMakeCurrent(dpy, surface, surface, ctx);
mEGLContext = ctx;
mEGLDisplay = dpy;
mEGLSurface = surface;
}catch(Exception e){
Log.v("SDL", e + "");
for(StackTraceElement s : e.getStackTrace()){
Log.v("SDL", s.toString());
}
}
Log.v("SDL","Done making!");
return true;
}
//EGL buffer flip
public void flipEGL(){
try{
EGL10 egl = (EGL10)EGLContext.getEGL();
GL10 gl = (GL10)mEGLContext.getGL();
egl.eglWaitNative(EGL10.EGL_NATIVE_RENDERABLE, null);
//drawing here
egl.eglWaitGL();
egl.eglSwapBuffers(mEGLDisplay, mEGLSurface);
}catch(Exception e){
Log.v("SDL", "flipEGL(): " + e);
for(StackTraceElement s : e.getStackTrace()){
Log.v("SDL", s.toString());
}
}
}
//Key events
public boolean onKey(View v, int keyCode, KeyEvent event){
if(event.getAction() == KeyEvent.ACTION_DOWN){
SDLActivity.onNativeKeyDown(keyCode);
return true;
}
else if(event.getAction() == KeyEvent.ACTION_UP){
SDLActivity.onNativeKeyUp(keyCode);
return true;
}
return false;
}
//Touch events
public boolean onTouch(View v, MotionEvent event){
int action = event.getAction();
float x = event.getX();
float y = event.getY();
float p = event.getPressure();
//TODO: Anything else we need to pass?
SDLActivity.onNativeTouch(action, x, y, p);
return true;
}
//Sensor events
public void enableSensor(int sensortype, boolean enabled){
//TODO: This uses getDefaultSensor - what if we have >1 accels?
if(enabled){
mSensorManager.registerListener(this,
mSensorManager.getDefaultSensor(sensortype),
SensorManager.SENSOR_DELAY_GAME, null);
}else{
mSensorManager.unregisterListener(this,
mSensorManager.getDefaultSensor(sensortype));
}
}
public void onAccuracyChanged(Sensor sensor, int accuracy){
//TODO
}
public void onSensorChanged(SensorEvent event){
if(event.sensor.getType() == Sensor.TYPE_ACCELEROMETER){
SDLActivity.onNativeAccel( event.values[0],
event.values[1],
event.values[2] );
}
}
}