int GetDeviceOrientation() {
int orientation_angle = 0;
orientation_direction_t direction;
orientation_get(&direction, &orientation_angle);
switch (direction) {
case ORIENTATION_TOP_UP: return 1; break;
case ORIENTATION_BOTTOM_UP: return 2; break;
case ORIENTATION_LEFT_UP: return 3; break;
case ORIENTATION_RIGHT_UP: return 4; break;
default:
return 0;
}
}
int main(int argc, char **argv) {
shutdown = false;
//Create a screen context that will be used to create an EGL surface to to receive libscreen events
screen_create_context(&screen_cxt, 0);
//Initialize BPS library
bps_initialize();
//Determine initial orientation angle
orientation_direction_t direction;
orientation_get(&direction, &orientation_angle);
//Use utility code to initialize EGL for rendering with GL ES 1.1
if (EXIT_SUCCESS != bbutil_init_egl(screen_cxt, GL_ES_1)) {
fprintf(stderr, "bbutil_init_egl failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Initialize application logic
if (EXIT_SUCCESS != init_blocks()) {
fprintf(stderr, "initialize failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator and screen events will be requested
if (BPS_SUCCESS != screen_request_events(screen_cxt)) {
fprintf(stderr, "screen_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "navigator_request_events failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Signal BPS library that navigator orientation is not to be locked
if (BPS_SUCCESS != navigator_rotation_lock(false)) {
fprintf(stderr, "navigator_rotation_lock failed\n");
bbutil_terminate();
screen_destroy_context(screen_cxt);
return 0;
}
//Setup Sensors
if (sensor_is_supported(SENSOR_TYPE_AZIMUTH_PITCH_ROLL)) {
//Microseconds between sensor reads. This is the rate at which the
//sensor data will be updated from hardware. The hardware update
//rate is set below using sensor_set_rate.
static const int SENSOR_RATE = 25000;
//Initialize the sensor by setting the rates at which the
//sensor values will be updated from hardware
sensor_set_rate(SENSOR_TYPE_AZIMUTH_PITCH_ROLL, SENSOR_RATE);
sensor_set_skip_duplicates(SENSOR_TYPE_AZIMUTH_PITCH_ROLL, true);
sensor_request_events(SENSOR_TYPE_AZIMUTH_PITCH_ROLL);
} else {
set_gravity(0.0f, -1.0f);
}
//Start with one cube on the screen
add_cube(200, 100);
int i = 0;
while (!shutdown) {
i = check(1);
// Handle user input and sensors
handle_events();
//Update cube positions
update();
// Draw Scene
render();
}
//Stop requesting events from libscreen
screen_stop_events(screen_cxt);
//Shut down BPS library for this process
bps_shutdown();
//Free app data
free(boxes);
//Use utility code to terminate EGL setup
bbutil_terminate();
//Destroy libscreen context
screen_destroy_context(screen_cxt);
return 0;
}
Platform* Platform::create(Game* game)
{
FileSystem::setResourcePath("./app/native/");
Platform* platform = new Platform(game);
bps_initialize();
accelerometer_set_update_frequency(FREQ_40_HZ);
navigator_request_events(0);
navigator_rotation_lock(true);
// Determine initial orientation angle.
orientation_direction_t direction;
orientation_get(&direction, &__orientationAngle);
int rc = 0;
int screenFormat = SCREEN_FORMAT_RGBA8888;
int screenUsage = SCREEN_USAGE_DISPLAY|SCREEN_USAGE_OPENGL_ES2;
int screenSwapInterval = WINDOW_VSYNC ? 1 : 0;
int screenTransparency = SCREEN_TRANSPARENCY_NONE;
int angle = atoi(getenv("ORIENTATION"));
// Hard-coded to (0,0).
int windowPosition[] =
{
0, 0
};
EGLint eglConfigCount;
// Hard-coded to 32-bit/OpenGL ES 2.0.
const EGLint eglConfigAttrs[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 24,
EGL_STENCIL_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
const EGLint eglContextAttrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
const EGLint eglSurfaceAttrs[] =
{
EGL_RENDER_BUFFER, EGL_BACK_BUFFER,
EGL_NONE
};
// Create the screen context.
rc = screen_create_context(&__screenContext, 0);
if (rc)
{
perror("screen_create_context");
goto error;
}
// Create the screen window.
rc = screen_create_window(&__screenWindow, __screenContext);
if (rc)
{
perror("screen_create_window");
goto error;
}
// Set/get any window prooperties.
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_FORMAT, &screenFormat);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_USAGE, &screenUsage);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_USAGE)");
goto error;
}
screen_display_t screen_display;
rc = screen_get_window_property_pv(__screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&screen_display);
if (rc)
{
perror("screen_get_window_property_pv(SCREEN_PROPERTY_DISPLAY)");
goto error;
}
screen_display_mode_t screen_mode;
rc = screen_get_display_property_pv(screen_display, SCREEN_PROPERTY_MODE, (void**)&screen_mode);
if (rc)
{
perror("screen_get_display_property_pv(SCREEN_PROPERTY_MODE)");
goto error;
}
int size[2];
rc = screen_get_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, size);
if (rc)
{
perror("screen_get_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
__screenWindowSize[0] = size[0];
__screenWindowSize[1] = size[1];
if ((angle == 0) || (angle == 180))
{
if (((screen_mode.width > screen_mode.height) && (size[0] < size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] > size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else if ((angle == 90) || (angle == 270))
{
if (((screen_mode.width > screen_mode.height) && (size[0] > size[1])) ||
((screen_mode.width < screen_mode.height) && (size[0] < size[1])))
{
__screenWindowSize[1] = size[0];
__screenWindowSize[0] = size[1];
}
}
else
{
perror("Navigator returned an unexpected orientation angle.");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_BUFFER_SIZE, __screenWindowSize);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_BUFFER_SIZE)");
goto error;
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_ROTATION, &angle);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_ROTATION)");
goto error;
}
if (windowPosition[0] != 0 || windowPosition[1] != 0)
{
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_POSITION, windowPosition);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_POSITION)");
goto error;
}
}
rc = screen_set_window_property_iv(__screenWindow, SCREEN_PROPERTY_TRANSPARENCY, &screenTransparency);
if (rc)
{
perror("screen_set_window_property_iv(SCREEN_PROPERTY_TRANSPARENCY)");
goto error;
}
// Double buffered.
rc = screen_create_window_buffers(__screenWindow, 2);
if (rc)
{
perror("screen_create_window_buffers");
goto error;
}
// Create screen event object.
rc = screen_create_event(&__screenEvent);
if (rc)
{
perror("screen_create_event");
goto error;
}
// Request screen events.
screen_request_events(__screenContext);
// Get the EGL display and initialize.
__eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (__eglDisplay == EGL_NO_DISPLAY)
{
perror("eglGetDisplay");
goto error;
}
if (eglInitialize(__eglDisplay, NULL, NULL) != EGL_TRUE)
{
perror("eglInitialize");
goto error;
}
if (eglChooseConfig(__eglDisplay, eglConfigAttrs, &__eglConfig, 1, &eglConfigCount) != EGL_TRUE || eglConfigCount == 0)
{
checkErrorEGL("eglChooseConfig");
goto error;
}
__eglContext = eglCreateContext(__eglDisplay, __eglConfig, EGL_NO_CONTEXT, eglContextAttrs);
if (__eglContext == EGL_NO_CONTEXT)
{
checkErrorEGL("eglCreateContext");
goto error;
}
__eglSurface = eglCreateWindowSurface(__eglDisplay, __eglConfig, __screenWindow, eglSurfaceAttrs);
if (__eglSurface == EGL_NO_SURFACE)
{
checkErrorEGL("eglCreateWindowSurface");
goto error;
}
if (eglMakeCurrent(__eglDisplay, __eglSurface, __eglSurface, __eglContext) != EGL_TRUE)
{
checkErrorEGL("eglMakeCurrent");
goto error;
}
// Set vsync.
eglSwapInterval(__eglDisplay, screenSwapInterval);
// Initialize OpenGL ES extensions.
__glExtensions = (const char*)glGetString(GL_EXTENSIONS);
if (strstr(__glExtensions, "GL_OES_vertex_array_object") || strstr(__glExtensions, "GL_ARB_vertex_array_object"))
{
// Disable VAO extension for now.
glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES");
glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArrays");
glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES");
glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES");
}
return platform;
error:
// TODO: cleanup
//
return NULL;
}
