frontends/d3d10umd/InputAssembly.cpp

/**************************************************************************
 *
 * Copyright 2012-2021 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, sub license, 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 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 NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 **************************************************************************/

/*
 * InputAssembly.cpp --
 *    Functions that manipulate the input assembly stage.
 */


#include <stdio.h>
#if defined(_MSC_VER) && !defined(snprintf)
#define snprintf _snprintf
#endif

#include "InputAssembly.h"
#include "State.h"

#include "Debug.h"
#include "Format.h"


/*
 * ----------------------------------------------------------------------
 *
 * IaSetTopology --
 *
 *    The IaSetTopology function sets the primitive topology to
 *    enable drawing for the input assember.
 *
 * ----------------------------------------------------------------------
 */

void APIENTRY
IaSetTopology(D3D10DDI_HDEVICE hDevice,                        // IN
              D3D10_DDI_PRIMITIVE_TOPOLOGY PrimitiveTopology)  // IN
{
   LOG_ENTRYPOINT();

   Device *pDevice = CastDevice(hDevice);

   enum pipe_prim_type primitive;
   switch (PrimitiveTopology) {
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_UNDEFINED:
      /* Apps might set topology to UNDEFINED when cleaning up on exit. */
      primitive = PIPE_PRIM_MAX;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_POINTLIST:
      primitive = PIPE_PRIM_POINTS;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_LINELIST:
      primitive = PIPE_PRIM_LINES;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_LINESTRIP:
      primitive = PIPE_PRIM_LINE_STRIP;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_TRIANGLELIST:
      primitive = PIPE_PRIM_TRIANGLES;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP:
      primitive = PIPE_PRIM_TRIANGLE_STRIP;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_LINELIST_ADJ:
      primitive = PIPE_PRIM_LINES_ADJACENCY;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ:
      primitive = PIPE_PRIM_LINE_STRIP_ADJACENCY;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ:
      primitive = PIPE_PRIM_TRIANGLES_ADJACENCY;
      break;
   case D3D10_DDI_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ:
      primitive = PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY;
      break;
   default:
      assert(0);
      primitive = PIPE_PRIM_MAX;
      break;
   }

   pDevice->primitive = primitive;
}


/*
 * ----------------------------------------------------------------------
 *
 * IaSetVertexBuffers --
 *
 *    The IaSetVertexBuffers function sets vertex buffers
 *    for an input assembler.
 *
 * ----------------------------------------------------------------------
 */

void APIENTRY
IaSetVertexBuffers(D3D10DDI_HDEVICE hDevice,                                     // IN
                   UINT StartBuffer,                                             // IN
                   UINT NumBuffers,                                              // IN
                   __in_ecount (NumBuffers) const D3D10DDI_HRESOURCE *phBuffers, // IN
                   __in_ecount (NumBuffers) const UINT *pStrides,                // IN
                   __in_ecount (NumBuffers) const UINT *pOffsets)                // IN
{
   static const float dummy[4] = {0.0f, 0.0f, 0.0f, 0.0f};

   LOG_ENTRYPOINT();

   Device *pDevice = CastDevice(hDevice);
   struct pipe_context *pipe = pDevice->pipe;
   unsigned i;

   for (i = 0; i < NumBuffers; i++) {
      struct pipe_vertex_buffer *vb = &pDevice->vertex_buffers[StartBuffer + i];
      struct pipe_resource *resource = CastPipeResource(phBuffers[i]);
      Resource *res = CastResource(phBuffers[i]);
      struct pipe_stream_output_target *so_target =
         res ? res->so_target : NULL;

      if (so_target && pDevice->draw_so_target != so_target) {
         if (pDevice->draw_so_target) {
            pipe_so_target_reference(&pDevice->draw_so_target, NULL);
         }
         pipe_so_target_reference(&pDevice->draw_so_target,
                                  so_target);
      }

      if (resource) {
         vb->stride = pStrides[i];
         vb->buffer_offset = pOffsets[i];
         if (vb->is_user_buffer) {
            vb->buffer.resource = NULL;
            vb->is_user_buffer = FALSE;
         }
         pipe_resource_reference(&vb->buffer.resource, resource);
      }
      else {
         vb->stride = 0;
         vb->buffer_offset = 0;
         if (!vb->is_user_buffer) {
            pipe_resource_reference(&vb->buffer.resource, NULL);
            vb->is_user_buffer = TRUE;
         }
         vb->buffer.user = dummy;
      }
   }

   for (i = 0; i < PIPE_MAX_ATTRIBS; ++i) {
      struct pipe_vertex_buffer *vb = &pDevice->vertex_buffers[i];

      /* XXX this is odd... */
      if (!vb->is_user_buffer && !vb->buffer.resource) {
         vb->stride = 0;
         vb->buffer_offset = 0;
         vb->is_user_buffer = TRUE;
         vb->buffer.user = dummy;
      }
   }

   /* Resubmit old and new vertex buffers.
    */
   pipe->set_vertex_buffers(pipe, 0, PIPE_MAX_ATTRIBS, 0, FALSE, pDevice->vertex_buffers);
}


/*
 * ----------------------------------------------------------------------
 *
 * IaSetIndexBuffer --
 *
 *    The IaSetIndexBuffer function sets an index buffer for
 *    an input assembler.
 *
 * ----------------------------------------------------------------------
 */

void APIENTRY
IaSetIndexBuffer(D3D10DDI_HDEVICE hDevice,   // IN
                 D3D10DDI_HRESOURCE hBuffer, // IN
                 DXGI_FORMAT Format,         // IN
                 UINT Offset)                // IN
{
   LOG_ENTRYPOINT();

   Device *pDevice = CastDevice(hDevice);
   struct pipe_resource *resource = CastPipeResource(hBuffer);

   if (resource) {
      pDevice->ib_offset = Offset;

      switch (Format) {
      case DXGI_FORMAT_R16_UINT:
         pDevice->index_size = 2;
         pDevice->restart_index = 0xffff;
         break;
      case DXGI_FORMAT_R32_UINT:
         pDevice->restart_index = 0xffffffff;
         pDevice->index_size = 4;
         break;
      default:
         assert(0);             /* should not happen */
         pDevice->index_size = 2;
         break;
      }
      pipe_resource_reference(&pDevice->index_buffer, resource);
   } else {
      pipe_resource_reference(&pDevice->index_buffer, NULL);
   }
}


/*
 * ----------------------------------------------------------------------
 *
 * CalcPrivateElementLayoutSize --
 *
 *    The CalcPrivateElementLayoutSize function determines the size
 *    of the user-mode display driver's private region of memory
 *    (that is, the size of internal driver structures, not the size
 *    of the resource video memory) for an element layout.
 *
 * ----------------------------------------------------------------------
 */

SIZE_T APIENTRY
CalcPrivateElementLayoutSize(
   D3D10DDI_HDEVICE hDevice,                                         // IN
   __in const D3D10DDIARG_CREATEELEMENTLAYOUT *pCreateElementLayout) // IN
{
   return sizeof(ElementLayout);
}


/*
 * ----------------------------------------------------------------------
 *
 * CreateElementLayout --
 *
 *    The CreateElementLayout function creates an element layout.
 *
 * ----------------------------------------------------------------------
 */

void APIENTRY
CreateElementLayout(
   D3D10DDI_HDEVICE hDevice,                                         // IN
   __in const D3D10DDIARG_CREATEELEMENTLAYOUT *pCreateElementLayout, // IN
   D3D10DDI_HELEMENTLAYOUT hElementLayout,                           // IN
   D3D10DDI_HRTELEMENTLAYOUT hRTElementLayout)                       // IN
{
   LOG_ENTRYPOINT();

   struct pipe_context *pipe = CastPipeContext(hDevice);
   ElementLayout *pElementLayout = CastElementLayout(hElementLayout);

   struct pipe_vertex_element elements[PIPE_MAX_ATTRIBS];
   memset(elements, 0, sizeof elements);

   unsigned num_elements = pCreateElementLayout->NumElements;
   unsigned max_elements = 0;
   for (unsigned i = 0; i < num_elements; i++) {
      const D3D10DDIARG_INPUT_ELEMENT_DESC* pVertexElement =
            &pCreateElementLayout->pVertexElements[i];
      struct pipe_vertex_element *ve =
            &elements[pVertexElement->InputRegister];

      ve->src_offset          = pVertexElement->AlignedByteOffset;
      ve->vertex_buffer_index = pVertexElement->InputSlot;
      ve->src_format          = FormatTranslate(pVertexElement->Format, FALSE);

      switch (pVertexElement->InputSlotClass) {
      case D3D10_DDI_INPUT_PER_VERTEX_DATA:
         ve->instance_divisor = 0;
         break;
      case D3D10_DDI_INPUT_PER_INSTANCE_DATA:
         if (!pVertexElement->InstanceDataStepRate) {
            LOG_UNSUPPORTED(!pVertexElement->InstanceDataStepRate);
            ve->instance_divisor = ~0;
         } else {
            ve->instance_divisor = pVertexElement->InstanceDataStepRate;
         }
         break;
      default:
         assert(0);
         break;
      }

      max_elements = MAX2(max_elements, pVertexElement->InputRegister + 1);
   }

   /* XXX: What do we do when there's a gap? */
   if (max_elements != num_elements) {
      DebugPrintf("%s: gap\n", __FUNCTION__);
   }

   pElementLayout->handle =
         pipe->create_vertex_elements_state(pipe, max_elements, elements);
}


/*
 * ----------------------------------------------------------------------
 *
 * DestroyElementLayout --
 *
 *    The DestroyElementLayout function destroys the specified
 *    element layout object. The element layout object can be
 *    destoyed only if it is not currently bound to a display device.
 *
 * ----------------------------------------------------------------------
 */

void APIENTRY
DestroyElementLayout(D3D10DDI_HDEVICE hDevice,                 // IN
                     D3D10DDI_HELEMENTLAYOUT hElementLayout)   // IN
{
   LOG_ENTRYPOINT();

   struct pipe_context *pipe = CastPipeContext(hDevice);
   ElementLayout *pElementLayout = CastElementLayout(hElementLayout);

   pipe->delete_vertex_elements_state(pipe, pElementLayout->handle);}


/*
 * ----------------------------------------------------------------------
 *
 * IaSetInputLayout --
 *
 *    The IaSetInputLayout function sets an input layout for
 *    the input assembler.
 *
 * ----------------------------------------------------------------------
 */

void APIENTRY
IaSetInputLayout(D3D10DDI_HDEVICE hDevice,               // IN
                 D3D10DDI_HELEMENTLAYOUT hInputLayout)   // IN
{
   LOG_ENTRYPOINT();

   struct pipe_context *pipe = CastPipeContext(hDevice);
   void *state = CastPipeInputLayout(hInputLayout);

   pipe->bind_vertex_elements_state(pipe, state);
}