Retro/pcem
Watch
1
0
Fork
You've already forked pcem
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added new GUI based on wxWidgets. Patch from bit.

Browse source
This commit is contained in:
pcem_emulator 2017-05-29 15:38:48 +01:00
commit 7fe91626d6
60 changed files with 11647 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

344
src/wx-sdl2-video.c Normal file
View file

@ -0,0 +1,344 @@
#include "wx-sdl2-video.h"
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "wx-sdl2.h"
#include "video.h"
void video_blit_complete();
static BITMAP *buffer32_vscale;
BITMAP *screen;
SDL_Texture* texture = NULL;
SDL_Renderer* renderer = NULL;
SDL_Rect old_screen_rect;
SDL_Rect screen_rect;
SDL_Rect updated_rect;
SDL_Rect window_rect;
SDL_Rect blit_rect;
SDL_Rect texture_rect;
int updated = 0;
SDL_mutex* blitMutex = NULL;
static void sdl_blit_memtoscreen(int x, int y, int y1, int y2, int w, int h);
static void sdl_blit_memtoscreen_8(int x, int y, int w, int h);
int video_scale_mode = 1;
int video_vsync = 0;
int video_focus_dim = 0;
int video_fullscreen_mode = 0;
static sdl_render_driver sdl_render_drivers[] = {
{ RENDERER_AUTO, "auto", "Auto" },
{ RENDERER_DIRECT3D, "direct3d", "Direct3D" },
{ RENDERER_OPENGL, "opengl", "OpenGL" },
{ RENDERER_OPENGLES2, "opengles2", "OpenGL ES 2" },
{ RENDERER_OPENGLES, "opengles", "OpenGL ES" },
{ RENDERER_SOFTWARE, "software", "Software" }
};
sdl_render_driver requested_render_driver;
char current_render_driver_name[50];
void hline(BITMAP *b, int x1, int y, int x2, int col)
{
if (y < 0 || y >= buffer32->h)
return;
for (; x1 < x2; x1++)
((uint32_t *)b->line[y])[x1] = col;
}
void blit(BITMAP *src, BITMAP *dst, int x1, int y1, int x2, int y2, int xs, int ys)
{
}
void stretch_blit(BITMAP *src, BITMAP *dst, int x1, int y1, int xs1, int ys1, int x2, int y2, int xs2, int ys2)
{
}
void rectfill(BITMAP *b, int x1, int y1, int x2, int y2, uint32_t col)
{
}
void set_palette(PALETTE p)
{
}
void destroy_bitmap(BITMAP *b)
{
}
BITMAP *create_bitmap(int x, int y)
{
BITMAP *b = malloc(sizeof(BITMAP) + (y * sizeof(uint8_t *)));
int c;
b->dat = malloc(x * y * 4);
for (c = 0; c < y; c++)
{
b->line[c] = b->dat + (c * x * 4);
}
b->w = x;
b->h = y;
return b;
}
sdl_render_driver* sdl_get_render_drivers(int* num)
{
if (num)
*num = SDL_arraysize(sdl_render_drivers);
return sdl_render_drivers;
}
sdl_render_driver sdl_get_render_driver_by_name(const char* name, int def)
{
int i;
for (i = 0; i < SDL_arraysize(sdl_render_drivers); ++i)
{
if (!strcmp(sdl_render_drivers[i].sdl_id, name))
{
return sdl_render_drivers[i];
}
}
return sdl_render_drivers[def];
}
sdl_render_driver* sdl_get_render_driver_by_name_ptr(const char* name)
{
int i;
for (i = 0; i < SDL_arraysize(sdl_render_drivers); ++i)
{
if (!strcmp(sdl_render_drivers[i].sdl_id, name))
{
return &sdl_render_drivers[i];
}
}
return 0;
}
sdl_render_driver sdl_get_render_driver_by_id(int id, int def)
{
int i;
for (i = 0; i < SDL_arraysize(sdl_render_drivers); ++i)
{
if (sdl_render_drivers[i].id == id)
{
return sdl_render_drivers[i];
}
}
return sdl_render_drivers[def];
}
void sdl_scale(int scale, SDL_Rect src, SDL_Rect* dst, int w, int h)
{
double t, b, l, r;
int ratio_w, ratio_h;
switch (scale)
{
case FULLSCR_SCALE_43:
t = 0;
b = src.h;
l = (src.w / 2) - ((src.h * 4) / (3 * 2));
r = (src.w / 2) + ((src.h * 4) / (3 * 2));
if (l < 0)
{
l = 0;
r = src.w;
t = (src.h / 2)
- ((src.w * 3) / (4 * 2));
b = (src.h / 2)
+ ((src.w * 3) / (4 * 2));
}
break;
case FULLSCR_SCALE_SQ:
t = 0;
b = src.h;
l = (src.w / 2) - ((src.h * w) / (h * 2));
r = (src.w / 2) + ((src.h * w) / (h * 2));
if (l < 0)
{
l = 0;
r = src.w;
t = (src.h / 2)
- ((src.w * h) / (w * 2));
b = (src.h / 2)
+ ((src.w * h) / (w * 2));
}
break;
case FULLSCR_SCALE_INT:
ratio_w = src.w / w;
ratio_h = src.h / h;
if (ratio_h < ratio_w)
ratio_w = ratio_h;
l = (src.w / 2) - ((w * ratio_w) / 2);
r = (src.w / 2) + ((w * ratio_w) / 2);
t = (src.h / 2) - ((h * ratio_w) / 2);
b = (src.h / 2) + ((h * ratio_w) / 2);
break;
case FULLSCR_SCALE_FULL:
default:
l = 0;
t = 0;
r = src.w;
b = src.h;
break;
}
dst->x = l;
dst->y = t;
dst->w = r - l;
dst->h = b - t;
}
static void set_updated_size(int x, int y, int w, int h)
{
if (updated)
{
updated_rect.x = x < updated_rect.x ? x : updated_rect.x;
updated_rect.y = y < updated_rect.y ? y : updated_rect.y;
updated_rect.w = w > updated_rect.w ? w : updated_rect.w;
updated_rect.h = h > updated_rect.h ? h : updated_rect.h;
}
else
{
updated_rect.x = x;
updated_rect.y = y;
updated_rect.w = w;
updated_rect.h = h;
updated = 1;
}
}
static void sdl_blit_memtoscreen(int x, int y, int y1, int y2, int w, int h)
{
if (y1 == y2)
{
video_blit_complete();
return; /*Nothing to do*/
}
int xx, yy;
SDL_Rect rect;
SDL_LockMutex(blitMutex);
for (yy = y1; yy < y2; yy++)
{
if ((y + yy) >= 0 && (y + yy) < buffer32->h)
memcpy(screen->dat + (yy * screen->w * 4),
&(((uint32_t *) buffer32->line[y + yy])[x]), w * 4);
}
set_updated_size(0, y1, w, y2 - y1);
// set_updated_size(0, 0, w, h);
blit_rect.w = w;
blit_rect.h = h;
SDL_UnlockMutex(blitMutex);
video_blit_complete();
}
int sdl_is_fullscreen(SDL_Window* window) {
int flags = SDL_GetWindowFlags(window);
return (flags&SDL_WINDOW_FULLSCREEN) || (flags&SDL_WINDOW_FULLSCREEN_DESKTOP);
}
int sdl_video_init()
{
blitMutex = SDL_CreateMutex();
updated = 0;
video_blit_memtoscreen_func = sdl_blit_memtoscreen;
requested_render_driver = sdl_get_render_driver_by_id(RENDERER_AUTO, RENDERER_AUTO);
buffer32_vscale = create_bitmap(2048, 2048);
screen = create_bitmap(2048, 2048);
return SDL_TRUE;
}
void sdl_video_close()
{
destroy_bitmap(buffer32_vscale);
destroy_bitmap(screen);
SDL_DestroyMutex(blitMutex);
}
int sdl_renderer_init(SDL_Window* window)
{
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, video_scale_mode ? "1" : "0");
const char* driver = requested_render_driver.sdl_id;
if (!driver) driver = "0";
SDL_SetHint(SDL_HINT_RENDER_DRIVER, driver);
int flags = SDL_RENDERER_ACCELERATED;
if (video_vsync) {
flags |= SDL_RENDERER_PRESENTVSYNC;
}
renderer = SDL_CreateRenderer(window, -1, flags);
SDL_RendererInfo rendererInfo;
SDL_GetRendererInfo(renderer, &rendererInfo);
sdl_render_driver* d = sdl_get_render_driver_by_name_ptr(rendererInfo.name);
if (!d)
strcpy(current_render_driver_name, "Unknown");
else
strcpy(current_render_driver_name, d->name);
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
screen->w, screen->h);
return SDL_TRUE;
}
void sdl_renderer_close()
{
if (texture)
{
SDL_DestroyTexture(texture);
texture = NULL;
}
if (renderer)
{
SDL_DestroyRenderer(renderer);
renderer = NULL;
}
}
int sdl_renderer_update(SDL_Window* window)
{
int render = 0;
SDL_LockMutex(blitMutex);
if (updated)
{
updated = 0;
SDL_UpdateTexture(texture, &updated_rect,
&((uint32_t*) screen->dat)[updated_rect.y
* screen->w + updated_rect.x],
screen->w * 4);
texture_rect.w = blit_rect.w;
texture_rect.h = blit_rect.h;
render = 1;
}
SDL_UnlockMutex(blitMutex);
return render;
}
void sdl_renderer_present(SDL_Window* window)
{
SDL_Rect wr;
int l, t, r, b;
SDL_GetWindowSize(window, &wr.w, &wr.h);
sdl_scale(video_fullscreen_scale, wr, &wr, texture_rect.w, texture_rect.h);
SDL_RenderClear(renderer);
SDL_RenderCopy(renderer, texture, &texture_rect, &wr);
if (video_focus_dim && !(SDL_GetWindowFlags(window)&SDL_WINDOW_INPUT_FOCUS)) {
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0x80);
SDL_RenderFillRect(renderer, NULL);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xff);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
}
SDL_RenderPresent(renderer);
}