Beispiel #1
0
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;
}
Beispiel #2
0
D3DSurface* D3DDevice::createSurface(size_t width, size_t height)
{
    D3DSurface* ret = NULL;

    ret = new D3DSurface(getDevice(), width, height);

    if(ret->getSurface())
    {
        return ret;
    }
    else
    {
        /* problem allocating surface */
        delete ret;
        return NULL;
    }
}
Beispiel #3
0
/* 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;
}
Beispiel #4
0
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();
}