mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-02-08 15:40:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Enable HAVE_VIDEO_LAYOUT by default

Browse Source
This commit is contained in:
twinaphex 2019-10-14 00:31:44 +02:00
parent 0eff23eeed
commit 4fbf823707
14 changed files with 270 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Makefile.common
View File

@ -844,13 +844,14 @@ endif
ifeq ($(HAVE_VIDEO_LAYOUT), 1)
DEFINES += -DHAVE_VIDEO_LAYOUT
OBJ += gfx/video_layout.o \
gfx/video_layout/view.o \
gfx/video_layout/element.o \
gfx/video_layout/component.o \
gfx/video_layout/internal.o \
gfx/video_layout/scope.o \
gfx/video_layout/load.o
OBJ += \
gfx/video_layout.o \
gfx/video_layout/view.o \
gfx/video_layout/element.o \
gfx/video_layout/component.o \
gfx/video_layout/internal.o \
gfx/video_layout/scope.o \
gfx/video_layout/load.o
endif
ifeq ($(HAVE_STB_FONT), 1)

254
gfx/video_layout/component.c
View File

@ -13,51 +13,51 @@ void component_init(component_t *comp, comp_type_t type)
switch (comp->type)
{
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
comp->attr.screen.index = 0;
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
comp->attr.image.file = NULL;
comp->attr.image.alpha_file = NULL;
comp->attr.image.image_idx = 0;
comp->attr.image.alpha_idx = 0;
comp->attr.image.loaded = false;
break;
case VIDEO_LAYOUT_C_TEXT:
comp->attr.text.string = NULL;
comp->attr.text.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
break;
case VIDEO_LAYOUT_C_COUNTER:
comp->attr.counter.digits = 2;
comp->attr.counter.max_state = 999;
comp->attr.counter.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
comp->attr.screen.index = 0;
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
comp->attr.image.file = NULL;
comp->attr.image.alpha_file = NULL;
comp->attr.image.image_idx = 0;
comp->attr.image.alpha_idx = 0;
comp->attr.image.loaded = false;
break;
case VIDEO_LAYOUT_C_TEXT:
comp->attr.text.string = NULL;
comp->attr.text.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
break;
case VIDEO_LAYOUT_C_COUNTER:
comp->attr.counter.digits = 2;
comp->attr.counter.max_state = 999;
comp->attr.counter.align = VIDEO_LAYOUT_TEXT_ALIGN_CENTER;
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
}
}
@ -72,51 +72,51 @@ void component_copy(component_t *comp, const component_t *src)
switch (comp->type)
{
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
comp->attr.screen.index = src->attr.screen.index;
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
comp->attr.image.file = init_string(src->attr.image.file);
comp->attr.image.alpha_file = init_string(src->attr.image.alpha_file);
comp->attr.image.image_idx = src->attr.image.image_idx;
comp->attr.image.alpha_idx = src->attr.image.alpha_idx;
comp->attr.image.loaded = src->attr.image.loaded;
break;
case VIDEO_LAYOUT_C_TEXT:
comp->attr.text.string = init_string(src->attr.text.string);
comp->attr.text.align = src->attr.text.align;
break;
case VIDEO_LAYOUT_C_COUNTER:
comp->attr.counter.digits = src->attr.counter.digits;
comp->attr.counter.max_state = src->attr.counter.max_state;
comp->attr.counter.align = src->attr.counter.align;
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
comp->attr.screen.index = src->attr.screen.index;
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
comp->attr.image.file = init_string(src->attr.image.file);
comp->attr.image.alpha_file = init_string(src->attr.image.alpha_file);
comp->attr.image.image_idx = src->attr.image.image_idx;
comp->attr.image.alpha_idx = src->attr.image.alpha_idx;
comp->attr.image.loaded = src->attr.image.loaded;
break;
case VIDEO_LAYOUT_C_TEXT:
comp->attr.text.string = init_string(src->attr.text.string);
comp->attr.text.align = src->attr.text.align;
break;
case VIDEO_LAYOUT_C_COUNTER:
comp->attr.counter.digits = src->attr.counter.digits;
comp->attr.counter.max_state = src->attr.counter.max_state;
comp->attr.counter.align = src->attr.counter.align;
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
}
}
@ -124,42 +124,42 @@ void component_deinit(component_t *comp)
{
switch (comp->type)
{
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
free(comp->attr.image.file);
free(comp->attr.image.alpha_file);
break;
case VIDEO_LAYOUT_C_TEXT:
free(comp->attr.text.string);
break;
case VIDEO_LAYOUT_C_COUNTER:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
free(comp->attr.image.file);
free(comp->attr.image.alpha_file);
break;
case VIDEO_LAYOUT_C_TEXT:
free(comp->attr.text.string);
break;
case VIDEO_LAYOUT_C_COUNTER:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
}
}

6
gfx/video_layout/component.h
View File

@ -23,8 +23,7 @@ typedef enum comp_type
VIDEO_LAYOUT_C_LED_16,
VIDEO_LAYOUT_C_LED_16_SC,
VIDEO_LAYOUT_C_REEL
}
comp_type_t;
} comp_type_t;
union comp_attr
{
@ -43,8 +42,7 @@ typedef struct component
video_layout_color_t color;
int enabled_state;
union comp_attr attr;
}
component_t;
} component_t;
void component_init (component_t *comp, comp_type_t type);
void component_copy (component_t *comp, const component_t *src);

12
gfx/video_layout/component_attr.h
View File

@ -4,8 +4,7 @@
typedef struct c_attr_screen
{
int index;
}
c_attr_screen_t;
} c_attr_screen_t;
typedef struct c_attr_image
{
@ -14,22 +13,19 @@ typedef struct c_attr_image
int image_idx;
int alpha_idx;
bool loaded;
}
c_attr_image_t;
} c_attr_image_t;
typedef struct c_attr_text
{
char *string;
video_layout_text_align_t align;
}
c_attr_text_t;
} c_attr_text_t;
typedef struct c_attr_counter
{
int digits;
int max_state;
video_layout_text_align_t align;
}
c_attr_counter_t;
} c_attr_counter_t;
#endif

11
gfx/video_layout/element.c
View File

@ -15,7 +15,7 @@ void element_init(element_t *elem, const char *name, int components_count)
elem->render_bounds = make_bounds_unit();
elem->components = (component_t*)(components_count > 0 ?
calloc(components_count, sizeof(component_t)) : NULL);
calloc(components_count, sizeof(component_t)) : NULL);
elem->components_count = components_count;
}
@ -30,7 +30,7 @@ void element_copy(element_t *elem, const element_t *src)
elem->render_bounds = src->render_bounds;
elem->components = (component_t*)(src->components_count > 0 ?
calloc(src->components_count, sizeof(component_t)) : NULL);
calloc(src->components_count, sizeof(component_t)) : NULL);
for (i = 0; i < src->components_count; ++i)
component_copy(&elem->components[i], &src->components[i]);
@ -40,7 +40,7 @@ void element_copy(element_t *elem, const element_t *src)
void element_deinit(element_t *elem)
{
int i;
unsigned i;
for (i = 0; i < elem->components_count; ++i)
component_deinit(&elem->components[i]);
@ -51,12 +51,11 @@ void element_deinit(element_t *elem)
void element_apply_orientation(element_t *elem, video_layout_orientation_t orientation)
{
int i;
unsigned i;
for (i = 0; i < elem->components_count; ++i)
{
component_t *comp;
comp = &elem->components[i];
component_t *comp = &elem->components[i];
comp->orientation ^= orientation;
if (orientation & VIDEO_LAYOUT_SWAP_XY)

4
gfx/video_layout/element.h
View File

@ -1,5 +1,6 @@
#ifndef VIDEO_LAYOUT_ELEMENT_H
#define VIDEO_LAYOUT_ELEMENT_H
#include "internal.h"
#include "component.h"
@ -17,8 +18,7 @@ typedef struct element
component_t *components;
int components_count;
}
element_t;
} element_t;
void element_init (element_t *elem, const char *name, int components_count);
void element_copy (element_t *elem, const element_t *src);

18
gfx/video_layout/internal.c
View File

@ -66,9 +66,7 @@ int get_int(const char *str)
float get_dec(const char *str)
{
float res;
res = 0.0f;
float res = 0.0f;
sscanf(str, "%f", &res);
return res;
@ -152,12 +150,16 @@ video_layout_bounds_t make_bounds_unit(void)
return bounds;
}
video_layout_bounds_t bounds_union(const video_layout_bounds_t *a, const video_layout_bounds_t *b)
video_layout_bounds_t bounds_union(
const video_layout_bounds_t *a,
const video_layout_bounds_t *b)
{
video_layout_bounds_t bounds;
if (!bounds_valid(a)) return *b;
if (!bounds_valid(b)) return *a;
if (!bounds_valid(a))
return *b;
if (!bounds_valid(b))
return *a;
bounds.x = MIN(a->x, b->x);
bounds.y = MIN(a->y, b->y);
@ -167,7 +169,9 @@ video_layout_bounds_t bounds_union(const video_layout_bounds_t *a, const video_l
return bounds;
}
void bounds_scale(video_layout_bounds_t *dst, const video_layout_bounds_t *dim)
void bounds_scale(
video_layout_bounds_t *dst,
const video_layout_bounds_t *dim)
{
dst->x *= dim->w;
dst->y *= dim->h;

174
gfx/video_layout/load.c
View File

@ -52,10 +52,8 @@ static const char *const video_layout_internal_screen_params[] =
static int child_count(rxml_node_t *node)
{
int res;
rxml_node_t *child;
res = 0;
int res = 0;
for (child = node->children; child; child = child->next)
++res;
@ -102,10 +100,8 @@ static void init_screen_params(scope_t *scope, int screen_index)
static video_layout_bounds_t parse_bounds(scope_t *scope, rxml_node_t *node)
{
video_layout_bounds_t bounds;
const char *prop;
bounds = make_bounds_unit();
video_layout_bounds_t bounds = make_bounds_unit();
if ((prop = scope_eval(scope, rxml_node_attrib(node, "x")))) bounds.x = get_dec(prop);
if ((prop = scope_eval(scope, rxml_node_attrib(node, "y")))) bounds.y = get_dec(prop);
@ -122,10 +118,8 @@ static video_layout_bounds_t parse_bounds(scope_t *scope, rxml_node_t *node)
static video_layout_color_t parse_color(scope_t *scope, rxml_node_t *node)
{
video_layout_color_t color;
const char *prop;
color = make_color_white();
video_layout_color_t color = make_color_white();
if ((prop = scope_eval(scope, rxml_node_attrib(node, "red")))) color.r = get_dec(prop);
if ((prop = scope_eval(scope, rxml_node_attrib(node, "green")))) color.g = get_dec(prop);
@ -137,10 +131,8 @@ static video_layout_color_t parse_color(scope_t *scope, rxml_node_t *node)
static video_layout_orientation_t parse_orientation(scope_t *scope, rxml_node_t *node)
{
video_layout_orientation_t result;
const char *prop;
result = VIDEO_LAYOUT_ROT0;
video_layout_orientation_t result = VIDEO_LAYOUT_ROT0;
if ((prop = scope_eval(scope, rxml_node_attrib(node, "rotate"))))
{
@ -223,14 +215,11 @@ static bool load_param(scope_t *scope, rxml_node_t *node, bool can_repeat)
static bool load_component(scope_t *scope, component_t *comp, rxml_node_t *node)
{
comp_type_t type;
bool result;
const char *state;
const char *attr;
rxml_node_t *n;
type = comp_type_from_str(node->name);
result = true;
comp_type_t type = comp_type_from_str(node->name);
bool result = true;
if (type == VIDEO_LAYOUT_C_UNKNOWN)
{
@ -254,72 +243,72 @@ static bool load_component(scope_t *scope, component_t *comp, rxml_node_t *node)
switch (comp->type)
{
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
{
if (!(attr = rxml_node_attrib(node, "file")))
case VIDEO_LAYOUT_C_UNKNOWN:
break;
case VIDEO_LAYOUT_C_SCREEN:
break;
case VIDEO_LAYOUT_C_RECT:
break;
case VIDEO_LAYOUT_C_DISK:
break;
case VIDEO_LAYOUT_C_IMAGE:
{
RARCH_LOG("video_layout: invalid component <%s />, missing 'file' attribute\n", node->name);
result = false;
}
set_string(&comp->attr.image.file, scope_eval(scope, attr));
if (!(attr = rxml_node_attrib(node, "file")))
{
RARCH_LOG("video_layout: invalid component <%s />, missing 'file' attribute\n", node->name);
result = false;
}
set_string(&comp->attr.image.file, scope_eval(scope, attr));
if ((attr = rxml_node_attrib(node, "alphafile")))
set_string(&comp->attr.image.alpha_file, scope_eval(scope, attr));
}
break;
case VIDEO_LAYOUT_C_TEXT:
{
if (!(attr = rxml_node_attrib(node, "string")))
if ((attr = rxml_node_attrib(node, "alphafile")))
set_string(&comp->attr.image.alpha_file, scope_eval(scope, attr));
}
break;
case VIDEO_LAYOUT_C_TEXT:
{
RARCH_LOG("video_layout: invalid component <%s />, missing 'string' attribute\n", node->name);
result = false;
if (!(attr = rxml_node_attrib(node, "string")))
{
RARCH_LOG("video_layout: invalid component <%s />, missing 'string' attribute\n", node->name);
result = false;
}
set_string(&comp->attr.text.string, scope_eval(scope, attr));
if ((attr = rxml_node_attrib(node, "align")))
comp->attr.text.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
}
set_string(&comp->attr.text.string, scope_eval(scope, attr));
break;
case VIDEO_LAYOUT_C_COUNTER:
{
if ((attr = rxml_node_attrib(node, "digits")))
comp->attr.counter.digits = get_int(scope_eval(scope, attr));
if ((attr = rxml_node_attrib(node, "align")))
comp->attr.text.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
}
break;
case VIDEO_LAYOUT_C_COUNTER:
{
if ((attr = rxml_node_attrib(node, "digits")))
comp->attr.counter.digits = get_int(scope_eval(scope, attr));
if ((attr = rxml_node_attrib(node, "maxstate")))
comp->attr.counter.max_state = get_int(scope_eval(scope, attr));
if ((attr = rxml_node_attrib(node, "maxstate")))
comp->attr.counter.max_state = get_int(scope_eval(scope, attr));
if ((attr = rxml_node_attrib(node, "align")))
comp->attr.counter.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
}
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
if ((attr = rxml_node_attrib(node, "align")))
comp->attr.counter.align = (video_layout_text_align_t)get_int(scope_eval(scope, attr));
}
break;
case VIDEO_LAYOUT_C_DOTMATRIX_X1:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H5:
break;
case VIDEO_LAYOUT_C_DOTMATRIX_H8:
break;
case VIDEO_LAYOUT_C_LED_7:
break;
case VIDEO_LAYOUT_C_LED_8_GTS1:
break;
case VIDEO_LAYOUT_C_LED_14:
break;
case VIDEO_LAYOUT_C_LED_14_SC:
break;
case VIDEO_LAYOUT_C_LED_16:
break;
case VIDEO_LAYOUT_C_LED_16_SC:
break;
case VIDEO_LAYOUT_C_REEL:
break;
}
return result;
@ -329,13 +318,11 @@ static bool load_element(scope_t *scope, rxml_node_t *node)
{
const char *name;
const char *state;
bool result;
int i;
element_t *elem;
rxml_node_t *n;
video_layout_bounds_t dim;
result = true;
bool result = true;
if (!(name = rxml_node_attrib(node, "name")))
{
@ -394,10 +381,8 @@ static bool load_element(scope_t *scope, rxml_node_t *node)
static bool load_screen(scope_t *scope, element_t *elem, rxml_node_t *node)
{
const char *index;
component_t *comp;
index = rxml_node_attrib(node, "index");
const char *index = rxml_node_attrib(node, "index");
element_init(elem, NULL, 1);
comp = &elem->components[0];
@ -412,10 +397,8 @@ static bool load_screen(scope_t *scope, element_t *elem, rxml_node_t *node)
static void merge_group(scope_t *scope, view_t *view, view_t *group,
bool has_bounds, video_layout_bounds_t n_bounds, video_layout_orientation_t n_orient, video_layout_color_t n_color)
{
bool constrain;
int i, j, k;
constrain = bounds_valid(&n_bounds);
bool constrain = bounds_valid(&n_bounds);
for (i = 0; i < group->layers_count; ++i)
{
@ -471,7 +454,7 @@ static bool load_view(scope_t *scope, view_t *view, rxml_node_t *node, bool is_n
view_init(view, scope_eval(scope, name));
}
result = true;
result = true;
has_bounds = false;
for (n = node->children; n; n = n->next)
@ -660,10 +643,8 @@ static bool load_group(scope_t *scope, rxml_node_t *node)
static bool load_top_level(scope_t *scope, int *view_count, rxml_node_t *root)
{
bool result;
rxml_node_t *node;
result = true;
bool result = true;
*view_count = 0;
for (node = root->children; node; node = node->next)
@ -695,12 +676,9 @@ static bool load_top_level(scope_t *scope, int *view_count, rxml_node_t *root)
static bool load_views(scope_t *scope, view_array_t *view_array, rxml_node_t *root)
{
bool result;
int i;
rxml_node_t *node;
result = true;
i = 0;
bool result = true;
int i = 0;
for (node = root->children; node; node = node->next)
{
@ -730,14 +708,12 @@ static bool load_views(scope_t *scope, view_array_t *view_array, rxml_node_t *ro
bool load(view_array_t *view_array, rxml_document_t *doc)
{
bool result;
rxml_node_t *root;
scope_t scope;
int view_count;
root = rxml_root_node(doc);
rxml_node_t *root = rxml_root_node(doc);
if (strcmp(root->name, "mamelayout") ||
strcmp(rxml_node_attrib(root, "version"), "2"))
strcmp(rxml_node_attrib(root, "version"), "2"))
{
RARCH_LOG("video_layout: invalid MAME Layout file\n");
return false;

34
gfx/video_layout/scope.c
View File

@ -38,15 +38,12 @@ static void param_deinit(param_t *param)
static param_t *param_find(scope_t *scope, const char *name, int level)
{
param_t *param;
param = scope->param;
param_t *param = scope->param;
while (param && param->level >= level)
{
if (strcmp(param->name, name) == 0)
{
return param;
}
param = param->prev;
}
@ -55,15 +52,13 @@ static param_t *param_find(scope_t *scope, const char *name, int level)
void scope_init(scope_t *scope)
{
scope->level = 0;
scope->level = 0;
scope->param = NULL;
scope->elements = NULL;
scope->param = NULL;
scope->elements = NULL;
scope->elements_count = 0;
scope->groups = NULL;
scope->groups_count = 0;
scope->groups = NULL;
scope->groups_count = 0;
}
void scope_deinit(scope_t *scope)
@ -114,7 +109,10 @@ void scope_repeat(scope_t *scope)
{
param_t *param;
for (param = scope->param; param && param->level >= scope->level; param = param->prev)
for (
param = scope->param;
param && param->level >= scope->level;
param = param->prev)
{
generator_t *gen;
if ((gen = param->generator))
@ -149,12 +147,9 @@ void scope_repeat(scope_t *scope)
void scope_param(scope_t *scope, const char *name, const char *value)
{
char *eval_name;
char *eval_value;
param_t *param;
eval_name = init_string(scope_eval(scope, name));
eval_value = init_string(scope_eval(scope, value));
char *eval_name = init_string(scope_eval(scope, name));
char *eval_value = init_string(scope_eval(scope, value));
if ((param = param_find(scope, eval_name, scope->level)))
{
@ -177,13 +172,11 @@ void scope_param(scope_t *scope, const char *name, const char *value)
void scope_generator(scope_t *scope, const char *name, const char *start, const char *increment, const char *lshift, const char *rshift)
{
char *e_name;
char *e_val;
char *e_inc;
generator_t *gen;
param_t *param;
e_name = init_string(scope_eval(scope, name));
char *e_name = init_string(scope_eval(scope, name));
if (param_find(scope, e_name, scope->level))
{
@ -234,7 +227,6 @@ const char *scope_eval(scope_t *scope, const char *src)
{
const char* next;
bool in_var;
char tmp[SCOPE_BUFFER_SIZE];
if (!src)

3
gfx/video_layout/scope.h
View File

@ -21,8 +21,7 @@ typedef struct scope
int groups_count;
char eval[SCOPE_BUFFER_SIZE];
}
scope_t;
} scope_t;
void scope_init (scope_t *scope);
void scope_deinit (scope_t *scope);

20
gfx/video_layout/types.h
View File

@ -1,7 +1,9 @@
#ifndef VIDEO_LAYOUT_TYPES_H
#define VIDEO_LAYOUT_TYPES_H
typedef unsigned char video_layout_orientation_t;
#include <stdint.h>
typedef uint8_t video_layout_orientation_t;
#define VIDEO_LAYOUT_FLIP_X 1
#define VIDEO_LAYOUT_FLIP_Y 2
@ -14,19 +16,17 @@ typedef unsigned char video_layout_orientation_t;
typedef enum video_layout_blend
{
VIDEO_LAYOUT_BLEND_ALPHA,
VIDEO_LAYOUT_BLEND_ALPHA = 0,
VIDEO_LAYOUT_BLEND_ADD,
VIDEO_LAYOUT_BLEND_MOD
}
video_layout_blend_t;
} video_layout_blend_t;
typedef enum video_layout_text_align
{
VIDEO_LAYOUT_TEXT_ALIGN_CENTER,
VIDEO_LAYOUT_TEXT_ALIGN_CENTER = 0,
VIDEO_LAYOUT_TEXT_ALIGN_LEFT,
VIDEO_LAYOUT_TEXT_ALIGN_RIGHT
}
video_layout_text_align_t;
} video_layout_text_align_t;
typedef struct video_layout_color
{
@ -34,8 +34,7 @@ typedef struct video_layout_color
float g;
float b;
float a;
}
video_layout_color_t;
} video_layout_color_t;
typedef struct video_layout_bounds
{
@ -43,7 +42,6 @@ typedef struct video_layout_bounds
float y;
float w;
float h;
}
video_layout_bounds_t;
} video_layout_bounds_t;
#endif

18
gfx/video_layout/view.c
View File

@ -26,7 +26,8 @@ element_t *layer_add_element(layer_t *layer)
{
element_t *elem;
vec_size((void**)&layer->elements, sizeof(element_t), ++layer->elements_count);
vec_size((void**)&layer->elements,
sizeof(element_t), ++layer->elements_count);
elem = &layer->elements[layer->elements_count - 1];
element_init(elem, NULL, 0);
@ -36,12 +37,12 @@ element_t *layer_add_element(layer_t *layer)
void view_init(view_t *view, const char *name)
{
view->name = init_string(name);
view->bounds = make_bounds();
view->name = init_string(name);
view->bounds = make_bounds();
view->render_bounds = make_bounds_unit();
view->layers = NULL;
view->layers_count = 0;
view->screens = NULL;
view->layers = NULL;
view->layers_count = 0;
view->screens = NULL;
view->screens_count = 0;
}
@ -197,9 +198,8 @@ void view_normalize(view_t *view)
void view_count_screens(view_t *view)
{
int idx, i, j, k;
idx = -1;
int i, j, k;
int idx = -1;
for (i = 0; i < view->layers_count; ++i)
{

9
gfx/video_layout/view.h
View File

@ -11,8 +11,7 @@ typedef struct layer
element_t *elements;
int elements_count;
}
layer_t;
} layer_t;
typedef struct view
{
@ -25,15 +24,13 @@ typedef struct view
video_layout_bounds_t *screens;
int screens_count;
}
view_t;
} view_t;
typedef struct view_array
{
view_t *views;
int views_count;
}
view_array_t;
} view_array_t;
void layer_init (layer_t *layer, const char *name);
void layer_deinit (layer_t *layer);

2
qb/config.params.sh
View File

@ -28,7 +28,7 @@ HAVE_BUILTINMBEDTLS=auto # Bake in the mbedtls library
C89_BUILTINMBEDTLS=no
CXX_BUILTINMBEDTLS=no
HAVE_OVERLAY=yes # Overlay support
HAVE_VIDEO_LAYOUT=no # Layout support
HAVE_VIDEO_LAYOUT=yes # Layout support
HAVE_DYNAMIC=yes # Dynamic loading of libretro library
HAVE_SDL=auto # SDL support
C89_SDL=no