static void menu_display_d3d_draw(void *data)
{
#if 0
   math_matrix_4x4          *mat = NULL;
#endif
   d3d_video_t              *d3d = (d3d_video_t*)video_driver_get_ptr(false);
   menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;

   if (!d3d || !draw)
      return;
   
   if (!draw->coords->vertex)
      draw->coords->vertex        = menu_display_d3d_get_default_vertices();
   if (!draw->coords->tex_coord)
      draw->coords->tex_coord     = menu_display_d3d_get_default_tex_coords();
   if (!draw->coords->lut_tex_coord)
      draw->coords->lut_tex_coord = menu_display_d3d_get_default_tex_coords();

   menu_display_d3d_viewport(draw);
   menu_display_d3d_bind_texture(draw);

#if 0
   mat = (math_matrix_4x4*)draw->matrix_data;
   if (!mat)
      mat                         = (math_matrix_4x4*)
         menu_display_d3d_get_default_mvp();
   video_shader_driver_set_coords(d3d, draw->coords);
   video_shader_driver_set_mvp(d3d, mat);
#endif

   d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)
         menu_display_prim_to_d3d_enum(draw->prim_type),
         0, draw->coords->vertices);
}
Ejemplo n.º 2
0
static void menu_display_d3d_draw_bg(
      unsigned width,
      unsigned height,
      uintptr_t texture,
      float handle_alpha,
      bool force_transparency,
      float *coord_color,
      float *coord_color2,
      const float *vertex,
      const float *tex_coord,
      size_t vertex_count,
      enum menu_display_prim_type prim_type)
{
   struct gfx_coords coords;
   const float *new_vertex    = NULL;
   const float *new_tex_coord = NULL;
   global_t     *global = global_get_ptr();
   settings_t *settings = config_get_ptr();
   d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);

   if (!d3d)
      return;

   new_vertex    = vertex;
   new_tex_coord = tex_coord;

   if (!new_vertex)
      new_vertex = &d3d_vertexes[0];
   if (!new_tex_coord)
      new_tex_coord = &d3d_tex_coords[0];

   coords.vertices      = vertex_count;
   coords.vertex        = new_vertex;
   coords.tex_coord     = new_tex_coord;
   coords.lut_tex_coord = new_tex_coord;
   coords.color         = (const float*)coord_color;

   menu_display_d3d_blend_begin();

   menu_display_ctl(MENU_DISPLAY_CTL_SET_VIEWPORT, NULL);

   if ((settings->menu.pause_libretro
      || !global->inited.main || (global->inited.core.type == CORE_TYPE_DUMMY))
      && !force_transparency
      && texture)
      coords.color = (const float*)coord_color2;

   menu_display_d3d_draw(0, 0, width, height,
         &coords, (math_matrix_4x4*)menu_display_d3d_get_default_mvp(),
         (uintptr_t)texture, prim_type);

   menu_display_d3d_blend_end();

#if 0
   gl->coords.color = gl->white_color_ptr;
#endif
}
Ejemplo n.º 3
0
static void menu_display_d3d_draw_bg(void *data)
{
   struct gfx_coords coords;
   const float    *new_vertex    = NULL;
   const float    *new_tex_coord = NULL;
   global_t              *global = global_get_ptr();
   settings_t          *settings = config_get_ptr();
   d3d_video_t              *d3d = d3d_get_ptr();
   menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;

   if (!d3d || !draw)
      return;

   (void)coords;

   new_vertex    = draw->vertex;
   new_tex_coord = draw->tex_coord;

   if (!new_vertex)
      new_vertex = &d3d_vertexes[0];
   if (!new_tex_coord)
      new_tex_coord = &d3d_tex_coords[0];

   coords.vertices      = draw->vertex_count;
   coords.vertex        = new_vertex;
   coords.tex_coord     = new_tex_coord;
   coords.lut_tex_coord = new_tex_coord;
   coords.color         = (const float*)draw->color;

   menu_display_d3d_blend_begin();

   menu_display_ctl(MENU_DISPLAY_CTL_SET_VIEWPORT, NULL);

   if (
         (   settings->menu.pause_libretro
          || !rarch_ctl(RARCH_CTL_IS_INITED, NULL) 
          || rarch_ctl(RARCH_CTL_IS_DUMMY_CORE, NULL)
         )
      && !draw->force_transparency && draw->texture)
      coords.color = (const float*)draw->color2;

   draw->x           = 0;
   draw->y           = 0;
   draw->matrix_data = (math_matrix_4x4*)
      menu_display_d3d_get_default_mvp();

   menu_display_d3d_draw(draw);

   menu_display_d3d_blend_end();

#if 0
   gl->coords.color = gl->white_color_ptr;
#endif
}
Ejemplo n.º 4
0
static void menu_display_d3d_draw(
      unsigned x, unsigned y,
      unsigned width, unsigned height,
      struct gfx_coords *coords,
      void *matrix_data,
      uintptr_t texture,
      enum menu_display_prim_type prim_type
      )
{
   D3DVIEWPORT vp       = {0};
   driver_t     *driver = driver_get_ptr();
   d3d_video_t *d3d = (d3d_video_t*)video_driver_get_ptr(NULL);
   math_matrix_4x4 *mat = (math_matrix_4x4*)matrix_data;

   if (!d3d)
      return;

   /* TODO - edge case */
   if (height <= 0)
      height = 1;

   if (!mat)
      mat = (math_matrix_4x4*)menu_display_d3d_get_default_mvp();
   if (!coords->vertex)
      coords->vertex = &d3d_vertexes[0];
   if (!coords->tex_coord)
      coords->tex_coord = &d3d_tex_coords[0];
   if (!coords->lut_tex_coord)
      coords->lut_tex_coord = &d3d_tex_coords[0];

   vp.X      = x;
   vp.Y      = y;
   vp.Width  = width;
   vp.Height = height;
   vp.MinZ   = 0.0f;
   vp.MaxZ   = 1.0f;

   d3d_set_viewport(d3d->dev, &vp);
   d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)texture);

#if 0
   gl->shader->set_coords(coords);
   gl->shader->set_mvp(driver->video_data, mat);
#endif

   d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)menu_display_prim_to_d3d_enum(prim_type), 0, coords->vertices);

#if 0
   gl->coords.color     = gl->white_color_ptr;
#endif
}
Ejemplo n.º 5
0
static void menu_display_d3d_draw(void *data)
{
   D3DVIEWPORT                vp = {0};
   math_matrix_4x4          *mat = NULL;
   d3d_video_t              *d3d = d3d_get_ptr();
   menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;

   if (!d3d || !draw)
      return;
   
   mat = (math_matrix_4x4*)draw->matrix_data;

   /* TODO - edge case */
   if (draw->height <= 0)
      draw->height = 1;

   if (!mat)
      mat                         = (math_matrix_4x4*)
         menu_display_d3d_get_default_mvp();
   if (!draw->coords->vertex)
      draw->coords->vertex        = &d3d_vertexes[0];
   if (!draw->coords->tex_coord)
      draw->coords->tex_coord     = &d3d_tex_coords[0];
   if (!draw->coords->lut_tex_coord)
      draw->coords->lut_tex_coord = &d3d_tex_coords[0];

   vp.X      = draw->x;
   vp.Y      = draw->y;
   vp.Width  = draw->width;
   vp.Height = draw->height;
   vp.MinZ   = 0.0f;
   vp.MaxZ   = 1.0f;

   d3d_set_viewports(d3d->dev, &vp);
   d3d_set_texture(d3d->dev, 0, (LPDIRECT3DTEXTURE)draw->texture);

#if 0
   video_shader_driver_set_coords(d3d, draw->coords);
   video_shader_driver_set_mvp(d3d, mat);
#endif

   d3d_draw_primitive(d3d->dev, (D3DPRIMITIVETYPE)
         menu_display_prim_to_d3d_enum(draw->prim_type),
         0, draw->coords->vertices);

#if 0
   gl->coords.color     = gl->white_color_ptr;
#endif
}
Ejemplo n.º 6
0
static void menu_display_d3d_draw(void *data, video_frame_info_t *video_info)
{
   unsigned i;
   video_shader_ctx_mvp_t mvp;
   math_matrix_4x4 mop, m1, m2;
   unsigned width, height;
   d3d_video_t *d3d              = video_info ? (d3d_video_t*)video_info->userdata : NULL;   
   menu_display_ctx_draw_t *draw = (menu_display_ctx_draw_t*)data;
   Vertex * pv                   = NULL;
   const float *vertex           = NULL;
   const float *tex_coord        = NULL;
   const float *color            = NULL;

   if (!d3d || !draw || draw->pipeline.id)
      return;
   if((d3d->menu_display.offset + draw->coords->vertices )
         > (unsigned)d3d->menu_display.size)
      return;

   pv           = (Vertex*)
      d3d_vertex_buffer_lock(d3d->menu_display.buffer);

   if (!pv)
      return;

   pv          += d3d->menu_display.offset;
   vertex       = draw->coords->vertex;
   tex_coord    = draw->coords->tex_coord;
   color        = draw->coords->color;

   if (!vertex)
      vertex    = menu_display_d3d_get_default_vertices();
   if (!tex_coord)
      tex_coord = menu_display_d3d_get_default_tex_coords();

   for (i = 0; i < draw->coords->vertices; i++)
   {
      int colors[4];

      colors[0]   = *color++ * 0xFF;
      colors[1]   = *color++ * 0xFF;
      colors[2]   = *color++ * 0xFF;
      colors[3]   = *color++ * 0xFF;

      pv[i].x     = *vertex++;
      pv[i].y     = *vertex++;
      pv[i].z     = 0.5f;
      pv[i].u     = *tex_coord++;
      pv[i].v     = *tex_coord++;
#ifdef HAVE_D3D8
	  if ((void*)draw->texture)
      {
         D3DSURFACE_DESC desc;
         if (d3d_texture_get_level_desc((void*)draw->texture, 0, &desc))
         {
            pv[i].u *= desc.Width;
            pv[i].v *= desc.Height;
         }
      }
#endif

      pv[i].color =
         D3DCOLOR_ARGB(
               colors[3], /* A */
               colors[0], /* R */
               colors[1], /* G */
               colors[2]  /* B */
               );
   }
   d3d_vertex_buffer_unlock(d3d->menu_display.buffer);

   if(!draw->matrix_data)
      draw->matrix_data = menu_display_d3d_get_default_mvp(video_info);

   /* ugh */
   video_driver_get_size(&width, &height);
   matrix_4x4_scale(m1,       2.0,  2.0, 0);
   matrix_4x4_translate(mop, -1.0, -1.0, 0);
   matrix_4x4_multiply(m2, mop, m1);
   matrix_4x4_multiply(m1,
         *((math_matrix_4x4*)draw->matrix_data), m2);
   matrix_4x4_scale(mop,
         (draw->width  / 2.0) / width,
         (draw->height / 2.0) / height, 0);
   matrix_4x4_multiply(m2, mop, m1);
   matrix_4x4_translate(mop,
         (draw->x + (draw->width  / 2.0)) / width,
         (draw->y + (draw->height / 2.0)) / height,
         0);
   matrix_4x4_multiply(m1, mop, m2);
   matrix_4x4_multiply(m2, d3d->mvp_transposed, m1);
   d3d_matrix_transpose(&m1, &m2);

   mvp.data   = d3d;
   mvp.matrix = &m1;
   video_driver_set_mvp(&mvp);
   menu_display_d3d_bind_texture(draw, (d3d_video_t*)video_info->userdata);
   d3d_draw_primitive(d3d->dev,
         menu_display_prim_to_d3d_enum(draw->prim_type),
         d3d->menu_display.offset,
         draw->coords->vertices - 
         ((draw->prim_type == MENU_DISPLAY_PRIM_TRIANGLESTRIP) 
          ? 2 : 0));

   d3d->menu_display.offset += draw->coords->vertices;
}