static void
SDLTest_ScreenShot(SDL_Renderer *renderer)
{
SDL_Rect viewport;
SDL_Surface *surface;
if (!renderer) {
return;
}
SDL_RenderGetViewport(renderer, &viewport);
surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
0x00FF0000, 0x0000FF00, 0x000000FF,
#else
0x000000FF, 0x0000FF00, 0x00FF0000,
#endif
0x00000000);
if (!surface) {
fprintf(stderr, "Couldn't create surface: %s\n", SDL_GetError());
return;
}
if (SDL_RenderReadPixels(renderer, NULL, surface->format->format,
surface->pixels, surface->pitch) < 0) {
fprintf(stderr, "Couldn't read screen: %s\n", SDL_GetError());
return;
}
if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) {
fprintf(stderr, "Couldn't save screenshot.bmp: %s\n", SDL_GetError());
return;
}
}
static void
loop(){
/* Check for events */
while (SDL_PollEvent(&event)) {
SDLTest_CommonEvent(state, &event, &done);
switch(event.type) {
case SDL_MOUSEMOTION:
{
rect.x += event.motion.xrel;
rect.y += event.motion.yrel;
}
break;
}
}
for (i = 0; i < state->num_windows; ++i) {
SDL_Rect viewport;
SDL_Renderer *renderer = state->renderers[i];
if (state->windows[i] == NULL)
continue;
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
/* Wrap the cursor rectangle at the screen edges to keep it visible */
SDL_RenderGetViewport(renderer, &viewport);
if (rect.x < viewport.x) rect.x += viewport.w;
if (rect.y < viewport.y) rect.y += viewport.h;
if (rect.x > viewport.x + viewport.w) rect.x -= viewport.w;
if (rect.y > viewport.y + viewport.h) rect.y -= viewport.h;
DrawRects(renderer, &rect);
SDL_RenderPresent(renderer);
}
}
// Called before the first frame
bool j1Render::Start()
{
LOG("render start");
// back background
SDL_RenderGetViewport(renderer, &viewport);
return true;
}
void
DrawChessBoard(SDL_Renderer * renderer)
{
int row = 0,coloum = 0,x = 0;
SDL_Rect rect, darea;
/* Get the Size of drawing surface */
SDL_RenderGetViewport(renderer, &darea);
for(row; row < 8; row++)
{
coloum = row%2;
x = x + coloum;
for(coloum; coloum < 4+(row%2); coloum++)
{
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
rect.w = darea.w/8;
rect.h = darea.h/8;
rect.x = x * rect.w;
rect.y = row * rect.h;
x = x + 2;
SDL_RenderFillRect(renderer, &rect);
}
x=0;
}
}
void
Draw(DrawState *s)
{
SDL_Rect viewport;
SDL_RenderGetViewport(s->renderer, &viewport);
/* Draw the background */
SDL_RenderCopy(s->renderer, s->background, NULL, NULL);
/* Scale and draw the sprite */
s->sprite_rect.w += s->scale_direction;
s->sprite_rect.h += s->scale_direction;
if (s->scale_direction > 0) {
if (s->sprite_rect.w >= viewport.w || s->sprite_rect.h >= viewport.h) {
s->scale_direction = -1;
}
} else {
if (s->sprite_rect.w <= 1 || s->sprite_rect.h <= 1) {
s->scale_direction = 1;
}
}
s->sprite_rect.x = (viewport.w - s->sprite_rect.w) / 2;
s->sprite_rect.y = (viewport.h - s->sprite_rect.h) / 2;
SDL_RenderCopy(s->renderer, s->sprite, NULL, &s->sprite_rect);
/* Update the screen! */
SDL_RenderPresent(s->renderer);
}
// Called before render is available
bool M_Render::Awake(pugi::xml_node& config)
{
LOG("Create SDL rendering context");
bool ret = true;
// load flags
Uint32 flags = SDL_RENDERER_ACCELERATED;
if (config.child("vsync").attribute("value").as_bool(true) == true)
{
flags |= SDL_RENDERER_PRESENTVSYNC;
LOG("Using vsync");
}
renderer = SDL_CreateRenderer(App->win->window, -1, flags);
if (renderer == NULL)
{
LOG("Could not create the renderer! SDL_Error: %s\n", SDL_GetError());
ret = false;
}
else
{
camera.w = App->win->screen_surface->w;
camera.h = App->win->screen_surface->h;
camera.x = 0;
camera.y = 0;
}
App->console->AddCVar("camera_x", &camera.x);
App->console->AddCVar("camera_y", &camera.y);
SDL_RenderGetViewport(renderer, &viewport);
return ret;
}
/* !!! and an initialized streaming object for srcWidth and srcHeight !!! */
static void setOutputRect(WVStreamingObject* streamObj)
{
StreamRendererPrivate* objPrivate = (StreamRendererPrivate*)streamObj->objPrivate;
/* compute ratios */
int outputWidth;
int outputHeight;
if(objPrivate->userDestRect.w && objPrivate->userDestRect.h){ //user give rect ?
outputWidth = objPrivate->userDestRect.w;
outputHeight = objPrivate->userDestRect.h;
}
else{
/* use renderer target */
SDL_Rect rendererRect;
SDL_RenderGetViewport(objPrivate->targetRenderer, &rendererRect);
outputWidth = rendererRect.w;
outputHeight = rendererRect.h;
}
double vidRatio = (double)streamObj->srcWidth/(double)streamObj->srcHeight;
double outputRatio = (double)outputWidth/(double)outputHeight;
int rem;
if(vidRatio >= outputRatio){
objPrivate->targetRect.w = outputWidth;
vidRatio = (double)outputWidth / vidRatio; //the corresponding height
objPrivate->targetRect.h = (int)vidRatio;
rem = outputHeight - objPrivate->targetRect.h;
rem /= 2;
if(objPrivate->userDestRect.w && objPrivate->userDestRect.h){ //user give rect ?
objPrivate->targetRect.x = objPrivate->userDestRect.x;
objPrivate->targetRect.y = objPrivate->userDestRect.y + rem;
}
else{
objPrivate->targetRect.x = 0;
objPrivate->targetRect.y = rem;
}
}
else{
objPrivate->targetRect.h = outputHeight;
vidRatio *= (double)outputHeight; //the corresponding width
objPrivate->targetRect.w = (int)vidRatio;
rem = outputWidth - objPrivate->targetRect.w;
rem /= 2;
if(objPrivate->userDestRect.w && objPrivate->userDestRect.h){ //user give rect ?
objPrivate->targetRect.y = objPrivate->userDestRect.y;
objPrivate->targetRect.x = objPrivate->userDestRect.x + rem;
}
else{
objPrivate->targetRect.y = 0;
objPrivate->targetRect.x = rem;
}
}
}
void bmx_SDL_RenderGetViewport(SDL_Renderer * renderer, int * x, int * y, int * w, int * h) {
SDL_Rect r;
SDL_RenderGetViewport(renderer, &r);
*x = r.x;
*y = r.y;
*w = r.w;
*h = r.h;
}
// Called before the first frame
bool j1Render::Start()
{
LOG("render start");
// back background
SDL_RenderGetViewport(renderer, &viewport);
//NOTE: My camera cooling, very simple and works, buts ask ric about if this is cheating
SetViewPort({ 0, 0, camera.w, camera.h });
return true;
}
void
DrawLines(SDL_Renderer * renderer)
{
int i;
int x1, y1, x2, y2;
SDL_Rect viewport;
/* Query the sizes */
SDL_RenderGetViewport(renderer, &viewport);
for (i = 0; i < num_objects; ++i) {
/* Cycle the color and alpha, if desired */
if (cycle_color) {
current_color += cycle_direction;
if (current_color < 0) {
current_color = 0;
cycle_direction = -cycle_direction;
}
if (current_color > 255) {
current_color = 255;
cycle_direction = -cycle_direction;
}
}
if (cycle_alpha) {
current_alpha += cycle_direction;
if (current_alpha < 0) {
current_alpha = 0;
cycle_direction = -cycle_direction;
}
if (current_alpha > 255) {
current_alpha = 255;
cycle_direction = -cycle_direction;
}
}
SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
(Uint8) current_color, (Uint8) current_alpha);
if (i == 0) {
SDL_RenderDrawLine(renderer, 0, 0, viewport.w - 1, viewport.h - 1);
SDL_RenderDrawLine(renderer, 0, viewport.h - 1, viewport.w - 1, 0);
SDL_RenderDrawLine(renderer, 0, viewport.h / 2, viewport.w - 1, viewport.h / 2);
SDL_RenderDrawLine(renderer, viewport.w / 2, 0, viewport.w / 2, viewport.h - 1);
} else {
x1 = (rand() % (viewport.w*2)) - viewport.w;
x2 = (rand() % (viewport.w*2)) - viewport.w;
y1 = (rand() % (viewport.h*2)) - viewport.h;
y2 = (rand() % (viewport.h*2)) - viewport.h;
SDL_RenderDrawLine(renderer, x1, y1, x2, y2);
}
}
}
void
DrawRects(SDL_Renderer * renderer)
{
int i;
SDL_Rect rect;
SDL_Rect viewport;
/* Query the sizes */
SDL_RenderGetViewport(renderer, &viewport);
for (i = 0; i < num_objects / 4; ++i) {
/* Cycle the color and alpha, if desired */
if (cycle_color) {
current_color += cycle_direction;
if (current_color < 0) {
current_color = 0;
cycle_direction = -cycle_direction;
}
if (current_color > 255) {
current_color = 255;
cycle_direction = -cycle_direction;
}
}
if (cycle_alpha) {
current_alpha += cycle_direction;
if (current_alpha < 0) {
current_alpha = 0;
cycle_direction = -cycle_direction;
}
if (current_alpha > 255) {
current_alpha = 255;
cycle_direction = -cycle_direction;
}
}
SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
(Uint8) current_color, (Uint8) current_alpha);
rect.w = rand() % (viewport.h / 2);
rect.h = rand() % (viewport.h / 2);
rect.x = (rand() % (viewport.w*2) - viewport.w) - (rect.w / 2);
rect.y = (rand() % (viewport.h*2) - viewport.h) - (rect.h / 2);
SDL_RenderFillRect(renderer, &rect);
}
}
SDL_bool
Draw(DrawState *s)
{
SDL_Rect viewport;
SDL_Texture *target;
SDL_RenderGetViewport(s->renderer, &viewport);
target = SDL_CreateTexture(s->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, viewport.w, viewport.h);
if (!target) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create render target texture: %s\n", SDL_GetError());
return SDL_FALSE;
}
SDL_SetRenderTarget(s->renderer, target);
/* Draw the background */
SDL_RenderCopy(s->renderer, s->background, NULL, NULL);
/* Scale and draw the sprite */
s->sprite_rect.w += s->scale_direction;
s->sprite_rect.h += s->scale_direction;
if (s->scale_direction > 0) {
if (s->sprite_rect.w >= viewport.w || s->sprite_rect.h >= viewport.h) {
s->scale_direction = -1;
}
} else {
if (s->sprite_rect.w <= 1 || s->sprite_rect.h <= 1) {
s->scale_direction = 1;
}
}
s->sprite_rect.x = (viewport.w - s->sprite_rect.w) / 2;
s->sprite_rect.y = (viewport.h - s->sprite_rect.h) / 2;
SDL_RenderCopy(s->renderer, s->sprite, NULL, &s->sprite_rect);
SDL_SetRenderTarget(s->renderer, NULL);
SDL_RenderCopy(s->renderer, target, NULL, NULL);
SDL_DestroyTexture(target);
/* Update the screen! */
SDL_RenderPresent(s->renderer);
return SDL_TRUE;
}
static void save_screenshot(const char *filename) {
if ( TCOD_ctx.renderer == TCOD_RENDERER_SDL ) {
/* This would be a lot easier if image saving could do textures. */
SDL_Rect rect;
SDL_RenderGetViewport(renderer, &rect);
Uint32 format = SDL_GetWindowPixelFormat(window);
SDL_Texture *texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
if (0 != texture) {
if (SDL_SetRenderTarget(renderer, texture)) {
void *pixels;
int pitch, access;
actual_rendering();
SDL_SetRenderTarget(renderer, NULL);
rect.x = rect.y = rect.w = rect.h = 0;
if (-1 != SDL_QueryTexture(texture, &format, &access, &rect.w, &rect.h) &&
-1 != SDL_LockTexture(texture, NULL, &pixels, &pitch)) {
int depth;
Uint32 rmask, gmask, bmask, amask;
if (SDL_TRUE == SDL_PixelFormatEnumToMasks(format, &depth, &rmask, &gmask, &bmask, &amask)) {
SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(pixels, rect.w, rect.h, depth, pitch, rmask, gmask, bmask, amask);
TCOD_sys_save_bitmap((void *)surface,filename);
SDL_FreeSurface(surface);
} else
TCOD_LOG(("TCOD_sys_save_screenshot - failed call to SDL_PixelFormatEnumToMasks"));
SDL_UnlockTexture(texture);
} else
TCOD_LOG(("TCOD_sys_save_screenshot - failed call to SDL_QueryTexture or SDL_LockTexture"));
} else
TCOD_LOG(("TCOD_sys_save_screenshot - failed call to SDL_SetRenderTarget"));
SDL_DestroyTexture(texture);
} else
TCOD_LOG(("TCOD_sys_save_screenshot - failed call to SDL_CreateTexture"));
#ifndef NO_OPENGL
} else {
SDL_Surface *screenshot=(SDL_Surface *)TCOD_opengl_get_screen();
TCOD_sys_save_bitmap((void *)screenshot,filename);
SDL_FreeSurface(screenshot);
#endif
}
}
void
DrawPoints(SDL_Renderer * renderer)
{
int i;
int x, y;
SDL_Rect viewport;
/* Query the sizes */
SDL_RenderGetViewport(renderer, &viewport);
for (i = 0; i < num_objects * 4; ++i) {
/* Cycle the color and alpha, if desired */
if (cycle_color) {
current_color += cycle_direction;
if (current_color < 0) {
current_color = 0;
cycle_direction = -cycle_direction;
}
if (current_color > 255) {
current_color = 255;
cycle_direction = -cycle_direction;
}
}
if (cycle_alpha) {
current_alpha += cycle_direction;
if (current_alpha < 0) {
current_alpha = 0;
cycle_direction = -cycle_direction;
}
if (current_alpha > 255) {
current_alpha = 255;
cycle_direction = -cycle_direction;
}
}
SDL_SetRenderDrawColor(renderer, 255, (Uint8) current_color,
(Uint8) current_color, (Uint8) current_alpha);
x = rand() % viewport.w;
y = rand() % viewport.h;
SDL_RenderDrawPoint(renderer, x, y);
}
}
void
Draw(DrawState *s)
{
SDL_Rect viewport;
SDL_Texture *target;
SDL_Point *center=NULL;
SDL_Point origin = {0,0};
SDL_RenderGetViewport(s->renderer, &viewport);
target = SDL_CreateTexture(s->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, viewport.w, viewport.h);
SDL_SetRenderTarget(s->renderer, target);
/* Draw the background */
SDL_RenderCopy(s->renderer, s->background, NULL, NULL);
/* Scale and draw the sprite */
s->sprite_rect.w += s->scale_direction;
s->sprite_rect.h += s->scale_direction;
if (s->scale_direction > 0) {
center = &origin;
if (s->sprite_rect.w >= viewport.w || s->sprite_rect.h >= viewport.h) {
s->scale_direction = -1;
}
} else {
if (s->sprite_rect.w <= 1 || s->sprite_rect.h <= 1) {
s->scale_direction = 1;
}
}
s->sprite_rect.x = (viewport.w - s->sprite_rect.w) / 2;
s->sprite_rect.y = (viewport.h - s->sprite_rect.h) / 2;
SDL_RenderCopyEx(s->renderer, s->sprite, NULL, &s->sprite_rect, (double)s->sprite_rect.w, center, s->scale_direction);
SDL_SetRenderTarget(s->renderer, NULL);
SDL_RenderCopy(s->renderer, target, NULL, NULL);
SDL_DestroyTexture(target);
/* Update the screen! */
SDL_RenderPresent(s->renderer);
/* SDL_Delay(10); */
}
void SDLFrontend::makeScreenshot (const std::string& filename)
{
assert(_renderer);
SDL_Rect viewport;
int bpp;
Uint32 rmask, gmask, bmask, amask;
SDL_RenderGetViewport(_renderer, &viewport);
SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_RGBA8888, &bpp, &rmask, &gmask, &bmask, &amask);
ScopedPtr<SDL_Surface> surface(SDL_CreateRGBSurface(0, viewport.w, viewport.h, bpp, rmask, gmask, bmask, amask));
if (!surface)
return;
if (SDL_RenderReadPixels(_renderer, nullptr, surface->format->format, surface->pixels, surface->pitch) < 0)
return;
const std::string fullFilename = FS.getAbsoluteWritePath() + filename + "-" + dateutil::getDateString() + ".png";
IMG_SavePNG(surface, fullFilename.c_str());
}
void SaveScreenshot()
{
char Filename[52];
SDL_Rect viewport;
SDL_Surface* surface;
Screenshot::GenerateName( Filename );
if( Filename[0] == '\0' ){
stat("Can not get screenshot name. Too many screenshots in folder");
return;
}
SDL_RenderGetViewport(renderer, &viewport);
surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24,
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
#else
0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
#endif
);
if (!surface)
{
stat("Couldn't create surface: %s\n", SDL_GetError());
return;
}
if ( SDL_RenderReadPixels(renderer, NULL, surface->format->format, surface->pixels, surface->pitch) < 0 )
{
stat("Couldn't read screen: %s\n", SDL_GetError());
return;
}
if( png_save_surface(Filename, surface) < 0 ){
SDL_FreeSurface( surface );
return;
}
SDL_FreeSurface( surface );
return;
}
void interface_resize(struct twinterface *twinterface, int w, int h)
{
#ifdef __ANDROID__
__android_log_print(ANDROID_LOG_DEBUG, "interface.c",
"Asked new twinterfacesize %dx%d.\n", w, h);
#endif
SDL_SetWindowSize(twinterface->window, w, h);
SDL_RenderGetViewport(twinterface->renderer, &twinterface->viewport);
SDL_DestroyTexture(twinterface->texture);
SDL_FreeSurface(twinterface->surface);
/* SDL interprets each pixel as a 32-bit number, so our masks must depend
on the endianness (byte order) of the machine */
Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
twinterface->surface = SDL_CreateRGBSurface(0, twinterface->viewport.w, twinterface->viewport.h, 32,
rmask, gmask, bmask, amask);
twinterface->texture = SDL_CreateTexture(twinterface->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, twinterface->viewport.w, twinterface->viewport.h);
interface_widgets_init(twinterface);
printf("New twinterfacesize is %dx%d.\n", twinterface->viewport.w, twinterface->viewport.h);
#ifdef __ANDROID__
__android_log_print(ANDROID_LOG_DEBUG, "interface.c",
"New twinterfacesize is %dx%d.\n", twinterface->viewport.w, twinterface->viewport.h);
#endif
}
void
DrawLines(SDL_Renderer * renderer)
{
int i;
SDL_Rect viewport;
/* Query the sizes */
SDL_RenderGetViewport(renderer, &viewport);
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
for (i = 0; i < num_lines; ++i) {
if (i == -1) {
SDL_RenderDrawLine(renderer, 0, 0, viewport.w - 1, viewport.h - 1);
SDL_RenderDrawLine(renderer, 0, viewport.h - 1, viewport.w - 1, 0);
SDL_RenderDrawLine(renderer, 0, viewport.h / 2, viewport.w - 1, viewport.h / 2);
SDL_RenderDrawLine(renderer, viewport.w / 2, 0, viewport.w / 2, viewport.h - 1);
} else {
SDL_RenderDrawLine(renderer, lines[i].x, lines[i].y, lines[i].w, lines[i].h);
}
}
}
void
MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
{
int sprite_w, sprite_h;
int i;
SDL_Rect viewport;
SDL_Rect *position, *velocity;
/* Query the sizes */
SDL_RenderGetViewport(renderer, &viewport);
SDL_QueryTexture(sprite, NULL, NULL, &sprite_w, &sprite_h);
/* Draw a gray background */
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
/* Move the sprite, bounce at the wall, and draw */
for (i = 0; i < NUM_SPRITES; ++i) {
position = &positions[i];
velocity = &velocities[i];
position->x += velocity->x;
if ((position->x < 0) || (position->x >= (viewport.w - sprite_w))) {
velocity->x = -velocity->x;
position->x += velocity->x;
}
position->y += velocity->y;
if ((position->y < 0) || (position->y >= (viewport.h - sprite_h))) {
velocity->y = -velocity->y;
position->y += velocity->y;
}
/* Blit the sprite onto the screen */
SDL_RenderCopy(renderer, sprite, NULL, position);
}
/* Update the screen! */
SDL_RenderPresent(renderer);
}
void RenderManagerSDL::refresh()
{
SDL_SetRenderTarget(mRenderer, NULL);
// We have a resizeable window
// Resize renderer if needed
// TODO: We should catch the resize event
SDL_Rect renderRect;
int windowX;
int windowY;
SDL_RenderGetViewport(mRenderer, &renderRect);
SDL_GetWindowSize(mWindow, &windowX, &windowY);
if (renderRect.w != windowX || renderRect.h != windowY)
{
renderRect.w = windowX;
renderRect.h = windowY;
SDL_RenderSetViewport(mRenderer, &renderRect);
}
SDL_RenderCopy(mRenderer, mRenderTarget, NULL, NULL);
SDL_RenderPresent(mRenderer);
SDL_SetRenderTarget(mRenderer, mRenderTarget);
}
static void KWSDL_setClipRect(KW_RenderDriver * driver, const KW_Rect * clip, int force) {
SDL_Renderer * renderer = ((KWSDL *)driver->priv)->renderer;
SDL_Rect viewport, cliprect;
static SDL_RendererInfo info;
static int isopengl = -1;
cliprect.x = clip->x; cliprect.y = clip->y; cliprect.w = clip->w; cliprect.h = clip->h;
if (isopengl < 0) {
SDL_GetRendererInfo(renderer, &info);
isopengl = (strcmp(info.name, "opengl") >= 0) ? 1 : 0;
}
if (isopengl && !force) {
/* fix for SDL buggy opengl scissor test. See SDL bug 2269.
* Not sure about other renderers. */
SDL_RenderGetViewport(renderer, &viewport);
cliprect.x += viewport.x; cliprect.y -= viewport.y;
}
if (KW_IsRectEmpty((*clip)))
SDL_RenderSetClipRect(renderer, NULL);
else
SDL_RenderSetClipRect(renderer, &cliprect);
}
SDL_bool
DrawComposite(DrawState *s)
{
SDL_Rect viewport, R;
SDL_Texture *target;
static SDL_bool blend_tested = SDL_FALSE;
if (!blend_tested) {
SDL_Texture *A, *B;
Uint32 P;
A = SDL_CreateTexture(s->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, 1, 1);
SDL_SetTextureBlendMode(A, SDL_BLENDMODE_BLEND);
B = SDL_CreateTexture(s->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, 1, 1);
SDL_SetTextureBlendMode(B, SDL_BLENDMODE_BLEND);
SDL_SetRenderTarget(s->renderer, A);
SDL_SetRenderDrawColor(s->renderer, 0x00, 0x00, 0x00, 0x80);
SDL_RenderFillRect(s->renderer, NULL);
SDL_SetRenderTarget(s->renderer, B);
SDL_SetRenderDrawColor(s->renderer, 0x00, 0x00, 0x00, 0x00);
SDL_RenderFillRect(s->renderer, NULL);
SDL_RenderCopy(s->renderer, A, NULL, NULL);
SDL_RenderReadPixels(s->renderer, NULL, SDL_PIXELFORMAT_ARGB8888, &P, sizeof(P));
SDL_Log("Blended pixel: 0x%8.8X\n", P);
SDL_DestroyTexture(A);
SDL_DestroyTexture(B);
blend_tested = SDL_TRUE;
}
SDL_RenderGetViewport(s->renderer, &viewport);
target = SDL_CreateTexture(s->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, viewport.w, viewport.h);
SDL_SetTextureBlendMode(target, SDL_BLENDMODE_BLEND);
SDL_SetRenderTarget(s->renderer, target);
/* Draw the background.
This is solid black so when the sprite is copied to it, any per-pixel alpha will be blended through.
*/
SDL_SetRenderDrawColor(s->renderer, 0x00, 0x00, 0x00, 0x00);
SDL_RenderFillRect(s->renderer, NULL);
/* Scale and draw the sprite */
s->sprite_rect.w += s->scale_direction;
s->sprite_rect.h += s->scale_direction;
if (s->scale_direction > 0) {
if (s->sprite_rect.w >= viewport.w || s->sprite_rect.h >= viewport.h) {
s->scale_direction = -1;
}
} else {
if (s->sprite_rect.w <= 1 || s->sprite_rect.h <= 1) {
s->scale_direction = 1;
}
}
s->sprite_rect.x = (viewport.w - s->sprite_rect.w) / 2;
s->sprite_rect.y = (viewport.h - s->sprite_rect.h) / 2;
SDL_RenderCopy(s->renderer, s->sprite, NULL, &s->sprite_rect);
SDL_SetRenderTarget(s->renderer, NULL);
SDL_RenderCopy(s->renderer, s->background, NULL, NULL);
SDL_SetRenderDrawBlendMode(s->renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(s->renderer, 0xff, 0x00, 0x00, 0x80);
R.x = 0;
R.y = 0;
R.w = 100;
R.h = 100;
SDL_RenderFillRect(s->renderer, &R);
SDL_SetRenderDrawBlendMode(s->renderer, SDL_BLENDMODE_NONE);
SDL_RenderCopy(s->renderer, target, NULL, NULL);
SDL_DestroyTexture(target);
/* Update the screen! */
SDL_RenderPresent(s->renderer);
return SDL_TRUE;
}
void Window::getViewPort( lx::Graphics::ImgRect& viewport ) const noexcept
{
SDL_Rect rect;
SDL_RenderGetViewport( m_wimpl->renderer, &rect );
viewport = { { rect.x, rect.y }, rect.w, rect.h };
}
Rect Renderer::getViewport() const {
SDL_Rect rect;
SDL_RenderGetViewport(_renderer, &rect);
return Rect(rect.x, rect.y, rect.w, rect.h);
}
void
MoveSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
{
int i;
SDL_Rect viewport, temp;
SDL_Rect *position, *velocity;
/* Query the sizes */
SDL_RenderGetViewport(renderer, &viewport);
/* Cycle the color and alpha, if desired */
if (cycle_color) {
current_color += cycle_direction;
if (current_color < 0) {
current_color = 0;
cycle_direction = -cycle_direction;
}
if (current_color > 255) {
current_color = 255;
cycle_direction = -cycle_direction;
}
SDL_SetTextureColorMod(sprite, 255, (Uint8) current_color,
(Uint8) current_color);
}
if (cycle_alpha) {
current_alpha += cycle_direction;
if (current_alpha < 0) {
current_alpha = 0;
cycle_direction = -cycle_direction;
}
if (current_alpha > 255) {
current_alpha = 255;
cycle_direction = -cycle_direction;
}
SDL_SetTextureAlphaMod(sprite, (Uint8) current_alpha);
}
/* Draw a gray background */
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
SDL_RenderClear(renderer);
/* Test points */
SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0x00, 0xFF);
SDL_RenderDrawPoint(renderer, 0, 0);
SDL_RenderDrawPoint(renderer, viewport.w-1, 0);
SDL_RenderDrawPoint(renderer, 0, viewport.h-1);
SDL_RenderDrawPoint(renderer, viewport.w-1, viewport.h-1);
/* Test horizontal and vertical lines */
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
SDL_RenderDrawLine(renderer, 1, 0, viewport.w-2, 0);
SDL_RenderDrawLine(renderer, 1, viewport.h-1, viewport.w-2, viewport.h-1);
SDL_RenderDrawLine(renderer, 0, 1, 0, viewport.h-2);
SDL_RenderDrawLine(renderer, viewport.w-1, 1, viewport.w-1, viewport.h-2);
/* Test fill and copy */
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
temp.x = 1;
temp.y = 1;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
temp.x = viewport.w-sprite_w-1;
temp.y = 1;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
temp.x = 1;
temp.y = viewport.h-sprite_h-1;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
temp.x = viewport.w-sprite_w-1;
temp.y = viewport.h-sprite_h-1;
temp.w = sprite_w;
temp.h = sprite_h;
SDL_RenderFillRect(renderer, &temp);
SDL_RenderCopy(renderer, sprite, NULL, &temp);
/* Test diagonal lines */
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
SDL_RenderDrawLine(renderer, sprite_w, sprite_h,
viewport.w-sprite_w-2, viewport.h-sprite_h-2);
SDL_RenderDrawLine(renderer, viewport.w-sprite_w-2, sprite_h,
sprite_w, viewport.h-sprite_h-2);
/* Conditionally move the sprites, bounce at the wall */
if (iterations == -1 || iterations > 0) {
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
velocity = &velocities[i];
position->x += velocity->x;
if ((position->x < 0) || (position->x >= (viewport.w - sprite_w))) {
velocity->x = -velocity->x;
position->x += velocity->x;
}
position->y += velocity->y;
if ((position->y < 0) || (position->y >= (viewport.h - sprite_h))) {
velocity->y = -velocity->y;
position->y += velocity->y;
}
}
/* Countdown sprite-move iterations and disable color changes at iteration end - used for visual tests. */
if (iterations > 0) {
iterations--;
if (iterations == 0) {
cycle_alpha = SDL_FALSE;
cycle_color = SDL_FALSE;
}
}
}
/* Draw sprites */
for (i = 0; i < num_sprites; ++i) {
position = &positions[i];
/* Blit the sprite onto the screen */
SDL_RenderCopy(renderer, sprite, NULL, position);
}
/* Update the screen! */
SDL_RenderPresent(renderer);
}
// Called by Rocket when it wants to render geometry that it does not wish to optimise.
void RocketSDLRenderInterfaceOpenGLES2::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
{
SDL_Texture* sdl_texture = NULL;
if(texture) render_data.glUseProgram(program_texture_id);
else render_data.glUseProgram(program_color_id);
int width, height;
SDL_Rect rvp;
SDL_RenderGetViewport(renderer, &rvp);
GLfloat projection[4][4];
// Prepare an orthographic projection
projection[0][0] = 2.0f / rvp.w;
projection[0][1] = 0.0f;
projection[0][2] = 0.0f;
projection[0][3] = 0.0f;
projection[1][0] = 0.0f;
//if (renderer->target) {
// projection[1][1] = 2.0f / height;
//} else {
projection[1][1] = -2.0f / rvp.h;
//}
projection[1][2] = 0.0f;
projection[1][3] = 0.0f;
projection[2][0] = 0.0f;
projection[2][1] = 0.0f;
projection[2][2] = 0.0f;
projection[2][3] = 0.0f;
projection[3][0] = -1.0f;
//if (renderer->target) {
// projection[3][1] = -1.0f;
//} else {
projection[3][1] = 1.0f;
//}
projection[3][2] = 0.0f;
projection[3][3] = 1.0f;
// Set the projection matrix
if (texture) {
render_data.glUniformMatrix4fv(u_texture_projection, 1, GL_FALSE, (GLfloat *)projection);
render_data.glUniform2f(u_texture_translation, translation.x, translation.y);
}
else {
render_data.glUniformMatrix4fv(u_color_projection, 1, GL_FALSE, (GLfloat *)projection);
render_data.glUniform2f(u_color_translation, translation.x, translation.y);
}
render_data.glEnable(GL_BLEND);
render_data.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
float texw, texh;
unsigned short newIndicies[num_indices];
for (int i = 0; i < num_indices; i++)
{
newIndicies[i] = (unsigned short) indices[i];
}
glVertexAttribPointer(ROCKETGLUE_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(Rocket::Core::Vertex), &vertices[0].position);
glVertexAttribPointer(ROCKETGLUE_ATTRIBUTE_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Rocket::Core::Vertex), &vertices[0].colour);
render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_POSITION);
render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_TEXCOORD);
render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_COLOR);
if(texture) {
sdl_texture = (SDL_Texture *) texture;
SDL_GL_BindTexture(sdl_texture, &texw, &texh);
render_data.glUniform1i(u_texture, 0);
glVertexAttribPointer(ROCKETGLUE_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, sizeof(Rocket::Core::Vertex), &vertices[0].tex_coord);
}
else {
render_data.glActiveTexture(GL_TEXTURE0);
render_data.glDisable(GL_TEXTURE_2D);
render_data.glDisableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_TEXCOORD);
}
render_data.glDrawElements(GL_TRIANGLES, num_indices, GL_UNSIGNED_SHORT, newIndicies);
/* We can disable ROCKETGLUE_ATTRIBUTE_COLOR (2) safely as SDL will reenable the vertex attrib 2 if it is required */
render_data.glDisableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_COLOR);
/* Leave ROCKETGLUE_ATTRIBUTE_POSITION (0) and ROCKETGLUE_ATTRIBUTE_TEXCOORD (1) enabled for compatibility with SDL which
doesn't re enable them when you call RenderCopy/Ex */
if(sdl_texture) SDL_GL_UnbindTexture(sdl_texture);
else render_data.glEnableVertexAttribArray(ROCKETGLUE_ATTRIBUTE_TEXCOORD);
/* Reset blending and draw a fake point just outside the screen to let SDL know that it needs to reset its state in case it wants to render a texture */
render_data.glDisable(GL_BLEND);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
SDL_RenderDrawPoint(renderer, -1, -1);
}
struct twinterface*interface_init()
{
struct twinterface *twinterface;
twinterface = (struct twinterface*) malloc(sizeof(struct twinterface));
twinterface->closeup = 0;
twinterface->overview = 0;
twinterface->btn_play = 0;
twinterface->btn_reset = 0;
twinterface->btn_reverse = 0;
twinterface->btn_deck = 0;
twinterface->btn_touch_mode = 0;
twinterface->label_pitch = 0;
twinterface->fader = 0;
twinterface->redraw = 0;
twinterface->volumeup_pressed = 0;
twinterface->renderedFrames = 0;
twinterface->last_track_length = tracks[0].length;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Initialize SDL */
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_Init fail : %s\n", SDL_GetError());
return twinterface;
}
/* Create window and renderer for given surface */
twinterface->window = SDL_CreateWindow(TITLE, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1280, 747, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if(!twinterface->window)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Window creation fail : %s\n",SDL_GetError());
return twinterface;
}
twinterface->renderer = SDL_CreateRenderer(twinterface->window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if(!twinterface->renderer)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Render creation for surface fail : %s\n",SDL_GetError());
return twinterface;
}
/* Get the Size of drawing surface */
SDL_RenderGetViewport(twinterface->renderer, &twinterface->viewport);
/* SDL interprets each pixel as a 32-bit number, so our masks must depend
on the endianness (byte order) of the machine */
Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
twinterface->surface = SDL_CreateRGBSurface(0, twinterface->viewport.w, twinterface->viewport.h, 32,
rmask, gmask, bmask, amask);
if(!twinterface->surface)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Surface creation fail : %s\n",SDL_GetError());
return twinterface;
}
twinterface->texture = SDL_CreateTexture(twinterface->renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, twinterface->viewport.w, twinterface->viewport.h);
/* Clear the rendering surface with the specified color */
SDL_SetRenderDrawColor(twinterface->renderer, 0x0, 0x0, 0x0, 0);
SDL_RenderClear(twinterface->renderer);
/* Start timer to post ticker events */
twinterface->timer = SDL_AddTimer(REFRESH, ticker, NULL);
/* Show deck 0 */
twinterface->current_deck = 0;
/* Initialize widgets */
interface_widgets_init(twinterface);
return twinterface;
}
void init(void) {
texturesList = createList();
musicList = createList();
fontList = createList();
black.r = 0; black.g = 0; black.b = 0;
white.r = 255; white.g = 255; white.b = 255;
// Initialize SDL2
if( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
fprintf(stderr, "Unable to initialize SDL: %s \n", SDL_GetError());
quit(1);
}
// Display available audio device
int count = SDL_GetNumAudioDevices(0), i;
for (i = 0; i < count; ++i ) {
fprintf(stderr, "Audio device %d: %s\n", i, SDL_GetAudioDeviceName(i, 0));
}
// init sound
int audio_rate = 22050;
Uint16 audio_format = AUDIO_S16SYS;
int nb_audio_channels = 4;
int audio_buffers = 4096;
if(Mix_OpenAudio(audio_rate, audio_format, nb_audio_channels, audio_buffers) != 0) {
fprintf(stderr, "Unable to initialize audio: %s\n", Mix_GetError());
quit(1);
}
// Get desktop information
if (SDL_GetDesktopDisplayMode(0, &displaymode) < 0) {
fprintf(stderr, "Could not get display mode: %s\n", SDL_GetError());
quit(1);
}
viewport.x = 0;
viewport.y = 0;
viewport.w = MIN(displaymode.w, 800);
viewport.h = MIN(displaymode.h, 600);
// Create an application window with the following settings:
window = SDL_CreateWindow(
"Game example", // window title
SDL_WINDOWPOS_UNDEFINED, // initial x destination
SDL_WINDOWPOS_UNDEFINED, // initial y destination
viewport.w, // width, in pixels
viewport.h, // height, in pixels
SDL_WINDOW_SHOWN // flags
);
// Check that the window was successfully made
if(window==NULL){
// In the event that the window could not be made...
fprintf(stderr, "Could not create window: %s\n", SDL_GetError());
quit(1);
}
renderer = SDL_CreateRenderer(window, -1, 0); // SDL_RENDERER_PRESENTVSYNC
if (renderer < 0) {
fprintf(stderr, "Could not create renderer: %s\n", SDL_GetError());
quit(1);
}
SDL_RenderGetViewport(renderer, &viewport);
if (TTF_Init() == -1) {
fprintf(stderr, "Unable to initialize SDL_ttf: %s \n", TTF_GetError());
quit(1);
}
}
