mirror of
https://github.com/joel16/SDL2.git
synced 2025-02-25 22:25:34 +00:00
indent
--HG-- extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%403608
This commit is contained in:
Sam Lantinga
parent
3071101f22
commit
483f2ba3fb
@ -174,7 +174,8 @@ void
|
||||
drawBlank(int x, int y)
|
||||
{
|
||||
SDL_Rect rect = { x, y, GLYPH_SIZE_SCREEN, GLYPH_SIZE_SCREEN };
|
||||
SDL_SetRenderDrawColor(bg_color.r, bg_color.g, bg_color.b, bg_color.unused);
|
||||
SDL_SetRenderDrawColor(bg_color.r, bg_color.g, bg_color.b,
|
||||
bg_color.unused);
|
||||
SDL_RenderFill(&rect);
|
||||
}
|
||||
|
||||
@ -254,7 +255,8 @@ main(int argc, char *argv[])
|
||||
loadFont();
|
||||
|
||||
/* draw the background, we'll just paint over it */
|
||||
SDL_SetRenderDrawColor(bg_color.r, bg_color.g, bg_color.b, bg_color.unused);
|
||||
SDL_SetRenderDrawColor(bg_color.r, bg_color.g, bg_color.b,
|
||||
bg_color.unused);
|
||||
SDL_RenderFill(NULL);
|
||||
SDL_RenderPresent();
|
||||
|
||||
|
||||
@ -168,7 +168,7 @@ render(void)
|
||||
{
|
||||
int i;
|
||||
SDL_SetRenderDrawColor(50, 50, 50, 255);
|
||||
SDL_RenderFill(NULL); /* draw background (gray) */
|
||||
SDL_RenderFill(NULL); /* draw background (gray) */
|
||||
/* draw the drum buttons */
|
||||
for (i = 0; i < NUM_DRUMS; i++) {
|
||||
SDL_Color color =
|
||||
|
||||
@ -50,7 +50,7 @@ extern "C"
|
||||
|
||||
#ifndef GL_API
|
||||
#define GL_API
|
||||
#endif /* GL_API */
|
||||
#endif /* GL_API */
|
||||
|
||||
/*
|
||||
** License Applicability. Except to the extent portions of this file are
|
||||
@ -347,10 +347,10 @@ extern "C"
|
||||
/* OpenGL ES 1.0 defines, they gone in 1.1 and 2.0 */
|
||||
#ifndef GL_MAX_ELEMENTS_VERTICES
|
||||
#define GL_MAX_ELEMENTS_VERTICES 0x80E8
|
||||
#endif /* GL_MAX_ELEMENTS_VERTICES */
|
||||
#endif /* GL_MAX_ELEMENTS_VERTICES */
|
||||
#ifndef GL_MAX_ELEMENTS_INDICES
|
||||
#define GL_MAX_ELEMENTS_INDICES 0x80E9
|
||||
#endif /* GL_MAX_ELEMENTS_INDICES */
|
||||
#endif /* GL_MAX_ELEMENTS_INDICES */
|
||||
|
||||
/* GetTextureParameter */
|
||||
/* GL_TEXTURE_MAG_FILTER */
|
||||
@ -669,7 +669,7 @@ extern "C"
|
||||
/* GL_OES_draw_texture */
|
||||
#ifndef GL_OES_draw_texture
|
||||
#define GL_TEXTURE_CROP_RECT_OES 0x8B9D
|
||||
#endif /* GL_OES_draw_texture */
|
||||
#endif /* GL_OES_draw_texture */
|
||||
|
||||
/* GL_OES_vertex_buffer_object */
|
||||
#ifndef GL_OES_vertex_buffer_object
|
||||
@ -687,7 +687,7 @@ extern "C"
|
||||
#define GL_BUFFER_SIZE_OES 0x8764
|
||||
#define GL_BUFFER_USAGE_OES 0x8765
|
||||
#define GL_BUFFER_ACCESS_OES 0x88BB
|
||||
#endif /* GL_OES_vertex_buffer_object */
|
||||
#endif /* GL_OES_vertex_buffer_object */
|
||||
|
||||
/*************************************************************/
|
||||
|
||||
@ -973,8 +973,9 @@ extern "C"
|
||||
/* GL_OES_query_matrix */
|
||||
#ifndef GL_OES_query_matrix
|
||||
#define GL_OES_query_matrix 1
|
||||
GL_API GLbitfield GL_APIENTRY glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]);
|
||||
#endif /* GL_OES_query_matrix */
|
||||
GL_API GLbitfield GL_APIENTRY glQueryMatrixxOES(GLfixed mantissa[16],
|
||||
GLint exponent[16]);
|
||||
#endif /* GL_OES_query_matrix */
|
||||
|
||||
/* GL_OES_point_sprite */
|
||||
#ifndef GL_OES_point_sprite
|
||||
@ -984,26 +985,35 @@ extern "C"
|
||||
/* GL_OES_draw_texture */
|
||||
#ifndef GL_OES_draw_texture
|
||||
#define GL_OES_draw_texture 1
|
||||
GL_API void GL_APIENTRY glDrawTexsOES (GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
|
||||
GL_API void GL_APIENTRY glDrawTexiOES (GLint x, GLint y, GLint z, GLint width, GLint height);
|
||||
GL_API void GL_APIENTRY glDrawTexxOES (GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
|
||||
GL_API void GL_APIENTRY glDrawTexsvOES (const GLshort *coords);
|
||||
GL_API void GL_APIENTRY glDrawTexivOES (const GLint *coords);
|
||||
GL_API void GL_APIENTRY glDrawTexxvOES (const GLfixed *coords);
|
||||
GL_API void GL_APIENTRY glDrawTexfOES (GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
|
||||
GL_API void GL_APIENTRY glDrawTexfvOES (const GLfloat *coords);
|
||||
#endif /* GL_OES_draw_texture */
|
||||
GL_API void GL_APIENTRY glDrawTexsOES(GLshort x, GLshort y, GLshort z,
|
||||
GLshort width, GLshort height);
|
||||
GL_API void GL_APIENTRY glDrawTexiOES(GLint x, GLint y, GLint z,
|
||||
GLint width, GLint height);
|
||||
GL_API void GL_APIENTRY glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z,
|
||||
GLfixed width, GLfixed height);
|
||||
GL_API void GL_APIENTRY glDrawTexsvOES(const GLshort * coords);
|
||||
GL_API void GL_APIENTRY glDrawTexivOES(const GLint * coords);
|
||||
GL_API void GL_APIENTRY glDrawTexxvOES(const GLfixed * coords);
|
||||
GL_API void GL_APIENTRY glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z,
|
||||
GLfloat width, GLfloat height);
|
||||
GL_API void GL_APIENTRY glDrawTexfvOES(const GLfloat * coords);
|
||||
#endif /* GL_OES_draw_texture */
|
||||
|
||||
/* GL_OES_single_precision */
|
||||
#ifndef GL_OES_single_precision
|
||||
#define GL_OES_single_precision 1
|
||||
GL_API void GL_APIENTRY glDepthRangefOES (GLclampf zNear, GLclampf zFar);
|
||||
GL_API void GL_APIENTRY glFrustumfOES (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
|
||||
GL_API void GL_APIENTRY glOrthofOES (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
|
||||
GL_API void GL_APIENTRY glClipPlanefOES (GLenum plane, const GLfloat *equation);
|
||||
GL_API void GL_APIENTRY glGetClipPlanefOES (GLenum pname, GLfloat eqn[4]);
|
||||
GL_API void GL_APIENTRY glClearDepthfOES (GLclampf depth);
|
||||
#endif /* GL_OES_single_precision */
|
||||
GL_API void GL_APIENTRY glDepthRangefOES(GLclampf zNear, GLclampf zFar);
|
||||
GL_API void GL_APIENTRY glFrustumfOES(GLfloat left, GLfloat right,
|
||||
GLfloat bottom, GLfloat top,
|
||||
GLfloat zNear, GLfloat zFar);
|
||||
GL_API void GL_APIENTRY glOrthofOES(GLfloat left, GLfloat right,
|
||||
GLfloat bottom, GLfloat top,
|
||||
GLfloat zNear, GLfloat zFar);
|
||||
GL_API void GL_APIENTRY glClipPlanefOES(GLenum plane,
|
||||
const GLfloat * equation);
|
||||
GL_API void GL_APIENTRY glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]);
|
||||
GL_API void GL_APIENTRY glClearDepthfOES(GLclampf depth);
|
||||
#endif /* GL_OES_single_precision */
|
||||
|
||||
/* GL_OES_vertex_buffer_object */
|
||||
#ifndef GL_OES_vertex_buffer_object
|
||||
@ -1012,10 +1022,12 @@ extern "C"
|
||||
GL_API void APIENTRY glDeleteBuffersOES(GLsizei, const GLuint *);
|
||||
GL_API void APIENTRY glGenBuffersOES(GLsizei, GLuint *);
|
||||
GL_API GLboolean APIENTRY glIsBufferOES(GLuint);
|
||||
GL_API void APIENTRY glBufferDataOES(GLenum, GLsizeiptr, const GLvoid *, GLenum);
|
||||
GL_API void APIENTRY glBufferSubDataOES(GLenum, GLintptr, GLsizeiptr, const GLvoid *);
|
||||
GL_API void APIENTRY glBufferDataOES(GLenum, GLsizeiptr, const GLvoid *,
|
||||
GLenum);
|
||||
GL_API void APIENTRY glBufferSubDataOES(GLenum, GLintptr, GLsizeiptr,
|
||||
const GLvoid *);
|
||||
GL_API void APIENTRY glGetBufferParameterivOES(GLenum, GLenum, GLint *);
|
||||
#endif /* GL_OES_vertex_buffer_object */
|
||||
#endif /* GL_OES_vertex_buffer_object */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -271,8 +271,8 @@ typedef enum
|
||||
SDL_GL_MULTISAMPLESAMPLES,
|
||||
SDL_GL_ACCELERATED_VISUAL,
|
||||
SDL_GL_RETAINED_BACKING,
|
||||
SDL_GL_CONTEXT_MAJOR_VERSION,
|
||||
SDL_GL_CONTEXT_MINOR_VERSION
|
||||
SDL_GL_CONTEXT_MAJOR_VERSION,
|
||||
SDL_GL_CONTEXT_MINOR_VERSION
|
||||
} SDL_GLattr;
|
||||
|
||||
|
||||
|
||||
@ -494,7 +494,7 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SDL_GetDesktopDisplayMode(&desktop_mode);
|
||||
|
||||
if (width == 0) {
|
||||
|
||||
@ -477,7 +477,8 @@ SDL_RunAudio(void *devicep)
|
||||
/* Wait for an audio buffer to become available */
|
||||
current_audio.impl.WaitDevice(device);
|
||||
} else {
|
||||
SDL_Delay((device->spec.samples * 1000) / device->spec.freq);
|
||||
SDL_Delay((device->spec.samples * 1000) /
|
||||
device->spec.freq);
|
||||
}
|
||||
}
|
||||
|
||||
@ -525,7 +526,7 @@ SDL_RunAudio(void *devicep)
|
||||
/* Wait for an audio buffer to become available */
|
||||
current_audio.impl.WaitDevice(device);
|
||||
} else {
|
||||
SDL_Delay((device->spec.samples * 1000) / device->spec.freq);
|
||||
SDL_Delay((device->spec.samples * 1000) / device->spec.freq);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -44,7 +44,7 @@ struct SDL_PrivateAudioData
|
||||
/* The audio device handle */
|
||||
int cardno;
|
||||
int deviceno;
|
||||
snd_pcm_t* audio_handle;
|
||||
snd_pcm_t *audio_handle;
|
||||
|
||||
/* The audio file descriptor */
|
||||
int audio_fd;
|
||||
@ -53,7 +53,7 @@ struct SDL_PrivateAudioData
|
||||
uint32_t timeout_on_wait;
|
||||
|
||||
/* Raw mixing buffer */
|
||||
Uint8* pcm_buf;
|
||||
Uint8 *pcm_buf;
|
||||
Uint32 pcm_len;
|
||||
};
|
||||
|
||||
|
||||
@ -34,9 +34,10 @@
|
||||
|
||||
/* Empty function stub to get OpenGL ES 1.0 support without */
|
||||
/* OpenGL ES extension GL_OES_draw_texture_supported */
|
||||
GL_API void GL_APIENTRY glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
|
||||
GL_API void GL_APIENTRY
|
||||
glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
|
||||
{
|
||||
return;
|
||||
return;
|
||||
}
|
||||
|
||||
#endif /* __QNXNTO__ */
|
||||
@ -105,8 +106,7 @@ SDL_RenderDriver GL_ES_RenderDriver = {
|
||||
{
|
||||
/* OpenGL ES 1.x supported formats list */
|
||||
SDL_PIXELFORMAT_BGR24,
|
||||
SDL_PIXELFORMAT_ABGR8888
|
||||
},
|
||||
SDL_PIXELFORMAT_ABGR8888},
|
||||
0,
|
||||
0}
|
||||
};
|
||||
@ -351,7 +351,7 @@ power_of_2(int input)
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
|
||||
GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
|
||||
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
|
||||
@ -363,15 +363,15 @@ GLES_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
|
||||
|
||||
switch (texture->format) {
|
||||
case SDL_PIXELFORMAT_BGR24:
|
||||
internalFormat = GL_RGB;
|
||||
format = GL_RGB;
|
||||
type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
internalFormat = GL_RGB;
|
||||
format = GL_RGB;
|
||||
type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ABGR8888:
|
||||
internalFormat = GL_RGBA;
|
||||
format = GL_RGBA;
|
||||
type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
internalFormat = GL_RGBA;
|
||||
format = GL_RGBA;
|
||||
type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
/*
|
||||
These formats would be supported if SDL had the necessary pixel formats
|
||||
case SDL_PIXELFORMAT_BGR565:
|
||||
@ -389,7 +389,7 @@ GLES_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
|
||||
format = GL_RGBA;
|
||||
type = GL_UNSIGNED_SHORT_4_4_4_4;
|
||||
break;
|
||||
*/
|
||||
*/
|
||||
default:
|
||||
SDL_SetError("Unsupported texture format");
|
||||
return -1;
|
||||
@ -533,8 +533,8 @@ GLES_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
|
||||
const SDL_Rect *rect, const void *pixels, int pitch)
|
||||
GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels, int pitch)
|
||||
{
|
||||
GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
|
||||
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
|
||||
@ -858,7 +858,7 @@ GLES_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_RenderPresent(SDL_Renderer *renderer)
|
||||
GLES_RenderPresent(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_GL_SwapWindow(renderer->window);
|
||||
}
|
||||
|
||||
@ -1496,10 +1496,9 @@ SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags)
|
||||
window->renderer = SDL_CurrentDisplay.render_drivers[index]
|
||||
.CreateRenderer(window, flags);
|
||||
|
||||
if (window->renderer==NULL)
|
||||
{
|
||||
/* Assuming renderer set its error */
|
||||
return -1;
|
||||
if (window->renderer == NULL) {
|
||||
/* Assuming renderer set its error */
|
||||
return -1;
|
||||
}
|
||||
|
||||
SDL_SelectRenderer(window->id);
|
||||
@ -2719,7 +2718,7 @@ SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
|
||||
{
|
||||
#if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES
|
||||
void (APIENTRY * glGetIntegervFunc) (GLenum pname, GLint * params);
|
||||
GLenum (APIENTRY * glGetErrorFunc) (void);
|
||||
GLenum(APIENTRY * glGetErrorFunc) (void);
|
||||
GLenum attrib = 0;
|
||||
GLenum error = 0;
|
||||
|
||||
@ -2734,7 +2733,7 @@ SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
|
||||
}
|
||||
|
||||
/* Clear value in any case */
|
||||
*value=0;
|
||||
*value = 0;
|
||||
|
||||
switch (attr) {
|
||||
case SDL_GL_RETAINED_BACKING:
|
||||
@ -2842,28 +2841,26 @@ SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
|
||||
}
|
||||
|
||||
glGetIntegervFunc(attrib, (GLint *) value);
|
||||
error=glGetErrorFunc();
|
||||
if (error!=GL_NO_ERROR)
|
||||
{
|
||||
switch (error)
|
||||
{
|
||||
case GL_INVALID_ENUM:
|
||||
{
|
||||
SDL_SetError("OpenGL error: GL_INVALID_ENUM");
|
||||
}
|
||||
break;
|
||||
case GL_INVALID_VALUE:
|
||||
{
|
||||
SDL_SetError("OpenGL error: GL_INVALID_VALUE");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
SDL_SetError("OpenGL error: %08X", error);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return -1;
|
||||
error = glGetErrorFunc();
|
||||
if (error != GL_NO_ERROR) {
|
||||
switch (error) {
|
||||
case GL_INVALID_ENUM:
|
||||
{
|
||||
SDL_SetError("OpenGL error: GL_INVALID_ENUM");
|
||||
}
|
||||
break;
|
||||
case GL_INVALID_VALUE:
|
||||
{
|
||||
SDL_SetError("OpenGL error: GL_INVALID_VALUE");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
SDL_SetError("OpenGL error: %08X", error);
|
||||
}
|
||||
break;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
#else
|
||||
|
||||
@ -88,7 +88,7 @@ SDL_RenderDriver NDS_RenderDriver = {
|
||||
SDL_PIXELFORMAT_INDEX8,
|
||||
SDL_PIXELFORMAT_ABGR1555,
|
||||
SDL_PIXELFORMAT_BGR555,
|
||||
}, /* u32 texture_formats[20] */
|
||||
}, /* u32 texture_formats[20] */
|
||||
(256), /* int max_texture_width */
|
||||
(256), /* int max_texture_height */
|
||||
}
|
||||
@ -107,8 +107,14 @@ typedef struct
|
||||
{ NDSTX_BG, NDSTX_SPR } type; /* represented in a bg or sprite. */
|
||||
int hw_index; /* index of sprite in OAM or bg from libnds */
|
||||
int pitch, bpp; /* useful information about the texture */
|
||||
struct { int x,y; } scale; /* x/y stretch (24.8 fixed point) */
|
||||
struct { int x,y; } scroll; /* x/y offset */
|
||||
struct
|
||||
{
|
||||
int x, y;
|
||||
} scale; /* x/y stretch (24.8 fixed point) */
|
||||
struct
|
||||
{
|
||||
int x, y;
|
||||
} scroll; /* x/y offset */
|
||||
int rotate; /* -32768 to 32767, texture rotation */
|
||||
u16 *vram_pixels; /* where the pixel data is stored (a pointer into VRAM) */
|
||||
u16 *vram_palette; /* where the palette data is stored if it's indexed. */
|
||||
@ -197,9 +203,9 @@ NDS_CreateRenderer(SDL_Window * window, Uint32 flags)
|
||||
renderer->info.max_texture_height =
|
||||
NDS_RenderDriver.info.max_texture_height;
|
||||
|
||||
data->sub = 0; /* TODO: this is hard-coded to the "main" screen.
|
||||
figure out how to detect whether to set it to
|
||||
"sub" screen. window->id, perhaps? */
|
||||
data->sub = 0; /* TODO: this is hard-coded to the "main" screen.
|
||||
figure out how to detect whether to set it to
|
||||
"sub" screen. window->id, perhaps? */
|
||||
data->bg_taken[2] = data->bg_taken[3] = 0;
|
||||
|
||||
return renderer;
|
||||
@ -310,9 +316,10 @@ NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
txdat->dim.vdy = 0x100;
|
||||
txdat->dim.pitch = pitch;
|
||||
txdat->dim.bpp = bpp;
|
||||
txdat->vram_pixels = (u16 *) (data->sub ? SPRITE_GFX_SUB : SPRITE_GFX);
|
||||
txdat->vram_pixels =
|
||||
(u16 *) (data->sub ? SPRITE_GFX_SUB : SPRITE_GFX);
|
||||
/* FIXME: use tileIdx*boundary
|
||||
to point to proper location */
|
||||
to point to proper location */
|
||||
} else {
|
||||
SDL_SetError("Out of NDS sprites.");
|
||||
}
|
||||
@ -332,20 +339,26 @@ NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
// hard-coded for 256x256 for now...
|
||||
// TODO: a series of if-elseif-else's to find the closest but larger size.
|
||||
if(!data->sub) {
|
||||
if(bpp==8) {
|
||||
txdat->hw_index = bgInit(whichbg, BgType_Bmp8, BgSize_B8_256x256, 0, 0);
|
||||
if (!data->sub) {
|
||||
if (bpp == 8) {
|
||||
txdat->hw_index =
|
||||
bgInit(whichbg, BgType_Bmp8, BgSize_B8_256x256, 0, 0);
|
||||
} else {
|
||||
txdat->hw_index = bgInit(whichbg, BgType_Bmp16, BgSize_B16_256x256, 0, 0);
|
||||
txdat->hw_index =
|
||||
bgInit(whichbg, BgType_Bmp16, BgSize_B16_256x256, 0,
|
||||
0);
|
||||
}
|
||||
} else {
|
||||
if(bpp==8) {
|
||||
txdat->hw_index = bgInitSub(whichbg, BgType_Bmp8, BgSize_B8_256x256, 0, 0);
|
||||
if (bpp == 8) {
|
||||
txdat->hw_index =
|
||||
bgInitSub(whichbg, BgType_Bmp8, BgSize_B8_256x256, 0,
|
||||
0);
|
||||
} else {
|
||||
txdat->hw_index = bgInitSub(whichbg, BgType_Bmp16, BgSize_B16_256x256, 0, 0);
|
||||
txdat->hw_index =
|
||||
bgInitSub(whichbg, BgType_Bmp16, BgSize_B16_256x256,
|
||||
0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
@ -357,14 +370,14 @@ NDS_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
bgUpdate(bg3);
|
||||
*/
|
||||
txdat->type = NDSTX_BG;
|
||||
txdat->pitch = (texture->w)*(bpp/8);
|
||||
txdat->pitch = (texture->w) * (bpp / 8);
|
||||
txdat->bpp = bpp;
|
||||
txdat->rotate = 0;
|
||||
txdat->scale.x = 0x100;
|
||||
txdat->scale.y = 0x100;
|
||||
txdat->scroll.x = 0;
|
||||
txdat->scroll.y = 0;
|
||||
txdat->vram_pixels = (u16*)bgGetGfxPtr(txdat->hw_index);
|
||||
txdat->vram_pixels = (u16 *) bgGetGfxPtr(txdat->hw_index);
|
||||
|
||||
bgSetCenter(txdat->hw_index, 0, 0);
|
||||
bgSetRotateScale(txdat->hw_index, txdat->rotate, txdat->scale.x,
|
||||
@ -458,7 +471,7 @@ NDS_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
|
||||
int i, j;
|
||||
|
||||
printf("NDS_RenderFill: stub\n");
|
||||
color = RGB8(r, g, b); /* macro in libnds that makes an ARGB1555 pixel */
|
||||
color = RGB8(r, g, b); /* macro in libnds that makes an ARGB1555 pixel */
|
||||
/* TODO: make a single-color sprite and stretch it.
|
||||
calculate the "HDX" width modifier of the sprite by:
|
||||
let S be the actual sprite's width (like, 32 pixels for example)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -29,8 +29,8 @@
|
||||
|
||||
/* GF headers must be included first for the Photon GF functions */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
#include <gf/gf.h>
|
||||
#include <GLES/egl.h>
|
||||
#include <gf/gf.h>
|
||||
#include <GLES/egl.h>
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
|
||||
#include "SDL_config.h"
|
||||
@ -45,17 +45,17 @@
|
||||
|
||||
typedef struct SDL_VideoData
|
||||
{
|
||||
PhRid_t rid[SDL_VIDEO_PHOTON_MAX_RIDS];
|
||||
uint32_t avail_rids;
|
||||
uint32_t current_device_id;
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
gf_dev_t gfdev; /* GF device handle */
|
||||
gf_dev_info_t gfdev_info; /* GF device information */
|
||||
SDL_bool gfinitialized; /* GF device initialization status */
|
||||
EGLDisplay egldisplay; /* OpenGL ES display connection */
|
||||
uint32_t egl_refcount; /* OpenGL ES reference count */
|
||||
uint32_t swapinterval; /* OpenGL ES default swap interval */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
PhRid_t rid[SDL_VIDEO_PHOTON_MAX_RIDS];
|
||||
uint32_t avail_rids;
|
||||
uint32_t current_device_id;
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
gf_dev_t gfdev; /* GF device handle */
|
||||
gf_dev_info_t gfdev_info; /* GF device information */
|
||||
SDL_bool gfinitialized; /* GF device initialization status */
|
||||
EGLDisplay egldisplay; /* OpenGL ES display connection */
|
||||
uint32_t egl_refcount; /* OpenGL ES reference count */
|
||||
uint32_t swapinterval; /* OpenGL ES default swap interval */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
} SDL_VideoData;
|
||||
|
||||
/* This is hardcoded value in photon/Pg.h */
|
||||
@ -67,19 +67,19 @@ typedef struct SDL_VideoData
|
||||
|
||||
typedef struct SDL_DisplayData
|
||||
{
|
||||
uint32_t device_id;
|
||||
uint32_t custom_refresh; /* Custom refresh rate for all modes */
|
||||
SDL_DisplayMode current_mode; /* Current video mode */
|
||||
uint8_t description[SDL_VIDEO_PHOTON_DEVICENAME_MAX];
|
||||
/* Device description */
|
||||
uint32_t caps; /* Device capabilities */
|
||||
PhCursorDef_t* cursor; /* Global cursor settings */
|
||||
SDL_bool cursor_visible; /* SDL_TRUE if cursor visible */
|
||||
uint32_t cursor_size; /* Cursor size in memory w/ structure */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
gf_display_t display; /* GF display handle */
|
||||
gf_display_info_t display_info; /* GF display information */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
uint32_t device_id;
|
||||
uint32_t custom_refresh; /* Custom refresh rate for all modes */
|
||||
SDL_DisplayMode current_mode; /* Current video mode */
|
||||
uint8_t description[SDL_VIDEO_PHOTON_DEVICENAME_MAX];
|
||||
/* Device description */
|
||||
uint32_t caps; /* Device capabilities */
|
||||
PhCursorDef_t *cursor; /* Global cursor settings */
|
||||
SDL_bool cursor_visible; /* SDL_TRUE if cursor visible */
|
||||
uint32_t cursor_size; /* Cursor size in memory w/ structure */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
gf_display_t display; /* GF display handle */
|
||||
gf_display_info_t display_info; /* GF display information */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
} SDL_DisplayData;
|
||||
|
||||
/* Maximum amount of OpenGL ES framebuffer configurations */
|
||||
@ -87,18 +87,18 @@ typedef struct SDL_DisplayData
|
||||
|
||||
typedef struct SDL_WindowData
|
||||
{
|
||||
SDL_bool uses_gles; /* if true window must support OpenGL ES*/
|
||||
PtWidget_t* window; /* window handle */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
EGLConfig gles_configs[SDL_VIDEO_GF_OPENGLES_CONFS];
|
||||
/* OpenGL ES framebuffer confs */
|
||||
EGLint gles_config; /* OpenGL ES configuration index */
|
||||
EGLContext gles_context; /* OpenGL ES context */
|
||||
EGLint gles_attributes[256]; /* OpenGL ES attributes for context */
|
||||
EGLSurface gles_surface; /* OpenGL ES target rendering surface */
|
||||
gf_surface_t gfsurface; /* OpenGL ES GF's surface */
|
||||
PdOffscreenContext_t* phsurface; /* OpenGL ES Photon's surface */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
SDL_bool uses_gles; /* if true window must support OpenGL ES */
|
||||
PtWidget_t *window; /* window handle */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
EGLConfig gles_configs[SDL_VIDEO_GF_OPENGLES_CONFS];
|
||||
/* OpenGL ES framebuffer confs */
|
||||
EGLint gles_config; /* OpenGL ES configuration index */
|
||||
EGLContext gles_context; /* OpenGL ES context */
|
||||
EGLint gles_attributes[256]; /* OpenGL ES attributes for context */
|
||||
EGLSurface gles_surface; /* OpenGL ES target rendering surface */
|
||||
gf_surface_t gfsurface; /* OpenGL ES GF's surface */
|
||||
PdOffscreenContext_t *phsurface; /* OpenGL ES Photon's surface */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
} SDL_WindowData;
|
||||
|
||||
/****************************************************************************/
|
||||
@ -106,8 +106,8 @@ typedef struct SDL_WindowData
|
||||
/****************************************************************************/
|
||||
typedef struct Photon_DeviceCaps
|
||||
{
|
||||
uint8_t* name;
|
||||
uint32_t caps;
|
||||
uint8_t *name;
|
||||
uint32_t caps;
|
||||
} Photon_DeviceCaps;
|
||||
|
||||
#define SDL_PHOTON_UNACCELERATED 0x00000000
|
||||
@ -120,41 +120,42 @@ typedef struct Photon_DeviceCaps
|
||||
/****************************************************************************/
|
||||
|
||||
/* Display and window functions */
|
||||
int photon_videoinit(_THIS);
|
||||
int photon_videoinit(_THIS);
|
||||
void photon_videoquit(_THIS);
|
||||
void photon_getdisplaymodes(_THIS);
|
||||
int photon_setdisplaymode(_THIS, SDL_DisplayMode* mode);
|
||||
int photon_setdisplaypalette(_THIS, SDL_Palette* palette);
|
||||
int photon_getdisplaypalette(_THIS, SDL_Palette* palette);
|
||||
int photon_setdisplaygammaramp(_THIS, Uint16* ramp);
|
||||
int photon_getdisplaygammaramp(_THIS, Uint16* ramp);
|
||||
int photon_createwindow(_THIS, SDL_Window* window);
|
||||
int photon_createwindowfrom(_THIS, SDL_Window* window, const void* data);
|
||||
void photon_setwindowtitle(_THIS, SDL_Window* window);
|
||||
void photon_setwindowicon(_THIS, SDL_Window* window, SDL_Surface* icon);
|
||||
void photon_setwindowposition(_THIS, SDL_Window* window);
|
||||
void photon_setwindowsize(_THIS, SDL_Window* window);
|
||||
void photon_showwindow(_THIS, SDL_Window* window);
|
||||
void photon_hidewindow(_THIS, SDL_Window* window);
|
||||
void photon_raisewindow(_THIS, SDL_Window* window);
|
||||
void photon_maximizewindow(_THIS, SDL_Window* window);
|
||||
void photon_minimizewindow(_THIS, SDL_Window* window);
|
||||
void photon_restorewindow(_THIS, SDL_Window* window);
|
||||
void photon_setwindowgrab(_THIS, SDL_Window* window);
|
||||
void photon_destroywindow(_THIS, SDL_Window* window);
|
||||
int photon_setdisplaymode(_THIS, SDL_DisplayMode * mode);
|
||||
int photon_setdisplaypalette(_THIS, SDL_Palette * palette);
|
||||
int photon_getdisplaypalette(_THIS, SDL_Palette * palette);
|
||||
int photon_setdisplaygammaramp(_THIS, Uint16 * ramp);
|
||||
int photon_getdisplaygammaramp(_THIS, Uint16 * ramp);
|
||||
int photon_createwindow(_THIS, SDL_Window * window);
|
||||
int photon_createwindowfrom(_THIS, SDL_Window * window, const void *data);
|
||||
void photon_setwindowtitle(_THIS, SDL_Window * window);
|
||||
void photon_setwindowicon(_THIS, SDL_Window * window, SDL_Surface * icon);
|
||||
void photon_setwindowposition(_THIS, SDL_Window * window);
|
||||
void photon_setwindowsize(_THIS, SDL_Window * window);
|
||||
void photon_showwindow(_THIS, SDL_Window * window);
|
||||
void photon_hidewindow(_THIS, SDL_Window * window);
|
||||
void photon_raisewindow(_THIS, SDL_Window * window);
|
||||
void photon_maximizewindow(_THIS, SDL_Window * window);
|
||||
void photon_minimizewindow(_THIS, SDL_Window * window);
|
||||
void photon_restorewindow(_THIS, SDL_Window * window);
|
||||
void photon_setwindowgrab(_THIS, SDL_Window * window);
|
||||
void photon_destroywindow(_THIS, SDL_Window * window);
|
||||
|
||||
/* Window manager function */
|
||||
SDL_bool photon_getwindowwminfo(_THIS, SDL_Window* window, struct SDL_SysWMinfo* info);
|
||||
SDL_bool photon_getwindowwminfo(_THIS, SDL_Window * window,
|
||||
struct SDL_SysWMinfo *info);
|
||||
|
||||
/* OpenGL/OpenGL ES functions */
|
||||
int photon_gl_loadlibrary(_THIS, const char* path);
|
||||
void* photon_gl_getprocaddres(_THIS, const char* proc);
|
||||
int photon_gl_loadlibrary(_THIS, const char *path);
|
||||
void *photon_gl_getprocaddres(_THIS, const char *proc);
|
||||
void photon_gl_unloadlibrary(_THIS);
|
||||
SDL_GLContext photon_gl_createcontext(_THIS, SDL_Window* window);
|
||||
int photon_gl_makecurrent(_THIS, SDL_Window* window, SDL_GLContext context);
|
||||
SDL_GLContext photon_gl_createcontext(_THIS, SDL_Window * window);
|
||||
int photon_gl_makecurrent(_THIS, SDL_Window * window, SDL_GLContext context);
|
||||
int photon_gl_setswapinterval(_THIS, int interval);
|
||||
int photon_gl_getswapinterval(_THIS);
|
||||
void photon_gl_swapwindow(_THIS, SDL_Window* window);
|
||||
void photon_gl_swapwindow(_THIS, SDL_Window * window);
|
||||
void photon_gl_deletecontext(_THIS, SDL_GLContext context);
|
||||
|
||||
/* Event handling function */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -35,7 +35,7 @@
|
||||
|
||||
typedef struct SDL_MouseData
|
||||
{
|
||||
SDL_DisplayData* didata;
|
||||
SDL_DisplayData *didata;
|
||||
} SDL_MouseData;
|
||||
|
||||
int32_t photon_addinputdevices(_THIS);
|
||||
|
||||
@ -104,9 +104,11 @@
|
||||
#define PHOTON_SCANCODE_SPACE 0x39
|
||||
#define PHOTON_SCANCODE_MENU 0x5D
|
||||
|
||||
#define PHOTON_SCANCODE_PRNSCR 0x54 /* only key pressed event, no release */
|
||||
#define PHOTON_SCANCODE_PRNSCR 0x54 /* only key pressed event, no release */
|
||||
#define PHOTON_SCANCODE_SCROLLLOCK 0x46
|
||||
/* #define PHOTON_SCANCODE_PAUSE 0x?? */ /* pause doesn't generates a scancode */
|
||||
#if 0 /* pause doesn't generates a scancode */
|
||||
#define PHOTON_SCANCODE_PAUSE 0x??
|
||||
#endif
|
||||
#define PHOTON_SCANCODE_INSERT 0x52
|
||||
#define PHOTON_SCANCODE_HOME 0x47
|
||||
#define PHOTON_SCANCODE_PAGEUP 0x49
|
||||
|
||||
@ -26,173 +26,173 @@
|
||||
|
||||
#include "SDL_photon_pixelfmt.h"
|
||||
|
||||
uint32_t photon_bits_to_sdl_pixelformat(uint32_t pixelfmt)
|
||||
uint32_t
|
||||
photon_bits_to_sdl_pixelformat(uint32_t pixelfmt)
|
||||
{
|
||||
switch(pixelfmt)
|
||||
{
|
||||
case 8:
|
||||
{
|
||||
return SDL_PIXELFORMAT_INDEX8;
|
||||
}
|
||||
break;
|
||||
case 15:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case 24:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB888;
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB8888;
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (pixelfmt) {
|
||||
case 8:
|
||||
{
|
||||
return SDL_PIXELFORMAT_INDEX8;
|
||||
}
|
||||
break;
|
||||
case 15:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case 24:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB888;
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB8888;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t photon_sdl_to_bits_pixelformat(uint32_t pixelfmt)
|
||||
uint32_t
|
||||
photon_sdl_to_bits_pixelformat(uint32_t pixelfmt)
|
||||
{
|
||||
switch(pixelfmt)
|
||||
{
|
||||
case SDL_PIXELFORMAT_INDEX8:
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB1555:
|
||||
{
|
||||
return 15;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ABGR1555:
|
||||
{
|
||||
return 15;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB888:
|
||||
{
|
||||
return 24;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_BGRA8888:
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB8888:
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YV12:
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YUY2:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_UYVY:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YVYU:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (pixelfmt) {
|
||||
case SDL_PIXELFORMAT_INDEX8:
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB1555:
|
||||
{
|
||||
return 15;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ABGR1555:
|
||||
{
|
||||
return 15;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB888:
|
||||
{
|
||||
return 24;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_BGRA8888:
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB8888:
|
||||
{
|
||||
return 32;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YV12:
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YUY2:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_UYVY:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YVYU:
|
||||
{
|
||||
return 16;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t photon_image_to_sdl_pixelformat(uint32_t pixelfmt)
|
||||
uint32_t
|
||||
photon_image_to_sdl_pixelformat(uint32_t pixelfmt)
|
||||
{
|
||||
switch(pixelfmt)
|
||||
{
|
||||
case Pg_IMAGE_PALETTE_BYTE:
|
||||
{
|
||||
return SDL_PIXELFORMAT_INDEX8;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_8888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_BGRA8888;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB888;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB555;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (pixelfmt) {
|
||||
case Pg_IMAGE_PALETTE_BYTE:
|
||||
{
|
||||
return SDL_PIXELFORMAT_INDEX8;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_8888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_BGRA8888;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB888;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB555;
|
||||
}
|
||||
break;
|
||||
case Pg_IMAGE_DIRECT_1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t photon_sdl_to_image_pixelformat(uint32_t pixelfmt)
|
||||
uint32_t
|
||||
photon_sdl_to_image_pixelformat(uint32_t pixelfmt)
|
||||
{
|
||||
switch(pixelfmt)
|
||||
{
|
||||
case SDL_PIXELFORMAT_INDEX8:
|
||||
{
|
||||
return Pg_IMAGE_PALETTE_BYTE;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_BGRA8888:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_8888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB888:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_565;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB1555:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_1555;
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (pixelfmt) {
|
||||
case SDL_PIXELFORMAT_INDEX8:
|
||||
{
|
||||
return Pg_IMAGE_PALETTE_BYTE;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_BGRA8888:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_8888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB888:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_565;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB1555:
|
||||
{
|
||||
return Pg_IMAGE_DIRECT_1555;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
|
||||
@ -34,308 +34,343 @@
|
||||
#include "SDL_photon_render.h"
|
||||
#include "SDL_photon.h"
|
||||
|
||||
static SDL_Renderer* photon_createrenderer(SDL_Window* window, Uint32 flags);
|
||||
static int photon_displaymodechanged(SDL_Renderer* renderer);
|
||||
static int photon_activaterenderer(SDL_Renderer* renderer);
|
||||
static int photon_createtexture(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int photon_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch);
|
||||
static int photon_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors);
|
||||
static int photon_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors);
|
||||
static int photon_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int photon_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int photon_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int photon_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int photon_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch);
|
||||
static int photon_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch);
|
||||
static void photon_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static void photon_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects);
|
||||
static int photon_renderpoint(SDL_Renderer* renderer, int x, int y);
|
||||
static int photon_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2);
|
||||
static int photon_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect);
|
||||
static int photon_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect);
|
||||
static void photon_renderpresent(SDL_Renderer* renderer);
|
||||
static void photon_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static void photon_destroyrenderer(SDL_Renderer* renderer);
|
||||
static SDL_Renderer *photon_createrenderer(SDL_Window * window, Uint32 flags);
|
||||
static int photon_displaymodechanged(SDL_Renderer * renderer);
|
||||
static int photon_activaterenderer(SDL_Renderer * renderer);
|
||||
static int photon_createtexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int photon_querytexturepixels(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture, void **pixels,
|
||||
int *pitch);
|
||||
static int photon_settexturepalette(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture,
|
||||
const SDL_Color * colors, int firstcolor,
|
||||
int ncolors);
|
||||
static int photon_gettexturepalette(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture, SDL_Color * colors,
|
||||
int firstcolor, int ncolors);
|
||||
static int photon_settexturecolormod(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int photon_settexturealphamod(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int photon_settextureblendmode(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int photon_settexturescalemode(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int photon_updatetexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture, const SDL_Rect * rect,
|
||||
const void *pixels, int pitch);
|
||||
static int photon_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, int markDirty,
|
||||
void **pixels, int *pitch);
|
||||
static void photon_unlocktexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static void photon_dirtytexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture, int numrects,
|
||||
const SDL_Rect * rects);
|
||||
static int photon_renderpoint(SDL_Renderer * renderer, int x, int y);
|
||||
static int photon_renderline(SDL_Renderer * renderer, int x1, int y1, int x2,
|
||||
int y2);
|
||||
static int photon_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect);
|
||||
static int photon_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect,
|
||||
const SDL_Rect * dstrect);
|
||||
static void photon_renderpresent(SDL_Renderer * renderer);
|
||||
static void photon_destroytexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static void photon_destroyrenderer(SDL_Renderer * renderer);
|
||||
|
||||
SDL_RenderDriver photon_renderdriver=
|
||||
{
|
||||
SDL_RenderDriver photon_renderdriver = {
|
||||
photon_createrenderer,
|
||||
{
|
||||
"photon",
|
||||
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
|
||||
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
|
||||
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
|
||||
SDL_RENDERER_ACCELERATED),
|
||||
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
|
||||
SDL_TEXTUREMODULATE_ALPHA),
|
||||
(SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
|
||||
SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
|
||||
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW),
|
||||
13,
|
||||
{
|
||||
SDL_PIXELFORMAT_INDEX8,
|
||||
SDL_PIXELFORMAT_RGB555,
|
||||
SDL_PIXELFORMAT_RGB565,
|
||||
SDL_PIXELFORMAT_RGB888,
|
||||
SDL_PIXELFORMAT_BGR888,
|
||||
SDL_PIXELFORMAT_ARGB8888,
|
||||
SDL_PIXELFORMAT_RGBA8888,
|
||||
SDL_PIXELFORMAT_ABGR8888,
|
||||
SDL_PIXELFORMAT_BGRA8888,
|
||||
SDL_PIXELFORMAT_YV12,
|
||||
SDL_PIXELFORMAT_YUY2,
|
||||
SDL_PIXELFORMAT_UYVY,
|
||||
SDL_PIXELFORMAT_YVYU
|
||||
},
|
||||
0,
|
||||
0
|
||||
}
|
||||
"photon",
|
||||
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
|
||||
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
|
||||
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
|
||||
SDL_RENDERER_ACCELERATED),
|
||||
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
|
||||
SDL_TEXTUREMODULATE_ALPHA),
|
||||
(SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
|
||||
SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
|
||||
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW),
|
||||
13,
|
||||
{
|
||||
SDL_PIXELFORMAT_INDEX8,
|
||||
SDL_PIXELFORMAT_RGB555,
|
||||
SDL_PIXELFORMAT_RGB565,
|
||||
SDL_PIXELFORMAT_RGB888,
|
||||
SDL_PIXELFORMAT_BGR888,
|
||||
SDL_PIXELFORMAT_ARGB8888,
|
||||
SDL_PIXELFORMAT_RGBA8888,
|
||||
SDL_PIXELFORMAT_ABGR8888,
|
||||
SDL_PIXELFORMAT_BGRA8888,
|
||||
SDL_PIXELFORMAT_YV12,
|
||||
SDL_PIXELFORMAT_YUY2,
|
||||
SDL_PIXELFORMAT_UYVY,
|
||||
SDL_PIXELFORMAT_YVYU},
|
||||
0,
|
||||
0}
|
||||
};
|
||||
|
||||
static SDL_Renderer* photon_createrenderer(SDL_Window* window, Uint32 flags)
|
||||
static SDL_Renderer *
|
||||
photon_createrenderer(SDL_Window * window, Uint32 flags)
|
||||
{
|
||||
SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(window);
|
||||
SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata;
|
||||
SDL_WindowData* wdata = (SDL_WindowData*)window->driverdata;
|
||||
SDL_Renderer* renderer = NULL;
|
||||
SDL_RenderData* rdata = NULL;
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
|
||||
SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
|
||||
SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
|
||||
SDL_Renderer *renderer = NULL;
|
||||
SDL_RenderData *rdata = NULL;
|
||||
|
||||
/* Allocate new renderer structure */
|
||||
renderer=(SDL_Renderer*)SDL_calloc(1, sizeof(SDL_Renderer));
|
||||
if (renderer==NULL)
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
/* Allocate new renderer structure */
|
||||
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(SDL_Renderer));
|
||||
if (renderer == NULL) {
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Allocate renderer data */
|
||||
rdata=(SDL_RenderData*)SDL_calloc(1, sizeof(SDL_RenderData));
|
||||
if (rdata==NULL)
|
||||
{
|
||||
SDL_free(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
/* Allocate renderer data */
|
||||
rdata = (SDL_RenderData *) SDL_calloc(1, sizeof(SDL_RenderData));
|
||||
if (rdata == NULL) {
|
||||
SDL_free(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
renderer->DisplayModeChanged=photon_displaymodechanged;
|
||||
renderer->ActivateRenderer=photon_activaterenderer;
|
||||
renderer->CreateTexture=photon_createtexture;
|
||||
renderer->QueryTexturePixels=photon_querytexturepixels;
|
||||
renderer->SetTexturePalette=photon_settexturepalette;
|
||||
renderer->GetTexturePalette=photon_gettexturepalette;
|
||||
renderer->SetTextureAlphaMod=photon_settexturealphamod;
|
||||
renderer->SetTextureColorMod=photon_settexturecolormod;
|
||||
renderer->SetTextureBlendMode=photon_settextureblendmode;
|
||||
renderer->SetTextureScaleMode=photon_settexturescalemode;
|
||||
renderer->UpdateTexture=photon_updatetexture;
|
||||
renderer->LockTexture=photon_locktexture;
|
||||
renderer->UnlockTexture=photon_unlocktexture;
|
||||
renderer->DirtyTexture=photon_dirtytexture;
|
||||
renderer->RenderPoint=photon_renderpoint;
|
||||
renderer->RenderLine=photon_renderline;
|
||||
renderer->RenderFill=photon_renderfill;
|
||||
renderer->RenderCopy=photon_rendercopy;
|
||||
renderer->RenderPresent = photon_renderpresent;
|
||||
renderer->DestroyTexture = photon_destroytexture;
|
||||
renderer->DestroyRenderer = photon_destroyrenderer;
|
||||
renderer->info = photon_renderdriver.info;
|
||||
renderer->window = window->id;
|
||||
renderer->driverdata = rdata;
|
||||
renderer->DisplayModeChanged = photon_displaymodechanged;
|
||||
renderer->ActivateRenderer = photon_activaterenderer;
|
||||
renderer->CreateTexture = photon_createtexture;
|
||||
renderer->QueryTexturePixels = photon_querytexturepixels;
|
||||
renderer->SetTexturePalette = photon_settexturepalette;
|
||||
renderer->GetTexturePalette = photon_gettexturepalette;
|
||||
renderer->SetTextureAlphaMod = photon_settexturealphamod;
|
||||
renderer->SetTextureColorMod = photon_settexturecolormod;
|
||||
renderer->SetTextureBlendMode = photon_settextureblendmode;
|
||||
renderer->SetTextureScaleMode = photon_settexturescalemode;
|
||||
renderer->UpdateTexture = photon_updatetexture;
|
||||
renderer->LockTexture = photon_locktexture;
|
||||
renderer->UnlockTexture = photon_unlocktexture;
|
||||
renderer->DirtyTexture = photon_dirtytexture;
|
||||
renderer->RenderPoint = photon_renderpoint;
|
||||
renderer->RenderLine = photon_renderline;
|
||||
renderer->RenderFill = photon_renderfill;
|
||||
renderer->RenderCopy = photon_rendercopy;
|
||||
renderer->RenderPresent = photon_renderpresent;
|
||||
renderer->DestroyTexture = photon_destroytexture;
|
||||
renderer->DestroyRenderer = photon_destroyrenderer;
|
||||
renderer->info = photon_renderdriver.info;
|
||||
renderer->window = window->id;
|
||||
renderer->driverdata = rdata;
|
||||
|
||||
/* Set render acceleration flag in case it is accelerated */
|
||||
if ((didata->caps & SDL_PHOTON_ACCELERATED)==SDL_PHOTON_ACCELERATED)
|
||||
{
|
||||
renderer->info.flags=SDL_RENDERER_ACCELERATED;
|
||||
}
|
||||
else
|
||||
{
|
||||
renderer->info.flags&=~(SDL_RENDERER_ACCELERATED);
|
||||
}
|
||||
/* Set render acceleration flag in case it is accelerated */
|
||||
if ((didata->caps & SDL_PHOTON_ACCELERATED) == SDL_PHOTON_ACCELERATED) {
|
||||
renderer->info.flags = SDL_RENDERER_ACCELERATED;
|
||||
} else {
|
||||
renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED);
|
||||
}
|
||||
|
||||
rdata->window=window;
|
||||
rdata->window = window;
|
||||
|
||||
/* Check if upper level requested synchronization on vsync signal */
|
||||
if ((flags & SDL_RENDERER_PRESENTVSYNC)==SDL_RENDERER_PRESENTVSYNC)
|
||||
{
|
||||
rdata->enable_vsync=SDL_TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
rdata->enable_vsync=SDL_FALSE;
|
||||
}
|
||||
/* Check if upper level requested synchronization on vsync signal */
|
||||
if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) {
|
||||
rdata->enable_vsync = SDL_TRUE;
|
||||
} else {
|
||||
rdata->enable_vsync = SDL_FALSE;
|
||||
}
|
||||
|
||||
/* Check what buffer copy/flip scheme is requested */
|
||||
rdata->surfaces_count=0;
|
||||
if ((flags & SDL_RENDERER_SINGLEBUFFER)==SDL_RENDERER_SINGLEBUFFER)
|
||||
{
|
||||
if ((flags & SDL_RENDERER_PRESENTDISCARD)==SDL_RENDERER_PRESENTDISCARD)
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;
|
||||
}
|
||||
else
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
}
|
||||
rdata->surfaces_count=1;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP2)==SDL_RENDERER_PRESENTFLIP2)
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_PRESENTFLIP2;
|
||||
rdata->surfaces_count=2;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP3)==SDL_RENDERER_PRESENTFLIP3)
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_PRESENTFLIP3;
|
||||
rdata->surfaces_count=3;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
rdata->surfaces_count=1;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Check what buffer copy/flip scheme is requested */
|
||||
rdata->surfaces_count = 0;
|
||||
if ((flags & SDL_RENDERER_SINGLEBUFFER) == SDL_RENDERER_SINGLEBUFFER) {
|
||||
if ((flags & SDL_RENDERER_PRESENTDISCARD) ==
|
||||
SDL_RENDERER_PRESENTDISCARD) {
|
||||
renderer->info.flags |=
|
||||
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;
|
||||
} else {
|
||||
renderer->info.flags |=
|
||||
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
}
|
||||
rdata->surfaces_count = 1;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 0;
|
||||
} else {
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP2) == SDL_RENDERER_PRESENTFLIP2) {
|
||||
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
|
||||
rdata->surfaces_count = 2;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 1;
|
||||
} else {
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP3) ==
|
||||
SDL_RENDERER_PRESENTFLIP3) {
|
||||
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
|
||||
rdata->surfaces_count = 3;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 1;
|
||||
} else {
|
||||
renderer->info.flags |=
|
||||
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
rdata->surfaces_count = 1;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return renderer;
|
||||
return renderer;
|
||||
}
|
||||
|
||||
void photon_addrenderdriver(_THIS)
|
||||
void
|
||||
photon_addrenderdriver(_THIS)
|
||||
{
|
||||
uint32_t it;
|
||||
uint32_t it;
|
||||
|
||||
for (it=0; it<_this->num_displays; it++)
|
||||
{
|
||||
SDL_AddRenderDriver(it, &photon_renderdriver);
|
||||
}
|
||||
for (it = 0; it < _this->num_displays; it++) {
|
||||
SDL_AddRenderDriver(it, &photon_renderdriver);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************/
|
||||
/* SDL render interface */
|
||||
/****************************************************************************/
|
||||
static int photon_displaymodechanged(SDL_Renderer* renderer)
|
||||
static int
|
||||
photon_displaymodechanged(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata;
|
||||
SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
|
||||
|
||||
/* Remove all allocated surfaces, they are no more valid */
|
||||
/* Remove all allocated surfaces, they are no more valid */
|
||||
|
||||
/* TODO: Add video mode change detection and new parameters detection */
|
||||
/* TODO: Add video mode change detection and new parameters detection */
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int photon_activaterenderer(SDL_Renderer* renderer)
|
||||
static int
|
||||
photon_activaterenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata;
|
||||
SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(rdata->window);
|
||||
SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata;
|
||||
SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(rdata->window);
|
||||
SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int photon_createtexture(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
photon_createtexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
SDL_RenderData* renderdata=(SDL_RenderData*)renderer->driverdata;
|
||||
SDL_Window* window=SDL_GetWindowFromID(renderer->window);
|
||||
SDL_VideoDisplay* display=SDL_GetDisplayFromWindow(window);
|
||||
SDL_TextureData* tdata=NULL;
|
||||
SDL_RenderData *renderdata = (SDL_RenderData *) renderer->driverdata;
|
||||
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
|
||||
SDL_TextureData *tdata = NULL;
|
||||
|
||||
/* Allocate texture driver data */
|
||||
tdata=(SDL_TextureData*)SDL_calloc(1, sizeof(SDL_TextureData));
|
||||
if (tdata==NULL)
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
/* Allocate texture driver data */
|
||||
tdata = (SDL_TextureData *) SDL_calloc(1, sizeof(SDL_TextureData));
|
||||
if (tdata == NULL) {
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Set texture driver data */
|
||||
texture->driverdata=tdata;
|
||||
/* Set texture driver data */
|
||||
texture->driverdata = tdata;
|
||||
|
||||
}
|
||||
|
||||
static int photon_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch)
|
||||
static int
|
||||
photon_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
void **pixels, int *pitch)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors)
|
||||
static int
|
||||
photon_settexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Color * colors, int firstcolor,
|
||||
int ncolors)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors)
|
||||
static int
|
||||
photon_gettexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
SDL_Color * colors, int firstcolor, int ncolors)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
photon_settexturecolormod(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
photon_settexturealphamod(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
photon_settextureblendmode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
photon_settexturescalemode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch)
|
||||
static int
|
||||
photon_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels, int pitch)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch)
|
||||
static int
|
||||
photon_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, int markDirty, void **pixels,
|
||||
int *pitch)
|
||||
{
|
||||
}
|
||||
|
||||
static void photon_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static void
|
||||
photon_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static void photon_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects)
|
||||
static void
|
||||
photon_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
int numrects, const SDL_Rect * rects)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_renderpoint(SDL_Renderer* renderer, int x, int y)
|
||||
static int
|
||||
photon_renderpoint(SDL_Renderer * renderer, int x, int y)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2)
|
||||
static int
|
||||
photon_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect)
|
||||
static int
|
||||
photon_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect)
|
||||
{
|
||||
}
|
||||
|
||||
static int photon_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect)
|
||||
static int
|
||||
photon_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
|
||||
{
|
||||
}
|
||||
|
||||
static void photon_renderpresent(SDL_Renderer* renderer)
|
||||
static void
|
||||
photon_renderpresent(SDL_Renderer * renderer)
|
||||
{
|
||||
}
|
||||
|
||||
static void photon_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static void
|
||||
photon_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static void photon_destroyrenderer(SDL_Renderer* renderer)
|
||||
static void
|
||||
photon_destroyrenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata;
|
||||
uint32_t it;
|
||||
SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
|
||||
uint32_t it;
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -35,11 +35,11 @@
|
||||
|
||||
typedef struct SDL_RenderData
|
||||
{
|
||||
SDL_Window* window; /* SDL window type */
|
||||
SDL_bool enable_vsync; /* VSYNC flip synchronization enable */
|
||||
uint32_t surface_visible_idx; /* Index of visible surface */
|
||||
uint32_t surface_render_idx; /* Index of render surface */
|
||||
uint32_t surfaces_count; /* Amount of allocated surfaces */
|
||||
SDL_Window *window; /* SDL window type */
|
||||
SDL_bool enable_vsync; /* VSYNC flip synchronization enable */
|
||||
uint32_t surface_visible_idx; /* Index of visible surface */
|
||||
uint32_t surface_render_idx; /* Index of render surface */
|
||||
uint32_t surfaces_count; /* Amount of allocated surfaces */
|
||||
} SDL_RenderData;
|
||||
|
||||
typedef struct SDL_TextureData
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -42,7 +42,7 @@
|
||||
|
||||
typedef struct SDL_MouseData
|
||||
{
|
||||
SDL_DisplayData* didata;
|
||||
SDL_DisplayData *didata;
|
||||
} SDL_MouseData;
|
||||
|
||||
int32_t gf_addinputdevices(_THIS);
|
||||
@ -65,85 +65,85 @@ int32_t gf_delinputdevices(_THIS);
|
||||
|
||||
typedef struct _hid_byte
|
||||
{
|
||||
uint8_t HIDB_Length;
|
||||
uint8_t HIDB_Type;
|
||||
uint8_t HIDB_Tag;
|
||||
uint8_t reserved[1];
|
||||
uint8_t HIDB_Length;
|
||||
uint8_t HIDB_Type;
|
||||
uint8_t HIDB_Tag;
|
||||
uint8_t reserved[1];
|
||||
} hid_byte_t;
|
||||
|
||||
typedef struct _hidd_global_item
|
||||
{
|
||||
uint16_t usage_page;
|
||||
uint16_t logical_min;
|
||||
uint16_t logical_max;
|
||||
uint16_t physical_min;
|
||||
uint16_t physical_max;
|
||||
uint16_t unit_expo;
|
||||
uint16_t unit;
|
||||
uint16_t report_size;
|
||||
uint16_t report_id;
|
||||
uint16_t report_count;
|
||||
uint16_t usage_page;
|
||||
uint16_t logical_min;
|
||||
uint16_t logical_max;
|
||||
uint16_t physical_min;
|
||||
uint16_t physical_max;
|
||||
uint16_t unit_expo;
|
||||
uint16_t unit;
|
||||
uint16_t report_size;
|
||||
uint16_t report_id;
|
||||
uint16_t report_count;
|
||||
} hidd_global_item_t;
|
||||
|
||||
typedef struct _hidd_local_item
|
||||
{
|
||||
uint16_t type;
|
||||
uint8_t reserved[2];
|
||||
uint32_t value;
|
||||
struct _hidd_local_item* next_local;
|
||||
struct _hidd_local_item* alt_local;
|
||||
uint16_t type;
|
||||
uint8_t reserved[2];
|
||||
uint32_t value;
|
||||
struct _hidd_local_item *next_local;
|
||||
struct _hidd_local_item *alt_local;
|
||||
} hidd_local_item_t;
|
||||
|
||||
typedef struct _hidd_local_table
|
||||
{
|
||||
hidd_local_item_t* usage_info;
|
||||
hidd_local_item_t* designator_info;
|
||||
hidd_local_item_t* string_info;
|
||||
uint8_t delimiter;
|
||||
uint8_t reserved[3];
|
||||
hidd_local_item_t *usage_info;
|
||||
hidd_local_item_t *designator_info;
|
||||
hidd_local_item_t *string_info;
|
||||
uint8_t delimiter;
|
||||
uint8_t reserved[3];
|
||||
} hidd_local_table_t;
|
||||
|
||||
typedef struct _hidd_field
|
||||
{
|
||||
struct hidd_report_instance* report;
|
||||
struct hidd_collection* collection;
|
||||
uint16_t report_offset;
|
||||
uint16_t flags;
|
||||
hidd_global_item_t gitem;
|
||||
hidd_local_table_t* ltable;
|
||||
struct _hidd_field* next_field;
|
||||
void* user;
|
||||
struct hidd_report_instance *report;
|
||||
struct hidd_collection *collection;
|
||||
uint16_t report_offset;
|
||||
uint16_t flags;
|
||||
hidd_global_item_t gitem;
|
||||
hidd_local_table_t *ltable;
|
||||
struct _hidd_field *next_field;
|
||||
void *user;
|
||||
} hidd_field_t;
|
||||
|
||||
typedef struct hidd_report_instance
|
||||
{
|
||||
uint8_t report_id;
|
||||
uint8_t reserved[1];
|
||||
uint16_t report_type;
|
||||
hidd_field_t* field;
|
||||
uint16_t num_field;
|
||||
uint16_t byte_len;
|
||||
uint16_t bit_len;
|
||||
uint8_t reserved2[2];
|
||||
struct hidd_collection* collection;
|
||||
struct hidd_report_instance* next_col_report;
|
||||
struct hidd_report_instance* next_report;
|
||||
uint8_t report_id;
|
||||
uint8_t reserved[1];
|
||||
uint16_t report_type;
|
||||
hidd_field_t *field;
|
||||
uint16_t num_field;
|
||||
uint16_t byte_len;
|
||||
uint16_t bit_len;
|
||||
uint8_t reserved2[2];
|
||||
struct hidd_collection *collection;
|
||||
struct hidd_report_instance *next_col_report;
|
||||
struct hidd_report_instance *next_report;
|
||||
} hidd_report_instance_t;
|
||||
|
||||
typedef struct hidd_report
|
||||
{
|
||||
TAILQ_ENTRY(hidd_report) link;
|
||||
hidd_report_instance_t* rinst;
|
||||
hidd_device_instance_t* dev_inst;
|
||||
uint32_t flags;
|
||||
struct hidd_connection* connection;
|
||||
void* user;
|
||||
TAILQ_ENTRY(hidd_report) link;
|
||||
hidd_report_instance_t *rinst;
|
||||
hidd_device_instance_t *dev_inst;
|
||||
uint32_t flags;
|
||||
struct hidd_connection *connection;
|
||||
void *user;
|
||||
} hidd_report_t;
|
||||
|
||||
typedef struct hidview_device
|
||||
{
|
||||
struct hidd_report_instance* instance;
|
||||
struct hidd_report* report;
|
||||
struct hidd_report_instance *instance;
|
||||
struct hidd_report *report;
|
||||
} hidview_device_t;
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
@ -30,21 +30,25 @@
|
||||
/* This is OpenGL ES 1.0 helper functions from OpenGL ES 1.1 specification, */
|
||||
/* which could be implemented independently from hardware, just wrappers */
|
||||
|
||||
GLAPI void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
|
||||
GLAPI void APIENTRY
|
||||
glTexParameteri(GLenum target, GLenum pname, GLint param)
|
||||
{
|
||||
glTexParameterx(target, pname, (GLfixed)param);
|
||||
return;
|
||||
glTexParameterx(target, pname, (GLfixed) param);
|
||||
return;
|
||||
}
|
||||
|
||||
GLAPI void APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
|
||||
GLAPI void APIENTRY
|
||||
glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
|
||||
{
|
||||
/* Retrieve one parameter only */
|
||||
glTexParameterx(target, pname, (GLfixed)*params);
|
||||
return;
|
||||
/* Retrieve one parameter only */
|
||||
glTexParameterx(target, pname, (GLfixed) * params);
|
||||
return;
|
||||
}
|
||||
|
||||
GLAPI void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
|
||||
GLAPI void APIENTRY
|
||||
glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
|
||||
{
|
||||
glColor4f(((GLfloat)red)/255.f, ((GLfloat)green)/255.f, ((GLfloat)blue)/255.f, ((GLfloat)alpha)/255.f);
|
||||
return;
|
||||
glColor4f(((GLfloat) red) / 255.f, ((GLfloat) green) / 255.f,
|
||||
((GLfloat) blue) / 255.f, ((GLfloat) alpha) / 255.f);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -31,7 +31,9 @@
|
||||
#include <GLES/glext.h>
|
||||
|
||||
GLAPI void APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param);
|
||||
GLAPI void APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
|
||||
GLAPI void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
|
||||
GLAPI void APIENTRY glTexParameteriv(GLenum target, GLenum pname,
|
||||
const GLint * params);
|
||||
GLAPI void APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue,
|
||||
GLubyte alpha);
|
||||
|
||||
#endif /* __SDL_GF_OPENGLES_H__ */
|
||||
|
||||
@ -27,148 +27,148 @@
|
||||
#include "SDL_config.h"
|
||||
#include "SDL_gf_pixelfmt.h"
|
||||
|
||||
gf_format_t qnxgf_sdl_to_gf_pixelformat(uint32_t pixelfmt)
|
||||
gf_format_t
|
||||
qnxgf_sdl_to_gf_pixelformat(uint32_t pixelfmt)
|
||||
{
|
||||
switch(pixelfmt)
|
||||
{
|
||||
case SDL_PIXELFORMAT_INDEX8:
|
||||
{
|
||||
return GF_FORMAT_PAL8;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB1555:
|
||||
{
|
||||
return GF_FORMAT_PACK_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ABGR1555:
|
||||
{
|
||||
return GF_FORMAT_PACK_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
{
|
||||
return GF_FORMAT_PACK_RGB565;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB888:
|
||||
{
|
||||
return GF_FORMAT_BGR888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_BGRA8888:
|
||||
{
|
||||
return GF_FORMAT_BGRA8888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB8888:
|
||||
{
|
||||
return GF_FORMAT_ARGB8888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YV12:
|
||||
{
|
||||
return GF_FORMAT_PLANAR_YUV_YV12;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YUY2:
|
||||
{
|
||||
return GF_FORMAT_PACK_YUV_YUY2;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_UYVY:
|
||||
{
|
||||
return GF_FORMAT_PACK_YUV_UYVY;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YVYU:
|
||||
{
|
||||
return GF_FORMAT_PACK_YUV_YVYU;
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (pixelfmt) {
|
||||
case SDL_PIXELFORMAT_INDEX8:
|
||||
{
|
||||
return GF_FORMAT_PAL8;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB1555:
|
||||
{
|
||||
return GF_FORMAT_PACK_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ABGR1555:
|
||||
{
|
||||
return GF_FORMAT_PACK_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
{
|
||||
return GF_FORMAT_PACK_RGB565;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB888:
|
||||
{
|
||||
return GF_FORMAT_BGR888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_BGRA8888:
|
||||
{
|
||||
return GF_FORMAT_BGRA8888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_ARGB8888:
|
||||
{
|
||||
return GF_FORMAT_ARGB8888;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YV12:
|
||||
{
|
||||
return GF_FORMAT_PLANAR_YUV_YV12;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YUY2:
|
||||
{
|
||||
return GF_FORMAT_PACK_YUV_YUY2;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_UYVY:
|
||||
{
|
||||
return GF_FORMAT_PACK_YUV_UYVY;
|
||||
}
|
||||
break;
|
||||
case SDL_PIXELFORMAT_YVYU:
|
||||
{
|
||||
return GF_FORMAT_PACK_YUV_YVYU;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return GF_FORMAT_INVALID;
|
||||
return GF_FORMAT_INVALID;
|
||||
}
|
||||
|
||||
uint32_t qnxgf_gf_to_sdl_pixelformat(gf_format_t pixelfmt)
|
||||
uint32_t
|
||||
qnxgf_gf_to_sdl_pixelformat(gf_format_t pixelfmt)
|
||||
{
|
||||
switch(pixelfmt)
|
||||
{
|
||||
case GF_FORMAT_PAL8:
|
||||
{
|
||||
return SDL_PIXELFORMAT_INDEX8;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKLE_ARGB1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_ARGB1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKBE_ARGB1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ABGR1555;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKBE_RGB565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKLE_RGB565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_RGB565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_BGR888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB888;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_BGRA8888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_BGRA8888;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_ARGB8888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB8888;
|
||||
}
|
||||
break;
|
||||
switch (pixelfmt) {
|
||||
case GF_FORMAT_PAL8:
|
||||
{
|
||||
return SDL_PIXELFORMAT_INDEX8;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKLE_ARGB1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_ARGB1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB1555;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKBE_ARGB1555:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ABGR1555;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKBE_RGB565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PKLE_RGB565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_RGB565:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB565;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_BGR888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_RGB888;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_BGRA8888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_BGRA8888;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_ARGB8888:
|
||||
{
|
||||
return SDL_PIXELFORMAT_ARGB8888;
|
||||
}
|
||||
break;
|
||||
|
||||
case GF_FORMAT_PLANAR_YUV_YV12:
|
||||
{
|
||||
return SDL_PIXELFORMAT_YV12;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_YUV_YUY2:
|
||||
{
|
||||
return SDL_PIXELFORMAT_YUY2;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_YUV_UYVY:
|
||||
{
|
||||
return SDL_PIXELFORMAT_UYVY;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_YUV_YVYU:
|
||||
{
|
||||
return SDL_PIXELFORMAT_YVYU;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case GF_FORMAT_PLANAR_YUV_YV12:
|
||||
{
|
||||
return SDL_PIXELFORMAT_YV12;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_YUV_YUY2:
|
||||
{
|
||||
return SDL_PIXELFORMAT_YUY2;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_YUV_UYVY:
|
||||
{
|
||||
return SDL_PIXELFORMAT_UYVY;
|
||||
}
|
||||
break;
|
||||
case GF_FORMAT_PACK_YUV_YVYU:
|
||||
{
|
||||
return SDL_PIXELFORMAT_YVYU;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return SDL_PIXELFORMAT_UNKNOWN;
|
||||
return SDL_PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
|
||||
@ -32,7 +32,7 @@
|
||||
#include <gf/gf.h>
|
||||
|
||||
gf_format_t qnxgf_sdl_to_gf_pixelformat(uint32_t pixelfmt);
|
||||
uint32_t qnxgf_gf_to_sdl_pixelformat(gf_format_t pixelfmt);
|
||||
uint32_t qnxgf_gf_to_sdl_pixelformat(gf_format_t pixelfmt);
|
||||
|
||||
#endif /* __SDL_GF_PIXELFMT_H__ */
|
||||
|
||||
|
||||
@ -34,368 +34,392 @@
|
||||
#include "SDL_gf_render.h"
|
||||
#include "SDL_qnxgf.h"
|
||||
|
||||
static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags);
|
||||
static int gf_displaymodechanged(SDL_Renderer* renderer);
|
||||
static int gf_activaterenderer(SDL_Renderer* renderer);
|
||||
static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int gf_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch);
|
||||
static int gf_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors);
|
||||
static int gf_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors);
|
||||
static int gf_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int gf_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int gf_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int gf_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static int gf_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch);
|
||||
static int gf_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch);
|
||||
static void gf_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static void gf_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects);
|
||||
static int gf_renderpoint(SDL_Renderer* renderer, int x, int y);
|
||||
static int gf_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2);
|
||||
static int gf_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect);
|
||||
static int gf_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect);
|
||||
static void gf_renderpresent(SDL_Renderer* renderer);
|
||||
static void gf_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture);
|
||||
static void gf_destroyrenderer(SDL_Renderer* renderer);
|
||||
static SDL_Renderer *gf_createrenderer(SDL_Window * window, Uint32 flags);
|
||||
static int gf_displaymodechanged(SDL_Renderer * renderer);
|
||||
static int gf_activaterenderer(SDL_Renderer * renderer);
|
||||
static int gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static int gf_querytexturepixels(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture, void **pixels,
|
||||
int *pitch);
|
||||
static int gf_settexturepalette(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture,
|
||||
const SDL_Color * colors, int firstcolor,
|
||||
int ncolors);
|
||||
static int gf_gettexturepalette(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture, SDL_Color * colors,
|
||||
int firstcolor, int ncolors);
|
||||
static int gf_settexturecolormod(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int gf_settexturealphamod(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int gf_settextureblendmode(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int gf_settexturescalemode(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels,
|
||||
int pitch);
|
||||
static int gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, int markDirty, void **pixels,
|
||||
int *pitch);
|
||||
static void gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static void gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
int numrects, const SDL_Rect * rects);
|
||||
static int gf_renderpoint(SDL_Renderer * renderer, int x, int y);
|
||||
static int gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2,
|
||||
int y2);
|
||||
static int gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect);
|
||||
static int gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
|
||||
static void gf_renderpresent(SDL_Renderer * renderer);
|
||||
static void gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static void gf_destroyrenderer(SDL_Renderer * renderer);
|
||||
|
||||
SDL_RenderDriver gf_renderdriver=
|
||||
{
|
||||
SDL_RenderDriver gf_renderdriver = {
|
||||
gf_createrenderer,
|
||||
{
|
||||
"qnxgf",
|
||||
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
|
||||
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
|
||||
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
|
||||
SDL_RENDERER_ACCELERATED),
|
||||
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
|
||||
SDL_TEXTUREMODULATE_ALPHA),
|
||||
(SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
|
||||
SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
|
||||
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW),
|
||||
13,
|
||||
{
|
||||
SDL_PIXELFORMAT_INDEX8,
|
||||
SDL_PIXELFORMAT_RGB555,
|
||||
SDL_PIXELFORMAT_RGB565,
|
||||
SDL_PIXELFORMAT_RGB888,
|
||||
SDL_PIXELFORMAT_BGR888,
|
||||
SDL_PIXELFORMAT_ARGB8888,
|
||||
SDL_PIXELFORMAT_RGBA8888,
|
||||
SDL_PIXELFORMAT_ABGR8888,
|
||||
SDL_PIXELFORMAT_BGRA8888,
|
||||
SDL_PIXELFORMAT_YV12,
|
||||
SDL_PIXELFORMAT_YUY2,
|
||||
SDL_PIXELFORMAT_UYVY,
|
||||
SDL_PIXELFORMAT_YVYU
|
||||
},
|
||||
0,
|
||||
0
|
||||
}
|
||||
"qnxgf",
|
||||
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
|
||||
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
|
||||
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
|
||||
SDL_RENDERER_ACCELERATED),
|
||||
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
|
||||
SDL_TEXTUREMODULATE_ALPHA),
|
||||
(SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
|
||||
SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
|
||||
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_SLOW),
|
||||
13,
|
||||
{
|
||||
SDL_PIXELFORMAT_INDEX8,
|
||||
SDL_PIXELFORMAT_RGB555,
|
||||
SDL_PIXELFORMAT_RGB565,
|
||||
SDL_PIXELFORMAT_RGB888,
|
||||
SDL_PIXELFORMAT_BGR888,
|
||||
SDL_PIXELFORMAT_ARGB8888,
|
||||
SDL_PIXELFORMAT_RGBA8888,
|
||||
SDL_PIXELFORMAT_ABGR8888,
|
||||
SDL_PIXELFORMAT_BGRA8888,
|
||||
SDL_PIXELFORMAT_YV12,
|
||||
SDL_PIXELFORMAT_YUY2,
|
||||
SDL_PIXELFORMAT_UYVY,
|
||||
SDL_PIXELFORMAT_YVYU},
|
||||
0,
|
||||
0}
|
||||
};
|
||||
|
||||
static SDL_Renderer* gf_createrenderer(SDL_Window* window, Uint32 flags)
|
||||
static SDL_Renderer *
|
||||
gf_createrenderer(SDL_Window * window, Uint32 flags)
|
||||
{
|
||||
SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(window);
|
||||
SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata;
|
||||
SDL_WindowData* wdata = (SDL_WindowData*)window->driverdata;
|
||||
SDL_Renderer* renderer = NULL;
|
||||
SDL_RenderData* rdata = NULL;
|
||||
uint32_t it;
|
||||
int32_t jt;
|
||||
int32_t status;
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
|
||||
SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
|
||||
SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
|
||||
SDL_Renderer *renderer = NULL;
|
||||
SDL_RenderData *rdata = NULL;
|
||||
uint32_t it;
|
||||
int32_t jt;
|
||||
int32_t status;
|
||||
|
||||
/* Check if it is OpenGL ES window */
|
||||
if ((window->flags & SDL_WINDOW_OPENGL)==SDL_WINDOW_OPENGL)
|
||||
{
|
||||
/* No error, just no need to create 2D renderer for OpenGL ES window */
|
||||
return NULL;
|
||||
}
|
||||
/* Check if it is OpenGL ES window */
|
||||
if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {
|
||||
/* No error, just no need to create 2D renderer for OpenGL ES window */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Allocate new renderer structure */
|
||||
renderer=(SDL_Renderer*)SDL_calloc(1, sizeof(SDL_Renderer));
|
||||
if (renderer==NULL)
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
/* Allocate new renderer structure */
|
||||
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(SDL_Renderer));
|
||||
if (renderer == NULL) {
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Allocate renderer data */
|
||||
rdata=(SDL_RenderData*)SDL_calloc(1, sizeof(SDL_RenderData));
|
||||
if (rdata==NULL)
|
||||
{
|
||||
SDL_free(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
/* Allocate renderer data */
|
||||
rdata = (SDL_RenderData *) SDL_calloc(1, sizeof(SDL_RenderData));
|
||||
if (rdata == NULL) {
|
||||
SDL_free(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
renderer->DisplayModeChanged=gf_displaymodechanged;
|
||||
renderer->ActivateRenderer=gf_activaterenderer;
|
||||
renderer->CreateTexture=gf_createtexture;
|
||||
renderer->QueryTexturePixels=gf_querytexturepixels;
|
||||
renderer->SetTexturePalette=gf_settexturepalette;
|
||||
renderer->GetTexturePalette=gf_gettexturepalette;
|
||||
renderer->SetTextureAlphaMod=gf_settexturealphamod;
|
||||
renderer->SetTextureColorMod=gf_settexturecolormod;
|
||||
renderer->SetTextureBlendMode=gf_settextureblendmode;
|
||||
renderer->SetTextureScaleMode=gf_settexturescalemode;
|
||||
renderer->UpdateTexture=gf_updatetexture;
|
||||
renderer->LockTexture=gf_locktexture;
|
||||
renderer->UnlockTexture=gf_unlocktexture;
|
||||
renderer->DirtyTexture=gf_dirtytexture;
|
||||
renderer->RenderPoint=gf_renderpoint;
|
||||
renderer->RenderLine=gf_renderline;
|
||||
renderer->RenderFill=gf_renderfill;
|
||||
renderer->RenderCopy=gf_rendercopy;
|
||||
renderer->RenderPresent = gf_renderpresent;
|
||||
renderer->DestroyTexture = gf_destroytexture;
|
||||
renderer->DestroyRenderer = gf_destroyrenderer;
|
||||
renderer->info = gf_renderdriver.info;
|
||||
renderer->window = window->id;
|
||||
renderer->driverdata = rdata;
|
||||
renderer->DisplayModeChanged = gf_displaymodechanged;
|
||||
renderer->ActivateRenderer = gf_activaterenderer;
|
||||
renderer->CreateTexture = gf_createtexture;
|
||||
renderer->QueryTexturePixels = gf_querytexturepixels;
|
||||
renderer->SetTexturePalette = gf_settexturepalette;
|
||||
renderer->GetTexturePalette = gf_gettexturepalette;
|
||||
renderer->SetTextureAlphaMod = gf_settexturealphamod;
|
||||
renderer->SetTextureColorMod = gf_settexturecolormod;
|
||||
renderer->SetTextureBlendMode = gf_settextureblendmode;
|
||||
renderer->SetTextureScaleMode = gf_settexturescalemode;
|
||||
renderer->UpdateTexture = gf_updatetexture;
|
||||
renderer->LockTexture = gf_locktexture;
|
||||
renderer->UnlockTexture = gf_unlocktexture;
|
||||
renderer->DirtyTexture = gf_dirtytexture;
|
||||
renderer->RenderPoint = gf_renderpoint;
|
||||
renderer->RenderLine = gf_renderline;
|
||||
renderer->RenderFill = gf_renderfill;
|
||||
renderer->RenderCopy = gf_rendercopy;
|
||||
renderer->RenderPresent = gf_renderpresent;
|
||||
renderer->DestroyTexture = gf_destroytexture;
|
||||
renderer->DestroyRenderer = gf_destroyrenderer;
|
||||
renderer->info = gf_renderdriver.info;
|
||||
renderer->window = window->id;
|
||||
renderer->driverdata = rdata;
|
||||
|
||||
/* Set render acceleration flag in case it is accelerated */
|
||||
if ((didata->caps & SDL_GF_ACCELERATED)==SDL_GF_ACCELERATED)
|
||||
{
|
||||
renderer->info.flags=SDL_RENDERER_ACCELERATED;
|
||||
}
|
||||
else
|
||||
{
|
||||
renderer->info.flags&=~(SDL_RENDERER_ACCELERATED);
|
||||
}
|
||||
/* Set render acceleration flag in case it is accelerated */
|
||||
if ((didata->caps & SDL_GF_ACCELERATED) == SDL_GF_ACCELERATED) {
|
||||
renderer->info.flags = SDL_RENDERER_ACCELERATED;
|
||||
} else {
|
||||
renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED);
|
||||
}
|
||||
|
||||
rdata->window=window;
|
||||
rdata->window = window;
|
||||
|
||||
/* Check if upper level requested synchronization on vsync signal */
|
||||
if ((flags & SDL_RENDERER_PRESENTVSYNC)==SDL_RENDERER_PRESENTVSYNC)
|
||||
{
|
||||
rdata->enable_vsync=SDL_TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
rdata->enable_vsync=SDL_FALSE;
|
||||
}
|
||||
/* Check if upper level requested synchronization on vsync signal */
|
||||
if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) {
|
||||
rdata->enable_vsync = SDL_TRUE;
|
||||
} else {
|
||||
rdata->enable_vsync = SDL_FALSE;
|
||||
}
|
||||
|
||||
/* Check what buffer copy/flip scheme is requested */
|
||||
rdata->surfaces_count=0;
|
||||
if ((flags & SDL_RENDERER_SINGLEBUFFER)==SDL_RENDERER_SINGLEBUFFER)
|
||||
{
|
||||
if ((flags & SDL_RENDERER_PRESENTDISCARD)==SDL_RENDERER_PRESENTDISCARD)
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;
|
||||
}
|
||||
else
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
}
|
||||
rdata->surfaces_count=1;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP2)==SDL_RENDERER_PRESENTFLIP2)
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_PRESENTFLIP2;
|
||||
rdata->surfaces_count=2;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP3)==SDL_RENDERER_PRESENTFLIP3)
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_PRESENTFLIP3;
|
||||
rdata->surfaces_count=3;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
renderer->info.flags|=SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
rdata->surfaces_count=1;
|
||||
rdata->surface_visible_idx=0;
|
||||
rdata->surface_render_idx=0;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Check what buffer copy/flip scheme is requested */
|
||||
rdata->surfaces_count = 0;
|
||||
if ((flags & SDL_RENDERER_SINGLEBUFFER) == SDL_RENDERER_SINGLEBUFFER) {
|
||||
if ((flags & SDL_RENDERER_PRESENTDISCARD) ==
|
||||
SDL_RENDERER_PRESENTDISCARD) {
|
||||
renderer->info.flags |=
|
||||
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;
|
||||
} else {
|
||||
renderer->info.flags |=
|
||||
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
}
|
||||
rdata->surfaces_count = 1;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 0;
|
||||
} else {
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP2) == SDL_RENDERER_PRESENTFLIP2) {
|
||||
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
|
||||
rdata->surfaces_count = 2;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 1;
|
||||
} else {
|
||||
if ((flags & SDL_RENDERER_PRESENTFLIP3) ==
|
||||
SDL_RENDERER_PRESENTFLIP3) {
|
||||
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
|
||||
rdata->surfaces_count = 3;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 1;
|
||||
} else {
|
||||
renderer->info.flags |=
|
||||
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
|
||||
rdata->surfaces_count = 1;
|
||||
rdata->surface_visible_idx = 0;
|
||||
rdata->surface_render_idx = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Create layer surfaces, which could be visible */
|
||||
for (it=0; it<rdata->surfaces_count; it++)
|
||||
{
|
||||
/* TODO: add palette creation */
|
||||
/* Create layer surfaces, which could be visible */
|
||||
for (it = 0; it < rdata->surfaces_count; it++) {
|
||||
/* TODO: add palette creation */
|
||||
|
||||
/* Create displayable surfaces */
|
||||
status=gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0,
|
||||
didata->current_mode.w, didata->current_mode.h,
|
||||
qnxgf_sdl_to_gf_pixelformat(didata->current_mode.format), NULL,
|
||||
GF_SURFACE_CREATE_2D_ACCESSIBLE);
|
||||
/* Create displayable surfaces */
|
||||
status =
|
||||
gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0,
|
||||
didata->current_mode.w,
|
||||
didata->current_mode.h,
|
||||
qnxgf_sdl_to_gf_pixelformat(didata->
|
||||
current_mode.
|
||||
format), NULL,
|
||||
GF_SURFACE_CREATE_2D_ACCESSIBLE);
|
||||
|
||||
if (status!=GF_ERR_OK)
|
||||
{
|
||||
/* Free already allocated surfaces */
|
||||
for (jt=it-1; jt>0; jt--)
|
||||
{
|
||||
gf_surface_free(rdata->surface[jt]);
|
||||
rdata->surface[jt]=NULL;
|
||||
}
|
||||
SDL_free(rdata);
|
||||
SDL_free(renderer);
|
||||
if (status==GF_ERR_MEM)
|
||||
{
|
||||
SDL_SetError("unsufficient free video memory");
|
||||
}
|
||||
else
|
||||
{
|
||||
SDL_SetError("error during displayable surface creation");
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
if (status != GF_ERR_OK) {
|
||||
/* Free already allocated surfaces */
|
||||
for (jt = it - 1; jt > 0; jt--) {
|
||||
gf_surface_free(rdata->surface[jt]);
|
||||
rdata->surface[jt] = NULL;
|
||||
}
|
||||
SDL_free(rdata);
|
||||
SDL_free(renderer);
|
||||
if (status == GF_ERR_MEM) {
|
||||
SDL_SetError("unsufficient free video memory");
|
||||
} else {
|
||||
SDL_SetError("error during displayable surface creation");
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Get detailed information about allocated surface */
|
||||
gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]);
|
||||
}
|
||||
/* Get detailed information about allocated surface */
|
||||
gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]);
|
||||
}
|
||||
|
||||
return renderer;
|
||||
return renderer;
|
||||
}
|
||||
|
||||
void gf_addrenderdriver(_THIS)
|
||||
void
|
||||
gf_addrenderdriver(_THIS)
|
||||
{
|
||||
uint32_t it;
|
||||
uint32_t it;
|
||||
|
||||
for (it=0; it<_this->num_displays; it++)
|
||||
{
|
||||
SDL_AddRenderDriver(it, &gf_renderdriver);
|
||||
}
|
||||
for (it = 0; it < _this->num_displays; it++) {
|
||||
SDL_AddRenderDriver(it, &gf_renderdriver);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************/
|
||||
/* SDL render interface */
|
||||
/****************************************************************************/
|
||||
static int gf_displaymodechanged(SDL_Renderer* renderer)
|
||||
static int
|
||||
gf_displaymodechanged(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata;
|
||||
SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
|
||||
|
||||
/* Remove all allocated surfaces, they are no more valid */
|
||||
/* Remove all allocated surfaces, they are no more valid */
|
||||
|
||||
/* TODO: Add video mode change detection and new parameters detection */
|
||||
/* TODO: Add video mode change detection and new parameters detection */
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gf_activaterenderer(SDL_Renderer* renderer)
|
||||
static int
|
||||
gf_activaterenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata;
|
||||
SDL_VideoDisplay* display = SDL_GetDisplayFromWindow(rdata->window);
|
||||
SDL_DisplayData* didata = (SDL_DisplayData*)display->driverdata;
|
||||
SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(rdata->window);
|
||||
SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
|
||||
|
||||
/* Setup current surface as visible */
|
||||
/* Setup current surface as visible */
|
||||
// gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1);
|
||||
|
||||
/* Set visible surface when hardware in idle state */
|
||||
/* Set visible surface when hardware in idle state */
|
||||
// gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int gf_createtexture(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
SDL_RenderData* renderdata=(SDL_RenderData*)renderer->driverdata;
|
||||
SDL_Window* window=SDL_GetWindowFromID(renderer->window);
|
||||
SDL_VideoDisplay* display=SDL_GetDisplayFromWindow(window);
|
||||
SDL_TextureData* tdata=NULL;
|
||||
SDL_RenderData *renderdata = (SDL_RenderData *) renderer->driverdata;
|
||||
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
|
||||
SDL_TextureData *tdata = NULL;
|
||||
|
||||
/* Allocate texture driver data */
|
||||
tdata=(SDL_TextureData*)SDL_calloc(1, sizeof(SDL_TextureData));
|
||||
if (tdata==NULL)
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
/* Allocate texture driver data */
|
||||
tdata = (SDL_TextureData *) SDL_calloc(1, sizeof(SDL_TextureData));
|
||||
if (tdata == NULL) {
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Set texture driver data */
|
||||
texture->driverdata=tdata;
|
||||
/* Set texture driver data */
|
||||
texture->driverdata = tdata;
|
||||
|
||||
}
|
||||
|
||||
static int gf_querytexturepixels(SDL_Renderer* renderer, SDL_Texture* texture, void** pixels, int* pitch)
|
||||
static int
|
||||
gf_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
void **pixels, int *pitch)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_settexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color* colors, int firstcolor, int ncolors)
|
||||
static int
|
||||
gf_settexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Color * colors, int firstcolor, int ncolors)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_gettexturepalette(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Color* colors, int firstcolor, int ncolors)
|
||||
static int
|
||||
gf_gettexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
SDL_Color * colors, int firstcolor, int ncolors)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_settexturecolormod(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
gf_settexturecolormod(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_settexturealphamod(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
gf_settexturealphamod(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_settextureblendmode(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
gf_settextureblendmode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_settexturescalemode(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static int
|
||||
gf_settexturescalemode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_updatetexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, const void* pixels, int pitch)
|
||||
static int
|
||||
gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels, int pitch)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_locktexture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* rect, int markDirty, void** pixels, int* pitch)
|
||||
static int
|
||||
gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, int markDirty, void **pixels,
|
||||
int *pitch)
|
||||
{
|
||||
}
|
||||
|
||||
static void gf_unlocktexture(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static void
|
||||
gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static void gf_dirtytexture(SDL_Renderer* renderer, SDL_Texture* texture, int numrects, const SDL_Rect* rects)
|
||||
static void
|
||||
gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,
|
||||
const SDL_Rect * rects)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_renderpoint(SDL_Renderer* renderer, int x, int y)
|
||||
static int
|
||||
gf_renderpoint(SDL_Renderer * renderer, int x, int y)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_renderline(SDL_Renderer* renderer, int x1, int y1, int x2, int y2)
|
||||
static int
|
||||
gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_renderfill(SDL_Renderer* renderer, const SDL_Rect* rect)
|
||||
static int
|
||||
gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect)
|
||||
{
|
||||
}
|
||||
|
||||
static int gf_rendercopy(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Rect* srcrect, const SDL_Rect* dstrect)
|
||||
static int
|
||||
gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
|
||||
{
|
||||
}
|
||||
|
||||
static void gf_renderpresent(SDL_Renderer* renderer)
|
||||
static void
|
||||
gf_renderpresent(SDL_Renderer * renderer)
|
||||
{
|
||||
}
|
||||
|
||||
static void gf_destroytexture(SDL_Renderer* renderer, SDL_Texture* texture)
|
||||
static void
|
||||
gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static void gf_destroyrenderer(SDL_Renderer* renderer)
|
||||
static void
|
||||
gf_destroyrenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_RenderData* rdata=(SDL_RenderData*)renderer->driverdata;
|
||||
uint32_t it;
|
||||
SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
|
||||
uint32_t it;
|
||||
|
||||
for (it=0; it<rdata->surfaces_count; it++)
|
||||
{
|
||||
if (rdata->surface[it]!=NULL)
|
||||
{
|
||||
gf_surface_free(rdata->surface[it]);
|
||||
}
|
||||
}
|
||||
for (it = 0; it < rdata->surfaces_count; it++) {
|
||||
if (rdata->surface[it] != NULL) {
|
||||
gf_surface_free(rdata->surface[it]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
|
||||
@ -35,19 +35,19 @@
|
||||
|
||||
typedef struct SDL_RenderData
|
||||
{
|
||||
SDL_Window* window; /* SDL window type */
|
||||
SDL_bool enable_vsync; /* VSYNC flip synchronization enable */
|
||||
gf_surface_t surface[SDL_GF_MAX_SURFACES]; /* Surface handles */
|
||||
gf_surface_info_t surface_info[SDL_GF_MAX_SURFACES]; /* Surface info */
|
||||
uint32_t surface_visible_idx; /* Index of visible surface */
|
||||
uint32_t surface_render_idx; /* Index of render surface */
|
||||
uint32_t surfaces_count; /* Amount of allocated surfaces */
|
||||
SDL_Window *window; /* SDL window type */
|
||||
SDL_bool enable_vsync; /* VSYNC flip synchronization enable */
|
||||
gf_surface_t surface[SDL_GF_MAX_SURFACES]; /* Surface handles */
|
||||
gf_surface_info_t surface_info[SDL_GF_MAX_SURFACES]; /* Surface info */
|
||||
uint32_t surface_visible_idx; /* Index of visible surface */
|
||||
uint32_t surface_render_idx; /* Index of render surface */
|
||||
uint32_t surfaces_count; /* Amount of allocated surfaces */
|
||||
} SDL_RenderData;
|
||||
|
||||
typedef struct SDL_TextureData
|
||||
{
|
||||
gf_surface_t surface;
|
||||
gf_surface_info_t surface_info;
|
||||
gf_surface_t surface;
|
||||
gf_surface_info_t surface_info;
|
||||
} SDL_TextureData;
|
||||
|
||||
extern void gf_addrenderdriver(_THIS);
|
||||
|
||||
@ -32,9 +32,9 @@
|
||||
/* PS/2 and USB keyboards are generating this packet */
|
||||
typedef struct key_packet
|
||||
{
|
||||
uint8_t modifiers;
|
||||
uint8_t data;
|
||||
uint8_t codes[6];
|
||||
uint8_t modifiers;
|
||||
uint8_t data;
|
||||
uint8_t codes[6];
|
||||
} key_packet;
|
||||
|
||||
/* Key modifier codes */
|
||||
|
||||
@ -32,38 +32,38 @@
|
||||
/* USB keyboard multimedia keys are generating this packet */
|
||||
typedef struct mouse_packet2
|
||||
{
|
||||
uint8_t buttons;
|
||||
int8_t wheel;
|
||||
uint8_t buttons;
|
||||
int8_t wheel;
|
||||
} mouse_packet2;
|
||||
|
||||
/* PS/2 mice are generating this packet */
|
||||
typedef struct mouse_packet4
|
||||
{
|
||||
uint8_t buttons;
|
||||
int8_t horizontal;
|
||||
int8_t vertical;
|
||||
int8_t wheel;
|
||||
uint8_t buttons;
|
||||
int8_t horizontal;
|
||||
int8_t vertical;
|
||||
int8_t wheel;
|
||||
} mouse_packet4;
|
||||
|
||||
/* USB keyboard with mice wheel onboard generating this packet */
|
||||
typedef struct mouse_packet5
|
||||
{
|
||||
uint8_t buttons;
|
||||
int8_t horizontal;
|
||||
int8_t vertical;
|
||||
int8_t wheel;
|
||||
uint8_t state;
|
||||
uint8_t buttons;
|
||||
int8_t horizontal;
|
||||
int8_t vertical;
|
||||
int8_t wheel;
|
||||
uint8_t state;
|
||||
} mouse_packet5;
|
||||
|
||||
/* USB multi-button mice are generating this packet */
|
||||
typedef struct mouse_packet8
|
||||
{
|
||||
uint8_t buttons;
|
||||
int8_t horizontal;
|
||||
int8_t vertical;
|
||||
int8_t wheel;
|
||||
int16_t horizontal_precision;
|
||||
int16_t vertical_precision;
|
||||
uint8_t buttons;
|
||||
int8_t horizontal;
|
||||
int8_t vertical;
|
||||
int8_t wheel;
|
||||
int16_t horizontal_precision;
|
||||
int16_t vertical_precision;
|
||||
} mouse_packet8;
|
||||
|
||||
#endif /* __SDL_HIDDI_MOUSE_H__ */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -33,19 +33,19 @@
|
||||
#include <gf/gf3d.h>
|
||||
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
#include <GLES/egl.h>
|
||||
#include <GLES/egl.h>
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
|
||||
typedef struct SDL_VideoData
|
||||
{
|
||||
gf_dev_t gfdev; /* GF device handle */
|
||||
gf_dev_info_t gfdev_info; /* GF device information */
|
||||
SDL_bool gfinitialized; /* GF device initialization status */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
EGLDisplay egldisplay; /* OpenGL ES display connection */
|
||||
uint32_t egl_refcount; /* OpenGL ES reference count */
|
||||
uint32_t swapinterval; /* OpenGL ES default swap interval */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
gf_dev_t gfdev; /* GF device handle */
|
||||
gf_dev_info_t gfdev_info; /* GF device information */
|
||||
SDL_bool gfinitialized; /* GF device initialization status */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
EGLDisplay egldisplay; /* OpenGL ES display connection */
|
||||
uint32_t egl_refcount; /* OpenGL ES reference count */
|
||||
uint32_t swapinterval; /* OpenGL ES default swap interval */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
} SDL_VideoData;
|
||||
|
||||
#define SDL_VIDEO_GF_DEVICENAME_MAX 257
|
||||
@ -53,18 +53,18 @@ typedef struct SDL_VideoData
|
||||
|
||||
typedef struct SDL_DisplayData
|
||||
{
|
||||
gf_display_info_t display_info; /* GF display information */
|
||||
gf_display_t display; /* GF display handle */
|
||||
uint32_t custom_refresh; /* Custom refresh rate for all modes */
|
||||
SDL_DisplayMode current_mode; /* Current video mode */
|
||||
uint8_t description[SDL_VIDEO_GF_DEVICENAME_MAX];
|
||||
/* Device description */
|
||||
uint32_t caps; /* Device capabilities */
|
||||
SDL_bool layer_attached; /* Layer attach status */
|
||||
gf_layer_t layer; /* Graphics layer to which attached */
|
||||
gf_surface_t surface[3]; /* Visible surface on the display */
|
||||
SDL_bool cursor_visible; /* SDL_TRUE if cursor visible */
|
||||
gf_cursor_t cursor; /* Cursor shape which was set last */
|
||||
gf_display_info_t display_info; /* GF display information */
|
||||
gf_display_t display; /* GF display handle */
|
||||
uint32_t custom_refresh; /* Custom refresh rate for all modes */
|
||||
SDL_DisplayMode current_mode; /* Current video mode */
|
||||
uint8_t description[SDL_VIDEO_GF_DEVICENAME_MAX];
|
||||
/* Device description */
|
||||
uint32_t caps; /* Device capabilities */
|
||||
SDL_bool layer_attached; /* Layer attach status */
|
||||
gf_layer_t layer; /* Graphics layer to which attached */
|
||||
gf_surface_t surface[3]; /* Visible surface on the display */
|
||||
SDL_bool cursor_visible; /* SDL_TRUE if cursor visible */
|
||||
gf_cursor_t cursor; /* Cursor shape which was set last */
|
||||
} SDL_DisplayData;
|
||||
|
||||
/* Maximum amount of OpenGL ES framebuffer configurations */
|
||||
@ -72,23 +72,23 @@ typedef struct SDL_DisplayData
|
||||
|
||||
typedef struct SDL_WindowData
|
||||
{
|
||||
SDL_bool uses_gles; /* true if window support OpenGL ES */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
gf_3d_target_t target; /* OpenGL ES window target */
|
||||
SDL_bool target_created; /* GF 3D target is created if true */
|
||||
EGLConfig gles_configs[SDL_VIDEO_GF_OPENGLES_CONFS];
|
||||
/* OpenGL ES framebuffer confs */
|
||||
EGLint gles_config; /* Config index in the array of cfgs */
|
||||
EGLContext gles_context; /* OpenGL ES context */
|
||||
EGLint gles_attributes[256]; /* OpenGL ES attributes for context */
|
||||
EGLSurface gles_surface; /* OpenGL ES target rendering surface */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
SDL_bool uses_gles; /* true if window support OpenGL ES */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
gf_3d_target_t target; /* OpenGL ES window target */
|
||||
SDL_bool target_created; /* GF 3D target is created if true */
|
||||
EGLConfig gles_configs[SDL_VIDEO_GF_OPENGLES_CONFS];
|
||||
/* OpenGL ES framebuffer confs */
|
||||
EGLint gles_config; /* Config index in the array of cfgs */
|
||||
EGLContext gles_context; /* OpenGL ES context */
|
||||
EGLint gles_attributes[256]; /* OpenGL ES attributes for context */
|
||||
EGLSurface gles_surface; /* OpenGL ES target rendering surface */
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
} SDL_WindowData;
|
||||
|
||||
typedef struct SDL_GLDriverData
|
||||
{
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
#if defined(SDL_VIDEO_OPENGL_ES)
|
||||
#endif /* SDL_VIDEO_OPENGL_ES */
|
||||
} SDL_GLDriverData;
|
||||
|
||||
/****************************************************************************/
|
||||
@ -96,59 +96,60 @@ typedef struct SDL_GLDriverData
|
||||
/****************************************************************************/
|
||||
typedef struct GF_DeviceCaps
|
||||
{
|
||||
uint8_t* name;
|
||||
uint32_t caps;
|
||||
uint8_t *name;
|
||||
uint32_t caps;
|
||||
} GF_DeviceCaps;
|
||||
|
||||
#define SDL_GF_UNACCELERATED 0x00000000 /* driver is unaccelerated */
|
||||
#define SDL_GF_ACCELERATED 0x00000001 /* driver is accelerated */
|
||||
#define SDL_GF_NOLOWRESOLUTION 0x00000000 /* no modes below 640x480 */
|
||||
#define SDL_GF_LOWRESOLUTION 0x00000002 /* support modes <640x480 */
|
||||
#define SDL_GF_UNACCELERATED_3D 0x00000000 /* software OpenGL ES */
|
||||
#define SDL_GF_ACCELERATED_3D 0x00000004 /* hardware acc. OpenGL ES */
|
||||
#define SDL_GF_NOVIDEOMEMORY 0x00000000 /* no video memory alloc. */
|
||||
#define SDL_GF_VIDEOMEMORY 0x00000008 /* has video memory alloc. */
|
||||
#define SDL_GF_UNACCELERATED 0x00000000 /* driver is unaccelerated */
|
||||
#define SDL_GF_ACCELERATED 0x00000001 /* driver is accelerated */
|
||||
#define SDL_GF_NOLOWRESOLUTION 0x00000000 /* no modes below 640x480 */
|
||||
#define SDL_GF_LOWRESOLUTION 0x00000002 /* support modes <640x480 */
|
||||
#define SDL_GF_UNACCELERATED_3D 0x00000000 /* software OpenGL ES */
|
||||
#define SDL_GF_ACCELERATED_3D 0x00000004 /* hardware acc. OpenGL ES */
|
||||
#define SDL_GF_NOVIDEOMEMORY 0x00000000 /* no video memory alloc. */
|
||||
#define SDL_GF_VIDEOMEMORY 0x00000008 /* has video memory alloc. */
|
||||
|
||||
/****************************************************************************/
|
||||
/* SDL_VideoDevice functions declaration */
|
||||
/****************************************************************************/
|
||||
|
||||
/* Display and window functions */
|
||||
int qnxgf_videoinit(_THIS);
|
||||
int qnxgf_videoinit(_THIS);
|
||||
void qnxgf_videoquit(_THIS);
|
||||
void qnxgf_getdisplaymodes(_THIS);
|
||||
int qnxgf_setdisplaymode(_THIS, SDL_DisplayMode* mode);
|
||||
int qnxgf_setdisplaypalette(_THIS, SDL_Palette* palette);
|
||||
int qnxgf_getdisplaypalette(_THIS, SDL_Palette* palette);
|
||||
int qnxgf_setdisplaygammaramp(_THIS, Uint16* ramp);
|
||||
int qnxgf_getdisplaygammaramp(_THIS, Uint16* ramp);
|
||||
int qnxgf_createwindow(_THIS, SDL_Window* window);
|
||||
int qnxgf_createwindowfrom(_THIS, SDL_Window* window, const void* data);
|
||||
void qnxgf_setwindowtitle(_THIS, SDL_Window* window);
|
||||
void qnxgf_setwindowicon(_THIS, SDL_Window* window, SDL_Surface* icon);
|
||||
void qnxgf_setwindowposition(_THIS, SDL_Window* window);
|
||||
void qnxgf_setwindowsize(_THIS, SDL_Window* window);
|
||||
void qnxgf_showwindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_hidewindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_raisewindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_maximizewindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_minimizewindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_restorewindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_setwindowgrab(_THIS, SDL_Window* window);
|
||||
void qnxgf_destroywindow(_THIS, SDL_Window* window);
|
||||
int qnxgf_setdisplaymode(_THIS, SDL_DisplayMode * mode);
|
||||
int qnxgf_setdisplaypalette(_THIS, SDL_Palette * palette);
|
||||
int qnxgf_getdisplaypalette(_THIS, SDL_Palette * palette);
|
||||
int qnxgf_setdisplaygammaramp(_THIS, Uint16 * ramp);
|
||||
int qnxgf_getdisplaygammaramp(_THIS, Uint16 * ramp);
|
||||
int qnxgf_createwindow(_THIS, SDL_Window * window);
|
||||
int qnxgf_createwindowfrom(_THIS, SDL_Window * window, const void *data);
|
||||
void qnxgf_setwindowtitle(_THIS, SDL_Window * window);
|
||||
void qnxgf_setwindowicon(_THIS, SDL_Window * window, SDL_Surface * icon);
|
||||
void qnxgf_setwindowposition(_THIS, SDL_Window * window);
|
||||
void qnxgf_setwindowsize(_THIS, SDL_Window * window);
|
||||
void qnxgf_showwindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_hidewindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_raisewindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_maximizewindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_minimizewindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_restorewindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_setwindowgrab(_THIS, SDL_Window * window);
|
||||
void qnxgf_destroywindow(_THIS, SDL_Window * window);
|
||||
|
||||
/* Window manager function */
|
||||
SDL_bool qnxgf_getwindowwminfo(_THIS, SDL_Window* window, struct SDL_SysWMinfo* info);
|
||||
SDL_bool qnxgf_getwindowwminfo(_THIS, SDL_Window * window,
|
||||
struct SDL_SysWMinfo *info);
|
||||
|
||||
/* OpenGL/OpenGL ES functions */
|
||||
int qnxgf_gl_loadlibrary(_THIS, const char* path);
|
||||
void* qnxgf_gl_getprocaddres(_THIS, const char* proc);
|
||||
int qnxgf_gl_loadlibrary(_THIS, const char *path);
|
||||
void *qnxgf_gl_getprocaddres(_THIS, const char *proc);
|
||||
void qnxgf_gl_unloadlibrary(_THIS);
|
||||
SDL_GLContext qnxgf_gl_createcontext(_THIS, SDL_Window* window);
|
||||
int qnxgf_gl_makecurrent(_THIS, SDL_Window* window, SDL_GLContext context);
|
||||
SDL_GLContext qnxgf_gl_createcontext(_THIS, SDL_Window * window);
|
||||
int qnxgf_gl_makecurrent(_THIS, SDL_Window * window, SDL_GLContext context);
|
||||
int qnxgf_gl_setswapinterval(_THIS, int interval);
|
||||
int qnxgf_gl_getswapinterval(_THIS);
|
||||
void qnxgf_gl_swapwindow(_THIS, SDL_Window* window);
|
||||
void qnxgf_gl_swapwindow(_THIS, SDL_Window * window);
|
||||
void qnxgf_gl_deletecontext(_THIS, SDL_GLContext context);
|
||||
|
||||
/* Event handling function */
|
||||
|
||||
@ -481,7 +481,7 @@ GDI_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
/* Crap, we've lost the original pixel data... *sigh* */
|
||||
}
|
||||
return 0;
|
||||
#ifndef _WIN32_WCE /* WinCE has no alphablend */
|
||||
#ifndef _WIN32_WCE /* WinCE has no alphablend */
|
||||
case SDL_BLENDMODE_MASK:
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
if (!data->premultiplied && data->pixels) {
|
||||
@ -627,7 +627,7 @@ GDI_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
pitch);
|
||||
} else if (data->pixels) {
|
||||
#ifndef _WIN32_WCE
|
||||
/* WinCE has no GdiFlush */
|
||||
/* WinCE has no GdiFlush */
|
||||
GdiFlush();
|
||||
#endif
|
||||
*pixels =
|
||||
|
||||
@ -191,12 +191,12 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
||||
0, 0);
|
||||
SDL_SendWindowEvent(data->windowID,
|
||||
SDL_WINDOWEVENT_RESTORED, 0, 0);
|
||||
#ifndef _WIN32_WCE /* WinCE misses IsZoomed() */
|
||||
#ifndef _WIN32_WCE /* WinCE misses IsZoomed() */
|
||||
if (IsZoomed(hwnd)) {
|
||||
SDL_SendWindowEvent(data->windowID,
|
||||
SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
if (keyboard && keyboard->focus != data->windowID) {
|
||||
SDL_SetKeyboardFocus(index, data->windowID);
|
||||
}
|
||||
@ -218,18 +218,18 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
||||
*/
|
||||
#ifdef _WIN32_WCE
|
||||
case WM_MOUSEMOVE:
|
||||
SDL_SendMouseMotion(0, 0, LOWORD(lParam), HIWORD(lParam), 0);
|
||||
break;
|
||||
|
||||
SDL_SendMouseMotion(0, 0, LOWORD(lParam), HIWORD(lParam), 0);
|
||||
break;
|
||||
|
||||
case WM_LBUTTONDOWN:
|
||||
SDL_SendMouseMotion(0, 0, LOWORD(lParam), HIWORD(lParam), 0);
|
||||
SDL_SendMouseButton(0, SDL_PRESSED, SDL_BUTTON_LEFT);
|
||||
break;
|
||||
|
||||
SDL_SendMouseMotion(0, 0, LOWORD(lParam), HIWORD(lParam), 0);
|
||||
SDL_SendMouseButton(0, SDL_PRESSED, SDL_BUTTON_LEFT);
|
||||
break;
|
||||
|
||||
case WM_LBUTTONUP:
|
||||
SDL_SendMouseMotion(0, 0, LOWORD(lParam), HIWORD(lParam), 0);
|
||||
SDL_SendMouseButton(0, SDL_RELEASED, SDL_BUTTON_LEFT);
|
||||
break;
|
||||
SDL_SendMouseMotion(0, 0, LOWORD(lParam), HIWORD(lParam), 0);
|
||||
SDL_SendMouseButton(0, SDL_RELEASED, SDL_BUTTON_LEFT);
|
||||
break;
|
||||
#else /* _WIN32_WCE */
|
||||
|
||||
case WM_INPUT: /* mouse events */
|
||||
@ -261,7 +261,7 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
GetCursorPos(&point);
|
||||
ScreenToClient(hwnd, &point);
|
||||
|
||||
@ -314,7 +314,7 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
||||
}
|
||||
return (0);
|
||||
#endif /* _WIN32_WCE */
|
||||
|
||||
|
||||
case WM_MOUSELEAVE:
|
||||
{
|
||||
int i;
|
||||
@ -598,7 +598,7 @@ WIN_WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
||||
case WM_NCPAINT:
|
||||
{
|
||||
if (SDL_GetWindowFlags(data->windowID) & SDL_WINDOW_FOREIGN) {
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@ -28,7 +28,7 @@ int
|
||||
WIN_SetDisplayGammaRamp(_THIS, Uint16 * ramp)
|
||||
{
|
||||
#ifdef _WIN32_WCE
|
||||
return -1;
|
||||
return -1;
|
||||
#else
|
||||
SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
|
||||
HDC hdc;
|
||||
@ -50,7 +50,7 @@ int
|
||||
WIN_GetDisplayGammaRamp(_THIS, Uint16 * ramp)
|
||||
{
|
||||
#ifdef _WIN32_WCE
|
||||
return -1;
|
||||
return -1;
|
||||
#else
|
||||
SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
|
||||
HDC hdc;
|
||||
|
||||
@ -55,10 +55,10 @@ WIN_GetDisplayMode(LPCTSTR deviceName, DWORD index, SDL_DisplayMode * mode)
|
||||
mode->driverdata = data;
|
||||
#ifdef _WIN32_WCE
|
||||
/* In WinCE EnumDisplaySettings(ENUM_CURRENT_SETTINGS) doesn't take the user defined orientation
|
||||
into account but GetSystemMetrixs does. */
|
||||
if(index == ENUM_CURRENT_SETTINGS) {
|
||||
mode->w = GetSystemMetrics(SM_CXSCREEN);
|
||||
mode->h = GetSystemMetrics(SM_CYSCREEN);
|
||||
into account but GetSystemMetrixs does. */
|
||||
if (index == ENUM_CURRENT_SETTINGS) {
|
||||
mode->w = GetSystemMetrics(SM_CXSCREEN);
|
||||
mode->h = GetSystemMetrics(SM_CYSCREEN);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -211,12 +211,12 @@ WIN_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
|
||||
{
|
||||
SDL_DisplayModeData *data = (SDL_DisplayModeData *) mode->driverdata;
|
||||
LONG status;
|
||||
|
||||
|
||||
#ifdef _WIN32_WCE
|
||||
/* TODO: implement correctly.
|
||||
On my Asus MyPAL, if I execute the code below
|
||||
I get DISP_CHANGE_BADFLAGS and the Titlebar of the fullscreen window stays
|
||||
visible ... (SDL_RaiseWindow() would fix that one)*/
|
||||
visible ... (SDL_RaiseWindow() would fix that one) */
|
||||
return 0;
|
||||
#endif
|
||||
|
||||
|
||||
@ -40,7 +40,11 @@
|
||||
#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
|
||||
#endif
|
||||
|
||||
typedef HGLRC (APIENTRYP PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int * attribList);
|
||||
typedef HGLRC(APIENTRYP PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC,
|
||||
HGLRC
|
||||
hShareContext,
|
||||
const int
|
||||
*attribList);
|
||||
|
||||
int
|
||||
WIN_GL_LoadLibrary(_THIS, const char *path)
|
||||
@ -502,17 +506,19 @@ WIN_GL_CreateContext(_THIS, SDL_Window * window)
|
||||
PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB;
|
||||
HGLRC temp_context = _this->gl_data->wglCreateContext(hdc);
|
||||
if (!temp_context) {
|
||||
SDL_SetError("Could not create GL context");
|
||||
SDL_SetError("Could not create GL context");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/* Make the context current */
|
||||
if (WIN_GL_MakeCurrent(_this, window, temp_context) < 0) {
|
||||
WIN_GL_DeleteContext(_this, temp_context);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) _this->gl_data->wglGetProcAddress("wglCreateContextAttribsARB");
|
||||
|
||||
wglCreateContextAttribsARB =
|
||||
(PFNWGLCREATECONTEXTATTRIBSARBPROC) _this->gl_data->
|
||||
wglGetProcAddress("wglCreateContextAttribsARB");
|
||||
if (!wglCreateContextAttribsARB) {
|
||||
SDL_SetError("GL 3.x is not supported");
|
||||
context = temp_context;
|
||||
@ -520,7 +526,7 @@ WIN_GL_CreateContext(_THIS, SDL_Window * window)
|
||||
int attribs[] = {
|
||||
WGL_CONTEXT_MAJOR_VERSION_ARB, _this->gl_config.major_version,
|
||||
WGL_CONTEXT_MINOR_VERSION_ARB, _this->gl_config.minor_version,
|
||||
0
|
||||
0
|
||||
};
|
||||
/* Create the GL 3.x context */
|
||||
context = wglCreateContextAttribsARB(hdc, 0, attribs);
|
||||
@ -528,7 +534,7 @@ WIN_GL_CreateContext(_THIS, SDL_Window * window)
|
||||
_this->gl_data->wglDeleteContext(temp_context);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (!context) {
|
||||
SDL_SetError("Could not create GL context");
|
||||
return NULL;
|
||||
|
||||
@ -242,8 +242,7 @@ WIN_CreateWindow(_THIS, SDL_Window * window)
|
||||
}
|
||||
g_hCtx[window->id] = videodata->WTOpenA(hwnd, &lc, TRUE);
|
||||
}
|
||||
|
||||
#ifndef _WIN32_WCE /* has no RawInput */
|
||||
#ifndef _WIN32_WCE /* has no RawInput */
|
||||
/* we're telling the window, we want it to report raw input events from mice */
|
||||
Rid.usUsagePage = 0x01;
|
||||
Rid.usUsage = 0x02;
|
||||
|
||||
@ -77,7 +77,13 @@
|
||||
static void X11_GL_InitExtensions(_THIS);
|
||||
|
||||
/* Typedef for the GL 3.0 context creation function */
|
||||
typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);
|
||||
typedef GLXContext(*PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display * dpy,
|
||||
GLXFBConfig config,
|
||||
GLXContext
|
||||
share_context,
|
||||
Bool direct,
|
||||
const int
|
||||
*attrib_list);
|
||||
|
||||
int
|
||||
X11_GL_LoadLibrary(_THIS, const char *path)
|
||||
@ -283,7 +289,7 @@ X11_GL_GetVisual(_THIS, Display * display, int screen)
|
||||
/* 64 seems nice. */
|
||||
int attribs[64];
|
||||
int i = 0;
|
||||
|
||||
|
||||
/* Setup our GLX attributes according to the gl_config. */
|
||||
attribs[i++] = GLX_RGBA;
|
||||
attribs[i++] = GLX_RED_SIZE;
|
||||
@ -395,42 +401,64 @@ X11_GL_CreateContext(_THIS, SDL_Window * window)
|
||||
v.visualid = XVisualIDFromVisual(xattr.visual);
|
||||
vinfo = XGetVisualInfo(display, VisualScreenMask | VisualIDMask, &v, &n);
|
||||
if (vinfo) {
|
||||
if (_this->gl_config.major_version < 3) {
|
||||
if (_this->gl_config.major_version < 3) {
|
||||
context =
|
||||
_this->gl_data->glXCreateContext(display, vinfo, NULL, True);
|
||||
} else {
|
||||
/* If we want a GL 3.0 context or later we need to get a temporary
|
||||
context to grab the new context creation function */
|
||||
GLXContext temp_context = _this->gl_data->glXCreateContext(display, vinfo, NULL, True);
|
||||
GLXContext temp_context =
|
||||
_this->gl_data->glXCreateContext(display, vinfo, NULL, True);
|
||||
if (!temp_context) {
|
||||
SDL_SetError("Could not create GL context");
|
||||
SDL_SetError("Could not create GL context");
|
||||
return NULL;
|
||||
} else {
|
||||
int attribs[] = {
|
||||
GLX_CONTEXT_MAJOR_VERSION_ARB, _this->gl_config.major_version,
|
||||
GLX_CONTEXT_MINOR_VERSION_ARB, _this->gl_config.minor_version,
|
||||
0
|
||||
GLX_CONTEXT_MAJOR_VERSION_ARB,
|
||||
_this->gl_config.major_version,
|
||||
GLX_CONTEXT_MINOR_VERSION_ARB,
|
||||
_this->gl_config.minor_version,
|
||||
0
|
||||
};
|
||||
|
||||
|
||||
/* Get a pointer to the context creation function for GL 3.0 */
|
||||
PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs = (PFNGLXCREATECONTEXTATTRIBSARBPROC)_this->gl_data->glXGetProcAddress((GLubyte*)"glXCreateContextAttribsARB");
|
||||
PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribs =
|
||||
(PFNGLXCREATECONTEXTATTRIBSARBPROC) _this->gl_data->
|
||||
glXGetProcAddress((GLubyte *)
|
||||
"glXCreateContextAttribsARB");
|
||||
if (!glXCreateContextAttribs) {
|
||||
SDL_SetError("GL 3.x is not supported");
|
||||
context = temp_context;
|
||||
} else {
|
||||
/* Create a GL 3.x context */
|
||||
GLXFBConfig *framebuffer_config = NULL;
|
||||
int fbcount = 0;
|
||||
GLXFBConfig* (*glXChooseFBConfig)(Display* disp, int screen, const int* attrib_list, int* nelements);
|
||||
int fbcount = 0;
|
||||
GLXFBConfig *(*glXChooseFBConfig) (Display * disp,
|
||||
int screen,
|
||||
const int *attrib_list,
|
||||
int *nelements);
|
||||
|
||||
glXChooseFBConfig = (GLXFBConfig* (*)(Display*, int, const int*, int*))_this->gl_data->glXGetProcAddress((GLubyte*)"glXChooseFBConfig");
|
||||
glXChooseFBConfig =
|
||||
(GLXFBConfig *
|
||||
(*)(Display *, int, const int *,
|
||||
int *)) _this->gl_data->
|
||||
glXGetProcAddress((GLubyte *) "glXChooseFBConfig");
|
||||
|
||||
if (!glXChooseFBConfig || !(framebuffer_config = glXChooseFBConfig(display, DefaultScreen(display), NULL, &fbcount))) {
|
||||
SDL_SetError("No good framebuffers found. GL 3.x disabled");
|
||||
if (!glXChooseFBConfig
|
||||
|| !(framebuffer_config =
|
||||
glXChooseFBConfig(display,
|
||||
DefaultScreen(display), NULL,
|
||||
&fbcount))) {
|
||||
SDL_SetError
|
||||
("No good framebuffers found. GL 3.x disabled");
|
||||
context = temp_context;
|
||||
} else {
|
||||
context = glXCreateContextAttribs(display, framebuffer_config[0], NULL, True, attribs);
|
||||
_this->gl_data->glXDestroyContext(display, temp_context);
|
||||
} else {
|
||||
context =
|
||||
glXCreateContextAttribs(display,
|
||||
framebuffer_config[0],
|
||||
NULL, True, attribs);
|
||||
_this->gl_data->glXDestroyContext(display,
|
||||
temp_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -118,10 +118,10 @@ main(int argc, char *argv[])
|
||||
/* you may want to change these according to the platform */
|
||||
video_w = 320;
|
||||
video_h = 480;
|
||||
#ifdef __QNXNTO__
|
||||
video_h = 640;
|
||||
video_w = 480;
|
||||
#endif /* __QNXNTO__ */
|
||||
#ifdef __QNXNTO__
|
||||
video_h = 640;
|
||||
video_w = 480;
|
||||
#endif /* __QNXNTO__ */
|
||||
|
||||
if (argv[1]) {
|
||||
gl_library = argv[1];
|
||||
@ -153,11 +153,11 @@ main(int argc, char *argv[])
|
||||
pixels[3 * i + 2] = rand() % 250 - 125;
|
||||
}
|
||||
|
||||
#ifdef __QNXNTO__
|
||||
f.glViewport(0, 0, video_h, video_w);
|
||||
#else
|
||||
f.glViewport(0, 0, video_w, video_h);
|
||||
#endif /* __QNXNTO__ */
|
||||
#ifdef __QNXNTO__
|
||||
f.glViewport(0, 0, video_h, video_w);
|
||||
#else
|
||||
f.glViewport(0, 0, video_w, video_h);
|
||||
#endif /* __QNXNTO__ */
|
||||
|
||||
f.glMatrixMode(GL_PROJECTION);
|
||||
f.glLoadIdentity();
|
||||
|
||||
@ -242,51 +242,54 @@ main(int argc, char *argv[])
|
||||
printf("Extensions : %s\n", glGetString(GL_EXTENSIONS));
|
||||
printf("\n");
|
||||
|
||||
status=SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", 16, value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError());
|
||||
}
|
||||
if (fsaa) {
|
||||
status=SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError());
|
||||
printf("Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value);
|
||||
printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa,
|
||||
value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError());
|
||||
printf("Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
}
|
||||
if (accel) {
|
||||
status=SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
|
||||
if (!status)
|
||||
{
|
||||
status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value);
|
||||
} else {
|
||||
printf("Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError());
|
||||
printf("Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
#include "SDL_opengles.h"
|
||||
|
||||
static CommonState *state;
|
||||
static SDL_GLContext *context=NULL;
|
||||
static SDL_GLContext *context = NULL;
|
||||
|
||||
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
|
||||
static void
|
||||
@ -22,10 +22,8 @@ quit(int rc)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (context!=NULL)
|
||||
{
|
||||
for (i=0; i<state->num_windows; i++)
|
||||
{
|
||||
if (context != NULL) {
|
||||
for (i = 0; i < state->num_windows; i++) {
|
||||
if (context[i]) {
|
||||
SDL_GL_DeleteContext(context[i]);
|
||||
}
|
||||
@ -149,16 +147,14 @@ main(int argc, char *argv[])
|
||||
quit(2);
|
||||
}
|
||||
|
||||
context=SDL_calloc(state->num_windows, sizeof(SDL_GLContext));
|
||||
if (context==NULL)
|
||||
{
|
||||
fprintf(stderr, "Out of memory!\n");
|
||||
quit(2);
|
||||
context = SDL_calloc(state->num_windows, sizeof(SDL_GLContext));
|
||||
if (context == NULL) {
|
||||
fprintf(stderr, "Out of memory!\n");
|
||||
quit(2);
|
||||
}
|
||||
|
||||
/* Create OpenGL ES contexts */
|
||||
for (i=0; i<state->num_windows; i++)
|
||||
{
|
||||
for (i = 0; i < state->num_windows; i++) {
|
||||
context[i] = SDL_GL_CreateContext(state->windows[i]);
|
||||
if (!context[i]) {
|
||||
fprintf(stderr, "SDL_GL_CreateContext(): %s\n", SDL_GetError());
|
||||
@ -181,59 +177,65 @@ main(int argc, char *argv[])
|
||||
printf("Extensions : %s\n", glGetString(GL_EXTENSIONS));
|
||||
printf("\n");
|
||||
|
||||
status=SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_RED_SIZE: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_GREEN_SIZE: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_BLUE_SIZE: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", 16, value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_DEPTH_SIZE: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
if (fsaa) {
|
||||
status=SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
status=SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);
|
||||
status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value);
|
||||
printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa,
|
||||
value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
}
|
||||
if (accel) {
|
||||
status=SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
|
||||
if (!status)
|
||||
{
|
||||
status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
|
||||
if (!status) {
|
||||
printf("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value);
|
||||
} else {
|
||||
fprintf(stderr, "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError());
|
||||
fprintf(stderr, "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n",
|
||||
SDL_GetError());
|
||||
}
|
||||
}
|
||||
|
||||
/* Set rendering settings for each context */
|
||||
for (i = 0; i < state->num_windows; ++i) {
|
||||
status=SDL_GL_MakeCurrent(state->windows[i], context[i]);
|
||||
if (status)
|
||||
{
|
||||
status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
|
||||
if (status) {
|
||||
printf("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
|
||||
|
||||
/* Continue for next window */
|
||||
@ -262,13 +264,12 @@ main(int argc, char *argv[])
|
||||
}
|
||||
for (i = 0; i < state->num_windows; ++i) {
|
||||
int w, h;
|
||||
status=SDL_GL_MakeCurrent(state->windows[i], context[i]);
|
||||
if (status)
|
||||
{
|
||||
printf("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
|
||||
status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
|
||||
if (status) {
|
||||
printf("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
|
||||
|
||||
/* Continue for next window */
|
||||
continue;
|
||||
/* Continue for next window */
|
||||
continue;
|
||||
}
|
||||
SDL_GetWindowSize(state->windows[i], &w, &h);
|
||||
glViewport(0, 0, w, h);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user