Subversion Repositories Kolibri OS

/**********************************************************

 * Copyright 2008-2009 VMware, Inc.  All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use, copy,

 * modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 **********************************************************/

#include "draw/draw_context.h"

#include "draw/draw_vbuf.h"

#include "util/u_inlines.h"

#include "pipe/p_state.h"

#include "svga_context.h"

#include "svga_swtnl.h"

#include "svga_state.h"

#include "svga_tgsi.h"

#include "svga_swtnl_private.h"

#define SVGA_POINT_ADJ_X -0.375f

#define SVGA_POINT_ADJ_Y -0.5f

#define SVGA_LINE_ADJ_X -0.5f

#define SVGA_LINE_ADJ_Y -0.5f

#define SVGA_TRIANGLE_ADJ_X -0.375f

#define SVGA_TRIANGLE_ADJ_Y -0.5f

static void set_draw_viewport( struct svga_context *svga )

{

   struct pipe_viewport_state vp = svga->curr.viewport;

   float adjx = 0.0f;

   float adjy = 0.0f;

   switch (svga->curr.reduced_prim) {

   case PIPE_PRIM_POINTS:

      adjx = SVGA_POINT_ADJ_X;

      adjy = SVGA_POINT_ADJ_Y;

      break;

   case PIPE_PRIM_LINES:

      /* XXX: This is to compensate for the fact that wide lines are

       * going to be drawn with triangles, but we're not catching all

       * cases where that will happen.

       */

      if (svga->curr.rast->need_pipeline & SVGA_PIPELINE_FLAG_LINES)

      {

         adjx = SVGA_LINE_ADJ_X + 0.175f;

         adjy = SVGA_LINE_ADJ_Y - 0.175f;

      }

      else {

         adjx = SVGA_LINE_ADJ_X;

         adjy = SVGA_LINE_ADJ_Y;

      }

      break;

   case PIPE_PRIM_TRIANGLES:

      adjx += SVGA_TRIANGLE_ADJ_X;

      adjy += SVGA_TRIANGLE_ADJ_Y;

      break;

   }

   vp.translate[0] += adjx;

   vp.translate[1] += adjy;

   draw_set_viewport_states(svga->swtnl.draw, 0, 1, &vp);

}

static enum pipe_error

update_swtnl_draw( struct svga_context *svga,

                   unsigned dirty )

{

   draw_flush( svga->swtnl.draw );

   if (dirty & SVGA_NEW_VS)

      draw_bind_vertex_shader(svga->swtnl.draw,

                              svga->curr.vs->draw_shader);

   if (dirty & SVGA_NEW_FS)

      draw_bind_fragment_shader(svga->swtnl.draw,

                                svga->curr.fs->draw_shader);

   if (dirty & SVGA_NEW_VBUFFER)

      draw_set_vertex_buffers(svga->swtnl.draw, 0,

                              svga->curr.num_vertex_buffers,

                              svga->curr.vb);

   if (dirty & SVGA_NEW_VELEMENT)

      draw_set_vertex_elements(svga->swtnl.draw,

                               svga->curr.velems->count,

                               svga->curr.velems->velem );

   if (dirty & SVGA_NEW_CLIP)

      draw_set_clip_state(svga->swtnl.draw,

                          &svga->curr.clip);

   if (dirty & (SVGA_NEW_VIEWPORT |

                SVGA_NEW_REDUCED_PRIMITIVE |

                SVGA_NEW_RAST))

      set_draw_viewport( svga );

   if (dirty & SVGA_NEW_RAST)

      draw_set_rasterizer_state(svga->swtnl.draw,

                                &svga->curr.rast->templ,

                                (void *) svga->curr.rast);

   /* Tell the draw module how deep the Z/depth buffer is.

    *

    * If no depth buffer is bound, send the utility function the

    * format for no bound depth (PIPE_FORMAT_NONE).

    */

   if (dirty & SVGA_NEW_FRAME_BUFFER)

      draw_set_zs_format(svga->swtnl.draw,

         (svga->curr.framebuffer.zsbuf) ?

             svga->curr.framebuffer.zsbuf->format : PIPE_FORMAT_NONE);

   return PIPE_OK;

}

struct svga_tracked_state svga_update_swtnl_draw =

{

   "update draw module state",

   (SVGA_NEW_VS |

    SVGA_NEW_VBUFFER |

    SVGA_NEW_VELEMENT |

    SVGA_NEW_CLIP |

    SVGA_NEW_VIEWPORT |

    SVGA_NEW_RAST |

    SVGA_NEW_FRAME_BUFFER |

    SVGA_NEW_REDUCED_PRIMITIVE),

   update_swtnl_draw

};

enum pipe_error

svga_swtnl_update_vdecl( struct svga_context *svga )

{

   struct svga_vbuf_render *svga_render = svga_vbuf_render(svga->swtnl.backend);

   struct draw_context *draw = svga->swtnl.draw;

   struct vertex_info *vinfo = &svga_render->vertex_info;

   SVGA3dVertexDecl vdecl[PIPE_MAX_ATTRIBS];

   const enum interp_mode colorInterp =

      svga->curr.rast->templ.flatshade ? INTERP_CONSTANT : INTERP_LINEAR;

   struct svga_fragment_shader *fs = svga->curr.fs;

   int offset = 0;

   int nr_decls = 0;

   int src;

   unsigned i;

   memset(vinfo, 0, sizeof(*vinfo));

   memset(vdecl, 0, sizeof(vdecl));

   draw_prepare_shader_outputs(draw);

   /* always add position */

   src = draw_find_shader_output(draw, TGSI_SEMANTIC_POSITION, 0);

   draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_LINEAR, src);

   vinfo->attrib[0].emit = EMIT_4F;

   vdecl[0].array.offset = offset;

   vdecl[0].identity.type = SVGA3D_DECLTYPE_FLOAT4;

   vdecl[0].identity.usage = SVGA3D_DECLUSAGE_POSITIONT;

   vdecl[0].identity.usageIndex = 0;

   offset += 16;

   nr_decls++;

   for (i = 0; i < fs->base.info.num_inputs; i++) {

      const unsigned sem_name = fs->base.info.input_semantic_name[i];

      const unsigned sem_index = fs->base.info.input_semantic_index[i];

      src = draw_find_shader_output(draw, sem_name, sem_index);

      vdecl[nr_decls].array.offset = offset;

      vdecl[nr_decls].identity.usageIndex = sem_index;

      switch (sem_name) {

      case TGSI_SEMANTIC_COLOR:

         draw_emit_vertex_attr(vinfo, EMIT_4F, colorInterp, src);

         vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_COLOR;

         vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4;

         offset += 16;

         nr_decls++;

         break;

      case TGSI_SEMANTIC_GENERIC:

         draw_emit_vertex_attr(vinfo, EMIT_4F, INTERP_PERSPECTIVE, src);

         vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD;

         vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4;

         vdecl[nr_decls].identity.usageIndex =

            svga_remap_generic_index(fs->generic_remap_table, sem_index);

         offset += 16;

         nr_decls++;

         break;

      case TGSI_SEMANTIC_FOG:

         draw_emit_vertex_attr(vinfo, EMIT_1F, INTERP_PERSPECTIVE, src);

         vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD;

         vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT1;

         assert(vdecl[nr_decls].identity.usageIndex == 0);

         offset += 4;

         nr_decls++;

         break;

      case TGSI_SEMANTIC_POSITION:

         /* generated internally, not a vertex shader output */

         break;

      default:

         assert(0);

      }

   }

   draw_compute_vertex_size(vinfo);

   svga_render->vdecl_count = nr_decls;

   for (i = 0; i < svga_render->vdecl_count; i++)

      vdecl[i].array.stride = offset;

   if (memcmp(svga_render->vdecl, vdecl, sizeof(vdecl)) == 0)

      return PIPE_OK;

   memcpy(svga_render->vdecl, vdecl, sizeof(vdecl));

   svga->swtnl.new_vdecl = TRUE;

   return PIPE_OK;

}

static enum pipe_error

update_swtnl_vdecl( struct svga_context *svga,

                    unsigned dirty )

{

   return svga_swtnl_update_vdecl( svga );

}

struct svga_tracked_state svga_update_swtnl_vdecl =

{

   "update draw module vdecl",

   (SVGA_NEW_VS |

    SVGA_NEW_FS),

   update_swtnl_vdecl

};