static int
DirectFB_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, const void * pixels, int pitch)
{
SDL_Window *window = renderer->window;
SDL_DFB_WINDOWDATA(window);
Uint32 sdl_format;
unsigned char* laypixels;
int laypitch;
DFBSurfacePixelFormat dfb_format;
SDL_DFB_CHECK(windata->surface->GetPixelFormat(windata->surface, &dfb_format));
sdl_format = DirectFB_DFBToSDLPixelFormat(dfb_format);
SDL_DFB_CHECK(windata->surface->Lock(windata->surface, DSLF_WRITE, (void **) &laypixels, &laypitch));
laypixels += (rect->y * laypitch + rect->x * SDL_BYTESPERPIXEL(sdl_format) );
SDL_ConvertPixels(rect->w, rect->h,
format, pixels, pitch,
sdl_format, laypixels, laypitch);
SDL_DFB_CHECK(windata->surface->Unlock(windata->surface));
return 0;
}
static int
SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
SDL_Surface *surface = SW_ActivateRenderer(renderer);
Uint32 src_format;
void *src_pixels;
if (!surface) {
return -1;
}
/* NOTE: The rect is already adjusted according to the viewport by
* SDL_RenderReadPixels.
*/
if (rect->x < 0 || rect->x+rect->w > surface->w ||
rect->y < 0 || rect->y+rect->h > surface->h) {
return SDL_SetError("Tried to read outside of surface bounds");
}
src_format = surface->format->format;
src_pixels = (void*)((Uint8 *) surface->pixels +
rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel);
return SDL_ConvertPixels(rect->w, rect->h,
src_format, src_pixels, surface->pitch,
format, pixels, pitch);
}
static int
DirectFB_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
Uint32 sdl_format;
unsigned char* laypixels;
int laypitch;
DFBSurfacePixelFormat dfb_format;
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
IDirectFBSurface *winsurf = data->target;
DirectFB_ActivateRenderer(renderer);
winsurf->GetPixelFormat(winsurf, &dfb_format);
sdl_format = DirectFB_DFBToSDLPixelFormat(dfb_format);
winsurf->Lock(winsurf, DSLF_READ, (void **) &laypixels, &laypitch);
laypixels += (rect->y * laypitch + rect->x * SDL_BYTESPERPIXEL(sdl_format) );
SDL_ConvertPixels(rect->w, rect->h,
sdl_format, laypixels, laypitch,
format, pixels, pitch);
winsurf->Unlock(winsurf);
return 0;
}
static int
SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
SDL_Surface *surface = SW_ActivateRenderer(renderer);
Uint32 src_format;
void *src_pixels;
if (!surface) {
return -1;
}
if (rect->x < 0 || rect->x+rect->w > surface->w ||
rect->y < 0 || rect->y+rect->h > surface->h) {
SDL_SetError("Tried to read outside of surface bounds");
return -1;
}
src_format = SDL_MasksToPixelFormatEnum(
surface->format->BitsPerPixel,
surface->format->Rmask, surface->format->Gmask,
surface->format->Bmask, surface->format->Amask);
src_pixels = (void*)((Uint8 *) surface->pixels +
rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel);
return SDL_ConvertPixels(rect->w, rect->h,
src_format, src_pixels, surface->pitch,
format, pixels, pitch);
}
static int
SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
SDL_Surface *surface = SW_ActivateRenderer(renderer);
Uint32 src_format;
void *src_pixels;
SDL_Rect final_rect;
if (!surface) {
return -1;
}
if (renderer->viewport.x || renderer->viewport.y) {
final_rect.x = renderer->viewport.x + rect->x;
final_rect.y = renderer->viewport.y + rect->y;
final_rect.w = rect->w;
final_rect.h = rect->h;
rect = &final_rect;
}
if (rect->x < 0 || rect->x+rect->w > surface->w ||
rect->y < 0 || rect->y+rect->h > surface->h) {
return SDL_SetError("Tried to read outside of surface bounds");
}
src_format = surface->format->format;
src_pixels = (void*)((Uint8 *) surface->pixels +
rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel);
return SDL_ConvertPixels(rect->w, rect->h,
src_format, src_pixels, surface->pitch,
format, pixels, pitch);
}
static int
D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
D3DSURFACE_DESC desc;
LPDIRECT3DSURFACE9 backBuffer;
LPDIRECT3DSURFACE9 surface;
RECT d3drect;
D3DLOCKED_RECT locked;
HRESULT result;
result = IDirect3DDevice9_GetBackBuffer(data->device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backBuffer);
if (FAILED(result)) {
return D3D_SetError("GetBackBuffer()", result);
}
result = IDirect3DSurface9_GetDesc(backBuffer, &desc);
if (FAILED(result)) {
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("GetDesc()", result);
}
result = IDirect3DDevice9_CreateOffscreenPlainSurface(data->device, desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &surface, NULL);
if (FAILED(result)) {
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("CreateOffscreenPlainSurface()", result);
}
result = IDirect3DDevice9_GetRenderTargetData(data->device, backBuffer, surface);
if (FAILED(result)) {
IDirect3DSurface9_Release(surface);
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("GetRenderTargetData()", result);
}
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;
d3drect.bottom = rect->y + rect->h;
result = IDirect3DSurface9_LockRect(surface, &locked, &d3drect, D3DLOCK_READONLY);
if (FAILED(result)) {
IDirect3DSurface9_Release(surface);
IDirect3DSurface9_Release(backBuffer);
return D3D_SetError("LockRect()", result);
}
SDL_ConvertPixels(rect->w, rect->h,
D3DFMTToPixelFormat(desc.Format), locked.pBits, locked.Pitch,
format, pixels, pitch);
IDirect3DSurface9_UnlockRect(surface);
IDirect3DSurface9_Release(surface);
IDirect3DSurface9_Release(backBuffer);
return 0;
}
static int
GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 pixel_format, void * pixels, int pitch)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window;
Uint32 temp_format = SDL_PIXELFORMAT_ARGB8888;
void *temp_pixels;
int temp_pitch;
GLint internalFormat;
GLenum format, type;
Uint8 *src, *dst, *tmp;
int w, h, length, rows;
int status;
GL_ActivateRenderer(renderer);
temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
temp_pixels = SDL_malloc(rect->h * temp_pitch);
if (!temp_pixels) {
SDL_OutOfMemory();
return -1;
}
convert_format(data, temp_format, &internalFormat, &format, &type);
SDL_GetWindowSize(window, &w, &h);
data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
data->glPixelStorei(GL_PACK_ROW_LENGTH,
(temp_pitch / SDL_BYTESPERPIXEL(temp_format)));
data->glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
format, type, temp_pixels);
/* Flip the rows to be top-down */
length = rect->w * SDL_BYTESPERPIXEL(temp_format);
src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
dst = (Uint8*)temp_pixels;
tmp = SDL_stack_alloc(Uint8, length);
rows = rect->h / 2;
while (rows--) {
SDL_memcpy(tmp, dst, length);
SDL_memcpy(dst, src, length);
SDL_memcpy(src, tmp, length);
dst += temp_pitch;
src -= temp_pitch;
}
SDL_stack_free(tmp);
status = SDL_ConvertPixels(rect->w, rect->h,
temp_format, temp_pixels, temp_pitch,
pixel_format, pixels, pitch);
SDL_free(temp_pixels);
return status;
}
static int
GLES_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 pixel_format, void * pixels, int pitch)
{
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
void *temp_pixels;
int temp_pitch;
Uint8 *src, *dst, *tmp;
int w, h, length, rows;
int status;
GLES_ActivateRenderer(renderer);
temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
temp_pixels = SDL_malloc(rect->h * temp_pitch);
if (!temp_pixels) {
return SDL_OutOfMemory();
}
SDL_GetRendererOutputSize(renderer, &w, &h);
data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
data->glReadPixels(rect->x, renderer->target ? rect->y : (h-rect->y)-rect->h,
rect->w, rect->h, GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
/* Flip the rows to be top-down if necessary */
if (!renderer->target) {
length = rect->w * SDL_BYTESPERPIXEL(temp_format);
src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
dst = (Uint8*)temp_pixels;
tmp = SDL_stack_alloc(Uint8, length);
rows = rect->h / 2;
while (rows--) {
SDL_memcpy(tmp, dst, length);
SDL_memcpy(dst, src, length);
SDL_memcpy(src, tmp, length);
dst += temp_pitch;
src -= temp_pitch;
}
SDL_stack_free(tmp);
}
status = SDL_ConvertPixels(rect->w, rect->h,
temp_format, temp_pixels, temp_pitch,
pixel_format, pixels, pitch);
SDL_free(temp_pixels);
return status;
}
//-----------------------------------------------------------------------------
void AdScreen::Present(void) {
int pitch;
void* pixels;
SDL_LockTexture(s_pTexture, NULL, &pixels, &pitch);
SDL_ConvertPixels(
s_pScreen->w,
s_pScreen->h,
s_pScreen->format->format,
s_pScreen->pixels,
s_pScreen->pitch,
SDL_PIXELFORMAT_RGBA8888,
pixels, pitch
);
SDL_UnlockTexture(s_pTexture);
SDL_RenderCopy(GetRenderer(), s_pTexture, NULL, NULL);
SDL_RenderPresent(GetRenderer());
s_iFrames++;
s_uiCurrentCount = SDL_GetPerformanceCounter();
s_uiDiffCount = (s_uiCurrentCount-s_uiLastCount);
s_uiCountFreq = SDL_GetPerformanceFrequency();
s_fElapsedTime = ((float) s_uiDiffCount/(float) s_uiCountFreq);
if((1.0f/60.0f)-s_fElapsedTime > 0) {
// NOTE: without this there seems to be a more consistent framerate
// but on older computers sometimes the vsync doesn't work right
//SDL_Delay((uint32_t) (1000.0f*((1.0f/60.0f)-s_fElapsedTime)));
s_fTotTime += 1.0f/60.0f;
} else {
s_fTotTime += s_fElapsedTime;
}
s_uiLastCount = s_uiCurrentCount;
if(s_fTotTime >= 1.0f) {
char strTitle[0x20] = "";
sprintf(strTitle, "%s, FPS: %d", WINDOW_TITLE, s_iFrames);
SDL_SetWindowTitle(GetWindow(), strTitle);
s_fTotTime = 0;
s_iFrames = 0;
}
}
static int lua_SDL_ConvertPixels(State & state){
Stack * stack = state.stack;
stack->push<bool>(SDL_ConvertPixels(
stack->to<int>(1),
stack->to<int>(2),
stack->to<int>(3),
stack->to<void*>(4),
stack->to<int>(5),
stack->to<int>(6),
stack->to<void*>(7),
stack->to<int>(8)
) == 0);
return 1;
}
static int
SDL_UpdateTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
const void *pixels, int pitch)
{
SDL_Texture *native = texture->native;
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
/* We can lock the texture and copy to it */
void *native_pixels;
int native_pitch;
if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
return -1;
}
SDL_ConvertPixels(rect->w, rect->h,
texture->format, pixels, pitch,
native->format, native_pixels, native_pitch);
SDL_UnlockTexture(native);
} else {
/* Use a temporary buffer for updating */
void *temp_pixels;
int temp_pitch;
temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
temp_pixels = SDL_malloc(rect->h * temp_pitch);
if (!temp_pixels) {
SDL_OutOfMemory();
return -1;
}
SDL_ConvertPixels(rect->w, rect->h,
texture->format, pixels, pitch,
native->format, temp_pixels, temp_pitch);
SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
SDL_free(temp_pixels);
}
return 0;
}
static int
SDL_DUMMY_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, const void * pixels, int pitch)
{
SDL_DUMMY_RenderData *data =
(SDL_DUMMY_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display;
SDL_Surface *screen = data->screens[data->current_screen];
Uint32 screen_format = display->current_mode.format;
Uint8 *screen_pixels = (Uint8 *) screen->pixels +
rect->y * screen->pitch +
rect->x * screen->format->BytesPerPixel;
int screen_pitch = screen->pitch;
return SDL_ConvertPixels(rect->w, rect->h,
format, pixels, pitch,
screen_format, screen_pixels, screen_pitch);
}
static int
X11_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, const void * pixels, int pitch)
{
X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display;
Uint32 screen_format = display->current_mode.format;
XImage *image;
void *image_pixels;
int image_pitch;
image_pitch = rect->w * SDL_BYTESPERPIXEL(screen_format);
image_pixels = SDL_malloc(rect->h * image_pitch);
if (!image_pixels) {
SDL_OutOfMemory();
return -1;
}
image = XCreateImage(data->display, data->visual,
data->depth, ZPixmap, 0, image_pixels,
rect->w, rect->h,
SDL_BYTESPERPIXEL(screen_format) * 8,
image_pitch);
if (!image) {
SDL_SetError("XCreateImage() failed");
return -1;
}
SDL_ConvertPixels(rect->w, rect->h,
format, pixels, pitch,
screen_format, image->data, image->bytes_per_line);
XPutImage(data->display, data->drawable, data->gc,
image, 0, 0, rect->x, rect->y, rect->w, rect->h);
image->data = NULL;
XDestroyImage(image);
SDL_free(image_pixels);
return 0;
}
static int
X11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display;
Uint32 screen_format = display->current_mode.format;
XImage *image;
image = XGetImage(data->display, data->drawable, rect->x, rect->y,
rect->w, rect->h, AllPlanes, ZPixmap);
SDL_ConvertPixels(rect->w, rect->h,
screen_format, image->data, image->bytes_per_line,
format, pixels, pitch);
XDestroyImage(image);
return 0;
}
static void
SDL_UnlockTextureNative(SDL_Texture * texture)
{
SDL_Texture *native = texture->native;
void *native_pixels;
int native_pitch;
const SDL_Rect *rect = &texture->locked_rect;
const void* pixels = (void *) ((Uint8 *) texture->pixels +
rect->y * texture->pitch +
rect->x * SDL_BYTESPERPIXEL(texture->format));
int pitch = texture->pitch;
if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
return;
}
SDL_ConvertPixels(rect->w, rect->h,
texture->format, pixels, pitch,
native->format, native_pixels, native_pitch);
SDL_UnlockTexture(native);
}
static int
GDI_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch)
{
GDI_RenderData *renderdata = (GDI_RenderData *) renderer->driverdata;
SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display;
struct {
HBITMAP hbm;
void *pixels;
int pitch;
Uint32 format;
} data;
data.format = display->current_mode.format;
data.pitch = (rect->w * SDL_BYTESPERPIXEL(data.format));
data.hbm = GDI_CreateDIBSection(renderdata->memory_hdc, rect->w, rect->h,
data.pitch, data.format, NULL,
&data.pixels);
if (!data.hbm) {
WIN_SetError("Couldn't create bitmap");
return -1;
}
SelectObject(renderdata->memory_hdc, data.hbm);
if (!BitBlt(renderdata->memory_hdc, 0, 0, rect->w, rect->h,
renderdata->current_hdc, rect->x, rect->y, SRCCOPY)) {
WIN_SetError("BitBlt()");
DeleteObject(data.hbm);
return -1;
}
SDL_ConvertPixels(rect->w, rect->h,
data.format, data.pixels, data.pitch,
format, pixels, pitch);
DeleteObject(data.hbm);
return 0;
}
//-----------------------------------------------------------------------------
int SDL_main(int argc, char *argv[]) {
// NOTE: check for the correct number of arguements
if(argc<2) {
fprintf(stderr, "Error: need a level name.\n");
return -1;
}
// NOTE: add the sqlite db to the levels directory
char filename[0xFF];
sprintf(filename, "levels/%s.db", argv[1]);
// NOTE: open database connection
if(sqlite3_open_v2(filename, &db, SQLITE_OPEN_READONLY, NULL)) {
fprintf(stderr, "sqlite3_open: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
return -1;
}
/* === */
start();
/* === */
int wallSprite00Inds[2*3] = {
03, 04,
35, 36,
67, 68
};
SDL_Color wall00Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *wallSprite00 = buildSprite(2, 3, wall00Color, wallSprite00Inds);
int floorSprite00Inds[2*3] = {
17, 18,
49, 50,
81, 82
};
SDL_Color floorSprite00Color = {0x33,0x33,0x33,0xFF};
SDL_Surface *floorSprite00 = buildSprite(2, 3, floorSprite00Color, floorSprite00Inds);
int doorSprite00Inds[2*3] = {
29, 30,
61, 62,
93, 94
};
SDL_Color doorSprite00Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *doorSprite00 = buildSprite(2, 3, doorSprite00Color, doorSprite00Inds);
int wallSprite01Inds[2*3] = {
97, 98,
129, 130,
161, 162
};
SDL_Color wall01Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *wallSprite01 = buildSprite(2, 3, wall01Color, wallSprite01Inds);
int wallSprite02Inds[2*3] = {
105, 106,
137, 138,
169, 170
};
SDL_Color wallSprite02Color = {0xFF,0xFF,0xFF,0xFF};
SDL_Surface *wallSprite02 = buildSprite(2, 3, wallSprite02Color, wallSprite02Inds);
/* === */
while(running) {
/* === */
pollInput();
SDL_RenderClear(renderer);
SDL_FillRect(screen, 0, 0x00);
/* === */
loadTiles();
SDL_Rect tempRect = {
0, 0, SPRITE_W*2, SPRITE_H*3
};
int i, j;
for(j=0; j<12; j++) {
for(i=0; i<30; i++) {
tempRect.x = SPRITE_W*2*i;
tempRect.y = SPRITE_H*3*j;
switch(lvl.tiles[j][i]) {
case 0x01: {
SDL_BlitSurface(wallSprite00, NULL, screen, &tempRect);
} break;
case 0x02: {
SDL_BlitSurface(doorSprite00, NULL, screen, &tempRect);
} break;
case 0x03: {
SDL_BlitSurface(wallSprite01, NULL, screen, &tempRect);
} break;
case 0x04: {
SDL_BlitSurface(wallSprite02, NULL, screen, &tempRect);
} break;
default: {
SDL_BlitSurface(floorSprite00, NULL, screen, &tempRect);
} break;
}
}
}
/* === */
int pitch;
void *pixels;
// NOTE: get the pixels for the screen texture
SDL_LockTexture(texture, NULL, &pixels, &pitch);
// NOTE: set the pixels for the screen texture
SDL_ConvertPixels(
screen->w,
screen->h,
screen->format->format,
screen->pixels,
screen->pitch,
SDL_PIXELFORMAT_RGBA8888,
pixels, pitch
);
// NOTE: lock the texture so that it may be presented
SDL_UnlockTexture(texture);
// NOTE: present the texture
SDL_RenderCopy(renderer, texture, NULL, NULL);
SDL_RenderPresent(renderer);
SDL_Delay(10);
/* === */
}
/* === */
SDL_FreeSurface(wallSprite00);
wallSprite00 = NULL;
SDL_FreeSurface(floorSprite00);
floorSprite00 = NULL;
SDL_FreeSurface(doorSprite00);
doorSprite00 = NULL;
SDL_FreeSurface(wallSprite01);
wallSprite01 = NULL;
SDL_FreeSurface(wallSprite02);
wallSprite02 = NULL;
/* === */
quit();
/* === */
// NTOE: close the database connection
sqlite3_close(db);
db = NULL;
fclose(stderr);
return 0;
}
