ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(deps/switchres) Remove unused files grid.cpp and examples/

This commit is contained in:
LibretroAdmin 2022-09-05 18:39:45 +02:00
parent ddeef350bd
commit 6b4e20d414
4 changed files with 0 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
deps/switchres/examples/README.md vendored
View File

@ -1,56 +0,0 @@
# ANY OS - BASIC INFORMATION
## Build libswitchres
It supports cross compilation, and will build both dynamic and static libs as per the target OS
```bash
make libswitchres
```
## Basic usage as a client with examples
libswitchres can be called in 2 different ways (with example code):
* `test_dlopen.c` -> by explicitely opening a .so/.dll, import the srlib object and call associated functions
* `test_liblink.c` -> by simply linking libswitchres at build time
These options are generic whether you build for Linux or Windows
* -I ../ (to get libswitchres_wrapper.h)
* -L ../ or -L ./ (for win32, when the dll has been copied in the examples folder)
* -lswitchres to link the lib if not manually opening it in the code
#please note#: static libs aven't been tested yet
# LINUX
You'll need a few extra parameters for gcc:
* -ldl (will try later to find a way to statically link libdl.a)
When running, dont forget to add before the binary LD_LIBRARY_PATH=<libswitchres.so pass, even if it's ./>:$LD_LIBRARY_PATH
## Examples:
```bash
make libswitchres
cd examples
g++ -o linux_dl_test test_dlopen.cpp -I ../ -ldl
LD_LIBRARY_PATH=../:$LD_LIBRARY_PATH ./linux_dl_test
g++ -o linux_link_lib test_liblink.cpp -I ../ -L../ -lswitchres -ldl
LD_LIBRARY_PATH=../:$LD_LIBRARY_PATH ./linux_link_lib
```
# WINDOWS
Pretty much the same as Linux, but with mingw64. The resulting exe and dll can be tested with wine
## Examples (cross-building from windows)
```
make PLATFORM=NT CROSS_COMPILE=x86_64-w64-mingw32- libswitchres
(copy the dll to examples)
x86_64-w64-mingw32-g++-win32 test_dlopen.cpp -o w32_loaddll.exe -I ../ -static-libgcc -static-libstdc++
w32_loaddll.exe
x86_64-w64-mingw32-g++-win32 test_liblink.cpp -o w32_linkdll.exe -I ../ -static-libgcc -static-libstdc++ -L ./ -lswitchres
w32_linkdll.exe
```
Note that, when building w32_linkdll.exe, I couldn't point to another dir else than ./ with -L

81
deps/switchres/examples/test_dlopen.cpp vendored
View File

@ -1,81 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#ifdef __cplusplus
#include <cstring> // required for strcpy
#endif
#ifdef __linux__
#define LIBSWR "libswitchres.so"
#elif _WIN32
#define LIBSWR "libswitchres.dll"
#endif
#include <switchres/switchres_wrapper.h>
int main(int argc, char** argv) {
const char* err_msg;
printf("About to open %s.\n", LIBSWR);
// Load the lib
LIBTYPE dlp = OPENLIB(LIBSWR);
// Loading failed, inform and exit
if (!dlp) {
printf("Loading %s failed.\n", LIBSWR);
printf("Error: %s\n", LIBERROR());
exit(EXIT_FAILURE);
}
printf("Loading %s succeded.\n", LIBSWR);
// Load the init()
LIBERROR();
srAPI* SRobj = (srAPI*)LIBFUNC(dlp, "srlib");
if ((err_msg = LIBERROR()) != NULL) {
printf("Failed to load srAPI: %s\n", err_msg);
CLOSELIB(dlp);
exit(EXIT_FAILURE);
}
// Testing the function
printf("Init a new switchres_manager object:\n");
SRobj->init();
SRobj->sr_init_disp();
// Call mode + get result values
int w = 384, h = 224;
double rr = 59.583393;
unsigned char interlace = 0, ret;
sr_mode srm;
printf("Orignial resolution expected: %dx%d@%f-%d\n", w, h, rr, interlace);
ret = SRobj->sr_add_mode(w, h, rr, interlace, &srm);
if(!ret)
{
printf("ERROR: couldn't add the required mode. Exiting!\n");
SRobj->deinit();
exit(1);
}
printf("Got resolution: %dx%d%c@%f\n", srm.width, srm.height, srm.interlace, srm.refresh);
printf("Press Any Key to switch to new mode\n");
getchar();
ret = SRobj->sr_switch_to_mode(srm.width, srm.height, rr, srm.interlace, &srm);
if(!ret)
{
printf("ERROR: couldn't switch to the required mode. Exiting!\n");
SRobj->deinit();
exit(1);
}
printf("Press Any Key to quit.\n");
getchar();
// Clean the mess, kiss goodnight SR
SRobj->deinit();
// We're done, let's closer
CLOSELIB(dlp);
}

30
deps/switchres/examples/test_liblink.cpp vendored
View File

@ -1,30 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <switchres/switchres_wrapper.h>
int main(int argc, char** argv) {
sr_mode srm;
unsigned char ret;
sr_init();
sr_init_disp();
ret = sr_add_mode(384, 224, 59.63, 0, &srm);
if(!ret)
{
printf("ERROR: couldn't add the required mode. Exiting!\n");
sr_deinit();
exit(1);
}
printf("SR returned resolution: %dx%d%c@%f\n", srm.width, srm.height, srm.interlace, srm.refresh);
ret = sr_switch_to_mode(384, 224, 59.63, 0, &srm);
if(!ret)
{
printf("ERROR: couldn't switch to the required mode. Exiting!\n");
sr_deinit();
exit(1);
}
sr_deinit();
}

228
deps/switchres/grid.cpp vendored
View File

@ -1,228 +0,0 @@
/**************************************************************
grid.cpp - Simple test grid
---------------------------------------------------------
Switchres Modeline generation engine for emulation
License GPL-2.0+
Copyright 2010-2021 Chris Kennedy, Antonio Giner,
Alexandre Wodarczyk, Gil Delescluse
**************************************************************/
#define SDL_MAIN_HANDLED
#define NUM_GRIDS 2
#include <SDL2/SDL.h>
typedef struct grid_display
{
int index;
int width;
int height;
SDL_Window *window;
SDL_Renderer *renderer;
} GRID_DISPLAY;
//============================================================
// draw_grid
//============================================================
void draw_grid(int num_grid, int width, int height, SDL_Renderer *renderer)
{
// Clean the surface
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_Rect rect {0, 0, width, height};
switch (num_grid)
{
case 0:
// 16 x 12 squares
{
// Fill the screen with red
rect = {0, 0, width, height};
SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
SDL_RenderFillRect(renderer, &rect);
// Draw white rectangle
rect = {width / 32, height / 24 , width - width / 16, height - height / 12};
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderFillRect(renderer, &rect);
// Draw grid using black rectangles
SDL_Rect rects[16 * 12];
// Set the thickness of horizontal and vertical lines based on the screen resolution
int line_w = round(float(width) / 320.0);
int line_h = round(float(height) / 240.0);
if ( line_w < 1 ) line_w = 1;
if ( line_h < 1 ) line_h = 1;
float rect_w = (width - line_w * 17) / 16.0;
float rect_h = (height - line_h * 13) / 12.0;
for (int i = 0; i < 16; i++)
{
int x_pos1 = ceil(i * rect_w);
int x_pos2 = ceil((i+1) * rect_w);
for (int j = 0; j < 12; j++)
{
int y_pos1 = ceil(j * rect_h);
int y_pos2 = ceil((j+1) * rect_h);
rects[i + j * 16] = {x_pos1 + (i+1) * line_w , y_pos1 + (j+1) * line_h, x_pos2 - x_pos1, y_pos2 - y_pos1};
}
}
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderFillRects(renderer, rects, 16 * 12);
}
break;
case 1:
// cps2 grid
// Draw outer rectangle
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
SDL_RenderDrawRect(renderer, &rect);
for (int i = 0; i < width / 16; i++)
{
for (int j = 0; j < height / 16; j++)
{
if (i == 0 || j == 0 || i == (width / 16) - 1 || j == (height / 16) - 1)
SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
else
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
rect = {i * 16, j * 16, 16, 16};
SDL_RenderDrawRect(renderer, &rect);
rect = {i * 16 + 7, j * 16 + 7, 2, 2};
SDL_RenderDrawRect(renderer, &rect);
}
}
break;
}
SDL_RenderPresent(renderer);
}
//============================================================
// main
//============================================================
int main(int argc, char **argv)
{
SDL_Window* win_array[10] = {};
GRID_DISPLAY display_array[10] = {};
int display_total = 0;
// Initialize SDL
if (SDL_Init(SDL_INIT_VIDEO) != 0)
{
printf("error initializing SDL: %s\n", SDL_GetError());
return 1;
}
// Get target displays
if (argc > 1)
{
// Parse command line for display indexes
int display_index = 0;
int num_displays = SDL_GetNumVideoDisplays();
for (int arg = 1; arg < argc; arg++)
{
sscanf(argv[arg], "%d", &display_index);
if (display_index < 0 || display_index > num_displays - 1)
{
printf("error, bad display_index: %d\n", display_index);
return 1;
}
display_array[display_total].index = display_index;
display_total++;
}
}
else
{
// No display specified, use default
display_array[0].index = 0;
display_total = 1;
}
// Create windows
for (int disp = 0; disp < display_total; disp++)
{
// Get target display size
SDL_DisplayMode dm;
SDL_GetCurrentDisplayMode(display_array[disp].index, &dm);
SDL_ShowCursor(SDL_DISABLE);
display_array[disp].width = dm.w;
display_array[disp].height = dm.h;
// Create window
display_array[disp].window = SDL_CreateWindow("Switchres test grid", SDL_WINDOWPOS_CENTERED_DISPLAY(display_array[disp].index), SDL_WINDOWPOS_CENTERED, dm.w, dm.h, SDL_WINDOW_FULLSCREEN_DESKTOP);
// Required by Window multi-monitor
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
// Create renderer
display_array[disp].renderer = SDL_CreateRenderer(display_array[disp].window, -1, SDL_RENDERER_ACCELERATED);
// Draw grid
draw_grid(0, display_array[disp].width, display_array[disp].height, display_array[disp].renderer);
}
// Wait for escape key
bool close = false;
int num_grid = 0;
while (!close)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
close = true;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.scancode)
{
case SDL_SCANCODE_ESCAPE:
close = true;
break;
case SDL_SCANCODE_TAB:
num_grid ++;
for (int disp = 0; disp < display_total; disp++)
draw_grid(num_grid % NUM_GRIDS, display_array[disp].width, display_array[disp].height, display_array[disp].renderer);
break;
default:
break;
}
}
}
}
// Destroy all windows
for (int disp = 0; disp < display_total; disp++)
SDL_DestroyWindow(display_array[disp].window);
SDL_Quit();
return 0;
}