bool screenshot_dump(const char *folder, const void *frame,
unsigned width, unsigned height, int pitch, bool bgr24)
{
(void)folder;
(void)frame;
(void)width;
(void)height;
(void)pitch;
(void)bgr24;
d3d_video_t *d3d = (d3d_video_t*)driver.video_data;
HRESULT ret = S_OK;
char filename[PATH_MAX_LENGTH];
char shotname[PATH_MAX_LENGTH];
fill_dated_filename(shotname, "bmp", sizeof(shotname));
snprintf(filename, sizeof(filename), "%s\\%s", g_settings.screenshot_directory, shotname);
D3DSurface *surf = NULL;
d3d->dev->GetBackBuffer(-1, D3DBACKBUFFER_TYPE_MONO, &surf);
ret = XGWriteSurfaceToFile(surf, filename);
surf->Release();
if(ret == S_OK)
{
RARCH_LOG("Screenshot saved: %s.\n", filename);
msg_queue_push(g_extern.msg_queue, "Screenshot saved.", 1, 30);
return true;
}
return false;
}
/* Take frame bottom-up. */
static bool screenshot_dump(
const char *global_name_base,
const char *folder,
const void *frame,
unsigned width,
unsigned height,
int pitch, bool bgr24)
{
char filename[PATH_MAX_LENGTH] = {0};
char shotname[256] = {0};
bool ret = false;
settings_t *settings = config_get_ptr();
#if defined(HAVE_ZLIB_DEFLATE) && defined(HAVE_RPNG)
uint8_t *out_buffer = NULL;
struct scaler_ctx scaler = {0};
#endif
if (settings->auto_screenshot_filename)
{
fill_dated_filename(shotname, IMG_EXT, sizeof(shotname));
fill_pathname_join(filename, folder, shotname, sizeof(filename));
}
else
{
snprintf(shotname, sizeof(shotname),"%s.png", path_basename(global_name_base));
fill_pathname_join(filename, folder, shotname, sizeof(filename));
}
#ifdef _XBOX1
d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(true);
D3DSurface *surf = NULL;
d3d->dev->GetBackBuffer(-1, D3DBACKBUFFER_TYPE_MONO, &surf);
if (XGWriteSurfaceToFile(surf, filename) == S_OK)
ret = true;
surf->Release();
#elif defined(HAVE_ZLIB_DEFLATE) && defined(HAVE_RPNG)
out_buffer = (uint8_t*)malloc(width * height * 3);
if (!out_buffer)
return false;
video_frame_convert_to_bgr24(
&scaler,
out_buffer,
(const uint8_t*)frame + ((int)height - 1) * pitch,
width, height,
-pitch,
bgr24);
scaler_ctx_gen_reset(&scaler);
ret = rpng_save_image_bgr24(
filename,
out_buffer,
width,
height,
width * 3
);
free(out_buffer);
#elif defined(HAVE_RBMP)
enum rbmp_source_type bmp_type = RBMP_SOURCE_TYPE_DONT_CARE;
if (bgr24)
bmp_type = RBMP_SOURCE_TYPE_BGR24;
else if (video_driver_get_pixel_format() == RETRO_PIXEL_FORMAT_XRGB8888)
bmp_type = RBMP_SOURCE_TYPE_XRGB888;
ret = rbmp_save_image(filename,
frame,
width,
height,
pitch,
bmp_type);
#endif
#ifdef HAVE_IMAGEVIEWER
if (ret == true)
{
if (content_push_to_history_playlist(g_defaults.image_history, filename,
"imageviewer", "builtin"))
playlist_write_file(g_defaults.image_history);
}
#endif
return ret;
}
void Font::RenderToTexture(CSurface &texture, const string &str, dword height, dword style, D3DXCOLOR color, int maxWidth, bool fade)
{
xdk_d3d_video_t *d3d = (xdk_d3d_video_t*)driver.video_data;
if (m_pFont == NULL)
return;
m_pFont->SetTextHeight(height);
m_pFont->SetTextStyle(style);
m_pFont->SetTextColor(color);
dword dwMaxWidth = (maxWidth <= 0) ? 1000 : maxWidth;
// get the exact width and height required to display the string
dword dwRequiredWidth = GetRequiredWidth(str, height, style);
dword dwRequiredHeight = GetRequiredHeight(str, height, style);;
// calculate the texture width and height needed to display the font
dword dwTextureWidth = dwRequiredWidth * 2;
dword dwTextureHeight = dwRequiredHeight * 2;
{
// because the textures are swizzled we make sure
// the dimensions are a power of two
for(dword wmask = 1; dwTextureWidth &(dwTextureWidth - 1); wmask = (wmask << 1 ) + 1)
dwTextureWidth = (dwTextureWidth + wmask) & ~wmask;
for(dword hmask = 1; dwTextureHeight &(dwTextureHeight - 1); hmask = (hmask << 1) + 1)
dwTextureHeight = ( dwTextureHeight + hmask ) & ~hmask;
// also enforce a minimum pitch of 64 bytes
dwTextureWidth = max(64 / XGBytesPerPixelFromFormat(D3DFMT_A8R8G8B8), dwTextureWidth);
}
// create an temporary image surface to render to
D3DSurface *pTempSurface;
d3d->d3d_render_device->CreateImageSurface(dwTextureWidth, dwTextureHeight, D3DFMT_LIN_A8R8G8B8, &pTempSurface);
// clear the temporary surface
{
D3DLOCKED_RECT tmpLr;
pTempSurface->LockRect(&tmpLr, NULL, 0);
memset(tmpLr.pBits, 0, dwTextureWidth * dwTextureHeight * XGBytesPerPixelFromFormat(D3DFMT_A8R8G8B8));
pTempSurface->UnlockRect();
}
// render the text to the temporary surface
word *wcBuf = StringToWChar(str);
m_pFont->TextOut(pTempSurface, wcBuf, -1, 0, 0);
delete [] wcBuf;
// create the texture that will be drawn to the screen
texture.Destroy();
texture.Create(dwTextureWidth, dwTextureHeight);
// copy from the temporary surface to the final texture
{
D3DLOCKED_RECT tmpLr;
D3DLOCKED_RECT txtLr;
pTempSurface->LockRect(&tmpLr, NULL, 0);
texture.GetTexture()->LockRect(0, &txtLr, NULL, 0);
if (fade)
{
// draw the last 35 pixels of the string fading out to max width or texture width
dword dwMinFadeDistance = min(static_cast<dword>(dwTextureWidth * 0.35), 35);
dword dwFadeStart = min(dwTextureWidth, dwMaxWidth - dwMinFadeDistance);
dword dwFadeEnd = min(dwTextureWidth, dwMaxWidth);
dword dwFadeDistance = dwFadeEnd - dwFadeStart;
for (dword h = 0; h < dwTextureHeight; h++)
{
for (dword w = 0; w < dwFadeDistance; w++)
{
dword *pColor = reinterpret_cast<dword *>(tmpLr.pBits);
dword offset = (h * dwTextureWidth) + (dwFadeStart + w);
D3DXCOLOR color = D3DXCOLOR(pColor[offset]);
color.a = color.a * (1.0f - static_cast<float>(w) / static_cast<float>(dwFadeDistance));
pColor[offset] = color;
}
}
}
// dont draw anything > than max width
for (dword h = 0; h < dwTextureHeight; h++)
{
for (dword w = min(dwTextureWidth, dwMaxWidth); w < dwTextureWidth; w++)
{
dword *pColor = reinterpret_cast<dword *>(tmpLr.pBits);
dword offset = (h * dwTextureWidth) + w;
D3DXCOLOR color = D3DXCOLOR(pColor[offset]);
color.a = 0.0;
pColor[offset] = color;
}
}
// copy and swizzle the linear surface to the swizzled texture
XGSwizzleRect(tmpLr.pBits, tmpLr.Pitch, NULL, txtLr.pBits, dwTextureWidth, dwTextureHeight, NULL, 4);
texture.GetTexture()->UnlockRect(0);
pTempSurface->UnlockRect();
}
pTempSurface->Release();
}