sdl2_renderer.cc

Go to the documentation of this file.

#include "app/gfx/backend/sdl2_renderer.h"
 
#include "absl/strings/str_format.h"
#include "app/gfx/core/bitmap.h"
#include "app/platform/sdl_compat.h"
 
namespace yaze {
namespace gfx {
 
SDL2Renderer::SDL2Renderer() = default;
 
SDL2Renderer::~SDL2Renderer() {
  Shutdown();
}
 
bool SDL2Renderer::Initialize(SDL_Window* window) {
  // Create an SDL2 renderer with hardware acceleration.
  renderer_ = std::unique_ptr<SDL_Renderer, util::SDL_Deleter>(
      platform::CreateRenderer(window));
 
  if (renderer_ == nullptr) {
    // Log an error if renderer creation fails.
    printf("SDL_CreateRenderer Error: %s\n", SDL_GetError());
    return false;
  }
 
  // SDL3 sets vsync separately; this is a no-op on SDL2.
  platform::SetRenderVSync(renderer_.get(), 1);
 
  // Set the blend mode to allow for transparency.
  SDL_SetRenderDrawBlendMode(renderer_.get(), SDL_BLENDMODE_BLEND);
  return true;
}
 
void SDL2Renderer::Shutdown() {
  renderer_.reset();
}
 
TextureHandle SDL2Renderer::CreateTexture(int width, int height) {
  // The TextureHandle is a void*, so we cast the SDL_Texture* to it.
  // SDL2's SDL_CreateTexture takes Uint32 for format
  // SDL2's SDL_CreateTexture takes Uint32 for format
  SDL_Texture* texture = SDL_CreateTexture(
      renderer_.get(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING,
      width, height);
  
  if (texture) {
    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
  }
  
  return static_cast<TextureHandle>(texture);
}
 
TextureHandle SDL2Renderer::CreateTextureWithFormat(int width, int height,
                                                    uint32_t format,
                                                    int access) {
  return static_cast<TextureHandle>(
      SDL_CreateTexture(renderer_.get(), format, access, width, height));
}
 
void SDL2Renderer::UpdateTexture(TextureHandle texture, const Bitmap& bitmap) {
  SDL_Surface* surface = bitmap.surface();
 
  // Validate texture, surface, and surface format
  if (!texture || !surface || !surface->format) {
    return;
  }
 
  // Validate surface has pixels
  if (!surface->pixels || surface->w <= 0 || surface->h <= 0) {
    return;
  }
 
  // Convert the bitmap's surface to RGBA8888 format for compatibility with the
  // texture.
  auto converted_surface =
      std::unique_ptr<SDL_Surface, util::SDL_Surface_Deleter>(
          platform::ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_RGBA8888));
 
  if (!converted_surface || !converted_surface->pixels) {
    return;
  }
 
  // Update the texture with the pixels from the converted surface.
  SDL_UpdateTexture(static_cast<SDL_Texture*>(texture), nullptr,
                    converted_surface->pixels, converted_surface->pitch);
}
 
void SDL2Renderer::DestroyTexture(TextureHandle texture) {
  if (texture) {
    SDL_DestroyTexture(static_cast<SDL_Texture*>(texture));
  }
}
 
bool SDL2Renderer::LockTexture(TextureHandle texture, SDL_Rect* rect,
                               void** pixels, int* pitch) {
  return SDL_LockTexture(static_cast<SDL_Texture*>(texture), rect, pixels,
                         pitch) == 0;
}
 
void SDL2Renderer::UnlockTexture(TextureHandle texture) {
  SDL_UnlockTexture(static_cast<SDL_Texture*>(texture));
}
 
void SDL2Renderer::Clear() {
  SDL_RenderClear(renderer_.get());
}
 
void SDL2Renderer::Present() {
  SDL_RenderPresent(renderer_.get());
}
 
void SDL2Renderer::RenderCopy(TextureHandle texture, const SDL_Rect* srcrect,
                              const SDL_Rect* dstrect) {
  platform::RenderTexture(renderer_.get(),
                          static_cast<SDL_Texture*>(texture), srcrect, dstrect);
}
 
void SDL2Renderer::SetRenderTarget(TextureHandle texture) {
  SDL_SetRenderTarget(renderer_.get(), static_cast<SDL_Texture*>(texture));
}
 
void SDL2Renderer::SetDrawColor(SDL_Color color) {
  SDL_SetRenderDrawColor(renderer_.get(), color.r, color.g, color.b, color.a);
}
 
}  // namespace gfx
}  // namespace yaze