Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2024-12-26 07:23:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[client] cosmetics

Browse Source
This commit is contained in:
Geoffrey McRae 2017-12-17 20:16:43 +11:00
parent 71c7f30265
commit deee61efa9
2 changed files with 11 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
client/main.c
View File

@ -44,19 +44,19 @@ Place, Suite 330, Boston, MA 02111-1307 USA
struct AppState
{
bool running;
bool started;
bool running;
bool started;
TTF_Font *font;
SDL_Point srcSize;
LG_RendererRect dstRect;
SDL_Point cursor;
bool cursorVisible;
bool haveCursorPos;
float scaleX, scaleY;
TTF_Font * font;
SDL_Point srcSize;
LG_RendererRect dstRect;
SDL_Point cursor;
bool cursorVisible;
bool haveCursorPos;
float scaleX, scaleY;
const LG_Renderer * lgr ;
void * lgrData;
const LG_Renderer * lgr ;
void * lgrData;
SDL_Window * window;
struct KVMFRHeader * shm;

168
client/renderers/basic.c
View File

@ -1,168 +0,0 @@
#include "lg-renderer.h"
#include <stdbool.h>
#include <stdint.h>
#include <SDL2/SDL.h>
#include "debug.h"
#include "memcpySSE.h"
struct LGR_Basic
{
bool initialized;
LG_RendererFormat format;
size_t texSize;
size_t dataWidth;
SDL_Renderer * renderer;
SDL_Texture * texture;
SDL_Rect destRect;
};
const char * lgr_basic_get_name()
{
return "Basic";
}
bool lgr_basic_initialize(void ** opaque, const LG_RendererParams params, const LG_RendererFormat format)
{
// create our local storage
*opaque = malloc(sizeof(struct LGR_Basic));
if (!*opaque)
{
DEBUG_INFO("Failed to allocate %lu bytes", sizeof(struct LGR_Basic));
return false;
}
memset(*opaque, 0, sizeof(struct LGR_Basic));
struct LGR_Basic * this = (struct LGR_Basic *)*opaque;
this->renderer = SDL_CreateRenderer(params.window, -1,
SDL_RENDERER_ACCELERATED |
SDL_RENDERER_PRESENTVSYNC
);
if (!this->renderer)
{
DEBUG_ERROR("Failed to create renderer");
return false;
}
Uint32 sdlFormat;
switch(format.bpp)
{
case 24:
sdlFormat = SDL_PIXELFORMAT_RGB24;
break;
case 32:
sdlFormat = SDL_PIXELFORMAT_ARGB8888;
break;
default:
DEBUG_ERROR("Unsupported bpp");
return false;
}
// calculate the texture size in bytes
this->texSize = format.height * format.pitch;
// create the target texture
this->texture = SDL_CreateTexture(
this->renderer,
sdlFormat,
SDL_TEXTUREACCESS_STREAMING,
format.width,
format.height
);
if (!this->texture)
{
DEBUG_ERROR("SDL_CreateTexture failed");
return false;
}
memcpy(&this->format, &format, sizeof(LG_RendererFormat));
this->dataWidth = this->format.width * (this->format.bpp / 8);
this->initialized = true;
return true;
}
void lgr_basic_deinitialize(void * opaque)
{
struct LGR_Basic * this = (struct LGR_Basic *)opaque;
if (!this)
return;
if (this->texture)
SDL_DestroyTexture(this->texture);
if (this->renderer)
SDL_DestroyRenderer(this->renderer);
free(this);
}
bool lgr_basic_is_compatible(void * opaque, const LG_RendererFormat format)
{
const struct LGR_Basic * this = (struct LGR_Basic *)opaque;
if (!this || !this->initialized)
return false;
return (memcmp(&this->format, &format, sizeof(LG_RendererFormat)) == 0);
}
void lgr_basic_on_resize(void * opaque, const int width, const int height, const LG_RendererRect destRect)
{
struct LGR_Basic * this = (struct LGR_Basic *)opaque;
if (!this || !this->initialized)
return;
this->destRect.x = destRect.x;
this->destRect.y = destRect.y;
this->destRect.w = destRect.w;
this->destRect.h = destRect.h;
}
bool lgr_basic_render(void * opaque, const uint8_t * data, bool resample)
{
struct LGR_Basic * this = (struct LGR_Basic *)opaque;
if (!this || !this->initialized)
return false;
int pitch;
uint8_t * dest;
if (SDL_LockTexture(this->texture, NULL, (void**)&dest, &pitch) != 0)
{
DEBUG_ERROR("Failed to lock the texture for update");
return false;
}
if (pitch == this->format.pitch)
memcpySSE(dest, data, this->texSize);
else
{
for(unsigned int y = 0; y < this->format.height; ++y)
{
memcpySSE(dest, data, this->dataWidth);
dest += pitch;
data += this->format.pitch;
}
}
SDL_UnlockTexture(this->texture);
SDL_RenderCopy(this->renderer, this->texture, NULL, &this->destRect);
SDL_RenderPresent(this->renderer);
return true;
}
const LG_Renderer LGR_Basic =
{
.get_name = lgr_basic_get_name,
.initialize = lgr_basic_initialize,
.deinitialize = lgr_basic_deinitialize,
.is_compatible = lgr_basic_is_compatible,
.on_resize = lgr_basic_on_resize,
.render = lgr_basic_render
};