Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2024-11-25 14:57:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[client] egl: refactor to use project naming standard

Browse Source
This commit is contained in:
Geoffrey McRae 2021-08-08 17:16:10 +10:00
parent f4a925a750
commit 266ad27998
23 changed files with 292 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
client/renderers/EGL/cursor.c
View File

@ -84,28 +84,28 @@ static bool egl_cursor_tex_init(struct CursorTex * t,
const char * vertex_code , size_t vertex_size, const char * vertex_code , size_t vertex_size,
const char * fragment_code, size_t fragment_size) const char * fragment_code, size_t fragment_size)
{ {
if (!egl_texture_init(&t->texture, NULL, EGL_TEXTYPE_BUFFER, false)) if (!egl_textureInit(&t->texture, NULL, EGL_TEXTYPE_BUFFER, false))
{ {
DEBUG_ERROR("Failed to initialize the cursor texture"); DEBUG_ERROR("Failed to initialize the cursor texture");
return false; return false;
} }
if (!egl_shader_init(&t->shader)) if (!egl_shaderInit(&t->shader))
{ {
DEBUG_ERROR("Failed to initialize the cursor shader"); DEBUG_ERROR("Failed to initialize the cursor shader");
return false; return false;
} }
if (!egl_shader_compile(t->shader, if (!egl_shaderCompile(t->shader,
vertex_code, vertex_size, fragment_code, fragment_size)) vertex_code, vertex_size, fragment_code, fragment_size))
{ {
DEBUG_ERROR("Failed to compile the cursor shader"); DEBUG_ERROR("Failed to compile the cursor shader");
return false; return false;
} }
t->uMousePos = egl_shader_get_uniform_location(t->shader, "mouse" ); t->uMousePos = egl_shaderGetUniform(t->shader, "mouse" );
t->uRotate = egl_shader_get_uniform_location(t->shader, "rotate"); t->uRotate = egl_shaderGetUniform(t->shader, "rotate");
t->uCBMode = egl_shader_get_uniform_location(t->shader, "cbMode"); t->uCBMode = egl_shaderGetUniform(t->shader, "cbMode");
return true; return true;
} }
@ -130,10 +130,10 @@ static inline void egl_cursor_tex_uniforms(EGL_Cursor * cursor, struct CursorTex
static void egl_cursor_tex_free(struct CursorTex * t) static void egl_cursor_tex_free(struct CursorTex * t)
{ {
egl_texture_free(&t->texture); egl_texture_free(&t->texture);
egl_shader_free (&t->shader ); egl_shaderFree (&t->shader );
}; };
bool egl_cursor_init(EGL_Cursor ** cursor) bool egl_cursorInit(EGL_Cursor ** cursor)
{ {
*cursor = (EGL_Cursor *)malloc(sizeof(EGL_Cursor)); *cursor = (EGL_Cursor *)malloc(sizeof(EGL_Cursor));
if (!*cursor) if (!*cursor)
@ -155,13 +155,13 @@ bool egl_cursor_init(EGL_Cursor ** cursor)
b_shader_cursor_mono_frag, b_shader_cursor_mono_frag_size)) b_shader_cursor_mono_frag, b_shader_cursor_mono_frag_size))
return false; return false;
if (!egl_model_init(&(*cursor)->model)) if (!egl_modelInit(&(*cursor)->model))
{ {
DEBUG_ERROR("Failed to initialize the cursor model"); DEBUG_ERROR("Failed to initialize the cursor model");
return false; return false;
} }
egl_model_set_default((*cursor)->model); egl_modelSetDefault((*cursor)->model);
(*cursor)->cbMode = option_get_int("egl", "cbMode"); (*cursor)->cbMode = option_get_int("egl", "cbMode");
@ -173,7 +173,7 @@ bool egl_cursor_init(EGL_Cursor ** cursor)
return true; return true;
} }
void egl_cursor_free(EGL_Cursor ** cursor) void egl_cursorFree(EGL_Cursor ** cursor)
{ {
if (!*cursor) if (!*cursor)
return; return;
@ -184,13 +184,13 @@ void egl_cursor_free(EGL_Cursor ** cursor)
egl_cursor_tex_free(&(*cursor)->norm); egl_cursor_tex_free(&(*cursor)->norm);
egl_cursor_tex_free(&(*cursor)->mono); egl_cursor_tex_free(&(*cursor)->mono);
egl_model_free(&(*cursor)->model); egl_modelFree(&(*cursor)->model);
free(*cursor); free(*cursor);
*cursor = NULL; *cursor = NULL;
} }
bool egl_cursor_set_shape(EGL_Cursor * cursor, const LG_RendererCursor type, bool egl_cursorSetShape(EGL_Cursor * cursor, const LG_RendererCursor type,
const int width, const int height, const int stride, const uint8_t * data) const int width, const int height, const int stride, const uint8_t * data)
{ {
LG_LOCK(cursor->lock); LG_LOCK(cursor->lock);
@ -223,21 +223,21 @@ bool egl_cursor_set_shape(EGL_Cursor * cursor, const LG_RendererCursor type,
return true; return true;
} }
void egl_cursor_set_size(EGL_Cursor * cursor, const float w, const float h) void egl_cursorSetSize(EGL_Cursor * cursor, const float w, const float h)
{ {
struct CursorSize size = { .w = w, .h = h }; struct CursorSize size = { .w = w, .h = h };
atomic_store(&cursor->size, size); atomic_store(&cursor->size, size);
} }
void egl_cursor_set_state(EGL_Cursor * cursor, const bool visible, const float x, const float y) void egl_cursorSetState(EGL_Cursor * cursor, const bool visible, const float x, const float y)
{ {
cursor->visible = visible; cursor->visible = visible;
struct CursorPos pos = { .x = x, .y = y}; struct CursorPos pos = { .x = x, .y = y};
atomic_store(&cursor->pos, pos); atomic_store(&cursor->pos, pos);
} }
struct CursorState egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rotate, struct CursorState egl_cursorRender(EGL_Cursor * cursor,
int width, int height) LG_RendererRotate rotate, int width, int height)
{ {
if (!cursor->visible) if (!cursor->visible)
return (struct CursorState) { .visible = false }; return (struct CursorState) { .visible = false };
@ -256,9 +256,9 @@ struct CursorState egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rota
case LG_CURSOR_COLOR: case LG_CURSOR_COLOR:
{ {
egl_texture_setup(cursor->norm.texture, EGL_PF_BGRA, cursor->width, cursor->height, cursor->stride); egl_textureSetup(cursor->norm.texture, EGL_PF_BGRA, cursor->width, cursor->height, cursor->stride);
egl_texture_update(cursor->norm.texture, data); egl_textureUpdate(cursor->norm.texture, data);
egl_model_set_texture(cursor->model, cursor->norm.texture); egl_modelSetTexture(cursor->model, cursor->norm.texture);
break; break;
} }
@ -280,10 +280,10 @@ struct CursorState egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rota
xor[y * cursor->width + x] = xorMask; xor[y * cursor->width + x] = xorMask;
} }
egl_texture_setup (cursor->norm.texture, EGL_PF_BGRA, cursor->width, cursor->height, cursor->width * 4); egl_textureSetup (cursor->norm.texture, EGL_PF_BGRA, cursor->width, cursor->height, cursor->width * 4);
egl_texture_setup (cursor->mono.texture, EGL_PF_BGRA, cursor->width, cursor->height, cursor->width * 4); egl_textureSetup (cursor->mono.texture, EGL_PF_BGRA, cursor->width, cursor->height, cursor->width * 4);
egl_texture_update(cursor->norm.texture, (uint8_t *)and); egl_textureUpdate(cursor->norm.texture, (uint8_t *)and);
egl_texture_update(cursor->mono.texture, (uint8_t *)xor); egl_textureUpdate(cursor->mono.texture, (uint8_t *)xor);
break; break;
} }
} }
@ -341,35 +341,35 @@ struct CursorState egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rota
{ {
case LG_CURSOR_MONOCHROME: case LG_CURSOR_MONOCHROME:
{ {
egl_shader_use(cursor->norm.shader); egl_shaderUse(cursor->norm.shader);
egl_cursor_tex_uniforms(cursor, &cursor->norm, true, pos.x, pos.y, size.w, size.h); egl_cursor_tex_uniforms(cursor, &cursor->norm, true, pos.x, pos.y, size.w, size.h);
glBlendFunc(GL_ZERO, GL_SRC_COLOR); glBlendFunc(GL_ZERO, GL_SRC_COLOR);
egl_model_set_texture(cursor->model, cursor->norm.texture); egl_modelSetTexture(cursor->model, cursor->norm.texture);
egl_model_render(cursor->model); egl_modelRender(cursor->model);
egl_shader_use(cursor->mono.shader); egl_shaderUse(cursor->mono.shader);
egl_cursor_tex_uniforms(cursor, &cursor->mono, true, pos.x, pos.y, size.w, size.h); egl_cursor_tex_uniforms(cursor, &cursor->mono, true, pos.x, pos.y, size.w, size.h);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO); glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
egl_model_set_texture(cursor->model, cursor->mono.texture); egl_modelSetTexture(cursor->model, cursor->mono.texture);
egl_model_render(cursor->model); egl_modelRender(cursor->model);
break; break;
} }
case LG_CURSOR_COLOR: case LG_CURSOR_COLOR:
{ {
egl_shader_use(cursor->norm.shader); egl_shaderUse(cursor->norm.shader);
egl_cursor_tex_uniforms(cursor, &cursor->norm, false, pos.x, pos.y, size.w, size.h); egl_cursor_tex_uniforms(cursor, &cursor->norm, false, pos.x, pos.y, size.w, size.h);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
egl_model_render(cursor->model); egl_modelRender(cursor->model);
break; break;
} }
case LG_CURSOR_MASKED_COLOR: case LG_CURSOR_MASKED_COLOR:
{ {
egl_shader_use(cursor->mono.shader); egl_shaderUse(cursor->mono.shader);
egl_cursor_tex_uniforms(cursor, &cursor->mono, false, pos.x, pos.y, size.w, size.h); egl_cursor_tex_uniforms(cursor, &cursor->mono, false, pos.x, pos.y, size.w, size.h);
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO); glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
egl_model_render(cursor->model); egl_modelRender(cursor->model);
break; break;
} }
} }

14
client/renderers/EGL/cursor.h
View File

@ -31,10 +31,10 @@ struct CursorState {
struct Rect rect; struct Rect rect;
}; };
bool egl_cursor_init(EGL_Cursor ** cursor); bool egl_cursorInit(EGL_Cursor ** cursor);
void egl_cursor_free(EGL_Cursor ** cursor); void egl_cursorFree(EGL_Cursor ** cursor);
bool egl_cursor_set_shape( bool egl_cursorSetShape(
EGL_Cursor * cursor, EGL_Cursor * cursor,
const LG_RendererCursor type, const LG_RendererCursor type,
const int width, const int width,
@ -42,10 +42,10 @@ bool egl_cursor_set_shape(
const int stride, const int stride,
const uint8_t * data); const uint8_t * data);
void egl_cursor_set_size(EGL_Cursor * cursor, const float x, const float y); void egl_cursorSetSize(EGL_Cursor * cursor, const float x, const float y);
void egl_cursor_set_state(EGL_Cursor * cursor, const bool visible, void egl_cursorSetState(EGL_Cursor * cursor, const bool visible,
const float x, const float y); const float x, const float y);
struct CursorState egl_cursor_render(EGL_Cursor * cursor, LG_RendererRotate rotate, struct CursorState egl_cursorRender(EGL_Cursor * cursor,
int width, int height); LG_RendererRotate rotate, int width, int height);

22
client/renderers/EGL/damage.c
View File

@ -52,12 +52,12 @@ struct EGL_Damage
GLint uTransform; GLint uTransform;
}; };
void egl_damage_config_ui(EGL_Damage * damage) void egl_damageConfigUI(EGL_Damage * damage)
{ {
igCheckbox("Show damage overlay", &damage->show); igCheckbox("Show damage overlay", &damage->show);
} }
bool egl_damage_init(EGL_Damage ** damage) bool egl_damageInit(EGL_Damage ** damage)
{ {
*damage = (EGL_Damage *)malloc(sizeof(EGL_Damage)); *damage = (EGL_Damage *)malloc(sizeof(EGL_Damage));
if (!*damage) if (!*damage)
@ -68,13 +68,13 @@ bool egl_damage_init(EGL_Damage ** damage)
memset(*damage, 0, sizeof(EGL_Damage)); memset(*damage, 0, sizeof(EGL_Damage));
if (!egl_shader_init(&(*damage)->shader)) if (!egl_shaderInit(&(*damage)->shader))
{ {
DEBUG_ERROR("Failed to initialize the damage shader"); DEBUG_ERROR("Failed to initialize the damage shader");
return false; return false;
} }
if (!egl_shader_compile((*damage)->shader, if (!egl_shaderCompile((*damage)->shader,
b_shader_damage_vert, b_shader_damage_vert_size, b_shader_damage_vert, b_shader_damage_vert_size,
b_shader_damage_frag, b_shader_damage_frag_size)) b_shader_damage_frag, b_shader_damage_frag_size))
{ {
@ -88,18 +88,18 @@ bool egl_damage_init(EGL_Damage ** damage)
return false; return false;
} }
(*damage)->uTransform = egl_shader_get_uniform_location((*damage)->shader, "transform"); (*damage)->uTransform = egl_shaderGetUniform((*damage)->shader, "transform");
return true; return true;
} }
void egl_damage_free(EGL_Damage ** damage) void egl_damageFree(EGL_Damage ** damage)
{ {
if (!*damage) if (!*damage)
return; return;
egl_desktopRectsFree(&(*damage)->mesh); egl_desktopRectsFree(&(*damage)->mesh);
egl_shader_free(&(*damage)->shader); egl_shaderFree(&(*damage)->shader);
free(*damage); free(*damage);
*damage = NULL; *damage = NULL;
@ -111,14 +111,14 @@ static void update_matrix(EGL_Damage * damage)
damage->translateX, damage->translateY, damage->scaleX, damage->scaleY, damage->rotate); damage->translateX, damage->translateY, damage->scaleX, damage->scaleY, damage->rotate);
} }
void egl_damage_setup(EGL_Damage * damage, int width, int height) void egl_damageSetup(EGL_Damage * damage, int width, int height)
{ {
damage->width = width; damage->width = width;
damage->height = height; damage->height = height;
update_matrix(damage); update_matrix(damage);
} }
void egl_damage_resize(EGL_Damage * damage, float translateX, float translateY, void egl_damageResize(EGL_Damage * damage, float translateX, float translateY,
float scaleX, float scaleY) float scaleX, float scaleY)
{ {
damage->translateX = translateX; damage->translateX = translateX;
@ -128,7 +128,7 @@ void egl_damage_resize(EGL_Damage * damage, float translateX, float translateY,
update_matrix(damage); update_matrix(damage);
} }
bool egl_damage_render(EGL_Damage * damage, LG_RendererRotate rotate, const struct DesktopDamage * data) bool egl_damageRender(EGL_Damage * damage, LG_RendererRotate rotate, const struct DesktopDamage * data)
{ {
if (!damage->show) if (!damage->show)
return false; return false;
@ -142,7 +142,7 @@ bool egl_damage_render(EGL_Damage * damage, LG_RendererRotate rotate, const stru
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
egl_shader_use(damage->shader); egl_shaderUse(damage->shader);
glUniformMatrix3x2fv(damage->uTransform, 1, GL_FALSE, damage->transform); glUniformMatrix3x2fv(damage->uTransform, 1, GL_FALSE, damage->transform);
if (data && data->count != 0) if (data && data->count != 0)

12
client/renderers/EGL/damage.h
View File

@ -33,12 +33,12 @@ struct DesktopDamage
typedef struct EGL_Damage EGL_Damage; typedef struct EGL_Damage EGL_Damage;
bool egl_damage_init(EGL_Damage ** damage); bool egl_damageInit(EGL_Damage ** damage);
void egl_damage_free(EGL_Damage ** damage); void egl_damageFree(EGL_Damage ** damage);
void egl_damage_config_ui(EGL_Damage * damage); void egl_damageConfigUI(EGL_Damage * damage);
void egl_damage_setup(EGL_Damage * damage, int width, int height); void egl_damageSetup(EGL_Damage * damage, int width, int height);
void egl_damage_resize(EGL_Damage * damage, float translateX, float translateY, void egl_damageResize(EGL_Damage * damage, float translateX, float translateY,
float scaleX, float scaleY); float scaleX, float scaleY);
bool egl_damage_render(EGL_Damage * damage, LG_RendererRotate rotate, bool egl_damageRender(EGL_Damage * damage, LG_RendererRotate rotate,
const struct DesktopDamage * data); const struct DesktopDamage * data);

52
client/renderers/EGL/desktop.c
View File

@ -86,30 +86,30 @@ static bool egl_init_desktop_shader(
const char * fragment_code, size_t fragment_size const char * fragment_code, size_t fragment_size
) )
{ {
if (!egl_shader_init(&shader->shader)) if (!egl_shaderInit(&shader->shader))
return false; return false;
if (!egl_shader_compile(shader->shader, if (!egl_shaderCompile(shader->shader,
vertex_code , vertex_size, vertex_code , vertex_size,
fragment_code, fragment_size)) fragment_code, fragment_size))
{ {
return false; return false;
} }
egl_shader_associate_textures(shader->shader, 1); egl_shaderAssocTextures(shader->shader, 1);
shader->uTransform = egl_shader_get_uniform_location(shader->shader, "transform"); shader->uTransform = egl_shaderGetUniform(shader->shader, "transform");
shader->uUVScale = egl_shader_get_uniform_location(shader->shader, "uvScale" ); shader->uUVScale = egl_shaderGetUniform(shader->shader, "uvScale" );
shader->uDesktopSize = egl_shader_get_uniform_location(shader->shader, "size" ); shader->uDesktopSize = egl_shaderGetUniform(shader->shader, "size" );
shader->uScaleAlgo = egl_shader_get_uniform_location(shader->shader, "scaleAlgo"); shader->uScaleAlgo = egl_shaderGetUniform(shader->shader, "scaleAlgo");
shader->uNV = egl_shader_get_uniform_location(shader->shader, "nv" ); shader->uNV = egl_shaderGetUniform(shader->shader, "nv" );
shader->uNVGain = egl_shader_get_uniform_location(shader->shader, "nvGain" ); shader->uNVGain = egl_shaderGetUniform(shader->shader, "nvGain" );
shader->uCBMode = egl_shader_get_uniform_location(shader->shader, "cbMode" ); shader->uCBMode = egl_shaderGetUniform(shader->shader, "cbMode" );
return true; return true;
} }
bool egl_desktop_init(EGL_Desktop ** desktop, EGLDisplay * display, bool useDMA, int maxRects) bool egl_desktopInit(EGL_Desktop ** desktop, EGLDisplay * display, bool useDMA, int maxRects)
{ {
*desktop = (EGL_Desktop *)malloc(sizeof(EGL_Desktop)); *desktop = (EGL_Desktop *)malloc(sizeof(EGL_Desktop));
if (!*desktop) if (!*desktop)
@ -121,7 +121,7 @@ bool egl_desktop_init(EGL_Desktop ** desktop, EGLDisplay * display, bool useDMA,
memset(*desktop, 0, sizeof(EGL_Desktop)); memset(*desktop, 0, sizeof(EGL_Desktop));
(*desktop)->display = display; (*desktop)->display = display;
if (!egl_texture_init(&(*desktop)->texture, display, if (!egl_textureInit(&(*desktop)->texture, display,
useDMA ? EGL_TEXTYPE_DMABUF : EGL_TEXTYPE_FRAMEBUFFER, true)) useDMA ? EGL_TEXTYPE_DMABUF : EGL_TEXTYPE_FRAMEBUFFER, true))
{ {
DEBUG_ERROR("Failed to initialize the desktop texture"); DEBUG_ERROR("Failed to initialize the desktop texture");
@ -167,7 +167,7 @@ void egl_desktop_toggle_nv(int key, void * opaque)
app_invalidateWindow(true); app_invalidateWindow(true);
} }
bool egl_desktop_scale_validate(struct Option * opt, const char ** error) bool egl_desktopScaleValidate(struct Option * opt, const char ** error)
{ {
if (opt->value.x_int >= 0 && opt->value.x_int < EGL_SCALE_MAX) if (opt->value.x_int >= 0 && opt->value.x_int < EGL_SCALE_MAX)
return true; return true;
@ -176,13 +176,13 @@ bool egl_desktop_scale_validate(struct Option * opt, const char ** error)
return false; return false;
} }
void egl_desktop_free(EGL_Desktop ** desktop) void egl_desktopFree(EGL_Desktop ** desktop)
{ {
if (!*desktop) if (!*desktop)
return; return;
egl_texture_free (&(*desktop)->texture ); egl_texture_free (&(*desktop)->texture );
egl_shader_free (&(*desktop)->shader_generic.shader); egl_shaderFree (&(*desktop)->shader_generic.shader);
egl_desktopRectsFree(&(*desktop)->mesh ); egl_desktopRectsFree(&(*desktop)->mesh );
free(*desktop); free(*desktop);
@ -195,7 +195,7 @@ static const char * algorithmNames[EGL_SCALE_MAX] = {
[EGL_SCALE_LINEAR] = "Linear", [EGL_SCALE_LINEAR] = "Linear",
}; };
void egl_desktop_config_ui(EGL_Desktop * desktop) void egl_desktopConfigUI(EGL_Desktop * desktop)
{ {
igText("Scale algorithm:"); igText("Scale algorithm:");
igPushItemWidth(igGetWindowWidth() - igGetStyle()->WindowPadding.x * 2); igPushItemWidth(igGetWindowWidth() - igGetStyle()->WindowPadding.x * 2);
@ -228,7 +228,7 @@ void egl_desktop_config_ui(EGL_Desktop * desktop)
igPopItemWidth(); igPopItemWidth();
} }
bool egl_desktop_setup(EGL_Desktop * desktop, const LG_RendererFormat format) bool egl_desktopSetup(EGL_Desktop * desktop, const LG_RendererFormat format)
{ {
memcpy(&desktop->format, &format, sizeof(LG_RendererFormat)); memcpy(&desktop->format, &format, sizeof(LG_RendererFormat));
@ -263,7 +263,7 @@ bool egl_desktop_setup(EGL_Desktop * desktop, const LG_RendererFormat format)
desktop->width = format.width; desktop->width = format.width;
desktop->height = format.height; desktop->height = format.height;
if (!egl_texture_setup( if (!egl_textureSetup(
desktop->texture, desktop->texture,
pixFmt, pixFmt,
format.width, format.width,
@ -283,27 +283,27 @@ bool egl_desktop_update(EGL_Desktop * desktop, const FrameBuffer * frame, int dm
{ {
if (desktop->useDMA && dmaFd >= 0) if (desktop->useDMA && dmaFd >= 0)
{ {
if (egl_texture_update_from_dma(desktop->texture, frame, dmaFd)) if (egl_textureUpdateFromDMA(desktop->texture, frame, dmaFd))
return true; return true;
DEBUG_WARN("DMA update failed, disabling DMABUF imports"); DEBUG_WARN("DMA update failed, disabling DMABUF imports");
desktop->useDMA = false; desktop->useDMA = false;
egl_texture_free(&desktop->texture); egl_texture_free(&desktop->texture);
if (!egl_texture_init(&desktop->texture, desktop->display, EGL_TEXTYPE_FRAMEBUFFER, true)) if (!egl_textureInit(&desktop->texture, desktop->display, EGL_TEXTYPE_FRAMEBUFFER, true))
{ {
DEBUG_ERROR("Failed to initialize the desktop texture"); DEBUG_ERROR("Failed to initialize the desktop texture");
return false; return false;
} }
if (!egl_desktop_setup(desktop, desktop->format)) if (!egl_desktopSetup(desktop, desktop->format))
return false; return false;
} }
return egl_texture_update_from_frame(desktop->texture, frame, damageRects, damageRectsCount); return egl_textureUpdateFromFrame(desktop->texture, frame, damageRects, damageRectsCount);
} }
bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, bool egl_desktopRender(EGL_Desktop * desktop, const float x, const float y,
const float scaleX, const float scaleY, enum EGL_DesktopScaleType scaleType, const float scaleX, const float scaleY, enum EGL_DesktopScaleType scaleType,
LG_RendererRotate rotate, const struct DamageRects * rects) LG_RendererRotate rotate, const struct DamageRects * rects)
{ {
@ -311,7 +311,7 @@ bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y,
return false; return false;
enum EGL_TexStatus status; enum EGL_TexStatus status;
if ((status = egl_texture_process(desktop->texture)) != EGL_TEX_STATUS_OK) if ((status = egl_textureProcess(desktop->texture)) != EGL_TEX_STATUS_OK)
{ {
if (status != EGL_TEX_STATUS_NOTREADY) if (status != EGL_TEX_STATUS_NOTREADY)
DEBUG_ERROR("Failed to process the desktop texture"); DEBUG_ERROR("Failed to process the desktop texture");
@ -344,7 +344,7 @@ bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y,
egl_desktopRectsUpdate(desktop->mesh, rects, desktop->width, desktop->height); egl_desktopRectsUpdate(desktop->mesh, rects, desktop->width, desktop->height);
const struct DesktopShader * shader = desktop->shader; const struct DesktopShader * shader = desktop->shader;
egl_shader_use(shader->shader); egl_shaderUse(shader->shader);
glUniform1i(shader->uScaleAlgo , scaleAlgo); glUniform1i(shader->uScaleAlgo , scaleAlgo);
glUniform2f(shader->uDesktopSize, desktop->width, desktop->height); glUniform2f(shader->uDesktopSize, desktop->width, desktop->height);
glUniform2f(shader->uUVScale , 1.0f / desktop->width, 1.0f / desktop->height); glUniform2f(shader->uUVScale , 1.0f / desktop->width, 1.0f / desktop->height);
@ -360,7 +360,7 @@ bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y,
glUniform1i(shader->uCBMode, desktop->cbMode); glUniform1i(shader->uCBMode, desktop->cbMode);
egl_texture_bind(desktop->texture); egl_textureBind(desktop->texture);
egl_desktopRectsRender(desktop->mesh); egl_desktopRectsRender(desktop->mesh);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
return true; return true;

12
client/renderers/EGL/desktop.h
View File

@ -35,15 +35,15 @@ enum EGL_DesktopScaleType
}; };
struct Option; struct Option;
bool egl_desktop_scale_validate(struct Option * opt, const char ** error); bool egl_desktopScaleValidate(struct Option * opt, const char ** error);
bool egl_desktop_init(EGL_Desktop ** desktop, EGLDisplay * display, bool useDMA, int maxRects); bool egl_desktopInit(EGL_Desktop ** desktop, EGLDisplay * display, bool useDMA, int maxRects);
void egl_desktop_free(EGL_Desktop ** desktop); void egl_desktopFree(EGL_Desktop ** desktop);
void egl_desktop_config_ui(EGL_Desktop * desktop); void egl_desktopConfigUI(EGL_Desktop * desktop);
bool egl_desktop_setup (EGL_Desktop * desktop, const LG_RendererFormat format); bool egl_desktopSetup (EGL_Desktop * desktop, const LG_RendererFormat format);
bool egl_desktop_update(EGL_Desktop * desktop, const FrameBuffer * frame, int dmaFd, bool egl_desktop_update(EGL_Desktop * desktop, const FrameBuffer * frame, int dmaFd,
const FrameDamageRect * damageRects, int damageRectsCount); const FrameDamageRect * damageRects, int damageRectsCount);
bool egl_desktop_render(EGL_Desktop * desktop, const float x, const float y, bool egl_desktopRender(EGL_Desktop * desktop, const float x, const float y,
const float scaleX, const float scaleY, enum EGL_DesktopScaleType scaleType, const float scaleX, const float scaleY, enum EGL_DesktopScaleType scaleType,
LG_RendererRotate rotate, const struct DamageRects * rects); LG_RendererRotate rotate, const struct DamageRects * rects);

12
client/renderers/EGL/draw.c
View File

@ -22,7 +22,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
void egl_draw_torus(EGL_Model * model, unsigned int pts, float x, float y, float inner, float outer) void egl_drawTorus(EGL_Model * model, unsigned int pts, float x, float y,
float inner, float outer)
{ {
GLfloat * v = (GLfloat *)malloc(sizeof(GLfloat) * (pts + 1) * 6); GLfloat * v = (GLfloat *)malloc(sizeof(GLfloat) * (pts + 1) * 6);
GLfloat * dst = v; GLfloat * dst = v;
@ -40,11 +41,12 @@ void egl_draw_torus(EGL_Model * model, unsigned int pts, float x, float y, float
*dst = 0.0f; ++dst; *dst = 0.0f; ++dst;
} }
egl_model_add_verticies(model, v, NULL, (pts + 1) * 2); egl_modelAddVerts(model, v, NULL, (pts + 1) * 2);
free(v); free(v);
} }
void egl_draw_torus_arc(EGL_Model * model, unsigned int pts, float x, float y, float inner, float outer, float s, float e) void egl_drawTorusArc(EGL_Model * model, unsigned int pts, float x, float y,
float inner, float outer, float s, float e)
{ {
GLfloat * v = (GLfloat *)malloc(sizeof(GLfloat) * (pts + 1) * 6); GLfloat * v = (GLfloat *)malloc(sizeof(GLfloat) * (pts + 1) * 6);
GLfloat * dst = v; GLfloat * dst = v;
@ -62,6 +64,6 @@ void egl_draw_torus_arc(EGL_Model * model, unsigned int pts, float x, float y, f
*dst = 0.0f; ++dst; *dst = 0.0f; ++dst;
} }
egl_model_add_verticies(model, v, NULL, (pts + 1) * 2); egl_modelAddVerts(model, v, NULL, (pts + 1) * 2);
free(v); free(v);
} }

7
client/renderers/EGL/draw.h
View File

@ -22,5 +22,8 @@
#include "model.h" #include "model.h"
void egl_draw_torus (EGL_Model * model, unsigned int pts, float x, float y, float inner, float outer); void egl_drawTorus(EGL_Model * model, unsigned int pts, float x, float y,
void egl_draw_torus_arc(EGL_Model * model, unsigned int pts, float x, float y, float inner, float outer, float s, float e); float inner, float outer);
void egl_drawTorusArc(EGL_Model * model, unsigned int pts, float x, float y,
float inner, float outer, float s, float e);

48
client/renderers/EGL/egl.c
View File

@ -171,7 +171,7 @@ static struct Option egl_options[] =
.name = "scale", .name = "scale",
.description = "Set the scale algorithm (0 = auto, 1 = nearest, 2 = linear)", .description = "Set the scale algorithm (0 = auto, 1 = nearest, 2 = linear)",
.type = OPTION_TYPE_INT, .type = OPTION_TYPE_INT,
.validator = egl_desktop_scale_validate, .validator = egl_desktopScaleValidate,
.value.x_int = 0 .value.x_int = 0
}, },
{ {
@ -251,10 +251,10 @@ static void egl_deinitialize(LG_Renderer * renderer)
app_unregisterGraph(this->importGraph); app_unregisterGraph(this->importGraph);
ringbuffer_free(&this->importTimings); ringbuffer_free(&this->importTimings);
egl_desktop_free(&this->desktop); egl_desktopFree(&this->desktop);
egl_cursor_free (&this->cursor); egl_cursorFree (&this->cursor);
egl_splash_free (&this->splash); egl_splashFree (&this->splash);
egl_damage_free (&this->damage); egl_damageFree (&this->damage);
LG_LOCK_FREE(this->lock); LG_LOCK_FREE(this->lock);
LG_LOCK_FREE(this->desktopDamageLock); LG_LOCK_FREE(this->desktopDamageLock);
@ -328,7 +328,7 @@ static void egl_calc_mouse_size(struct Inst * this)
{ {
case LG_ROTATE_0: case LG_ROTATE_0:
case LG_ROTATE_180: case LG_ROTATE_180:
egl_cursor_set_size(this->cursor, egl_cursorSetSize(this->cursor,
(this->mouseWidth * (1.0f / w)) * this->scaleX, (this->mouseWidth * (1.0f / w)) * this->scaleX,
(this->mouseHeight * (1.0f / h)) * this->scaleY (this->mouseHeight * (1.0f / h)) * this->scaleY
); );
@ -336,7 +336,7 @@ static void egl_calc_mouse_size(struct Inst * this)
case LG_ROTATE_90: case LG_ROTATE_90:
case LG_ROTATE_270: case LG_ROTATE_270:
egl_cursor_set_size(this->cursor, egl_cursorSetSize(this->cursor,
(this->mouseWidth * (1.0f / w)) * this->scaleY, (this->mouseWidth * (1.0f / w)) * this->scaleY,
(this->mouseHeight * (1.0f / h)) * this->scaleX (this->mouseHeight * (1.0f / h)) * this->scaleX
); );
@ -353,7 +353,7 @@ static void egl_calc_mouse_state(struct Inst * this)
{ {
case LG_ROTATE_0: case LG_ROTATE_0:
case LG_ROTATE_180: case LG_ROTATE_180:
egl_cursor_set_state( egl_cursorSetState(
this->cursor, this->cursor,
this->cursorVisible, this->cursorVisible,
(((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleX, (((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleX,
@ -363,7 +363,7 @@ static void egl_calc_mouse_state(struct Inst * this)
case LG_ROTATE_90: case LG_ROTATE_90:
case LG_ROTATE_270: case LG_ROTATE_270:
egl_cursor_set_state( egl_cursorSetState(
this->cursor, this->cursor,
this->cursorVisible, this->cursorVisible,
(((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleY, (((float)this->cursorX * this->mouseScaleX) - 1.0f) * this->scaleY,
@ -444,7 +444,7 @@ static void egl_onResize(LG_Renderer * renderer, const int width, const int heig
ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplOpenGL3_NewFrame();
egl_damage_resize(this->damage, this->translateX, this->translateY, this->scaleX, this->scaleY); egl_damageResize(this->damage, this->translateX, this->translateY, this->scaleX, this->scaleY);
} }
static bool egl_onMouseShape(LG_Renderer * renderer, const LG_RendererCursor cursor, static bool egl_onMouseShape(LG_Renderer * renderer, const LG_RendererCursor cursor,
@ -453,7 +453,7 @@ static bool egl_onMouseShape(LG_Renderer * renderer, const LG_RendererCursor cur
{ {
struct Inst * this = UPCAST(struct Inst, renderer); struct Inst * this = UPCAST(struct Inst, renderer);
if (!egl_cursor_set_shape(this->cursor, cursor, width, height, pitch, data)) if (!egl_cursorSetShape(this->cursor, cursor, width, height, pitch, data))
{ {
DEBUG_ERROR("Failed to update the cursor shape"); DEBUG_ERROR("Failed to update the cursor shape");
return false; return false;
@ -504,9 +504,9 @@ static bool egl_onFrameFormat(LG_Renderer * renderer, const LG_RendererFormat fo
} }
egl_update_scale_type(this); egl_update_scale_type(this);
egl_damage_setup(this->damage, format.width, format.height); egl_damageSetup(this->damage, format.width, format.height);
return egl_desktop_setup(this->desktop, format); return egl_desktopSetup(this->desktop, format);
} }
static bool egl_onFrame(LG_Renderer * renderer, const FrameBuffer * frame, int dmaFd, static bool egl_onFrame(LG_Renderer * renderer, const FrameBuffer * frame, int dmaFd,
@ -619,9 +619,9 @@ static void debugCallback(GLenum source, GLenum type, GLuint id,
static void egl_config_ui(void * opaque) static void egl_config_ui(void * opaque)
{ {
struct Inst * this = opaque; struct Inst * this = opaque;
egl_damage_config_ui(this->damage); egl_damageConfigUI(this->damage);
igSeparator(); igSeparator();
egl_desktop_config_ui(this->desktop); egl_desktopConfigUI(this->desktop);
} }
static bool egl_renderStartup(LG_Renderer * renderer, bool useDMA) static bool egl_renderStartup(LG_Renderer * renderer, bool useDMA)
@ -782,25 +782,25 @@ static bool egl_renderStartup(LG_Renderer * renderer, bool useDMA)
eglSwapInterval(this->display, this->opt.vsync ? 1 : 0); eglSwapInterval(this->display, this->opt.vsync ? 1 : 0);
if (!egl_desktop_init(&this->desktop, this->display, useDMA, MAX_ACCUMULATED_DAMAGE)) if (!egl_desktopInit(&this->desktop, this->display, useDMA, MAX_ACCUMULATED_DAMAGE))
{ {
DEBUG_ERROR("Failed to initialize the desktop"); DEBUG_ERROR("Failed to initialize the desktop");
return false; return false;
} }
if (!egl_cursor_init(&this->cursor)) if (!egl_cursorInit(&this->cursor))
{ {
DEBUG_ERROR("Failed to initialize the cursor"); DEBUG_ERROR("Failed to initialize the cursor");
return false; return false;
} }
if (!egl_splash_init(&this->splash)) if (!egl_splashInit(&this->splash))
{ {
DEBUG_ERROR("Failed to initialize the splash screen"); DEBUG_ERROR("Failed to initialize the splash screen");
return false; return false;
} }
if (!egl_damage_init(&this->damage)) if (!egl_damageInit(&this->damage))
{ {
DEBUG_ERROR("Failed to initialize the damage display"); DEBUG_ERROR("Failed to initialize the damage display");
return false; return false;
@ -952,7 +952,7 @@ static bool egl_render(LG_Renderer * renderer, LG_RendererRotate rotate,
if (this->start) if (this->start)
{ {
if (egl_desktop_render(this->desktop, if (egl_desktopRender(this->desktop,
this->translateX, this->translateY, this->translateX, this->translateY,
this->scaleX , this->scaleY , this->scaleX , this->scaleY ,
this->scaleType , rotate, renderAll ? NULL : accumulated)) this->scaleType , rotate, renderAll ? NULL : accumulated))
@ -965,7 +965,7 @@ static bool egl_render(LG_Renderer * renderer, LG_RendererRotate rotate,
this->waitDone = true; this->waitDone = true;
} }
cursorState = egl_cursor_render(this->cursor, cursorState = egl_cursorRender(this->cursor,
(this->format.rotate + rotate) % LG_ROTATE_MAX, (this->format.rotate + rotate) % LG_ROTATE_MAX,
this->width, this->height); this->width, this->height);
} }
@ -994,17 +994,17 @@ static bool egl_render(LG_Renderer * renderer, LG_RendererRotate rotate,
if (!this->waitDone) if (!this->waitDone)
{ {
egl_splash_render(this->splash, a, this->splashRatio); egl_splashRender(this->splash, a, this->splashRatio);
hasOverlay = true; hasOverlay = true;
} }
} }
else if (!this->start) else if (!this->start)
{ {
egl_splash_render(this->splash, 1.0f, this->splashRatio); egl_splashRender(this->splash, 1.0f, this->splashRatio);
hasOverlay = true; hasOverlay = true;
} }
hasOverlay |= egl_damage_render(this->damage, rotate, newFrame ? desktopDamage : NULL); hasOverlay |= egl_damageRender(this->damage, rotate, newFrame ? desktopDamage : NULL);
hasOverlay |= invalidateWindow; hasOverlay |= invalidateWindow;
struct Rect damage[KVMFR_MAX_DAMAGE_RECTS + MAX_OVERLAY_RECTS + 2]; struct Rect damage[KVMFR_MAX_DAMAGE_RECTS + MAX_OVERLAY_RECTS + 2];

22
client/renderers/EGL/model.c
View File

@ -53,7 +53,7 @@ struct FloatList
void update_uniform_bindings(EGL_Model * model); void update_uniform_bindings(EGL_Model * model);
bool egl_model_init(EGL_Model ** model) bool egl_modelInit(EGL_Model ** model)
{ {
*model = (EGL_Model *)malloc(sizeof(EGL_Model)); *model = (EGL_Model *)malloc(sizeof(EGL_Model));
if (!*model) if (!*model)
@ -69,7 +69,7 @@ bool egl_model_init(EGL_Model ** model)
return true; return true;
} }
void egl_model_free(EGL_Model ** model) void egl_modelFree(EGL_Model ** model)
{ {
if (!*model) if (!*model)
return; return;
@ -93,7 +93,7 @@ void egl_model_free(EGL_Model ** model)
*model = NULL; *model = NULL;
} }
void egl_model_set_default(EGL_Model * model) void egl_modelSetDefault(EGL_Model * model)
{ {
static const GLfloat square[] = static const GLfloat square[] =
{ {
@ -111,10 +111,10 @@ void egl_model_set_default(EGL_Model * model)
1.0f, 0.0f 1.0f, 0.0f
}; };
egl_model_add_verticies(model, square, uvs, 4); egl_modelAddVerts(model, square, uvs, 4);
} }
void egl_model_add_verticies(EGL_Model * model, const GLfloat * verticies, const GLfloat * uvs, const size_t count) void egl_modelAddVerts(EGL_Model * model, const GLfloat * verticies, const GLfloat * uvs, const size_t count)
{ {
struct FloatList * fl = (struct FloatList *)malloc(sizeof(struct FloatList)); struct FloatList * fl = (struct FloatList *)malloc(sizeof(struct FloatList));
@ -133,7 +133,7 @@ void egl_model_add_verticies(EGL_Model * model, const GLfloat * verticies, const
model->vertexCount += count; model->vertexCount += count;
} }
void egl_model_render(EGL_Model * model) void egl_modelRender(EGL_Model * model)
{ {
if (!model->vertexCount) if (!model->vertexCount)
return; return;
@ -184,10 +184,10 @@ void egl_model_render(EGL_Model * model)
glBindVertexArray(model->vao); glBindVertexArray(model->vao);
if (model->shader) if (model->shader)
egl_shader_use(model->shader); egl_shaderUse(model->shader);
if (model->texture) if (model->texture)
egl_texture_bind(model->texture); egl_textureBind(model->texture);
/* draw the arrays */ /* draw the arrays */
GLint offset = 0; GLint offset = 0;
@ -204,13 +204,13 @@ void egl_model_render(EGL_Model * model)
glUseProgram(0); glUseProgram(0);
} }
void egl_model_set_shader(EGL_Model * model, EGL_Shader * shader) void egl_modelSetShader(EGL_Model * model, EGL_Shader * shader)
{ {
model->shader = shader; model->shader = shader;
update_uniform_bindings(model); update_uniform_bindings(model);
} }
void egl_model_set_texture(EGL_Model * model, EGL_Texture * texture) void egl_modelSetTexture(EGL_Model * model, EGL_Texture * texture)
{ {
model->texture = texture; model->texture = texture;
update_uniform_bindings(model); update_uniform_bindings(model);
@ -221,5 +221,5 @@ void update_uniform_bindings(EGL_Model * model)
if (!model->shader || !model->texture) if (!model->shader || !model->texture)
return; return;
egl_shader_associate_textures(model->shader, 1); egl_shaderAssocTextures(model->shader, 1);
} }

14
client/renderers/EGL/model.h
View File

@ -28,12 +28,12 @@
typedef struct EGL_Model EGL_Model; typedef struct EGL_Model EGL_Model;
bool egl_model_init(EGL_Model ** model); bool egl_modelInit(EGL_Model ** model);
void egl_model_free(EGL_Model ** model); void egl_modelFree(EGL_Model ** model);
void egl_model_set_default (EGL_Model * model); void egl_modelSetDefault (EGL_Model * model);
void egl_model_add_verticies(EGL_Model * model, const GLfloat * verticies, const GLfloat * uvs, const size_t count); void egl_modelAddVerts(EGL_Model * model, const GLfloat * verticies, const GLfloat * uvs, const size_t count);
void egl_model_set_shader (EGL_Model * model, EGL_Shader * shader); void egl_modelSetShader (EGL_Model * model, EGL_Shader * shader);
void egl_model_set_texture (EGL_Model * model, EGL_Texture * texture); void egl_modelSetTexture (EGL_Model * model, EGL_Texture * texture);
void egl_model_render(EGL_Model * model); void egl_modelRender(EGL_Model * model);

17
client/renderers/EGL/shader.c
View File

@ -32,7 +32,7 @@ struct EGL_Shader
GLuint shader; GLuint shader;
}; };
bool egl_shader_init(EGL_Shader ** this) bool egl_shaderInit(EGL_Shader ** this)
{ {
*this = (EGL_Shader *)malloc(sizeof(EGL_Shader)); *this = (EGL_Shader *)malloc(sizeof(EGL_Shader));
if (!*this) if (!*this)
@ -45,7 +45,7 @@ bool egl_shader_init(EGL_Shader ** this)
return true; return true;
} }
void egl_shader_free(EGL_Shader ** this) void egl_shaderFree(EGL_Shader ** this)
{ {
if (!*this) if (!*this)
return; return;
@ -57,7 +57,7 @@ void egl_shader_free(EGL_Shader ** this)
*this = NULL; *this = NULL;
} }
bool egl_shader_load(EGL_Shader * this, const char * vertex_file, const char * fragment_file) bool egl_shaderLoad(EGL_Shader * this, const char * vertex_file, const char * fragment_file)
{ {
char * vertex_code, * fragment_code; char * vertex_code, * fragment_code;
size_t vertex_size, fragment_size; size_t vertex_size, fragment_size;
@ -79,13 +79,14 @@ bool egl_shader_load(EGL_Shader * this, const char * vertex_file, const char * f
DEBUG_INFO("Loaded fragment shader: %s", fragment_file); DEBUG_INFO("Loaded fragment shader: %s", fragment_file);
bool ret = egl_shader_compile(this, vertex_code, vertex_size, fragment_code, fragment_size); bool ret = egl_shaderCompile(this, vertex_code, vertex_size, fragment_code, fragment_size);
free(vertex_code); free(vertex_code);
free(fragment_code); free(fragment_code);
return ret; return ret;
} }
bool egl_shader_compile(EGL_Shader * this, const char * vertex_code, size_t vertex_size, const char * fragment_code, size_t fragment_size) bool egl_shaderCompile(EGL_Shader * this, const char * vertex_code,
size_t vertex_size, const char * fragment_code, size_t fragment_size)
{ {
if (this->hasShader) if (this->hasShader)
{ {
@ -186,7 +187,7 @@ bool egl_shader_compile(EGL_Shader * this, const char * vertex_code, size_t vert
return true; return true;
} }
void egl_shader_use(EGL_Shader * this) void egl_shaderUse(EGL_Shader * this)
{ {
if (this->hasShader) if (this->hasShader)
glUseProgram(this->shader); glUseProgram(this->shader);
@ -194,7 +195,7 @@ void egl_shader_use(EGL_Shader * this)
DEBUG_ERROR("Shader program has not been compiled"); DEBUG_ERROR("Shader program has not been compiled");
} }
void egl_shader_associate_textures(EGL_Shader * this, const int count) void egl_shaderAssocTextures(EGL_Shader * this, const int count)
{ {
char name[] = "sampler1"; char name[] = "sampler1";
glUseProgram(this->shader); glUseProgram(this->shader);
@ -212,7 +213,7 @@ void egl_shader_associate_textures(EGL_Shader * this, const int count)
glUseProgram(0); glUseProgram(0);
} }
GLint egl_shader_get_uniform_location(EGL_Shader * this, const char * name) GLint egl_shaderGetUniform(EGL_Shader * this, const char * name)
{ {
if (!this->shader) if (!this->shader)
{ {

19
client/renderers/EGL/shader.h
View File

@ -27,12 +27,17 @@
typedef struct EGL_Shader EGL_Shader; typedef struct EGL_Shader EGL_Shader;
bool egl_shader_init(EGL_Shader ** shader); bool egl_shaderInit(EGL_Shader ** shader);
void egl_shader_free(EGL_Shader ** shader); void egl_shaderFree(EGL_Shader ** shader);
bool egl_shader_load (EGL_Shader * model, const char * vertex_file, const char * fragment_file); bool egl_shaderLoad(EGL_Shader * model, const char * vertex_file,
bool egl_shader_compile(EGL_Shader * model, const char * vertex_code, size_t vertex_size, const char * fragment_code, size_t fragment_size); const char * fragment_file);
void egl_shader_use (EGL_Shader * shader);
void egl_shader_associate_textures(EGL_Shader * shader, const int count); bool egl_shaderCompile(EGL_Shader * model, const char * vertex_code,
GLint egl_shader_get_uniform_location(EGL_Shader * shader, const char * name); size_t vertex_size, const char * fragment_code, size_t fragment_size);
void egl_shaderUse(EGL_Shader * shader);
void egl_shaderAssocTextures(EGL_Shader * shader, const int count);
GLint egl_shaderGetUniform(EGL_Shader * shader, const char * name);

58
client/renderers/EGL/splash.c
View File

@ -49,7 +49,7 @@ struct EGL_Splash
GLint uScale; GLint uScale;
}; };
bool egl_splash_init(EGL_Splash ** splash) bool egl_splashInit(EGL_Splash ** splash)
{ {
*splash = (EGL_Splash *)malloc(sizeof(EGL_Splash)); *splash = (EGL_Splash *)malloc(sizeof(EGL_Splash));
if (!*splash) if (!*splash)
@ -60,13 +60,13 @@ bool egl_splash_init(EGL_Splash ** splash)
memset(*splash, 0, sizeof(EGL_Splash)); memset(*splash, 0, sizeof(EGL_Splash));
if (!egl_shader_init(&(*splash)->bgShader)) if (!egl_shaderInit(&(*splash)->bgShader))
{ {
DEBUG_ERROR("Failed to initialize the splash bgShader"); DEBUG_ERROR("Failed to initialize the splash bgShader");
return false; return false;
} }
if (!egl_shader_compile((*splash)->bgShader, if (!egl_shaderCompile((*splash)->bgShader,
b_shader_splash_bg_vert, b_shader_splash_bg_vert_size, b_shader_splash_bg_vert, b_shader_splash_bg_vert_size,
b_shader_splash_bg_frag, b_shader_splash_bg_frag_size)) b_shader_splash_bg_frag, b_shader_splash_bg_frag_size))
{ {
@ -74,21 +74,21 @@ bool egl_splash_init(EGL_Splash ** splash)
return false; return false;
} }
if (!egl_model_init(&(*splash)->bg)) if (!egl_modelInit(&(*splash)->bg))
{ {
DEBUG_ERROR("Failed to intiailize the splash bg model"); DEBUG_ERROR("Failed to intiailize the splash bg model");
return false; return false;
} }
egl_model_set_default((*splash)->bg); egl_modelSetDefault((*splash)->bg);
if (!egl_shader_init(&(*splash)->logoShader)) if (!egl_shaderInit(&(*splash)->logoShader))
{ {
DEBUG_ERROR("Failed to initialize the splash logoShader"); DEBUG_ERROR("Failed to initialize the splash logoShader");
return false; return false;
} }
if (!egl_shader_compile((*splash)->logoShader, if (!egl_shaderCompile((*splash)->logoShader,
b_shader_splash_logo_vert, b_shader_splash_logo_vert_size, b_shader_splash_logo_vert, b_shader_splash_logo_vert_size,
b_shader_splash_logo_frag, b_shader_splash_logo_frag_size)) b_shader_splash_logo_frag, b_shader_splash_logo_frag_size))
{ {
@ -96,9 +96,9 @@ bool egl_splash_init(EGL_Splash ** splash)
return false; return false;
} }
(*splash)->uScale = egl_shader_get_uniform_location((*splash)->logoShader, "scale"); (*splash)->uScale = egl_shaderGetUniform((*splash)->logoShader, "scale");
if (!egl_model_init(&(*splash)->logo)) if (!egl_modelInit(&(*splash)->logo))
{ {
DEBUG_ERROR("Failed to intiailize the splash model"); DEBUG_ERROR("Failed to intiailize the splash model");
return false; return false;
@ -106,12 +106,12 @@ bool egl_splash_init(EGL_Splash ** splash)
/* build the splash model */ /* build the splash model */
#define P(x) ((1.0f/800.0f)*(float)(x)) #define P(x) ((1.0f/800.0f)*(float)(x))
egl_draw_torus_arc((*splash)->logo, 30, P( 0 ), P(0), P(102), P(98), 0.0f, -M_PI); egl_drawTorusArc((*splash)->logo, 30, P( 0 ), P(0), P(102), P(98), 0.0f, -M_PI);
egl_draw_torus ((*splash)->logo, 30, P(-100), P(8), P(8 ), P(4 )); egl_drawTorus ((*splash)->logo, 30, P(-100), P(8), P(8 ), P(4 ));
egl_draw_torus ((*splash)->logo, 30, P( 100), P(8), P(8 ), P(4 )); egl_drawTorus ((*splash)->logo, 30, P( 100), P(8), P(8 ), P(4 ));
egl_draw_torus ((*splash)->logo, 60, P(0), P(0), P(83), P(79)); egl_drawTorus ((*splash)->logo, 60, P(0), P(0), P(83), P(79));
egl_draw_torus ((*splash)->logo, 60, P(0), P(0), P(67), P(63)); egl_drawTorus ((*splash)->logo, 60, P(0), P(0), P(67), P(63));
static const GLfloat lines[][12] = static const GLfloat lines[][12] =
{ {
@ -135,44 +135,44 @@ bool egl_splash_init(EGL_Splash ** splash)
} }
}; };
egl_model_add_verticies((*splash)->logo, lines[0], NULL, 4); egl_modelAddVerts((*splash)->logo, lines[0], NULL, 4);
egl_model_add_verticies((*splash)->logo, lines[1], NULL, 4); egl_modelAddVerts((*splash)->logo, lines[1], NULL, 4);
egl_model_add_verticies((*splash)->logo, lines[2], NULL, 4); egl_modelAddVerts((*splash)->logo, lines[2], NULL, 4);
egl_draw_torus_arc((*splash)->logo, 10, P(-26), P(-154), P(10), P(14), M_PI , -M_PI / 2.0); egl_drawTorusArc((*splash)->logo, 10, P(-26), P(-154), P(10), P(14), M_PI , -M_PI / 2.0);
egl_draw_torus_arc((*splash)->logo, 10, P( 26), P(-154), P(10), P(14), M_PI / 2.0f, -M_PI / 2.0); egl_drawTorusArc((*splash)->logo, 10, P( 26), P(-154), P(10), P(14), M_PI / 2.0f, -M_PI / 2.0);
#undef P #undef P
return true; return true;
} }
void egl_splash_free(EGL_Splash ** splash) void egl_splashFree(EGL_Splash ** splash)
{ {
if (!*splash) if (!*splash)
return; return;
egl_model_free(&(*splash)->bg ); egl_modelFree(&(*splash)->bg );
egl_model_free(&(*splash)->logo); egl_modelFree(&(*splash)->logo);
egl_shader_free(&(*splash)->bgShader ); egl_shaderFree(&(*splash)->bgShader );
egl_shader_free(&(*splash)->logoShader); egl_shaderFree(&(*splash)->logoShader);
free(*splash); free(*splash);
*splash = NULL; *splash = NULL;
} }
void egl_splash_render(EGL_Splash * splash, float alpha, float scaleY) void egl_splashRender(EGL_Splash * splash, float alpha, float scaleY)
{ {
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendColor(0, 0, 0, alpha); glBlendColor(0, 0, 0, alpha);
glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA); glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
egl_shader_use(splash->bgShader); egl_shaderUse(splash->bgShader);
egl_model_render(splash->bg); egl_modelRender(splash->bg);
egl_shader_use(splash->logoShader); egl_shaderUse(splash->logoShader);
glUniform1f(splash->uScale, scaleY); glUniform1f(splash->uScale, scaleY);
egl_model_render(splash->logo); egl_modelRender(splash->logo);
glDisable(GL_BLEND); glDisable(GL_BLEND);
} }

6
client/renderers/EGL/splash.h
View File

@ -24,7 +24,7 @@
typedef struct EGL_Splash EGL_Splash; typedef struct EGL_Splash EGL_Splash;
bool egl_splash_init(EGL_Splash ** splash); bool egl_splashInit(EGL_Splash ** splash);
void egl_splash_free(EGL_Splash ** splash); void egl_splashFree(EGL_Splash ** splash);
void egl_splash_render(EGL_Splash * splash, float alpha, float scaleY); void egl_splashRender(EGL_Splash * splash, float alpha, float scaleY);

14
client/renderers/EGL/texture.c
View File

@ -35,7 +35,7 @@ extern const EGL_TextureOps EGL_TextureBufferStream;
extern const EGL_TextureOps EGL_TextureFrameBuffer; extern const EGL_TextureOps EGL_TextureFrameBuffer;
extern const EGL_TextureOps EGL_TextureDMABUF; extern const EGL_TextureOps EGL_TextureDMABUF;
bool egl_texture_init(EGL_Texture ** texture, EGLDisplay * display, bool egl_textureInit(EGL_Texture ** texture, EGLDisplay * display,
EGL_TexType type, bool streaming) EGL_TexType type, bool streaming)
{ {
const EGL_TextureOps * ops; const EGL_TextureOps * ops;
@ -74,7 +74,7 @@ void egl_texture_free(EGL_Texture ** tex)
*tex = NULL; *tex = NULL;
} }
bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, bool egl_textureSetup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt,
size_t width, size_t height, size_t stride) size_t width, size_t height, size_t stride)
{ {
const struct EGL_TexSetup setup = const struct EGL_TexSetup setup =
@ -88,7 +88,7 @@ bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt,
return texture->ops->setup(texture, &setup); return texture->ops->setup(texture, &setup);
} }
bool egl_texture_update(EGL_Texture * texture, const uint8_t * buffer) bool egl_textureUpdate(EGL_Texture * texture, const uint8_t * buffer)
{ {
const struct EGL_TexUpdate update = const struct EGL_TexUpdate update =
{ {
@ -98,7 +98,7 @@ bool egl_texture_update(EGL_Texture * texture, const uint8_t * buffer)
return texture->ops->update(texture, &update); return texture->ops->update(texture, &update);
} }
bool egl_texture_update_from_frame(EGL_Texture * texture, bool egl_textureUpdateFromFrame(EGL_Texture * texture,
const FrameBuffer * frame, const FrameDamageRect * damageRects, const FrameBuffer * frame, const FrameDamageRect * damageRects,
int damageRectsCount) int damageRectsCount)
{ {
@ -112,7 +112,7 @@ bool egl_texture_update_from_frame(EGL_Texture * texture,
return texture->ops->update(texture, &update); return texture->ops->update(texture, &update);
} }
bool egl_texture_update_from_dma(EGL_Texture * texture, bool egl_textureUpdateFromDMA(EGL_Texture * texture,
const FrameBuffer * frame, const int dmaFd) const FrameBuffer * frame, const int dmaFd)
{ {
const struct EGL_TexUpdate update = const struct EGL_TexUpdate update =
@ -127,12 +127,12 @@ bool egl_texture_update_from_dma(EGL_Texture * texture,
return texture->ops->update(texture, &update); return texture->ops->update(texture, &update);
} }
enum EGL_TexStatus egl_texture_process(EGL_Texture * texture) enum EGL_TexStatus egl_textureProcess(EGL_Texture * texture)
{ {
return texture->ops->process(texture); return texture->ops->process(texture);
} }
enum EGL_TexStatus egl_texture_bind(EGL_Texture * texture) enum EGL_TexStatus egl_textureBind(EGL_Texture * texture)
{ {
return texture->ops->bind(texture); return texture->ops->bind(texture);
} }

16
client/renderers/EGL/texture.h
View File

@ -127,24 +127,22 @@ typedef struct EGL_TextureOps
} }
EGL_TextureOps; EGL_TextureOps;
bool egl_texture_init(EGL_Texture ** texture, EGLDisplay * display, bool egl_textureInit(EGL_Texture ** texture, EGLDisplay * display,
EGL_TexType type, bool streaming); EGL_TexType type, bool streaming);
void egl_texture_free(EGL_Texture ** tex); void egl_texture_free(EGL_Texture ** tex);
bool egl_texture_setup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt, bool egl_textureSetup(EGL_Texture * texture, enum EGL_PixelFormat pixFmt,
size_t width, size_t height, size_t stride); size_t width, size_t height, size_t stride);
bool egl_texture_update (EGL_Texture * texture, const uint8_t * buffer); bool egl_textureUpdate(EGL_Texture * texture, const uint8_t * buffer);
bool egl_texture_update_from_frame(EGL_Texture * texture, bool egl_textureUpdateFromFrame(EGL_Texture * texture,
const FrameBuffer * frame, const FrameDamageRect * damageRects, const FrameBuffer * frame, const FrameDamageRect * damageRects,
int damageRectsCount); int damageRectsCount);
bool egl_texture_update_from_dma(EGL_Texture * texture, bool egl_textureUpdateFromDMA(EGL_Texture * texture,
const FrameBuffer * frame, const int dmaFd); const FrameBuffer * frame, const int dmaFd);
enum EGL_TexStatus egl_texture_process(EGL_Texture * texture); enum EGL_TexStatus egl_textureProcess(EGL_Texture * texture);
enum EGL_TexStatus egl_texture_bind(EGL_Texture * texture); enum EGL_TexStatus egl_textureBind(EGL_Texture * texture);
int egl_texture_count(EGL_Texture * texture);

62
client/renderers/EGL/texture_buffer.c
View File

@ -31,9 +31,9 @@ extern const EGL_TextureOps EGL_TextureBufferStream;
// internal functions // internal functions
static void eglTexBuffer_cleanup(TextureBuffer * this) static void egl_texBuffer_cleanup(TextureBuffer * this)
{ {
eglTexUtilFreeBuffers(this->buf, this->texCount); egl_texUtilFreeBuffers(this->buf, this->texCount);
if (this->tex[0]) if (this->tex[0])
glDeleteTextures(this->texCount, this->tex); glDeleteTextures(this->texCount, this->tex);
@ -50,7 +50,7 @@ static void eglTexBuffer_cleanup(TextureBuffer * this)
// common functions // common functions
bool eglTexBuffer_init(EGL_Texture ** texture, EGLDisplay * display) bool egl_texBufferInit(EGL_Texture ** texture, EGLDisplay * display)
{ {
TextureBuffer * this; TextureBuffer * this;
if (!*texture) if (!*texture)
@ -71,24 +71,24 @@ bool eglTexBuffer_init(EGL_Texture ** texture, EGLDisplay * display)
return true; return true;
} }
void eglTexBuffer_free(EGL_Texture * texture) void egl_texBufferFree(EGL_Texture * texture)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
eglTexBuffer_cleanup(this); egl_texBuffer_cleanup(this);
LG_LOCK_FREE(this->copyLock); LG_LOCK_FREE(this->copyLock);
if (this->free) if (this->free)
free(this); free(this);
} }
bool eglTexBuffer_setup(EGL_Texture * texture, const EGL_TexSetup * setup) bool egl_texBufferSetup(EGL_Texture * texture, const EGL_TexSetup * setup)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
eglTexBuffer_cleanup(this); egl_texBuffer_cleanup(this);
if (!eglTexUtilGetFormat(setup, &this->format)) if (!egl_texUtilGetFormat(setup, &this->format))
return false; return false;
glGenSamplers(1, &this->sampler); glGenSamplers(1, &this->sampler);
@ -118,7 +118,7 @@ bool eglTexBuffer_setup(EGL_Texture * texture, const EGL_TexSetup * setup)
return true; return true;
} }
static bool eglTexBuffer_update(EGL_Texture * texture, const EGL_TexUpdate * update) static bool egl_texBuffer_update(EGL_Texture * texture, const EGL_TexUpdate * update)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
assert(update->type == EGL_TEXTYPE_BUFFER); assert(update->type == EGL_TEXTYPE_BUFFER);
@ -137,12 +137,12 @@ static bool eglTexBuffer_update(EGL_Texture * texture, const EGL_TexUpdate * upd
return true; return true;
} }
EGL_TexStatus eglTexBuffer_process(EGL_Texture * texture) EGL_TexStatus egl_texBufferProcess(EGL_Texture * texture)
{ {
return EGL_TEX_STATUS_OK; return EGL_TEX_STATUS_OK;
} }
EGL_TexStatus eglTexBuffer_bind(EGL_Texture * texture) EGL_TexStatus egl_texBufferBind(EGL_Texture * texture)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
@ -155,9 +155,9 @@ EGL_TexStatus eglTexBuffer_bind(EGL_Texture * texture)
// streaming functions // streaming functions
bool eglTexBuffer_stream_init(EGL_Texture ** texture, EGLDisplay * display) bool egl_texBufferStreamInit(EGL_Texture ** texture, EGLDisplay * display)
{ {
if (!eglTexBuffer_init(texture, display)) if (!egl_texBufferInit(texture, display))
return false; return false;
TextureBuffer * this = UPCAST(TextureBuffer, *texture); TextureBuffer * this = UPCAST(TextureBuffer, *texture);
@ -167,16 +167,16 @@ bool eglTexBuffer_stream_init(EGL_Texture ** texture, EGLDisplay * display)
return true; return true;
} }
bool eglTexBuffer_stream_setup(EGL_Texture * texture, const EGL_TexSetup * setup) bool egl_texBufferStreamSetup(EGL_Texture * texture, const EGL_TexSetup * setup)
{ {
if (!eglTexBuffer_setup(texture, setup)) if (!egl_texBufferSetup(texture, setup))
return false; return false;
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
return eglTexUtilGenBuffers(&this->format, this->buf, this->texCount); return egl_texUtilGenBuffers(&this->format, this->buf, this->texCount);
} }
static bool eglTexBuffer_stream_update(EGL_Texture * texture, static bool egl_texBufferStreamUpdate(EGL_Texture * texture,
const EGL_TexUpdate * update) const EGL_TexUpdate * update)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
@ -191,7 +191,7 @@ static bool eglTexBuffer_stream_update(EGL_Texture * texture,
return true; return true;
} }
EGL_TexStatus eglTexBuffer_stream_process(EGL_Texture * texture) EGL_TexStatus egl_texBufferStreamProcess(EGL_Texture * texture)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
@ -233,7 +233,7 @@ EGL_TexStatus eglTexBuffer_stream_process(EGL_Texture * texture)
return EGL_TEX_STATUS_OK; return EGL_TEX_STATUS_OK;
} }
EGL_TexStatus eglTexBuffer_stream_bind(EGL_Texture * texture) EGL_TexStatus egl_texBufferStreamBind(EGL_Texture * texture)
{ {
TextureBuffer * this = UPCAST(TextureBuffer, texture); TextureBuffer * this = UPCAST(TextureBuffer, texture);
@ -271,20 +271,20 @@ EGL_TexStatus eglTexBuffer_stream_bind(EGL_Texture * texture)
const EGL_TextureOps EGL_TextureBuffer = const EGL_TextureOps EGL_TextureBuffer =
{ {
.init = eglTexBuffer_init, .init = egl_texBufferInit,
.free = eglTexBuffer_free, .free = egl_texBufferFree,
.setup = eglTexBuffer_setup, .setup = egl_texBufferSetup,
.update = eglTexBuffer_update, .update = egl_texBuffer_update,
.process = eglTexBuffer_process, .process = egl_texBufferProcess,
.bind = eglTexBuffer_bind .bind = egl_texBufferBind
}; };
const EGL_TextureOps EGL_TextureBufferStream = const EGL_TextureOps EGL_TextureBufferStream =
{ {
.init = eglTexBuffer_stream_init, .init = egl_texBufferStreamInit,
.free = eglTexBuffer_free, .free = egl_texBufferFree,
.setup = eglTexBuffer_stream_setup, .setup = egl_texBufferStreamSetup,
.update = eglTexBuffer_stream_update, .update = egl_texBufferStreamUpdate,
.process = eglTexBuffer_stream_process, .process = egl_texBufferStreamProcess,
.bind = eglTexBuffer_stream_bind .bind = egl_texBufferStreamBind
}; };

18
client/renderers/EGL/texture_buffer.h
View File

@ -44,14 +44,14 @@ typedef struct TextureBuffer
} }
TextureBuffer; TextureBuffer;
bool eglTexBuffer_init(EGL_Texture ** texture_, EGLDisplay * display); bool egl_texBufferInit(EGL_Texture ** texture_, EGLDisplay * display);
void eglTexBuffer_free(EGL_Texture * texture_); void egl_texBufferFree(EGL_Texture * texture_);
bool eglTexBuffer_setup(EGL_Texture * texture_, const EGL_TexSetup * setup); bool egl_texBufferSetup(EGL_Texture * texture_, const EGL_TexSetup * setup);
EGL_TexStatus eglTexBuffer_process(EGL_Texture * texture_); EGL_TexStatus egl_texBufferProcess(EGL_Texture * texture_);
EGL_TexStatus eglTexBuffer_bind(EGL_Texture * texture_); EGL_TexStatus egl_texBufferBind(EGL_Texture * texture_);
bool eglTexBuffer_stream_init(EGL_Texture ** texture_, EGLDisplay * display); bool egl_texBufferStreamInit(EGL_Texture ** texture_, EGLDisplay * display);
bool eglTexBuffer_stream_setup(EGL_Texture * texture_, bool egl_texBufferStreamSetup(EGL_Texture * texture_,
const EGL_TexSetup * setup); const EGL_TexSetup * setup);
EGL_TexStatus eglTexBuffer_stream_process(EGL_Texture * texture_); EGL_TexStatus egl_texBufferStreamProcess(EGL_Texture * texture_);
EGL_TexStatus eglTexBuffer_stream_bind(EGL_Texture * texture_); EGL_TexStatus egl_texBufferStreamBind(EGL_Texture * texture_);

36
client/renderers/EGL/texture_dmabuf.c
View File

@ -47,7 +47,7 @@ EGL_TextureOps EGL_TextureDMABUF;
// internal functions // internal functions
static void eglTexDMABUF_cleanup(TexDMABUF * this) static void egl_texDMABUFCleanup(TexDMABUF * this)
{ {
for (size_t i = 0; i < this->imageUsed; ++i) for (size_t i = 0; i < this->imageUsed; ++i)
eglDestroyImage(this->display, this->images[i].image); eglDestroyImage(this->display, this->images[i].image);
@ -57,13 +57,13 @@ static void eglTexDMABUF_cleanup(TexDMABUF * this)
// dmabuf functions // dmabuf functions
static bool eglTexDMABUF_init(EGL_Texture ** texture, EGLDisplay * display) static bool egl_texDMABUFInit(EGL_Texture ** texture, EGLDisplay * display)
{ {
TexDMABUF * this = (TexDMABUF *)calloc(sizeof(*this), 1); TexDMABUF * this = (TexDMABUF *)calloc(sizeof(*this), 1);
*texture = &this->base.base; *texture = &this->base.base;
EGL_Texture * parent = &this->base.base; EGL_Texture * parent = &this->base.base;
if (!eglTexBuffer_init(&parent, display)) if (!egl_texBufferInit(&parent, display))
{ {
free(this); free(this);
*texture = NULL; *texture = NULL;
@ -74,26 +74,26 @@ static bool eglTexDMABUF_init(EGL_Texture ** texture, EGLDisplay * display)
return true; return true;
} }
static void eglTexDMABUF_free(EGL_Texture * texture) static void egl_texDMABUFFree(EGL_Texture * texture)
{ {
TextureBuffer * parent = UPCAST(TextureBuffer, texture); TextureBuffer * parent = UPCAST(TextureBuffer, texture);
TexDMABUF * this = UPCAST(TexDMABUF , parent); TexDMABUF * this = UPCAST(TexDMABUF , parent);
eglTexDMABUF_cleanup(this); egl_texDMABUFCleanup(this);
free(this->images); free(this->images);
eglTexBuffer_free(&parent->base); egl_texBufferFree(&parent->base);
free(this); free(this);
} }
static bool eglTexDMABUF_setup(EGL_Texture * texture, const EGL_TexSetup * setup) static bool egl_texDMABUFSetup(EGL_Texture * texture, const EGL_TexSetup * setup)
{ {
TextureBuffer * parent = UPCAST(TextureBuffer, texture); TextureBuffer * parent = UPCAST(TextureBuffer, texture);
TexDMABUF * this = UPCAST(TexDMABUF , parent); TexDMABUF * this = UPCAST(TexDMABUF , parent);
eglTexDMABUF_cleanup(this); egl_texDMABUFCleanup(this);
if (!eglTexBuffer_setup(&parent->base, setup)) if (!egl_texBufferSetup(&parent->base, setup))
return false; return false;
glBindTexture(GL_TEXTURE_2D, parent->tex[0]); glBindTexture(GL_TEXTURE_2D, parent->tex[0]);
@ -110,7 +110,7 @@ static bool eglTexDMABUF_setup(EGL_Texture * texture, const EGL_TexSetup * setup
return true; return true;
} }
static bool eglTexDMABUF_update(EGL_Texture * texture, static bool egl_texDMABUFUpdate(EGL_Texture * texture,
const EGL_TexUpdate * update) const EGL_TexUpdate * update)
{ {
TextureBuffer * parent = UPCAST(TextureBuffer, texture); TextureBuffer * parent = UPCAST(TextureBuffer, texture);
@ -177,12 +177,12 @@ static bool eglTexDMABUF_update(EGL_Texture * texture,
return true; return true;
} }
static EGL_TexStatus eglTexDMABUF_process(EGL_Texture * texture) static EGL_TexStatus egl_texDMABUFProcess(EGL_Texture * texture)
{ {
return EGL_TEX_STATUS_OK; return EGL_TEX_STATUS_OK;
} }
static EGL_TexStatus eglTexDMABUF_bind(EGL_Texture * texture) static EGL_TexStatus egl_texDMABUFBind(EGL_Texture * texture)
{ {
TextureBuffer * parent = UPCAST(TextureBuffer, texture); TextureBuffer * parent = UPCAST(TextureBuffer, texture);
@ -195,10 +195,10 @@ static EGL_TexStatus eglTexDMABUF_bind(EGL_Texture * texture)
EGL_TextureOps EGL_TextureDMABUF = EGL_TextureOps EGL_TextureDMABUF =
{ {
.init = eglTexDMABUF_init, .init = egl_texDMABUFInit,
.free = eglTexDMABUF_free, .free = egl_texDMABUFFree,
.setup = eglTexDMABUF_setup, .setup = egl_texDMABUFSetup,
.update = eglTexDMABUF_update, .update = egl_texDMABUFUpdate,
.process = eglTexDMABUF_process, .process = egl_texDMABUFProcess,
.bind = eglTexDMABUF_bind .bind = egl_texDMABUFBind
}; };

22
client/renderers/EGL/texture_framebuffer.c
View File

@ -40,13 +40,13 @@ typedef struct TexFB
} }
TexFB; TexFB;
static bool eglTexFB_init(EGL_Texture ** texture, EGLDisplay * display) static bool egl_texFBInit(EGL_Texture ** texture, EGLDisplay * display)
{ {
TexFB * this = calloc(sizeof(*this), 1); TexFB * this = calloc(sizeof(*this), 1);
*texture = &this->base.base; *texture = &this->base.base;
EGL_Texture * parent = &this->base.base; EGL_Texture * parent = &this->base.base;
if (!eglTexBuffer_stream_init(&parent, display)) if (!egl_texBufferStreamInit(&parent, display))
{ {
free(this); free(this);
*texture = NULL; *texture = NULL;
@ -59,16 +59,16 @@ static bool eglTexFB_init(EGL_Texture ** texture, EGLDisplay * display)
return true; return true;
} }
void eglTexFB_free(EGL_Texture * texture) void egl_texFBFree(EGL_Texture * texture)
{ {
TextureBuffer * parent = UPCAST(TextureBuffer, texture); TextureBuffer * parent = UPCAST(TextureBuffer, texture);
TexFB * this = UPCAST(TexFB , parent ); TexFB * this = UPCAST(TexFB , parent );
eglTexBuffer_free(texture); egl_texBufferFree(texture);
free(this); free(this);
} }
static bool eglTexFB_update(EGL_Texture * texture, const EGL_TexUpdate * update) static bool egl_texFBUpdate(EGL_Texture * texture, const EGL_TexUpdate * update)
{ {
TextureBuffer * parent = UPCAST(TextureBuffer, texture); TextureBuffer * parent = UPCAST(TextureBuffer, texture);
TexFB * this = UPCAST(TexFB , parent ); TexFB * this = UPCAST(TexFB , parent );
@ -132,10 +132,10 @@ static bool eglTexFB_update(EGL_Texture * texture, const EGL_TexUpdate * update)
EGL_TextureOps EGL_TextureFrameBuffer = EGL_TextureOps EGL_TextureFrameBuffer =
{ {
.init = eglTexFB_init, .init = egl_texFBInit,
.free = eglTexFB_free, .free = egl_texFBFree,
.setup = eglTexBuffer_stream_setup, .setup = egl_texBufferStreamSetup,
.update = eglTexFB_update, .update = egl_texFBUpdate,
.process = eglTexBuffer_stream_process, .process = egl_texBufferStreamProcess,
.bind = eglTexBuffer_stream_bind .bind = egl_texBufferStreamBind
}; };

14
client/renderers/EGL/texture_util.c
View File

@ -37,7 +37,7 @@
#define DRM_FORMAT_BGRA1010102 fourcc_code('B', 'A', '3', '0') #define DRM_FORMAT_BGRA1010102 fourcc_code('B', 'A', '3', '0')
#define DRM_FORMAT_ABGR16161616F fourcc_code('A', 'B', '4', 'H') #define DRM_FORMAT_ABGR16161616F fourcc_code('A', 'B', '4', 'H')
bool eglTexUtilGetFormat(const EGL_TexSetup * setup, EGL_TexFormat * fmt) bool egl_texUtilGetFormat(const EGL_TexSetup * setup, EGL_TexFormat * fmt)
{ {
switch(setup->pixFmt) switch(setup->pixFmt)
{ {
@ -87,7 +87,7 @@ bool eglTexUtilGetFormat(const EGL_TexSetup * setup, EGL_TexFormat * fmt)
return true; return true;
} }
bool eglTexUtilGenBuffers(const EGL_TexFormat * fmt, EGL_TexBuffer * buffers, bool egl_texUtilGenBuffers(const EGL_TexFormat * fmt, EGL_TexBuffer * buffers,
int count) int count)
{ {
for(int i = 0; i < count; ++i) for(int i = 0; i < count; ++i)
@ -106,14 +106,14 @@ bool eglTexUtilGenBuffers(const EGL_TexFormat * fmt, EGL_TexBuffer * buffers,
GL_MAP_COHERENT_BIT_EXT GL_MAP_COHERENT_BIT_EXT
); );
if (!eglTexUtilMapBuffer(buffer)) if (!egl_texUtilMapBuffer(buffer))
return false; return false;
} }
return true; return true;
} }
void eglTexUtilFreeBuffers(EGL_TexBuffer * buffers, int count) void egl_texUtilFreeBuffers(EGL_TexBuffer * buffers, int count)
{ {
for(int i = 0; i < count; ++i) for(int i = 0; i < count; ++i)
{ {
@ -122,13 +122,13 @@ void eglTexUtilFreeBuffers(EGL_TexBuffer * buffers, int count)
if (!buffer->pbo) if (!buffer->pbo)
continue; continue;
eglTexUtilUnmapBuffer(buffer); egl_texUtilUnmapBuffer(buffer);
glDeleteBuffers(1, &buffer->pbo); glDeleteBuffers(1, &buffer->pbo);
buffer->pbo = 0; buffer->pbo = 0;
} }
} }
bool eglTexUtilMapBuffer(EGL_TexBuffer * buffer) bool egl_texUtilMapBuffer(EGL_TexBuffer * buffer)
{ {
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer->pbo); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer->pbo);
buffer->map = glMapBufferRange( buffer->map = glMapBufferRange(
@ -148,7 +148,7 @@ bool eglTexUtilMapBuffer(EGL_TexBuffer * buffer)
return buffer->map; return buffer->map;
} }
void eglTexUtilUnmapBuffer(EGL_TexBuffer * buffer) void egl_texUtilUnmapBuffer(EGL_TexBuffer * buffer)
{ {
if (!buffer->map) if (!buffer->map)
return; return;

10
client/renderers/EGL/texture_util.h
View File

@ -45,9 +45,9 @@ typedef struct EGL_TexBuffer
} }
EGL_TexBuffer; EGL_TexBuffer;
bool eglTexUtilGetFormat(const EGL_TexSetup * setup, EGL_TexFormat * fmt); bool egl_texUtilGetFormat(const EGL_TexSetup * setup, EGL_TexFormat * fmt);
bool eglTexUtilGenBuffers(const EGL_TexFormat * fmt, EGL_TexBuffer * buffers, bool egl_texUtilGenBuffers(const EGL_TexFormat * fmt, EGL_TexBuffer * buffers,
int count); int count);
void eglTexUtilFreeBuffers(EGL_TexBuffer * buffers, int count); void egl_texUtilFreeBuffers(EGL_TexBuffer * buffers, int count);
bool eglTexUtilMapBuffer(EGL_TexBuffer * buffer); bool egl_texUtilMapBuffer(EGL_TexBuffer * buffer);
void eglTexUtilUnmapBuffer(EGL_TexBuffer * buffer); void egl_texUtilUnmapBuffer(EGL_TexBuffer * buffer);