Example #1
0
/**
 * Update statusbar information (leds etc) if/when needed.
 * 
 * May not be called when screen is locked (SDL limitation).
 */
void Statusbar_Update(SDL_Surface *surf)
{
	Uint32 color, currentticks;
	SDL_Rect rect;
	int i;

	if (!(StatusbarHeight && ConfigureParams.Screen.bShowStatusbar)) {
		/* not enabled (anymore), show overlay led instead? */
		if (ConfigureParams.Screen.bShowDriveLed) {
			Statusbar_OverlayDraw(surf);
		}
		return;
	}
	assert(surf);
	/* Statusbar_Init() not called before this? */
	assert(surf->h == ScreenHeight + StatusbarHeight);

	rect = LedRect;
	currentticks = SDL_GetTicks();
	for (i = 0; i < NUM_DEVICE_LEDS; i++) {
		if (Led[i].expire && Led[i].expire < currentticks) {
			Led[i].state = false;
		}
		if (Led[i].state == Led[i].oldstate) {
			continue;
		}
		Led[i].oldstate = Led[i].state;
		if (Led[i].state) {
			color = LedColorOn;
		} else {
			color = LedColorOff;
		}
		rect.x = Led[i].offset;
		SDL_FillRect(surf, &rect, color);
		SDL_UpdateRects(surf, 1, &rect);
		DEBUGPRINT(("LED[%d] = %s\n", i, Led[i].state?"ON":"OFF"));
	}

	Statusbar_ShowMessage(surf, currentticks);

	/* Draw dsp LED */
	if (bOldDspLed) {
		color = DspColorOn;
	} else {
		color = DspColorOff;
	}
	SDL_FillRect(surf, &DspLedRect, color);
	SDL_UpdateRects(surf, 1, &DspLedRect);
	DEBUGPRINT(("DSP LED = ON\n"));

    /* Draw scr2 LED */
    if (bOldSystemLed) {
        color = SysColorOn;
    } else {
        color = SysColorOff;
    }
    SDL_FillRect(surf, &SystemLedRect, color);
    SDL_UpdateRects(surf, 1, &SystemLedRect);
    DEBUGPRINT(("SCR2 LED = ON\n"));
}
Example #2
0
void
black_sdl_flip(game_manager * manager)
{
    /* Dirty_rects holds the new image locations and erase_rects holds the previous frames
     * locations. Both should be updated and then dirty_rects should be copied over to erase_rects,
     * dirty_rects should then be erased.
     */

    SDL_Surface *screen = manager->sdl_driver->screen;

	if(!manager->sdl_driver->full_screen_update)
	{

		SDL_UpdateRects(screen, manager->sdl_driver->dirty_rects_i, manager->sdl_driver->dirty_rects);
		SDL_UpdateRects(screen, manager->sdl_driver->erase_rects_i, manager->sdl_driver->erase_rects);

		erase_rects(manager);

		manager->sdl_driver->dirty_rects_i = 0;
	} else {
        SDL_Flip(screen);
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

		manager->sdl_driver->full_screen_update = 0;
	}
}
Example #3
0
void SystemStub_SDL::updateScreen(uint8 shakeOffset) {
	//SDL_Flip(_screen);
	
	const int mul = _scalers[_scaler].factor;
	if (shakeOffset == 0) {
		for (int i = 0; i < _numBlitRects; ++i) {
			SDL_Rect *br = &_blitRects[i];
			int16 dx = br->x * mul;
			int16 dy = br->y * mul;
			SDL_LockSurface(_sclscreen);
			uint16 *dst = (uint16 *)_sclscreen->pixels + dy * _sclscreen->pitch / 2 + dx;
			const uint16 *src = (uint16 *)_offscreen + (br->y + 1) * _screenW + (br->x + 1);
			(*_scalers[_scaler].proc)(dst, _sclscreen->pitch, src, _screenW, br->w, br->h);
			SDL_UnlockSurface(_sclscreen);
			br->x *= mul;
			br->y *= mul;
			br->w *= mul;
			br->h *= mul;
			SDL_BlitSurface(_sclscreen, br, _screen, br);
		}
		SDL_UpdateRects(_screen, _numBlitRects, _blitRects);
	} else {
		SDL_LockSurface(_sclscreen);
		uint16 w = _screenW;
		uint16 h = _screenH - shakeOffset;
		uint16 *dst = (uint16 *)_sclscreen->pixels;
		const uint16 *src = (uint16 *)_offscreen + _screenW + 1;
		(*_scalers[_scaler].proc)(dst, _sclscreen->pitch, src, _screenW, w, h);
		SDL_UnlockSurface(_sclscreen);

		SDL_Rect bsr, bdr;
		bdr.x = 0;
		bdr.y = 0;
		bdr.w = _screenW * mul;
		bdr.h = shakeOffset * mul;
		SDL_FillRect(_screen, &bdr, _pal[_overscanColor]);

		bsr.x = 0;
		bsr.y = 0;
		bsr.w = _screenW * mul;
		bsr.h = (_screenH - shakeOffset) * mul;
		bdr.x = 0;
		bdr.y = shakeOffset * mul;
		bdr.w = bsr.w;
		bdr.h = bsr.h;
		SDL_BlitSurface(_sclscreen, &bsr, _screen, &bdr);

		bdr.x = 0;
		bdr.y = 0;
		bdr.w = _screenW * mul;
		bdr.h = _screenH * mul;
		SDL_UpdateRects(_screen, 1, &bdr);
	}
	_numBlitRects = 0;
	
}
Example #4
0
void screen_c::flipDirty(void)
{
  SDL_Rect rects[10*13];
  int numrects = 0;

  for (int y = 0; y < 13; y++)
  {
    int rowStart = -1;

    for (int x = 0; x < 21; x++)
    {
      if (isDirty(x, y) && (x < 20))
      {
        if (rowStart == -1)
          rowStart = x;
      }
      else if (rowStart != -1)
      {
        rects[numrects].y = blockY*y;
        rects[numrects].x = blockX*rowStart;

        if (y == 12)
          rects[numrects].h = blockY/2;
        else
          rects[numrects].h = blockY;

        rects[numrects].w = blockX*(x-rowStart);
        numrects++;
        rowStart = -1;
      }
    }
  }
  SDL_UpdateRects(video, numrects, rects);
  animationState = 0;
}
void
MoveSprite(SDL_Surface * screen, SDL_Surface * light)
{
    SDL_Rect updates[2];
    Uint8 alpha;

    /* Erase the sprite if it was visible */
    if (sprite_visible) {
        updates[0] = position;
        SDL_BlitSurface(backing, NULL, screen, &updates[0]);
    } else {
        updates[0].x = 0;
        updates[0].y = 0;
        updates[0].w = 0;
        updates[0].h = 0;
        sprite_visible = 1;
    }

    /* Since the sprite is off the screen, we can do other drawing
       without being overwritten by the saved area behind the sprite.
     */
    if (light != NULL) {
        int x, y;

        SDL_GetMouseState(&x, &y);
        FlashLight(screen, light, x, y);
    }

    /* Move the sprite, bounce at the wall */
    position.x += x_vel;
    if ((position.x < 0) || (position.x >= screen->w)) {
        x_vel = -x_vel;
        position.x += x_vel;
    }
    position.y += y_vel;
    if ((position.y < 0) || (position.y >= screen->h)) {
        y_vel = -y_vel;
        position.y += y_vel;
    }

    /* Update transparency (fade in and out) */
    SDL_GetSurfaceAlphaMod(sprite, &alpha);
    if (((int) alpha + alpha_vel) < 0) {
        alpha_vel = -alpha_vel;
    } else if (((int) alpha + alpha_vel) > 255) {
        alpha_vel = -alpha_vel;
    }
    SDL_SetAlpha(sprite, SDL_SRCALPHA, (Uint8) (alpha + alpha_vel));

    /* Save the area behind the sprite */
    updates[1] = position;
    SDL_BlitSurface(screen, &updates[1], backing, NULL);

    /* Blit the sprite onto the screen */
    updates[1] = position;
    SDL_BlitSurface(sprite, NULL, screen, &updates[1]);

    /* Make it so! */
    SDL_UpdateRects(screen, 2, updates);
}
Example #6
0
/**
 * Initialize SDL
 *
 * @param int rows the number of rows that will be displayed
 * @param int cols the number of columns that will be displayed
 * @param int i the time interval in milliseconds after which the next
 * generation is drawn
 * @param ConwaysGameOfLife *cgol pointer to the object that encapsulates the
 * game's actual logic
 * @param positions_t positions the first generation of cells to be displayed
 *
 * @throws SDLException if SDL coudn't be initialized
 *
 * @see{
 *  game::getWindowSize
 * }
 *
 * TODO: allow the user to draw his own pattern using the mouse at the start
 * A nice feature for this would be to highlight the cell under the and only
 * set it if the user clicks on it
 */
Game::Game(int rows, int cols, unsigned int i, SDL_Color acolor,
           SDL_Color dcolor, ConwaysGameOfLife *cgol, positions_t pos)
        : no_rows(rows), no_columns(cols), interval(i), life(cgol){

    if(SDL_Init(SDL_INIT_VIDEO) < 0){
        throw SDLException("Couldn't initialize SDL!");
    }

    const SDL_VideoInfo* vinfo = SDL_GetVideoInfo();

    unsigned int length = std::min(vinfo->current_w, vinfo->current_h) - 50;
    setCellSideLength(length);

    SDL_Rect size = getWindowSize(length);

    screen = SDL_SetVideoMode(size.w, size.h, vinfo->vfmt->BitsPerPixel, flags);

    if(screen == nullptr){
        throw SDLException("Couldn't set SDL video mode!");
    }

    alive_color = SDL_MapRGB(vinfo->vfmt, acolor.r, acolor.g, acolor.b);
    dead_color = SDL_MapRGB(vinfo->vfmt, dcolor.r, dcolor.g, dcolor.b);

    std::vector<SDL_Rect> rects = setCells(pos, alive_color);

    SDL_UpdateRects(screen, rects.size(), rects.data());

    running = true;
}
Example #7
0
/**
 * Put sprite to screen and immediately update
 * real screen.
 * This version double y co-ordinate and height
 */
void put_sprite2(int x, int y, int breite, int hoehe, pointer sprite)
{
	pointer screen_ptr;
	SDL_Rect pos;
	int row;

	y <<=1;
	screen_ptr = (pointer)screen->pixels + ((y << 8) + (y << 6) + x);

	for (row = 0; row < hoehe; row++)
	{
		memcpy(screen_ptr, sprite, breite);
		screen_ptr+=320;
		memcpy(screen_ptr, sprite, breite);
		screen_ptr+=320;
		sprite += breite;
	}

	pos.x = x;
	pos.y = y;
	pos.w = breite;
	pos.h = hoehe<<1;

	SDL_BlitSurface(screen, &pos, real_screen, &pos);
	SDL_UpdateRects(real_screen, 1, &pos);
}
Example #8
0
/*
  Refresh display at given coordinates.
  Unlike SDL_UpdateRect() this function can eat coords that goes beyond screen
  boundaries.
  "rect" will be modified to represent the area actually refreshed.
*/
void SDLGui_UpdateRect(SDL_Rect *rect)
{
  if (rect->x < 0)
  {
    rect->w += rect->x;
    rect->x = 0;
  }
  if ((rect->x + rect->w) > sdlscrn->w)
    rect->w = (sdlscrn->w - rect->x);

  if (rect->y < 0)
  {
    rect->h += rect->y;
    rect->y = 0;
  }
  if ((rect->y + rect->h) > sdlscrn->h)
    rect->h = (sdlscrn->h - rect->y);

  if ((rect->w > 0) && (rect->h > 0))
  {
#if SDL_VERSION_ATLEAST(2, 0, 0)
    host->video->refreshScreenFromSurface(sdlscrn);
#else
    SDL_UpdateRects(sdlscrn, 1, rect);
#endif
  } else
  {
    rect->x = 0;
    rect->y = 0;
    rect->w = 0;
    rect->h = 0;
  }
}
Example #9
0
File: jpegplay.c Project: emon/emon
static int jpeg_blitimg2screen(SDL_Surface *img,    /* proper name? */
			       SDL_Surface *screen){

	int ret;
	SDL_Rect        dstrect;

	if (SDL_MUSTLOCK(screen)) {
		if (SDL_LockSurface(screen) < 0) {
			ComplainAndExit();
		}
	}
	dstrect.x = 0;
	dstrect.y = 0;
	dstrect.w = img->w;
	dstrect.h = img->h;
	ret=0;
	if (SDL_BlitSurface(img, NULL, screen, &dstrect) < 0) {
		ret=1;
		goto fail;
	}
	SDL_UpdateRects(screen, 1, &dstrect);
	/* screen surface unlock */
 fail:		
	if (SDL_MUSTLOCK(screen)) {
		SDL_UnlockSurface(screen);
	}
	return ret;
}
Example #10
0
void
gameover(struct game *g)
{
	SDL_Rect r;
	struct position *p = g->frontend;
	int pph;			/* points per hour */

#if 0
	if (g->running == false)
		return;
#endif
	pph = g->points * 3600.f / (time(NULL) - g->game_time);

    r.x = p->x + 10;
    r.y = p->y + p->size * PREVIEW_H + 60;
    char endMsg[1024];
    sprintf(endMsg,"GAME OVER\nYour Score: %i\nPress any key/button",g->points,g->lines_cleared,g->level);
    sf_puts(screen, &r, endMsg);
    SDL_UpdateRects(screen, 1, &r);

    r.y += r.h;

    SDL_Event e;
    while (SDL_WaitEvent(&e) && (e.type != SDL_KEYDOWN && e.type != SDL_MOUSEBUTTONDOWN)) {
        SDL_Delay(10);
    }


#if 0	
	g->running = false;
#endif
    restart_game(g);
}
Example #11
0
/**
 * Draw overlay led onto screen surface if any drives are enabled.
 */
static void Statusbar_OverlayDraw(SDL_Surface *surf)
{
	Uint32 currentticks = SDL_GetTicks();
	int i;

	assert(surf);
	for (i = 0; i < NUM_DEVICE_LEDS; i++) {
		if (Led[i].state) {
			if (Led[i].expire && Led[i].expire < currentticks) {
				Led[i].state = false;
				continue;
			}
			Statusbar_OverlayDrawLed(surf, LedColorOn);
			break;
		}
	}
	/* possible state transitions:
	 *   NONE -> DRAWN -> RESTORED -> DRAWN -> RESTORED -> NONE
	 * Other than NONE state needs to be updated on screen
	 */
	switch (bOverlayState) {
	case OVERLAY_RESTORED:
		bOverlayState = OVERLAY_NONE;
	case OVERLAY_DRAWN:
		SDL_UpdateRects(surf, 1, &OverlayLedRect);
		DEBUGPRINT(("Overlay LED = %s\n", bOverlayState==OVERLAY_DRAWN?"ON":"OFF"));
		break;
	case OVERLAY_NONE:
		break;
	}
}
/* Draw a randomly sized and colored box centered about (X,Y) */
void
DrawBox(SDL_Surface * screen, int X, int Y, int width, int height)
{
    static unsigned int seeded = 0;
    SDL_Rect area;
    Uint32 color;
    Uint32 randc;

    /* Seed the random number generator */
    if (seeded == 0) {
        srand((unsigned int)time(NULL));
        seeded = 1;
    }

    /* Get the bounds of the rectangle */
    area.w = (rand() % width);
    area.h = (rand() % height);
    area.x = X - (area.w / 2);
    area.y = Y - (area.h / 2);
    randc = (rand() % NUM_COLORS);

    if (screen->format->BytesPerPixel == 1) {
        color = randc;
    } else {
        color = SDL_MapRGB(screen->format, randc, randc, randc);
    }

    /* Do it! */
    SDL_FillRect(screen, &area, color);
    if (screen->flags & SDL_DOUBLEBUF) {
        SDL_Flip(screen);
    } else {
        SDL_UpdateRects(screen, 1, &area);
    }
}
Example #13
0
/**
**  Realize video memory.
*/
void RealizeVideoMemory()
{
#if defined(USE_OPENGL) || defined(USE_GLES)
	if (UseOpenGL) {
#ifdef USE_GLES_MAEMO
		SDL_GLES_SwapBuffers();
#endif
#ifdef USE_GLES_EGL
		eglSwapBuffers(eglDisplay, eglSurface);
#endif
#if defined(USE_OPENGL) || defined(USE_GLES_NATIVE)
		if (GLShaderPipelineSupported) {
			RenderFramebufferToScreen();
		} else {
			SDL_GL_SwapBuffers();
		}
#endif
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	} else
#endif
	{
		if (NumRects) {
			SDL_UpdateRects(TheScreen, NumRects, Rects);
			NumRects = 0;
		}
	}
	HideCursor();
}
Example #14
0
// generate_clips must be called once before this
bool RectManager::update_rects(SDL_Surface * surf) {

	if (!m_Clips)
		return false;
	
    SDL_UpdateRects(surf, m_Clips->length, &m_Clips->rects);
    return true;
}
Example #15
0
/* Redraw the widget and only the widget */
void GUI_Widget::Redraw(void)
{
  if (status==WIDGET_VISIBLE)
  {
    Display();
    SDL_UpdateRects(screen,1,&area);
  }
}
Example #16
0
void MoveSprites(SDL_Surface *screen, Uint32 background)
{
	int i, nupdates;
	SDL_Rect area, *position, *velocity;

	nupdates = 0;
	/* Erase all the sprites if necessary */
	if ( sprites_visible ) {
		SDL_FillRect(screen, NULL, background);
	}

	/* Move the sprite, bounce at the wall, and draw */
	for ( i=0; i<numsprites; ++i ) {
		position = &positions[i];
		velocity = &velocities[i];
		position->x += velocity->x;
		if ( (position->x < 0) || (position->x >= (screen->w - sprite_w)) ) {
			velocity->x = -velocity->x;
			position->x += velocity->x;
		}
		position->y += velocity->y;
		if ( (position->y < 0) || (position->y >= (screen->h - sprite_w)) ) {
			velocity->y = -velocity->y;
			position->y += velocity->y;
		}

		/* Blit the sprite onto the screen */
		area = *position;
		SDL_BlitSurface(sprite, NULL, screen, &area);
		sprite_rects[nupdates++] = area;
	}

#if DEBUG_FLIP
    {
	if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
            static int t = 0;

            Uint32 color = SDL_MapRGB (screen->format, 255, 0, 0);
            SDL_Rect r;
            r.x = (sin((float)t * 2 * 3.1459) + 1.0) / 2.0 * (screen->w-20);
            r.y = 0;
            r.w = 20;
            r.h = screen->h;
        
            SDL_FillRect (screen, &r, color);
            t+=2;
        }
    }
#endif
    
	/* Update the screen! */
	if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) {
		SDL_Flip(screen);
	} else {
		SDL_UpdateRects(screen, nupdates, sprite_rects);
	}
	sprites_visible = 1;
}
void CWidgetDisplay::PaintAllWidgets(CPaintingParms* pPaintingParms, CScreenEngine* pEngine)
{
   for (int iWidget = 0; iWidget < m_pWidgetManager->GetNumWidgets(); iWidget++)
   {
      m_pWidgetManager->GetWidget(iWidget)->PaintWidget(pPaintingParms, pEngine);
   }
   SDL_UpdateRects(pPaintingParms->m_pDrawingSurface, pPaintingParms->m_aRectsToUpdate);
   pPaintingParms->m_aRectsToUpdate.clear();
}
Example #18
0
void
sdl_swap_buffers()
{
	if (dirty_rect_counter > MAX_DIRTY_RECTS) {
		SDL_UpdateRect(screen.surf, 0, 0, 0, 0);
	} else if (dirty_rect_counter > 0) {
		SDL_UpdateRects(screen.surf, dirty_rect_counter, dirty_rects);
	}
	dirty_rect_counter = 0;
}
Example #19
0
HOOKFUNC void SDLCALL MySDL_UpdateRects(SDL_Surface* screen, int numrects, SDL_Rect* rects)
{
    debuglog(LCF_SDL|LCF_FRAME, __FUNCTION__ "(0x%X, %d, 0x%X) called.\n", screen, numrects, rects);
    usingSDLOrDD = true;
    if(!ShouldSkipDrawing(true, true))
        SDL_UpdateRects(screen, numrects, rects);
    // used_sdl_flip check needed for eversion, not needed for ?
    if(!used_sdl_flip)
        SDLFrameBoundary(screen);
}
Example #20
0
void clean()
{
	int i;
	if (gameflags.isfullscreen)
	{
		for( i = 0; i < laundrycount; i++)
		{ // fix -- sucks to have to do a loop here, but not
		  // easy to avoid.
			laundrylist[i].x += (FULLWIDTH - WIDTH) / 2;
			laundrylist[i].y += FULLTOPMARGIN;
		}
		SDL_UpdateRects(fullscreen, laundrycount, laundrylist);		
	}
	else
	{
		SDL_UpdateRects(screen, laundrycount, laundrylist);
	}
	laundrycount=0;
}
/*
** Thread who manage the SDL event [update map]
*/
int		movement_map(void *param)
{
  t_sdl		*sdl;

  sdl = (t_sdl *)param;
  while (42)
    {
      print_init_map(sdl);
      put_items_map(sdl);
      put_users(sdl);
      put_menu_minimap_sdl(sdl);
      SDL_UpdateRects(sdl->screen, 1, &sdl->game.pos_player);
      SDL_UpdateRects(sdl->screen, 1, &sdl->game.pos_item);
      event_radar(sdl);
      SDL_UpdateRect(sdl->screen, 0, 0, 0, 0);
      SDL_Delay(15);
    }
  return (0);
}
Example #22
0
int FbSdl::update(int x, int y, int w, int h, bool /*full*/)
{
    clc::Log::debug("ocher.sdl", "update");
    SDL_Rect dest;
    dest.x = x;
    dest.y = y;
    dest.w = w;
    dest.h = h;
    SDL_UpdateRects(m_screen, 1, &dest);
    return 0;
}
Example #23
0
void Font::drawString(SDL_Surface* surf, const string& text, int x, int y)
{
	int width, height;
	TTF_SizeText(font_, text.c_str(), &width, &height);
	SDL_Rect target = { x, y, width, height };
	SDL_Surface* textSurface = TTF_RenderText_Blended(font_, text.c_str(), color_);
	SDL_BlitSurface(textSurface, NULL, surf, &target);
	SDL_FreeSurface(textSurface);

	SDL_UpdateRects(surf, 1, &target);
}
Example #24
0
File: gui.c Project: v3n/audiality2
void gui_refresh(void)
{
	if(dirtyrects < 0)
	{
		SDL_UpdateRect(screen, 0, 0, 0, 0);
		dirtyrects = 0;
	}
	else
		SDL_UpdateRects(screen, dirtyrects, dirtytab);
	dirtyrects = 0;
}
Example #25
0
void UpdateScreen(void)
{
	int i;

	for ( i=0; i<numupdates; ++i ) {
		SDL_LowerBlit(blits[i].src, blits[i].srcrect,
						screen, blits[i].dstrect);
	}
	SDL_UpdateRects(screen, numupdates, dstupdate);
	numupdates = 0;
}
Example #26
0
/**
 * Draw 'msg' centered to the message area
 */
static void Statusbar_DrawMessage(SDL_Surface *surf, const char *msg)
{
	int fontw, fonth, offset;
	SDL_FillRect(surf, &MessageRect, GrayBg);
	if (*msg) {
		SDLGui_GetFontSize(&fontw, &fonth);
		offset = (MessageRect.w - strlen(msg) * fontw) / 2;
		SDLGui_Text(MessageRect.x + offset, MessageRect.y, msg);
	}
	SDL_UpdateRects(surf, 1, &MessageRect);
	DEBUGPRINT(("Draw message: '%s'\n", msg));
}
Example #27
0
void sdl_draw_mandelbrot(SDL_Surface *surface, complex double center, double zoom)
{
    int f,x,y,n;
    int maxiter = (WIDTH/2) * 0.049715909 * log10(zoom);
    complex double z, c;
    float C;

    static SDL_Rect rects[HEIGHT/FLIPS];

    fprintf(stderr, "zoom: %f\n", zoom);
    fprintf(stderr, "center point: %f %+fi\n", creal(center), 
                                              cimag(center) );
    fprintf(stderr, "iterations: %d\n", maxiter);

    for (f = 0; f < FLIPS; f++)
    {
        for  (y = f; y < HEIGHT; y += FLIPS)
        {
            for (x = 0; x < WIDTH; x++)
            {
                /* Get the complex poing on gauss space to be calculate */
                z = c = creal(center) + ((x - (WIDTH/2))/zoom) + 
                    ((cimag(center) + ((y - (HEIGHT/2))/zoom))*_Complex_I);

                #define X creal(z)
                #define Y cimag(z)

                /* Check if point lies within the main cardiod or 
                   in the period-2 buld */
                if ( (pow(X-.25,2) + pow(Y,2))*(pow(X,2) + (X/2) + pow(Y,2) - .1875) < pow(Y,2)/4 ||
                     pow(X+1,2) + pow(Y,2) < .0625 )
                    n = maxiter;
                else
                    /* Applies the actual mandelbrot formula on that point */
                    for (n = 0; n <= maxiter && cabs(z) < BAIL_OUT; n ++)
                        z = cpow(z, 2) + c;

                C = n - log2f(logf(cabs(z)) / M_LN2 );

                /* Paint the pixel calculated depending on the number 
                   of iterations found */
                ((Uint32*)surface->pixels)[(y*surface->w) + x] = (n >= maxiter)? 0 :
                    SDL_MapRGB( surface->format,
                    (1+sin(C*0.27 + 5))*127., (1+cos(C*0.85))*127., (1+sin(C*0.15))*127. );
            }
            rects[y/FLIPS].x = 0;
            rects[y/FLIPS].y = y;
            rects[y/FLIPS].w = WIDTH;
            rects[y/FLIPS].h = 1;
        }
        SDL_UpdateRects(surface, HEIGHT/FLIPS, rects);
    }
}
Example #28
0
void drawInstructions(struct game *g)
{
    SDL_Rect r;
    struct position *p = g->frontend;

    r.x = p->x2;
    r.y = p->y2 + p->size * PREVIEW_H + 60;
    char instMsg[1024];
    sprintf(instMsg,"\nCopypastris\nby Christiaan Janssen\nRemixed from sdltetris (sourceforge)\nBerlin 5h microJam 2012\n\nInstructions:\nMouse:    select on click\nCTRL+X:   cut\nCTRL+C:   copy\nCTRL+V:   paste");
    sf_puts(screen, &r, instMsg);
    SDL_UpdateRects(screen, 1, &r);
}
Example #29
0
static mrb_value mrb_sdl_video_update_rects (mrb_state *mrb, mrb_value self) {
  mrb_value surface = mrb_nil_value();
  mrb_int num;
  mrb_value rects = mrb_nil_value();

  mrb_get_args(mrb, "|o", &surface);
  mrb_get_args(mrb, "|i", &num);
  mrb_get_args(mrb, "|o", &rects);

  SDL_UpdateRects(mrb_value_to_sdl_surface(mrb, surface), num, mrb_value_to_sdl_rect(mrb, rects));
  return mrb_nil_value();
}
Example #30
0
static void DrawSurfaceToScreen()
{
	int n = _num_dirty_rects;
	if (n == 0) return;

	_num_dirty_rects = 0;
	if (n > MAX_DIRTY_RECTS) {
		SDL_CALL SDL_UpdateRect(_sdl_screen, 0, 0, 0, 0);
	} else {
		SDL_CALL SDL_UpdateRects(_sdl_screen, n, _dirty_rects);
	}
}