예제 #1
0
static void
SW_DestroyRenderer(SDL_Renderer * renderer)
{
    SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
    int i;

    if (data) {
        for (i = 0; i < SDL_arraysize(data->texture); ++i) {
            if (data->texture[i]) {
                DestroyTexture(data->renderer, data->texture[i]);
            }
        }
        if (data->surface.format) {
            SDL_SetSurfacePalette(&data->surface, NULL);
            SDL_FreeFormat(data->surface.format);
        }
        if (display->palette) {
            SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged,
                                data);
        }
        if (data->renderer) {
            data->renderer->DestroyRenderer(data->renderer);
        }
        SDL_FreeDirtyRects(&data->dirty);
        SDL_free(data);
    }
    SDL_free(renderer);
}
예제 #2
0
/*
 * Free a surface created by the above function.
 */
void
SDL_FreeSurface(SDL_Surface * surface)
{
    if (surface == NULL) {
        return;
    }
    if (surface->flags & SDL_DONTFREE) {
        return;
    }
    if (--surface->refcount > 0) {
        return;
    }
    while (surface->locked > 0) {
        SDL_UnlockSurface(surface);
    }
    if (surface->flags & SDL_RLEACCEL) {
        SDL_UnRLESurface(surface, 0);
    }
    if (surface->format) {
        SDL_SetSurfacePalette(surface, NULL);
        SDL_FreeFormat(surface->format);
        surface->format = NULL;
    }
    if (surface->map != NULL) {
        SDL_FreeBlitMap(surface->map);
        surface->map = NULL;
    }
    if (!(surface->flags & SDL_PREALLOC)) {
        SDL_free(surface->pixels);
    }
    SDL_free(surface);
}
예제 #3
0
	void SDLFilm::afterSet() {
		if (!texture)
			return; 
		SDL_FreeFormat(pixelFormat);
		pixelFormat = nullptr;
		pixels = nullptr;
		SDL_UnlockTexture(texture);
	}
예제 #4
0
SDL_Surface *
SDL_DisplayFormatAlpha(SDL_Surface * surface)
{
    SDL_PixelFormat *vf;
    SDL_PixelFormat *format;
    SDL_Surface *converted;
    /* default to ARGB8888 */
    Uint32 amask = 0xff000000;
    Uint32 rmask = 0x00ff0000;
    Uint32 gmask = 0x0000ff00;
    Uint32 bmask = 0x000000ff;

    if (!SDL_PublicSurface) {
        SDL_SetError("No video mode has been set");
        return NULL;
    }
    vf = SDL_PublicSurface->format;

    switch (vf->BytesPerPixel) {
    case 2:
        /* For XGY5[56]5, use, AXGY8888, where {X, Y} = {R, B}.
           For anything else (like ARGB4444) it doesn't matter
           since we have no special code for it anyway */
        if ((vf->Rmask == 0x1f) &&
            (vf->Bmask == 0xf800 || vf->Bmask == 0x7c00)) {
            rmask = 0xff;
            bmask = 0xff0000;
        }
        break;

    case 3:
    case 4:
        /* Keep the video format, as long as the high 8 bits are
           unused or alpha */
        if ((vf->Rmask == 0xff) && (vf->Bmask == 0xff0000)) {
            rmask = 0xff;
            bmask = 0xff0000;
        }
        break;

    default:
        /* We have no other optimised formats right now. When/if a new
           optimised alpha format is written, add the converter here */
        break;
    }
    format = SDL_AllocFormat(SDL_MasksToPixelFormatEnum(32, rmask,
                                                            gmask,
                                                            bmask,
                                                            amask));
    if (!format) {
        return NULL;
    }
    converted = SDL_ConvertSurface(surface, format, SDL_RLEACCEL);
    SDL_FreeFormat(format);
    return converted;
}
예제 #5
0
// create a bitmapped font with a drop-shadow.
bool NXFont::InitBitmapCharsShadowed(SDL_Surface *sheet, uint32_t fgcolor, \
									uint32_t color, uint32_t shadowcolor)
{
Uint32 format = screen->Format()->format;
NXFont fgfont, shadowfont;
SDL_Rect dstrect;



	// create temporary fonts in the fg and shadow color
	if (fgfont.InitBitmapChars(sheet, fgcolor, color))
		return 1;
	
	if (shadowfont.InitBitmapChars(sheet, fgcolor, shadowcolor))
		return 1;

	SDL_PixelFormat* pxformat = SDL_AllocFormat(format);
	if (!pxformat)
	{
		staterr("InitBitmapChars: SDL_AllocFormat failed: %s", SDL_GetError());
		return 1;
	}
	
	// now combine the two fonts
	uint32_t transp = SDL_MapRGB(pxformat, 0, 0, 0);
	for(int i=0;i<NUM_FONT_LETTERS;i++)
	{
		if (fgfont.letters[i])
		{
			letters[i] = SDL_CreateRGBSurface(0, \
							BITMAP_CHAR_WIDTH+1, BITMAP_CHAR_HEIGHT+1+SHADOW_OFFSET,
							pxformat->BitsPerPixel, \
							pxformat->Rmask, pxformat->Gmask,
							pxformat->Bmask, pxformat->Amask);
			
			SDL_FillRect(letters[i], NULL, transp);
			SDL_SetColorKey(letters[i], SDL_TRUE, transp);
			
			dstrect.x = 0;
			dstrect.y = SHADOW_OFFSET;
			SDL_BlitSurface(shadowfont.letters[i], NULL, letters[i], &dstrect);
			
			dstrect.x = 0;
			dstrect.y = 0;
			SDL_BlitSurface(fgfont.letters[i], NULL, letters[i], &dstrect);
		}
	}

	SDL_FreeFormat(pxformat);
	
	return 0;
}
Graphics::Texture* ResourceManager::texture(const string& filename)
{
    if (_textures.count(filename))
    {
        return _textures.at(filename).get();
    }

    string ext = filename.substr(filename.length() - 4);

    Graphics::Texture* texture = nullptr;

    if (ext == ".png")
    {
        // @fixme: this section looks quite ugly. we should try to do something with it someday
        SDL_Surface* tempSurface = IMG_Load(string(CrossPlatform::findFalltergeistDataPath() + "/" +filename).c_str());
        if (tempSurface == NULL)
        {
            throw Exception("ResourceManager::texture(name) - cannot load texture from file " + filename + ": " + IMG_GetError());
        }

        SDL_PixelFormat* pixelFormat = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA8888);
        SDL_Surface* tempSurface2 = SDL_ConvertSurface(tempSurface, pixelFormat, 0);
        texture = new Graphics::Texture(tempSurface2);

        SDL_FreeFormat(pixelFormat);
        SDL_FreeSurface(tempSurface);
        SDL_FreeSurface(tempSurface2);

    }
    else if (ext == ".rix")
    {
        auto rix = rixFileType(filename);
        if (!rix) return nullptr;
        texture = new Graphics::Texture(rix->width(), rix->height());
        texture->loadFromRGBA(rix->rgba());
    }
    else if (ext == ".frm")
    {
        auto frm = frmFileType(filename);
        if (!frm) return nullptr;
        texture = new Graphics::Texture(frm->width(), frm->height());
        texture->loadFromRGBA(frm->rgba(palFileType("color.pal")));
        texture->setMask(*frm->mask(palFileType("color.pal")));
    }
    else
    {
        throw Exception("ResourceManager::surface() - unknown image type:" + filename);
    }

    _textures.insert(make_pair(filename, unique_ptr<Graphics::Texture>(texture)));
    return texture;
}
Uint32 SDLHardwareRenderDevice::MapRGBA(Uint8 r, Uint8 g, Uint8 b, Uint8 a) {
	Uint32 u_format = SDL_GetWindowPixelFormat(window);
	SDL_PixelFormat* format = SDL_AllocFormat(u_format);

	if (format) {
		Uint32 ret = SDL_MapRGBA(format, r, g, b, a);
		SDL_FreeFormat(format);
		return ret;
	}
	else {
		return 0;
	}
}
예제 #8
0
SDL_Surface *
SDL_ConvertSurfaceFormat(SDL_Surface * surface, Uint32 pixel_format,
                         Uint32 flags)
{
    SDL_PixelFormat *fmt;
    SDL_Surface *convert = NULL;

    fmt = SDL_AllocFormat(pixel_format);
    if (fmt) {
        convert = SDL_ConvertSurface(surface, fmt, flags);
        SDL_FreeFormat(fmt);
    }
    return convert;
}
예제 #9
0
파일: grafx.c 프로젝트: cxong/cdogs-sdl
void GraphicsTerminate(GraphicsDevice *g)
{
    debug(D_NORMAL, "Shutting down video...\n");
    CArrayTerminate(&g->validModes);
    SDL_FreeSurface(g->icon);
    SDL_DestroyTexture(g->screen);
    SDL_DestroyTexture(g->bkg);
    SDL_DestroyTexture(g->brightnessOverlay);
    SDL_DestroyRenderer(g->renderer);
    SDL_FreeFormat(g->Format);
    SDL_DestroyWindow(g->window);
    SDL_VideoQuit();
    CFREE(g->buf);
}
예제 #10
0
파일: main.c 프로젝트: restonexyz/gel
static SDL_Surface* sload(const char* const path)
{
    SDL_Surface* const bmp = SDL_LoadBMP(path);
    if(bmp == NULL)
    {
        puts(SDL_GetError());
        exit(1);
    }
    SDL_PixelFormat* const allocation = SDL_AllocFormat(SDL_PIXELFORMAT_RGB888);
    SDL_Surface* const converted = SDL_ConvertSurface(bmp, allocation, 0);
    SDL_FreeFormat(allocation);
    SDL_FreeSurface(bmp);
    return converted;
}
예제 #11
0
/**
 * \brief Returns a buffer of the raw pixels of this surface.
 *
 * Pixels returned have the RGBA 32-bit format.
 *
 * \return The pixel buffer.
 */
std::string Surface::get_pixels() const {

  if (!software_destination &&
      Video::is_acceleration_enabled()) {
    // The surface is in GPU.
    return "";  // TODO
  }

  const int num_pixels = get_width() * get_height();
  if (internal_surface == nullptr) {
    // No surface: this may be a color.

    if (internal_color == nullptr) {
      // No color either: fully transparent surface.
      return std::string(num_pixels * 4, (size_t) 0);
    }

    uint8_t r, g, b, a;
    internal_color->get_components(r, g, b, a);
    std::string pixel;
    pixel += r;
    pixel += g;
    pixel += b;
    pixel += a;
    std::ostringstream oss;
    for (int i = 0; i < num_pixels; ++i) {
      oss << pixel;
    }
    return oss.str();
  }

  if (internal_surface->format->format == SDL_PIXELFORMAT_ABGR8888) {
    // No conversion needed.
    const char* buffer = static_cast<const char*>(internal_surface->pixels);
    return std::string(buffer, num_pixels * 4);
  }

  // Convert to RGBA format.
  SDL_PixelFormat* format = SDL_AllocFormat(SDL_PIXELFORMAT_ABGR8888);  // TODO keep this object
  SDL_Surface_UniquePtr converted_surface(SDL_ConvertSurface(
      internal_surface.get(),
      format,
      0
  ));
  SDL_FreeFormat(format);
  Debug::check_assertion(converted_surface != nullptr,
      "Failed to convert pixels to RGBA format");
  const char* buffer = static_cast<const char*>(converted_surface->pixels);
  return std::string(buffer, num_pixels * 4);
}
예제 #12
0
void WinDestroy()
{
    if(joystick) {
        SDL_JoystickClose(joystick);
        joystick = 0;
    }
    if(format)
        SDL_FreeFormat(format);
    format = NULL;
    if(renderer)
        SDL_DestroyRenderer(renderer);
    renderer = NULL;
    if(window)
        SDL_DestroyWindow(window);
    window = NULL;
};
Uint32 SDLHardwareImage::MapRGB(Uint8 r, Uint8 g, Uint8 b) {
	if (!surface) return 0;

	Uint32 u_format;
	SDL_QueryTexture(surface, &u_format, NULL, NULL, NULL);
	SDL_PixelFormat* format = SDL_AllocFormat(u_format);

	if (format) {
		Uint32 ret = SDL_MapRGB(format, r, g, b);
		SDL_FreeFormat(format);
		return ret;
	}
	else {
		return 0;
	}
}
void SDLHardwareRenderDevice::drawPixel(
	int x,
	int y,
	Uint32 color
) {
	Uint32 u_format = SDL_GetWindowPixelFormat(window);
	SDL_PixelFormat* format = SDL_AllocFormat(u_format);

	if (!format) return;

	SDL_Color rgba;
	SDL_GetRGBA(color, format, &rgba.r, &rgba.g, &rgba.b, &rgba.a);
	SDL_FreeFormat(format);

	SDL_SetRenderDrawColor(renderer, rgba.r, rgba.g, rgba.b, rgba.a);
	SDL_RenderDrawPoint(renderer, x, y);
}
void SDLHardwareImage::fillWithColor(Uint32 color) {
	if (!surface) return;

	Uint32 u_format;
	SDL_QueryTexture(surface, &u_format, NULL, NULL, NULL);
	SDL_PixelFormat* format = SDL_AllocFormat(u_format);

	if (!format) return;

	SDL_Color rgba;
	SDL_GetRGBA(color, format, &rgba.r, &rgba.g, &rgba.b, &rgba.a);
	SDL_FreeFormat(format);

	SDL_SetRenderTarget(renderer, surface);
	SDL_SetTextureBlendMode(surface, SDL_BLENDMODE_BLEND);
	SDL_SetRenderDrawColor(renderer, rgba.r, rgba.g , rgba.b, rgba.a);
	SDL_RenderClear(renderer);
	SDL_SetRenderTarget(renderer, NULL);
}
/*
 * Set the pixel at (x, y) to the given value
 */
void SDLHardwareImage::drawPixel(int x, int y, Uint32 pixel) {
	if (!surface) return;

	Uint32 u_format;
	SDL_QueryTexture(surface, &u_format, NULL, NULL, NULL);
	SDL_PixelFormat* format = SDL_AllocFormat(u_format);

	if (!format) return;

	SDL_Color rgba;
	SDL_GetRGBA(pixel, format, &rgba.r, &rgba.g, &rgba.b, &rgba.a);
	SDL_FreeFormat(format);

	SDL_SetRenderTarget(renderer, surface);
	SDL_SetTextureBlendMode(surface, SDL_BLENDMODE_BLEND);
	SDL_SetRenderDrawColor(renderer, rgba.r, rgba.g, rgba.b, rgba.a);
	SDL_RenderDrawPoint(renderer, x, y);
	SDL_SetRenderTarget(renderer, NULL);
}
예제 #17
0
파일: main.cpp 프로젝트: cdettmering/chip8
int main(int argc, char *argv[])
{
    google::InitGoogleLogging(argv[0]);

    // Setup the filename
    if(argc != 2) {
    	printUsage();
    	return 1;
    } else {
        std::string romName = argv[1];
        LOG(INFO) << "Reading rom " << romName;
        std::vector<unsigned char> rom = Chip8::FileUtils::readRom(romName);
        LOG(INFO) << "Rom size = " << rom.size();
        for(unsigned int i = 0; i < rom.size(); i++) {
            if(!Chip8::Memory::instance().write(Chip8::Memory::StartAddress + i, rom.at(i))) {
                LOG(INFO) << "Failed to load rom into " << (int) Chip8::Memory::StartAddress + i;
                std::cout << "Failed to load rom into " << (int) Chip8::Memory::StartAddress + i << std::endl;
                return 1;
            }
        }
        LOG(INFO) << "Loaded rom";
        for(unsigned int i = 0; i < rom.size(); i++) {
            unsigned char data = 0;
            Chip8::Memory::instance().read(Chip8::Memory::StartAddress + i, data);
            LOG(INFO) << (int) data;
        }
    }

    // Setup SDL.
    // Chip8 has a render size of 64x32 
    int upScale = 24;
    int error = SDL_Init(SDL_INIT_VIDEO);
    if(error < 0) {
        LOG(FATAL) << "Failed to init SDL - " << SDL_GetError(); 
    }
    SDL_Window *window = SDL_CreateWindow("Chip8", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Chip8::Video::Width * upScale, Chip8::Video::Height * upScale, SDL_WINDOW_RESIZABLE);
    //SDL_Window *window = SDL_CreateWindow("Chip8", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP);
    if(window == NULL) {
        LOG(FATAL) << "Failed to create window - " << SDL_GetError();
    }
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if(renderer == NULL) {
        LOG(FATAL) << "Failed to create renderer - " << SDL_GetError();
    }
    SDL_RenderSetScale(renderer, upScale, upScale);
    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, 0); 
    error = SDL_RenderSetLogicalSize(renderer, Chip8::Video::Width, Chip8::Video::Height);
    if(error < 0) {
        LOG(FATAL) << "Failed to set render size - " << SDL_GetError(); 
    }

    // Create the texture that will be drawn to the screen every frame.
    SDL_Texture *texture  = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, Chip8::Video::Width, Chip8::Video::Height);
    if(texture == NULL) {
        LOG(FATAL) << "Failed to create texture - " << SDL_GetError();
    }
    
    // Make sure to set the correct pixel format for the Video module
    SDL_PixelFormat *format = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA8888);
    if(format == NULL) {
        LOG(FATAL) << "Failed to create format - " << SDL_GetError();
    }

    Chip8::Video::instance().setPixelFormat(format);

    // Load fonts into memory
    for(unsigned char  i = 0; i < 0xF + 1; i++) {
        LOG(INFO) << "Getting font sprite " << (int) i;
        const unsigned char *sprite = Chip8::Fonts::getSprite(i);
        for(unsigned char j = 0; j < Chip8::Fonts::SpriteHeight; j++) {
            unsigned int address = 0x0 + (i * Chip8::Fonts::SpriteHeight) + j;
            LOG(INFO) << "Loading font sprite byte " << (int) j << " to memory address " << address;
            if(!Chip8::Memory::instance().write(address, sprite[j])) {
               LOG(INFO) << "Failed to load font sprite " << (int) i << " into memory address " << address;
            }
        } 
    }

    // Jump to start of rom
    Chip8::Cpu::instance().jump(Chip8::Memory::StartAddress);

    SDL_Event event;
    Uint32 lastFrame = SDL_GetTicks();
    Uint32 sixtyFrame = 1000 / 60;
    do {
        Uint32 currentFrame = SDL_GetTicks();
        Uint32 elapsed = currentFrame - lastFrame;
        lastFrame = currentFrame;
        if(elapsed < sixtyFrame) {
            SDL_Delay(sixtyFrame - elapsed);
        }

        // Handle event
        SDL_PollEvent(&event);
        switch(event.type) {
            case SDL_KEYDOWN:
                LOG(INFO) << "Key pressed " << event.key.keysym.scancode;
                if(event.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
                    LOG(INFO) << "Escape pressed exiting now";
                    SDL_FreeFormat(format);
                    SDL_DestroyTexture(texture);
                    SDL_DestroyRenderer(renderer);
                    SDL_DestroyWindow(window);
                    SDL_Quit();
                    return 0;
                } else if(Chip8::InputManager::instance().IsWaitingForKeyPress) {
                    unsigned char hex;
                    Chip8::InputManager::instance().toHex(event.key.keysym.scancode, hex);
                    LOG(INFO) << "InputManager waiting for key press key pressed = " << hex;
                    if(Chip8::InputManager::instance().isValidKey(hex)) {
                        LOG(INFO) << "Valid key detected, setting register " << Chip8::InputManager::instance().KeyPressRegister;
                        Chip8::InputManager::instance().IsWaitingForKeyPress = false;
                        Chip8::Memory::instance().setRegister(Chip8::InputManager::KeyPressRegister, hex);
                    }
                }
                break;
        }

        if(!Chip8::InputManager::instance().IsWaitingForKeyPress) {
            // Cpu step
            Chip8::Cpu::instance().step();
            Chip8::Timers::instance().step();
        }

        // Render screen
        SDL_RenderClear(renderer);
        SDL_UpdateTexture(texture, NULL, Chip8::Video::instance().getPixels(), Chip8::Video::Width * sizeof(Uint32));
        SDL_RenderCopy(renderer, texture, NULL, NULL);
        SDL_RenderPresent(renderer);
    } while(event.type != SDL_QUIT);

    SDL_FreeFormat(format);
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}
예제 #18
0
int main(int argc, char *argv[])
{
	Uint32 *buf = NULL;
	SDL_Texture *t = NULL;
	SDL_PixelFormat *format = NULL;
	SDL_Window *window = NULL;
	SDL_Renderer *renderer = NULL;

	// Init SDL
	if (SDL_Init(SDL_INIT_VIDEO) != 0)
	{
		printf("SDL_Init error: %s\n", SDL_GetError());
		goto bail;
	}

	// Create surface
	buf = malloc(SCREEN_W * SCREEN_H * sizeof(Uint32));
	if (buf == NULL)
	{
		printf("Failed to allocate buffer\n");
		goto bail;
	}

	// Create display window based on image size
	window = SDL_CreateWindow(
		argv[1], SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
		SCREEN_W, SCREEN_H, 0);
	if (window == NULL)
	{
		printf("Failed to create window: %s\n", SDL_GetError());
		goto bail;
	}
	format = SDL_AllocFormat(SDL_GetWindowPixelFormat(window));
	if (format == NULL)
	{
		printf("Failed to alloc pixel format: %s\n", SDL_GetError());
		goto bail;
	}
	renderer = SDL_CreateRenderer(window, -1, 0);
	if (renderer == NULL)
	{
		printf("Failed to create renderer: %s\n", SDL_GetError());
		goto bail;
	}
	SDL_RenderSetLogicalSize(renderer, SCREEN_W, SCREEN_H);

	// Create texture
	t = SDL_CreateTexture(
		renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING,
		SCREEN_W, SCREEN_H);
	if (t == NULL)
	{
		printf("Failed to create screen texture: %s\n", SDL_GetError());
		goto bail;
	}

	// Draw a palette on the buffer
#define MAX(x, y) ((x) > (y) ? (x) : (y))
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#define CLAMP(v, _min, _max) MAX((_min), MIN((_max), (v)))
#define GREY_MARGIN 20
	for (int y = 0; y < SCREEN_H; y++)
	{
		Uint8 v = (Uint8)CLAMP((SCREEN_H - y) * 255.0 / (SCREEN_H / 2), 0, 255);
		double s = CLAMP(y * 1.0 / (SCREEN_H / 2), 0.0, 1.0);
		for (int x = 0; x < SCREEN_W; x++)
		{
			SDL_Color c;
			c.a = 255;
			if (x < SCREEN_W - GREY_MARGIN)
			{
				double h = x * 360.0 / (SCREEN_W - GREY_MARGIN);
				double ff;
				Uint8 p, q, t;
				long i;
				double hh = h;
				if (hh >= 360.0)
				{
					hh = 0.0;
				}
				hh /= 60.0;
				i = (long)hh;
				ff = hh - i;
				p = (Uint8)CLAMP(v * (1.0 - s), 0, 255);
				q = (Uint8)CLAMP(v * (1.0 - (s * ff)), 0, 255);
				t = (Uint8)CLAMP(v * (1.0 - (s * (1.0 - ff))), 0, 255);

				switch (i)
				{
				case 0:
					c.r = v;
					c.g = t;
					c.b = p;
					break;
				case 1:
					c.r = q;
					c.g = v;
					c.b = p;
					break;
				case 2:
					c.r = p;
					c.g = v;
					c.b = t;
					break;

				case 3:
					c.r = p;
					c.g = q;
					c.b = v;
					break;
				case 4:
					c.r = t;
					c.g = p;
					c.b = v;
					break;
				case 5:
				default:
					c.r = v;
					c.g = p;
					c.b = q;
					break;
				}
			}
			else
			{
				c.r = c.g = c.b = (Uint8)CLAMP((SCREEN_H - y) * 255.0 / SCREEN_H, 0, 255);
			}
			Uint32 pixel = SDL_MapRGBA(format, c.r, c.g, c.b, c.a);
			buf[x + y*SCREEN_W] = pixel;
		}
	}

	// Render to texture
	SDL_UpdateTexture(t, NULL, buf, SCREEN_W * sizeof(Uint32));
	if (SDL_RenderClear(renderer) != 0)
	{
		printf("Failed to clear renderer: %s\n", SDL_GetError());
		goto bail;
	}

	// Blit the texture to screen
	if (SDL_RenderCopy(renderer, t, NULL, NULL) != 0)
	{
		printf("Failed to blit surface: %s\n", SDL_GetError());
		goto bail;
	}

	// Display
	SDL_RenderPresent(renderer);

	// Wait for keypress to exit
	bool quit = false;
	while (!quit)
	{
		SDL_Event e;
		while (SDL_PollEvent(&e))
		{
			if (e.type == SDL_KEYDOWN || e.type == SDL_QUIT)
			{
				quit = true;
			}
		}
		SDL_Delay(100);
	}


bail:
	SDL_DestroyTexture(t);
	free(buf);
	SDL_DestroyRenderer(renderer);
	SDL_FreeFormat(format);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}
예제 #19
0
		void destructor(State & state, SDL_PixelFormat * pixelformat){
			SDL_FreeFormat(pixelformat);
		}
예제 #20
0
int
SDL_WM_ToggleFullScreen(SDL_Surface * surface)
{
    int length;
    void *pixels;
    Uint8 *src, *dst;
    int row;
    int window_w;
    int window_h;

    if (!SDL_PublicSurface) {
        SDL_SetError("SDL_SetVideoMode() hasn't been called");
        return 0;
    }

    /* Copy the old bits out */
    length = SDL_PublicSurface->w * SDL_PublicSurface->format->BytesPerPixel;
    pixels = SDL_malloc(SDL_PublicSurface->h * length);
    if (pixels) {
        src = (Uint8*)SDL_PublicSurface->pixels;
        dst = (Uint8*)pixels;
        for (row = 0; row < SDL_PublicSurface->h; ++row) {
            SDL_memcpy(dst, src, length);
            src += SDL_PublicSurface->pitch;
            dst += length;
        }
    }

    /* Do the physical mode switch */
    if (SDL_GetWindowFlags(SDL_VideoWindow) & SDL_WINDOW_FULLSCREEN) {
        if (SDL_SetWindowFullscreen(SDL_VideoWindow, 0) < 0) {
            return 0;
        }
        SDL_PublicSurface->flags &= ~SDL_FULLSCREEN;
    } else {
        if (SDL_SetWindowFullscreen(SDL_VideoWindow, 1) < 0) {
            return 0;
        }
        SDL_PublicSurface->flags |= SDL_FULLSCREEN;
    }

    /* Recreate the screen surface */
    SDL_WindowSurface = SDL_GetWindowSurface(SDL_VideoWindow);
    if (!SDL_WindowSurface) {
        /* We're totally hosed... */
        return 0;
    }

    /* Center the public surface in the window surface */
    SDL_GetWindowSize(SDL_VideoWindow, &window_w, &window_h);
    SDL_VideoViewport.x = (window_w - SDL_VideoSurface->w)/2;
    SDL_VideoViewport.y = (window_h - SDL_VideoSurface->h)/2;
    SDL_VideoViewport.w = SDL_VideoSurface->w;
    SDL_VideoViewport.h = SDL_VideoSurface->h;

    /* Do some shuffling behind the application's back if format changes */
    if (SDL_VideoSurface->format->format != SDL_WindowSurface->format->format) {
        if (SDL_ShadowSurface) {
            if (SDL_ShadowSurface->format->format == SDL_WindowSurface->format->format) {
                /* Whee!  We don't need a shadow surface anymore! */
                SDL_VideoSurface->flags &= ~SDL_DONTFREE;
                SDL_FreeSurface(SDL_VideoSurface);
                SDL_free(SDL_ShadowSurface->pixels);
                SDL_VideoSurface = SDL_ShadowSurface;
                SDL_VideoSurface->flags |= SDL_PREALLOC;
                SDL_ShadowSurface = NULL;
            } else {
                /* No problem, just change the video surface format */
                SDL_FreeFormat(SDL_VideoSurface->format);
                SDL_VideoSurface->format = SDL_WindowSurface->format;
                SDL_VideoSurface->format->refcount++;
                SDL_InvalidateMap(SDL_ShadowSurface->map);
            }
        } else {
            /* We can make the video surface the shadow surface */
            SDL_ShadowSurface = SDL_VideoSurface;
            SDL_ShadowSurface->pitch = SDL_CalculatePitch(SDL_ShadowSurface);
            SDL_ShadowSurface->pixels = SDL_malloc(SDL_ShadowSurface->h * SDL_ShadowSurface->pitch);
            if (!SDL_ShadowSurface->pixels) {
                /* Uh oh, we're hosed */
                SDL_ShadowSurface = NULL;
                return 0;
            }
            SDL_ShadowSurface->flags &= ~SDL_PREALLOC;

            SDL_VideoSurface = SDL_CreateRGBSurfaceFrom(NULL, 0, 0, 32, 0, 0, 0, 0, 0);
            SDL_VideoSurface->flags = SDL_ShadowSurface->flags;
            SDL_VideoSurface->flags |= SDL_PREALLOC;
            SDL_FreeFormat(SDL_VideoSurface->format);
            SDL_VideoSurface->format = SDL_WindowSurface->format;
            SDL_VideoSurface->format->refcount++;
            SDL_VideoSurface->w = SDL_ShadowSurface->w;
            SDL_VideoSurface->h = SDL_ShadowSurface->h;
        }
    }

    /* Update the video surface */
    SDL_VideoSurface->pitch = SDL_WindowSurface->pitch;
    SDL_VideoSurface->pixels = (void *)((Uint8 *)SDL_WindowSurface->pixels +
        SDL_VideoViewport.y * SDL_VideoSurface->pitch +
        SDL_VideoViewport.x  * SDL_VideoSurface->format->BytesPerPixel);
    SDL_SetClipRect(SDL_VideoSurface, NULL);

    /* Copy the old bits back */
    if (pixels) {
        src = (Uint8*)pixels;
        dst = (Uint8*)SDL_PublicSurface->pixels;
        for (row = 0; row < SDL_PublicSurface->h; ++row) {
            SDL_memcpy(dst, src, length);
            src += length;
            dst += SDL_PublicSurface->pitch;
        }
        SDL_Flip(SDL_PublicSurface);
        SDL_free(pixels);
    }

    /* We're done! */
    return 1;
}
예제 #21
0
파일: grafx.c 프로젝트: cxong/cdogs-sdl
void GraphicsInitialize(GraphicsDevice *g)
{
    if (g->IsInitialized && !g->cachedConfig.RestartFlags)
    {
        return;
    }

    if (!g->IsWindowInitialized)
    {
        char buf[CDOGS_PATH_MAX];
        GetDataFilePath(buf, "cdogs_icon.bmp");
        g->icon = IMG_Load(buf);
        AddSupportedGraphicsModes(g);
        g->IsWindowInitialized = true;
    }

    g->IsInitialized = false;

    const int w = g->cachedConfig.Res.x;
    const int h = g->cachedConfig.Res.y;

    const bool initRenderer =
        !!(g->cachedConfig.RestartFlags & RESTART_RESOLUTION);
    const bool initTextures =
        !!(g->cachedConfig.RestartFlags &
           (RESTART_RESOLUTION | RESTART_SCALE_MODE));
    const bool initBrightness =
        !!(g->cachedConfig.RestartFlags &
           (RESTART_RESOLUTION | RESTART_SCALE_MODE | RESTART_BRIGHTNESS));

    if (initRenderer)
    {
        Uint32 sdlFlags = SDL_WINDOW_RESIZABLE;
        if (g->cachedConfig.Fullscreen)
        {
            sdlFlags |= SDL_WINDOW_FULLSCREEN;
        }

        LOG(LM_GFX, LL_INFO, "graphics mode(%dx%d %dx)",
            w, h, g->cachedConfig.ScaleFactor);
        // Get the previous window's size and recreate it
        Vec2i windowSize = Vec2iNew(
                               w * g->cachedConfig.ScaleFactor, h * g->cachedConfig.ScaleFactor);
        if (g->window)
        {
            SDL_GetWindowSize(g->window, &windowSize.x, &windowSize.y);
        }
        LOG(LM_GFX, LL_DEBUG, "destroying previous renderer");
        SDL_DestroyTexture(g->screen);
        SDL_DestroyTexture(g->bkg);
        SDL_DestroyTexture(g->brightnessOverlay);
        SDL_DestroyRenderer(g->renderer);
        SDL_FreeFormat(g->Format);
        SDL_DestroyWindow(g->window);
        LOG(LM_GFX, LL_DEBUG, "creating window %dx%d flags(%X)",
            windowSize.x, windowSize.y, sdlFlags);
        if (SDL_CreateWindowAndRenderer(
                    windowSize.x, windowSize.y, sdlFlags,
                    &g->window, &g->renderer) == -1 ||
                g->window == NULL || g->renderer == NULL)
        {
            LOG(LM_GFX, LL_ERROR, "cannot create window or renderer: %s",
                SDL_GetError());
            return;
        }
        char title[32];
        sprintf(title, "C-Dogs SDL %s%s",
                g->cachedConfig.IsEditor ? "Editor " : "",
                CDOGS_SDL_VERSION);
        LOG(LM_GFX, LL_DEBUG, "setting title(%s) and icon", title);
        SDL_SetWindowTitle(g->window, title);
        SDL_SetWindowIcon(g->window, g->icon);
        g->Format = SDL_AllocFormat(SDL_PIXELFORMAT_ARGB8888);

        if (SDL_RenderSetLogicalSize(g->renderer, w, h) != 0)
        {
            LOG(LM_GFX, LL_ERROR, "cannot set renderer logical size: %s",
                SDL_GetError());
            return;
        }

        GraphicsSetBlitClip(
            g, 0, 0, g->cachedConfig.Res.x - 1, g->cachedConfig.Res.y - 1);
    }

    if (initTextures)
    {
        if (!initRenderer)
        {
            SDL_DestroyTexture(g->screen);
            SDL_DestroyTexture(g->bkg);
            SDL_DestroyTexture(g->brightnessOverlay);
        }

        // Set render scale mode
        const char *renderScaleQuality = "nearest";
        switch ((ScaleMode)ConfigGetEnum(&gConfig, "Graphics.ScaleMode"))
        {
        case SCALE_MODE_NN:
            renderScaleQuality = "nearest";
            break;
        case SCALE_MODE_BILINEAR:
            renderScaleQuality = "linear";
            break;
        default:
            CASSERT(false, "unknown scale mode");
            break;
        }
        LOG(LM_GFX, LL_DEBUG, "setting scale quality %s", renderScaleQuality);
        if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, renderScaleQuality))
        {
            LOG(LM_GFX, LL_WARN, "cannot set render quality hint: %s",
                SDL_GetError());
        }

        g->screen = CreateTexture(
                        g->renderer, SDL_TEXTUREACCESS_STREAMING, Vec2iNew(w, h),
                        SDL_BLENDMODE_BLEND, 255);
        if (g->screen == NULL)
        {
            return;
        }

        CFREE(g->buf);
        CCALLOC(g->buf, GraphicsGetMemSize(&g->cachedConfig));
        g->bkg = CreateTexture(
                     g->renderer, SDL_TEXTUREACCESS_STATIC, Vec2iNew(w, h),
                     SDL_BLENDMODE_NONE, 255);
        if (g->bkg == NULL)
        {
            return;
        }
    }

    if (initBrightness)
    {
        if (!initRenderer && !initTextures)
        {
            SDL_DestroyTexture(g->brightnessOverlay);
        }

        const int brightness = ConfigGetInt(&gConfig, "Graphics.Brightness");
        // Alpha is approximately 50% max
        const Uint8 alpha = (Uint8)(brightness > 0 ? brightness : -brightness) * 13;
        g->brightnessOverlay = CreateTexture(
                                   g->renderer, SDL_TEXTUREACCESS_STATIC, Vec2iNew(w, h),
                                   SDL_BLENDMODE_BLEND, alpha);
        if (g->brightnessOverlay == NULL)
        {
            return;
        }
        const color_t overlayColour = brightness > 0 ? colorWhite : colorBlack;
        DrawRectangle(g, Vec2iZero(), g->cachedConfig.Res, overlayColour, 0);
        SDL_UpdateTexture(
            g->brightnessOverlay, NULL, g->buf,
            g->cachedConfig.Res.x * sizeof(Uint32));
        memset(g->buf, 0, GraphicsGetMemSize(&g->cachedConfig));
        g->cachedConfig.Brightness = brightness;
    }

    g->IsInitialized = true;
    g->cachedConfig.Res.x = w;
    g->cachedConfig.Res.y = h;
    g->cachedConfig.RestartFlags = 0;
}
예제 #22
0
SDL_Surface *
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
{
    SDL_DisplayMode desktop_mode;
    int display = GetVideoDisplay();
    int window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(display);
    int window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(display);
    int window_w;
    int window_h;
    Uint32 window_flags;
    Uint32 surface_flags;

    if (!SDL_GetVideoDevice()) {
        if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) {
            return NULL;
        }
    }

    SDL_GetDesktopDisplayMode(display, &desktop_mode);

    if (width == 0) {
        width = desktop_mode.w;
    }
    if (height == 0) {
        height = desktop_mode.h;
    }
    if (bpp == 0) {
        bpp = SDL_BITSPERPIXEL(desktop_mode.format);
    }

    /* See if we can simply resize the existing window and surface */
    if (SDL_ResizeVideoMode(width, height, bpp, flags) == 0) {
        return SDL_PublicSurface;
    }

    /* Destroy existing window */
    SDL_PublicSurface = NULL;
    if (SDL_ShadowSurface) {
        SDL_ShadowSurface->flags &= ~SDL_DONTFREE;
        SDL_FreeSurface(SDL_ShadowSurface);
        SDL_ShadowSurface = NULL;
    }
    if (SDL_VideoSurface) {
        SDL_VideoSurface->flags &= ~SDL_DONTFREE;
        SDL_FreeSurface(SDL_VideoSurface);
        SDL_VideoSurface = NULL;
    }
    if (SDL_VideoContext) {
        /* SDL_GL_MakeCurrent(0, NULL); *//* Doesn't do anything */
        SDL_GL_DeleteContext(SDL_VideoContext);
        SDL_VideoContext = NULL;
    }
    if (SDL_VideoWindow) {
        SDL_GetWindowPosition(SDL_VideoWindow, &window_x, &window_y);
        SDL_DestroyWindow(SDL_VideoWindow);
    }

    /* Set up the event filter */
    if (!SDL_GetEventFilter(NULL, NULL)) {
        SDL_SetEventFilter(SDL_CompatEventFilter, NULL);
    }

    /* Create a new window */
    window_flags = SDL_WINDOW_SHOWN;
    if (flags & SDL_FULLSCREEN) {
        window_flags |= SDL_WINDOW_FULLSCREEN;
    }
    if (flags & SDL_OPENGL) {
        window_flags |= SDL_WINDOW_OPENGL;
    }
    if (flags & SDL_RESIZABLE) {
        window_flags |= SDL_WINDOW_RESIZABLE;
    }
    if (flags & SDL_NOFRAME) {
        window_flags |= SDL_WINDOW_BORDERLESS;
    }
    GetEnvironmentWindowPosition(width, height, &window_x, &window_y);
    SDL_VideoWindow =
        SDL_CreateWindow(wm_title, window_x, window_y, width, height,
                         window_flags);
    if (!SDL_VideoWindow) {
        return NULL;
    }
    SDL_SetWindowIcon(SDL_VideoWindow, SDL_VideoIcon);

    SetupScreenSaver(flags);

    window_flags = SDL_GetWindowFlags(SDL_VideoWindow);
    surface_flags = 0;
    if (window_flags & SDL_WINDOW_FULLSCREEN) {
        surface_flags |= SDL_FULLSCREEN;
    }
    if ((window_flags & SDL_WINDOW_OPENGL) && (flags & SDL_OPENGL)) {
        surface_flags |= SDL_OPENGL;
    }
    if (window_flags & SDL_WINDOW_RESIZABLE) {
        surface_flags |= SDL_RESIZABLE;
    }
    if (window_flags & SDL_WINDOW_BORDERLESS) {
        surface_flags |= SDL_NOFRAME;
    }

    SDL_VideoFlags = flags;

    /* If we're in OpenGL mode, just create a stub surface and we're done! */
    if (flags & SDL_OPENGL) {
        SDL_VideoContext = SDL_GL_CreateContext(SDL_VideoWindow);
        if (!SDL_VideoContext) {
            return NULL;
        }
        if (SDL_GL_MakeCurrent(SDL_VideoWindow, SDL_VideoContext) < 0) {
            return NULL;
        }
        SDL_VideoSurface =
            SDL_CreateRGBSurfaceFrom(NULL, width, height, bpp, 0, 0, 0, 0, 0);
        if (!SDL_VideoSurface) {
            return NULL;
        }
        SDL_VideoSurface->flags |= surface_flags;
        SDL_PublicSurface = SDL_VideoSurface;
        return SDL_PublicSurface;
    }

    /* Create the screen surface */
    SDL_WindowSurface = SDL_GetWindowSurface(SDL_VideoWindow);
    if (!SDL_WindowSurface) {
        return NULL;
    }

    /* Center the public surface in the window surface */
    SDL_GetWindowSize(SDL_VideoWindow, &window_w, &window_h);
    SDL_VideoViewport.x = (window_w - width)/2;
    SDL_VideoViewport.y = (window_h - height)/2;
    SDL_VideoViewport.w = width;
    SDL_VideoViewport.h = height;

    SDL_VideoSurface = SDL_CreateRGBSurfaceFrom(NULL, 0, 0, 32, 0, 0, 0, 0, 0);
    SDL_VideoSurface->flags |= surface_flags;
    SDL_VideoSurface->flags |= SDL_DONTFREE;
    SDL_FreeFormat(SDL_VideoSurface->format);
    SDL_VideoSurface->format = SDL_WindowSurface->format;
    SDL_VideoSurface->format->refcount++;
    SDL_VideoSurface->w = width;
    SDL_VideoSurface->h = height;
    SDL_VideoSurface->pitch = SDL_WindowSurface->pitch;
    SDL_VideoSurface->pixels = (void *)((Uint8 *)SDL_WindowSurface->pixels +
        SDL_VideoViewport.y * SDL_VideoSurface->pitch +
        SDL_VideoViewport.x  * SDL_VideoSurface->format->BytesPerPixel);
    SDL_SetClipRect(SDL_VideoSurface, NULL);

    /* Create a shadow surface if necessary */
    if ((bpp != SDL_VideoSurface->format->BitsPerPixel)
        && !(flags & SDL_ANYFORMAT)) {
        SDL_ShadowSurface =
            SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0);
        if (!SDL_ShadowSurface) {
            return NULL;
        }
        SDL_ShadowSurface->flags |= surface_flags;
        SDL_ShadowSurface->flags |= SDL_DONTFREE;

        /* 8-bit SDL_ShadowSurface surfaces report that they have exclusive palette */
        if (SDL_ShadowSurface->format->palette) {
            SDL_ShadowSurface->flags |= SDL_HWPALETTE;
            SDL_DitherColors(SDL_ShadowSurface->format->palette->colors,
                             SDL_ShadowSurface->format->BitsPerPixel);
        }
        SDL_FillRect(SDL_ShadowSurface, NULL,
            SDL_MapRGB(SDL_ShadowSurface->format, 0, 0, 0));
    }
    SDL_PublicSurface =
        (SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface);

    ClearVideoSurface();

    /* We're finally done! */
    return SDL_PublicSurface;
}
예제 #23
0
SDL_Texture *
SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
{
    const SDL_PixelFormat *fmt;
    SDL_bool needAlpha;
    Uint32 i;
    Uint32 format;
    SDL_Texture *texture;

    CHECK_RENDERER_MAGIC(renderer, NULL);

    if (!surface) {
        SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
        return NULL;
    }

    /* See what the best texture format is */
    fmt = surface->format;
    if (fmt->Amask || SDL_GetColorKey(surface, NULL) == 0) {
        needAlpha = SDL_TRUE;
    } else {
        needAlpha = SDL_FALSE;
    }
    format = renderer->info.texture_formats[0];
    for (i = 0; i < renderer->info.num_texture_formats; ++i) {
        if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
                SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) {
            format = renderer->info.texture_formats[i];
            break;
        }
    }

    texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,
                                surface->w, surface->h);
    if (!texture) {
        return NULL;
    }

    if (format == surface->format->format) {
        if (SDL_MUSTLOCK(surface)) {
            SDL_LockSurface(surface);
            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
            SDL_UnlockSurface(surface);
        } else {
            SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
        }
    } else {
        SDL_PixelFormat *dst_fmt;
        SDL_Surface *temp = NULL;

        /* Set up a destination surface for the texture update */
        dst_fmt = SDL_AllocFormat(format);
        temp = SDL_ConvertSurface(surface, dst_fmt, 0);
        SDL_FreeFormat(dst_fmt);
        if (temp) {
            SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
            SDL_FreeSurface(temp);
        } else {
            SDL_DestroyTexture(texture);
            return NULL;
        }
    }

    {
        Uint8 r, g, b, a;
        SDL_BlendMode blendMode;

        SDL_GetSurfaceColorMod(surface, &r, &g, &b);
        SDL_SetTextureColorMod(texture, r, g, b);

        SDL_GetSurfaceAlphaMod(surface, &a);
        SDL_SetTextureAlphaMod(texture, a);

        if (SDL_GetColorKey(surface, NULL) == 0) {
            /* We converted to a texture with alpha format */
            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
        } else {
            SDL_GetSurfaceBlendMode(surface, &blendMode);
            SDL_SetTextureBlendMode(texture, blendMode);
        }
    }
    return texture;
}
예제 #24
0
// Create a font from a bitmapped font sheet.
// sheet: a 8bpp (paletted) sheet to create the font from.
// fgindex: color index of foreground color of letters.
// color: the color you want the letters to be.
bool NXFont::InitBitmapChars(SDL_Surface *sheet, uint32_t fgcolor, uint32_t color)
{
Uint32 format = screen->Format()->format;
SDL_Rect srcrect, dstrect;
SDL_Surface *letter;
int x, y, i;

	SDL_PixelFormat* pxformat = SDL_AllocFormat(format);
	if (!pxformat)
	{
		staterr("InitBitmapChars: SDL_AllocFormat failed: %s", SDL_GetError());
		return 1;
	}

	// NULL out letters we don't have a character for
	memset(this->letters, 0, sizeof(this->letters));
	
	// change the color of the letters by messing with the palette on the sheet
	ReplaceColor(sheet, fgcolor, color);
	
	// start at the top of the letter sheet.
	x = 0;
	y = 0;
	for(i=0;bitmap_map[i];i++)
	{
		uint8_t ch = bitmap_map[i];
		//stat("copying letter %d: '%c' from [%d,%d]", i, ch, x, y);
		
		// make character surface one pixel larger than the actual char so that there
		// is some space between letters in autospaced text such as on the menus.
		letter = SDL_CreateRGBSurface(0, \
							BITMAP_CHAR_WIDTH+1, BITMAP_CHAR_HEIGHT+1,
							pxformat->BitsPerPixel, \
							pxformat->Rmask, pxformat->Gmask,
							pxformat->Bmask, pxformat->Amask);
		if (!letter)
		{
			staterr("InitBitmapChars: failed to create surface for character %d/%d", i, ch);
			SDL_FreeFormat(pxformat);
			return 1;
		}
		
		SDL_FillRect(letter, NULL, SDL_MapRGB(pxformat, 0, 0, 0));
		
		// copy letter off of sheet
		srcrect.x = x;
		srcrect.y = y;
		srcrect.w = BITMAP_CHAR_WIDTH;
		srcrect.h = BITMAP_CHAR_HEIGHT;
		
		dstrect.x = 0;
		dstrect.y = 0;
		
		SDL_BlitSurface(sheet, &srcrect, letter, &dstrect);
		
		// make background transparent and copy into final position
		SDL_SetColorKey(letter, SDL_TRUE, SDL_MapRGB(pxformat, 0, 0, 0));

		SDL_PixelFormat * format = screen->Format();
		letters[ch] = SDL_ConvertSurfaceFormat(letter, format->format, 0);
		
		SDL_FreeSurface(letter);
		// letters[ch] = letter;
		
		// advance to next position on sheet
		x += BITMAP_SPAC_WIDTH;
		if (x >= sheet->w)
		{
			x = 0;
			y += BITMAP_SPAC_HEIGHT;
		}
	}

	return 0;
}
예제 #25
0
SDLWindowManager::SDLWindowManager(Application* application):
	WindowManager(application)
{
	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == -1)
	{
		throw RuntimeException("SDL initialization failed.");
	}

	int displayCount = SDL_GetNumVideoDisplays();
	displays.resize(displayCount);
	primaryDisplay = &displays[0];

	for (int i = 0; i < displayCount; ++i)
	{
		Display* display = &displays[i];

		const char* displayName = SDL_GetDisplayName(i);
		if (displayName)
		{
			display->setName(displayName);
		}

		SDL_DisplayMode sdlCurrentDisplayMode;
		SDL_GetCurrentDisplayMode(i, &sdlCurrentDisplayMode);

		int displayModeCount = SDL_GetNumDisplayModes(i);
		for (int j = 0; j < displayModeCount; ++j)
		{
			SDL_DisplayMode sdlDisplayMode;
			SDL_GetDisplayMode(i, j, &sdlDisplayMode);
			
			SDL_PixelFormat* format = SDL_AllocFormat(sdlDisplayMode.format);
			if (!format)
			{
				std::cerr << "Failed to create SDL pixel format: " << SDL_GetPixelFormatName(sdlDisplayMode.format) << '\n';
				continue;
			}

			int width = sdlDisplayMode.w;
			int height = sdlDisplayMode.h;
			int refreshRate = sdlDisplayMode.refresh_rate;
			int redBits, greenBits, blueBits, alphaBits;
			SDLPixelFormatMap::getChannelBits(format, &redBits, &greenBits, &blueBits, &alphaBits);

			SDL_FreeFormat(format);

			display->addMode(
				DisplayMode(width, height, redBits, greenBits, blueBits, alphaBits, refreshRate));

			if (sdlCurrentDisplayMode.w == sdlDisplayMode.w &&
				sdlCurrentDisplayMode.h == sdlDisplayMode.h &&
				sdlCurrentDisplayMode.format == sdlDisplayMode.format &&
				sdlCurrentDisplayMode.refresh_rate == sdlDisplayMode.refresh_rate)
			{
				display->setCurrentMode(j);
			}
		}
	}

	keyboard = new Keyboard("Default Keyboard");
	mouse = new Mouse("Default Mouse");
	
	application->getInputManager()->registerKeyboard(keyboard);
	application->getInputManager()->registerMouse(mouse);
}
예제 #26
0
/* !
 *  Tests surface conversion across all pixel formats.
 */
int
surface_testCompleteSurfaceConversion(void *arg)
{
    Uint32 pixel_formats[] = {
        SDL_PIXELFORMAT_INDEX8,
        SDL_PIXELFORMAT_RGB332,
        SDL_PIXELFORMAT_RGB444,
        SDL_PIXELFORMAT_RGB555,
        SDL_PIXELFORMAT_BGR555,
        SDL_PIXELFORMAT_ARGB4444,
        SDL_PIXELFORMAT_RGBA4444,
        SDL_PIXELFORMAT_ABGR4444,
        SDL_PIXELFORMAT_BGRA4444,
        SDL_PIXELFORMAT_ARGB1555,
        SDL_PIXELFORMAT_RGBA5551,
        SDL_PIXELFORMAT_ABGR1555,
        SDL_PIXELFORMAT_BGRA5551,
        SDL_PIXELFORMAT_RGB565,
        SDL_PIXELFORMAT_BGR565,
        SDL_PIXELFORMAT_RGB24,
        SDL_PIXELFORMAT_BGR24,
        SDL_PIXELFORMAT_RGB888,
        SDL_PIXELFORMAT_RGBX8888,
        SDL_PIXELFORMAT_BGR888,
        SDL_PIXELFORMAT_BGRX8888,
        SDL_PIXELFORMAT_ARGB8888,
        SDL_PIXELFORMAT_RGBA8888,
        SDL_PIXELFORMAT_ABGR8888,
        SDL_PIXELFORMAT_BGRA8888,
        SDL_PIXELFORMAT_ARGB2101010,
    };
    SDL_Surface *face = NULL, *cvt1, *cvt2, *final;
    SDL_PixelFormat *fmt1, *fmt2;
    int i, j, ret = 0;

    /* Create sample surface */
    face = SDLTest_ImageFace();
    SDLTest_AssertCheck(face != NULL, "Verify face surface is not NULL");
    if (face == NULL)
        return TEST_ABORTED;

    /* Set transparent pixel as the pixel at (0,0) */
    if (face->format->palette) {
       ret = SDL_SetColorKey(face, SDL_RLEACCEL, *(Uint8 *) face->pixels);
       SDLTest_AssertPass("Call to SDL_SetColorKey()");
       SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetColorKey, expected: 0, got: %i", ret);
    }

    for ( i = 0; i < SDL_arraysize(pixel_formats); ++i ) {
        for ( j = 0; j < SDL_arraysize(pixel_formats); ++j ) {
            fmt1 = SDL_AllocFormat(pixel_formats[i]);
            SDL_assert(fmt1 != NULL);
            cvt1 = SDL_ConvertSurface(face, fmt1, 0);
            SDL_assert(cvt1 != NULL);

            fmt2 = SDL_AllocFormat(pixel_formats[j]);
            SDL_assert(fmt1 != NULL);
            cvt2 = SDL_ConvertSurface(cvt1, fmt2, 0);
            SDL_assert(cvt2 != NULL);

            if ( fmt1->BytesPerPixel == face->format->BytesPerPixel &&
                 fmt2->BytesPerPixel == face->format->BytesPerPixel &&
                 (fmt1->Amask != 0) == (face->format->Amask != 0) &&
                 (fmt2->Amask != 0) == (face->format->Amask != 0) ) {
                final = SDL_ConvertSurface( cvt2, face->format, 0 );
                SDL_assert(final != NULL);

                /* Compare surface. */
                ret = SDLTest_CompareSurfaces( face, final, 0 );
                SDLTest_AssertCheck(ret == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", ret);
                SDL_FreeSurface(final);
            }

            SDL_FreeSurface(cvt1);
            SDL_FreeFormat(fmt1);
            SDL_FreeSurface(cvt2);
            SDL_FreeFormat(fmt2);
        }
    }
예제 #27
0
U32 SGL_DataSaveImage(const char* name, SDL_Surface * surf)
{
	U32 loc;
	U32 hash;
	SDL_Surface* convSurf;
	if (surf == NULL)
	{
		SDL_Log("SGL_DataSaveImage couldn't save because surf pointer is NULL");
		return SGL_FALSE;
	}
	if (surf->format->format != SDL_PIXELFORMAT_ARGB8888)
	{
		convSurf = surf;
	}
	else if (surf->format->BytesPerPixel <= 4)
	{
		//SDL_PIXELFORMAT_ARGB8888 == VK_FORMAT_B8G8R8A8_UNORM
		//I havent had time to check why the SDL pixel format is reversed in comparison to the vulkan format
		//27.2.2016 Vulkan doesnt currently support 3 component pixel formats, actually the only format i found working was mentioned above
		SDL_PixelFormat* format = SDL_AllocFormat(SDL_PIXELFORMAT_ARGB8888);
		convSurf = SDL_ConvertSurface(surf, format, 0);
		SDL_FreeFormat(format);
		if (convSurf == NULL)
		{
			SDL_Log("SGL_DataSaveImage couldn't convert surface to SDL_PIXELFORMAT_ARGB8888/VK_FORMAT_B8G8R8A8_UNORM, you could maybe add unimplemented format if vulkan supports it?");
			return SGL_FALSE;
		}
	}
	else
	{
		SDL_Log("SGL_DataSaveImage encountered unsupported pixel format. Aborting save");
		return SGL_FALSE;
	}
	targetData.block.imageCount++;
	{
		SDL_RWops* rw = SDL_RWFromFile(targetData.path, "rb+");
		if (rw == NULL)
		{
			SDL_Log("SGL_DataSaveImage couldn't open file in path: %s, SDL_Error:%s", targetData.path, SDL_GetError());
			return SGL_FALSE;
		}
		loc = (U32)SDL_RWseek(rw, 0, RW_SEEK_END);
		const SGL_FileSurface surfData = 
		{ 
			convSurf->flags, 
			convSurf->w, convSurf->h,
			convSurf->format->BitsPerPixel, 
			convSurf->format->Rmask, convSurf->format->Gmask, convSurf->format->Bmask, convSurf->format->Amask
		};
		if (SDL_RWwrite(rw, &surfData, sizeof(SGL_FileSurface), 1) != 1)
		{
			SDL_RWclose(rw);
			SDL_Log("SGL_DataSaveImage couldn't write to data file in path: %s", targetData.path);
			return SGL_FALSE;
		}
		{
			I32 y;
			const U32 pixelSize = convSurf->format->BytesPerPixel;
			//y axis gets flipped here
			//this prolly hurts the writing speed but this is done only when saving the textures
			for (y = surfData.h-1; y >= 0; y--)
			{
				I32 x;
				for (x = 0; x < surfData.w; x++)
				{
					SDL_RWwrite(rw, ((U8*)convSurf->pixels)+(y*surfData.w*pixelSize)+(x*pixelSize), pixelSize, 1);
				}
			}
		}
		SDL_RWseek(rw, 0, RW_SEEK_SET);
		if (SDL_RWwrite(rw, &targetData.block, sizeof(SGL_DataBlock), 1) != 1)
		{
			SDL_RWclose(rw);
			SDL_Log("SGL_DataSaveImage couldn't write to data file in path: %s, SDL_Error: %s", targetData.path, SDL_GetError());
			return SGL_FALSE;
		}
		SDL_RWclose(rw);
	}
	MurmurHash3_x86_32(name, (I32)SDL_strlen(name), targetData.block.seed, &hash);
	return AddNode(hash, loc);
}
예제 #28
0
int main(int argc, char** argv) 
#endif
{
#ifdef _WIN32
	LPSTR *argv = __argv;
	int argc = __argc;
	(void) argv;
	(void) argc;
#endif 
	SDL_Window *screen;
	SDL_Renderer *renderer;
	SDL_Shader *shader;

	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ){
		fprintf(stderr, "Error: %s \n", SDL_GetError());
		return 1;
	}

    SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 3 );
    SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 0 );
    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
    SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 24 );

	SDL_SetHint( SDL_HINT_RENDER_DRIVER, getenv("RENDER_DRIVER") ); 

	int width = 500;
	int height = 700;
	screen = SDL_CreateWindow("Caption",
			SDL_WINDOWPOS_CENTERED,
			SDL_WINDOWPOS_CENTERED,
			width, height,
			SDL_WINDOW_RESIZABLE);
			// SDL_WINDOW_FULLSCREEN_DESKTOP );
	if ( screen == NULL ) {
		fprintf(stderr, "Error: %s \n", SDL_GetError());
		return 2;
	}
	renderer = SDL_CreateRenderer( screen, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE );
	//renderer = SDL_CreateRenderer( screen, -1, SDL_RENDERER_SOFTWARE|SDL_RENDERER_TARGETTEXTURE );
	if ( renderer == NULL ) {
		fprintf(stderr, "Error: %s \n", SDL_GetError());
		return 3;
	}

	SDL_RenderSetLogicalSize(renderer, width, height);

	SDL_SetWindowTitle( screen, renderer->info.name );

	SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
	SDL_RenderClear(renderer);


	printf("renderer name: %s\n" , renderer->info.name );
	printf("SDL_PIXELFORMAT_UNKNOWN=    %d\n",SDL_PIXELFORMAT_UNKNOWN);
	printf("SDL_PIXELFORMAT_INDEX1LSB=  %d\n",SDL_PIXELFORMAT_INDEX1LSB);
	printf("SDL_PIXELFORMAT_INDEX1MSB=  %d\n",SDL_PIXELFORMAT_INDEX1MSB);
	printf("SDL_PIXELFORMAT_INDEX4LSB=  %d\n",SDL_PIXELFORMAT_INDEX4LSB);
	printf("SDL_PIXELFORMAT_INDEX4MSB=  %d\n",SDL_PIXELFORMAT_INDEX4MSB);
	printf("SDL_PIXELFORMAT_INDEX8=     %d\n",SDL_PIXELFORMAT_INDEX8);
	printf("SDL_PIXELFORMAT_RGB332=     %d\n",SDL_PIXELFORMAT_RGB332);
	printf("SDL_PIXELFORMAT_RGB444=     %d\n",SDL_PIXELFORMAT_RGB444);
	printf("SDL_PIXELFORMAT_RGB555=     %d\n",SDL_PIXELFORMAT_RGB555);
	printf("SDL_PIXELFORMAT_BGR555=     %d\n",SDL_PIXELFORMAT_BGR555);
	printf("SDL_PIXELFORMAT_ARGB4444=   %d\n",SDL_PIXELFORMAT_ARGB4444);
	printf("SDL_PIXELFORMAT_RGBA4444=   %d\n",SDL_PIXELFORMAT_RGBA4444);
	printf("SDL_PIXELFORMAT_ABGR4444=   %d\n",SDL_PIXELFORMAT_ABGR4444);
	printf("SDL_PIXELFORMAT_BGRA4444=   %d\n",SDL_PIXELFORMAT_BGRA4444);
	printf("SDL_PIXELFORMAT_ARGB1555=   %d\n",SDL_PIXELFORMAT_ARGB1555);
	printf("SDL_PIXELFORMAT_RGBA5551=   %d\n",SDL_PIXELFORMAT_RGBA5551);
	printf("SDL_PIXELFORMAT_ABGR1555=   %d\n",SDL_PIXELFORMAT_ABGR1555);
	printf("SDL_PIXELFORMAT_BGRA5551=   %d\n",SDL_PIXELFORMAT_BGRA5551);
	printf("SDL_PIXELFORMAT_RGB565=     %d\n",SDL_PIXELFORMAT_RGB565);
	printf("SDL_PIXELFORMAT_BGR565=     %d\n",SDL_PIXELFORMAT_BGR565);
	printf("SDL_PIXELFORMAT_RGB24=      %d\n",SDL_PIXELFORMAT_RGB24);
	printf("SDL_PIXELFORMAT_BGR24=      %d\n",SDL_PIXELFORMAT_BGR24);
	printf("SDL_PIXELFORMAT_RGB888=     %d\n",SDL_PIXELFORMAT_RGB888);
	printf("SDL_PIXELFORMAT_RGBX8888=   %d\n",SDL_PIXELFORMAT_RGBX8888);
	printf("SDL_PIXELFORMAT_BGR888=     %d\n",SDL_PIXELFORMAT_BGR888);
	printf("SDL_PIXELFORMAT_BGRX8888=   %d\n",SDL_PIXELFORMAT_BGRX8888);
	printf("SDL_PIXELFORMAT_ARGB8888=   %d\n",SDL_PIXELFORMAT_ARGB8888);
	printf("SDL_PIXELFORMAT_RGBA8888=   %d\n",SDL_PIXELFORMAT_RGBA8888);
	printf("SDL_PIXELFORMAT_ABGR8888=   %d\n",SDL_PIXELFORMAT_ABGR8888);
	printf("SDL_PIXELFORMAT_BGRA8888=   %d\n",SDL_PIXELFORMAT_BGRA8888);
	printf("SDL_PIXELFORMAT_ARGB2101010=%d\n",SDL_PIXELFORMAT_ARGB2101010);

	shader = SDL_createShader( renderer, "../shaders/do_nothing/do_nothing" );
	if ( shader == NULL ){
		fprintf(stderr, "Error: %s \n", SDL_GetError());
		return 4;
	}

	SDL_Surface* srf;
	srf = IMG_Load( "../img.png" );
	if ( !srf ) {
		fprintf(stderr, "Error: %s \n", SDL_GetError());
		return 5;
	}

	int i;
	Uint32 formats[] = {
		/* Indexed formats and YUV are not supported */
		SDL_PIXELFORMAT_RGB332,
		SDL_PIXELFORMAT_RGB444,
		SDL_PIXELFORMAT_RGB555,
		SDL_PIXELFORMAT_BGR555,
		SDL_PIXELFORMAT_ARGB4444,
		SDL_PIXELFORMAT_RGBA4444,
		SDL_PIXELFORMAT_ABGR4444,
		SDL_PIXELFORMAT_BGRA4444,
		SDL_PIXELFORMAT_ARGB1555,
		SDL_PIXELFORMAT_RGBA5551,
		SDL_PIXELFORMAT_ABGR1555,
		SDL_PIXELFORMAT_BGRA5551,
		SDL_PIXELFORMAT_RGB565,
		SDL_PIXELFORMAT_BGR565,
		SDL_PIXELFORMAT_RGB24,
		SDL_PIXELFORMAT_BGR24,
		SDL_PIXELFORMAT_RGB888,
		SDL_PIXELFORMAT_RGBX8888,
		SDL_PIXELFORMAT_BGR888,
		SDL_PIXELFORMAT_BGRX8888,
		SDL_PIXELFORMAT_ARGB8888,
		SDL_PIXELFORMAT_RGBA8888,
		SDL_PIXELFORMAT_ABGR8888,
		SDL_PIXELFORMAT_BGRA8888,
		SDL_PIXELFORMAT_ARGB2101010
	};
	
	char fmt_names[][NUM_OF_TEXTURES] = {
		"RGB332",
		"RGB444",
		"RGB555",
		"BGR555",
		"ARGB4444",
		"RGBA4444",
		"ABGR4444",
		"BGRA4444",
		"ARGB1555",
		"RGBA5551",
		"ABGR1555",
		"BGRA5551",
		"RGB565",
		"BGR565",
		"RGB24",
		"BGR24",
		"RGB888",
		"RGBX8888",
		"BGR888",
		"BGRX8888",
		"ARGB8888",
		"RGBA8888",
		"ABGR8888",
		"BGRA8888",
		"ARGB2101010"
	};

	SDL_BlendMode blendModes[] = {
		SDL_BLENDMODE_NONE,
		SDL_BLENDMODE_BLEND,
		SDL_BLENDMODE_ADD,
		SDL_BLENDMODE_MOD
	};
	char* blendNames[] = {
		"NONE",
		"BLEND",
		"ADD",
		"MOD"
	};
	int current_blend = 0;

	int colors[][4] = {
		{255,255,255,255},
		{255,  0,  0,255},
		{  0,255,  0,255},
		{  0,  0,255,255},
		{255,255,255,127}
	};
	char* colorNames[] = {
		"white",
		"red",
		"green",
		"blue",
		"semi transp."
	};
	int current_color = 0;

	SDL_Texture* textures[ NUM_OF_TEXTURES ];
	
	for ( i=0; i< (int)(NUM_OF_TEXTURES); i++) {
		SDL_PixelFormat* fmt = SDL_AllocFormat( formats[i] );
			SDL_assert(fmt != NULL);
		SDL_Surface* srf2 = SDL_ConvertSurface(srf, fmt, 0);
			SDL_assert(srf2 != NULL);
		textures[i] = SDL_CreateTextureFromSurface(renderer, srf2 );

		SDL_SetTextureBlendMode(textures[i], blendModes[current_blend]);
		SDL_FreeSurface( srf2 );
		SDL_FreeFormat(fmt);

		if ( !textures[i] ){
			return 1000 + i;
		}

		if ( textures[i]->native ){
			printf("native_tex: %d \n",textures[i]->native->format );
		}else{
			printf("SDL_tex: %d \n",textures[i]->format );
		}

	}
	SDL_FreeSurface(srf);

	SDL_SetRenderTarget( renderer, NULL );
	SDL_Event e;
	SDL_SetRenderDrawColor(renderer, 0,0,0,1);
	int ret = 0;
	int quit = 0;

	while ( !quit ) {
		SDLTest_DrawString( renderer,   8,   8, blendNames[current_blend] );
		SDLTest_DrawString( renderer, 108,   8, colorNames[current_color] );
		for ( i=0; i< (int)(NUM_OF_TEXTURES); i++) {
			int x=30+(i%8)*55;
			int y=30+(i/8)*75;
			SDL_Rect dst = {x,y,50,50};
			ret = SDL_renderCopyShd( shader, textures[i], NULL, &dst );
			if ( ret!=0 ){
				fprintf(stderr,"Err: %s\n", SDL_GetError());
			}
			SDLTest_DrawString( renderer, dst.x,dst.y+55 + (i%2==0 ? 10 : 0), fmt_names[i] );
			
			dst.y += (NUM_OF_TEXTURES)/8 * 75 + 85;
			SDL_RenderCopy( renderer, textures[i], NULL, &dst );
			SDLTest_DrawString( renderer, dst.x,dst.y+55 + (i%2==0 ? 10 : 0), fmt_names[i] );

		}
		while (SDL_PollEvent(&e)){
			switch ( e.type ) {
				case SDL_QUIT: 
					quit = 1; 
					break;
				case SDL_KEYDOWN: 
					switch ( e.key.keysym.sym ) {
						case SDLK_SPACE:
							current_blend = (current_blend+1)%4;
							for ( i=0; i< (int)(NUM_OF_TEXTURES); i++) {
								SDL_SetTextureBlendMode(textures[i], blendModes[current_blend]);
							}
							break;
						case SDLK_TAB:
							current_color = (current_color+1)%5;
							for ( i=0; i< (int)(NUM_OF_TEXTURES); i++) {
								SDL_SetTextureColorMod(textures[i], 
										colors[current_color][0],
										colors[current_color][1],
										colors[current_color][2]);
								SDL_SetTextureAlphaMod(textures[i], colors[current_color][3] );
							}
							break;
					}
					break;
				case SDL_WINDOWEVENT:
					SDL_updateViewport( shader );
			}
		}

		SDL_RenderPresent(renderer);

		SDL_SetRenderDrawColor(renderer, 160, 160, 160, 255);
		SDL_RenderClear(renderer);
		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);

	}
	for ( i=0; i<(int)NUM_OF_TEXTURES; i++ ) {
		SDL_DestroyTexture( textures[i] );
		textures[i] = NULL;
	}
	SDL_destroyShader( shader );
	SDL_DestroyRenderer( renderer );
	SDL_DestroyWindow( screen );
	SDL_Quit();

	return 0;
}
예제 #29
0
// create a font with a drop-shadow (used for "MNA" stage-name displays)
bool NXFont::InitCharsShadowed(TTF_Font *font, uint32_t color, uint32_t shadowcolor)
{
SDL_Color fgcolor, shcolor;
SDL_Surface *top, *bottom;
SDL_Rect dstrect;

	fgcolor.r = (uint8_t)(color >> 16);
	fgcolor.g = (uint8_t)(color >> 8);
	fgcolor.b = (uint8_t)(color);
	
	shcolor.r = (uint8_t)(shadowcolor >> 16);
	shcolor.g = (uint8_t)(shadowcolor >> 8);
	shcolor.b = (uint8_t)(shadowcolor);
	
	char str[2];
	str[1] = 0;
	
	SDL_PixelFormat* pxformat = SDL_AllocFormat(screen->Format()->format);
	if (!pxformat)
	{
		staterr("InitBitmapChars: SDL_AllocFormat failed: %s", SDL_GetError());
		return 1;
	}

	uint32_t transp = SDL_ALPHA_TRANSPARENT;

	for(int i=1;i<NUM_LETTERS_RENDERED;i++)
	{
		str[0] = i;
		
		top = TTF_RenderText_Solid(font, str, fgcolor);
		bottom = TTF_RenderText_Solid(font, str, shcolor);
		if (!top || !bottom)
		{
			staterr("InitCharsShadowed: failed to render character %d: %s", i, TTF_GetError());
			SDL_FreeFormat(pxformat);
			SDL_FreeSurface(top);
			SDL_FreeSurface(bottom);
			return 1;
		}
		
		letters[i] = SDL_CreateRGBSurface(0, top->w, top->h+SHADOW_OFFSET,
							pxformat->BitsPerPixel, pxformat->Rmask, pxformat->Gmask,
							pxformat->Bmask, pxformat->Amask);
		if (!letters[i])
		{
			staterr("InitCharsShadowed: failed to create surface for character %d: %s", i, SDL_GetError());
			SDL_FreeFormat(pxformat);
			SDL_FreeSurface(top);
			SDL_FreeSurface(bottom);
			return 1;
		}
		
		SDL_FillRect(letters[i], NULL, transp);
		SDL_SetColorKey(letters[i], SDL_TRUE, transp);
		
		dstrect.x = 0;
		dstrect.y = SHADOW_OFFSET;
		SDL_BlitSurface(bottom, NULL, letters[i], &dstrect);
		
		dstrect.x = 0;
		dstrect.y = 0;
		SDL_BlitSurface(top, NULL, letters[i], &dstrect);

		SDL_FreeSurface(top);
		SDL_FreeSurface(bottom);
	}
	
	return 0;
}
예제 #30
0
파일: bitmap.cpp 프로젝트: Ancurio/mkxp
	~BitmapPrivate()
	{
		SDL_FreeFormat(format);
		pixman_region_fini(&tainted);
	}