src/gallium/state_trackers/nine/vertexdeclaration9.c

   1 /*
   2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22
  23 #include "vertexdeclaration9.h"
  24 #include "vertexbuffer9.h"
  25 #include "device9.h"
  26 #include "nine_helpers.h"
  27
  28 #include "pipe/p_format.h"
  29 #include "pipe/p_context.h"
  30 #include "util/u_math.h"
  31 #include "util/u_format.h"
  32 #include "util/u_box.h"
  33 #include "translate/translate.h"
  34
  35 #define DBG_CHANNEL DBG_VERTEXDECLARATION
  36
  37 static inline enum pipe_format decltype_format(BYTE type)
  38 {
  39     switch (type) {
  40     case D3DDECLTYPE_FLOAT1:    return PIPE_FORMAT_R32_FLOAT;
  41     case D3DDECLTYPE_FLOAT2:    return PIPE_FORMAT_R32G32_FLOAT;
  42     case D3DDECLTYPE_FLOAT3:    return PIPE_FORMAT_R32G32B32_FLOAT;
  43     case D3DDECLTYPE_FLOAT4:    return PIPE_FORMAT_R32G32B32A32_FLOAT;
  44     case D3DDECLTYPE_D3DCOLOR:  return PIPE_FORMAT_B8G8R8A8_UNORM;
  45     case D3DDECLTYPE_UBYTE4:    return PIPE_FORMAT_R8G8B8A8_USCALED;
  46     case D3DDECLTYPE_SHORT2:    return PIPE_FORMAT_R16G16_SSCALED;
  47     case D3DDECLTYPE_SHORT4:    return PIPE_FORMAT_R16G16B16A16_SSCALED;
  48     case D3DDECLTYPE_UBYTE4N:   return PIPE_FORMAT_R8G8B8A8_UNORM;
  49     case D3DDECLTYPE_SHORT2N:   return PIPE_FORMAT_R16G16_SNORM;
  50     case D3DDECLTYPE_SHORT4N:   return PIPE_FORMAT_R16G16B16A16_SNORM;
  51     case D3DDECLTYPE_USHORT2N:  return PIPE_FORMAT_R16G16_UNORM;
  52     case D3DDECLTYPE_USHORT4N:  return PIPE_FORMAT_R16G16B16A16_UNORM;
  53     case D3DDECLTYPE_UDEC3:     return PIPE_FORMAT_R10G10B10X2_USCALED;
  54     case D3DDECLTYPE_DEC3N:     return PIPE_FORMAT_R10G10B10X2_SNORM;
  55     case D3DDECLTYPE_FLOAT16_2: return PIPE_FORMAT_R16G16_FLOAT;
  56     case D3DDECLTYPE_FLOAT16_4: return PIPE_FORMAT_R16G16B16A16_FLOAT;
  57     default:
  58         assert(!"Implementation error !");
  59     }
  60     return PIPE_FORMAT_NONE;
  61 }
  62
  63 static inline unsigned decltype_size(BYTE type)
  64 {
  65     switch (type) {
  66     case D3DDECLTYPE_FLOAT1: return 1 * sizeof(float);
  67     case D3DDECLTYPE_FLOAT2: return 2 * sizeof(float);
  68     case D3DDECLTYPE_FLOAT3: return 3 * sizeof(float);
  69     case D3DDECLTYPE_FLOAT4: return 4 * sizeof(float);
  70     case D3DDECLTYPE_D3DCOLOR: return 1 * sizeof(DWORD);
  71     case D3DDECLTYPE_UBYTE4: return 4 * sizeof(BYTE);
  72     case D3DDECLTYPE_SHORT2: return 2 * sizeof(short);
  73     case D3DDECLTYPE_SHORT4: return 4 * sizeof(short);
  74     case D3DDECLTYPE_UBYTE4N: return 4 * sizeof(BYTE);
  75     case D3DDECLTYPE_SHORT2N: return 2 * sizeof(short);
  76     case D3DDECLTYPE_SHORT4N: return 4 * sizeof(short);
  77     case D3DDECLTYPE_USHORT2N: return 2 * sizeof(short);
  78     case D3DDECLTYPE_USHORT4N: return 4 * sizeof(short);
  79     case D3DDECLTYPE_UDEC3: return 4;
  80     case D3DDECLTYPE_DEC3N: return 4;
  81     case D3DDECLTYPE_FLOAT16_2: return 2 * 2;
  82     case D3DDECLTYPE_FLOAT16_4: return 4 * 2;
  83     default:
  84         assert(!"Implementation error !");
  85     }
  86     return 0;
  87 }
  88
  89 /* Actually, arbitrary usage index values are permitted, but a
  90  * simple lookup table won't work in that case. Let's just wait
  91  * with making this more generic until we need it.
  92  */
  93 static inline boolean
  94 nine_d3ddeclusage_check(unsigned usage, unsigned usage_idx)
  95 {
  96     switch (usage) {
  97     case D3DDECLUSAGE_POSITIONT:
  98     case D3DDECLUSAGE_TESSFACTOR:
  99     case D3DDECLUSAGE_DEPTH:
 100     case D3DDECLUSAGE_NORMAL:
 101     case D3DDECLUSAGE_TANGENT:
 102     case D3DDECLUSAGE_BINORMAL:
 103     case D3DDECLUSAGE_POSITION:
 104     case D3DDECLUSAGE_BLENDWEIGHT:
 105     case D3DDECLUSAGE_BLENDINDICES:
 106     case D3DDECLUSAGE_COLOR:
 107         return TRUE;
 108     case D3DDECLUSAGE_PSIZE:
 109     case D3DDECLUSAGE_FOG:
 110     case D3DDECLUSAGE_SAMPLE:
 111         return usage_idx <= 0;
 112     case D3DDECLUSAGE_TEXCOORD:
 113         return usage_idx <= 15;
 114     default:
 115         return FALSE;
 116     }
 117 }
 118
 119 #define NINE_DECLUSAGE_CASE0(n) case D3DDECLUSAGE_##n: return NINE_DECLUSAGE_##n
 120 #define NINE_DECLUSAGE_CASEi(n) case D3DDECLUSAGE_##n: return NINE_DECLUSAGE_i(n, usage_idx)
 121 uint16_t
 122 nine_d3d9_to_nine_declusage(unsigned usage, unsigned usage_idx)
 123 {
 124     if (!nine_d3ddeclusage_check(usage, usage_idx))
 125         ERR("D3DDECLUSAGE_%u[%u]\n",usage,usage_idx);
 126     assert(nine_d3ddeclusage_check(usage, usage_idx));
 127     switch (usage) {
 128     NINE_DECLUSAGE_CASEi(POSITION);
 129     NINE_DECLUSAGE_CASEi(BLENDWEIGHT);
 130     NINE_DECLUSAGE_CASEi(BLENDINDICES);
 131     NINE_DECLUSAGE_CASEi(NORMAL);
 132     NINE_DECLUSAGE_CASE0(PSIZE);
 133     NINE_DECLUSAGE_CASEi(TEXCOORD);
 134     NINE_DECLUSAGE_CASEi(TANGENT);
 135     NINE_DECLUSAGE_CASEi(BINORMAL);
 136     NINE_DECLUSAGE_CASE0(TESSFACTOR);
 137     NINE_DECLUSAGE_CASEi(POSITIONT);
 138     NINE_DECLUSAGE_CASEi(COLOR);
 139     NINE_DECLUSAGE_CASE0(DEPTH);
 140     NINE_DECLUSAGE_CASE0(FOG);
 141     NINE_DECLUSAGE_CASE0(SAMPLE);
 142     default:
 143         assert(!"Invalid DECLUSAGE.");
 144         return NINE_DECLUSAGE_NONE;
 145     }
 146 }
 147
 148 static const char *nine_declusage_names[] =
 149 {
 150     [NINE_DECLUSAGE_POSITION]        = "POSITION",
 151     [NINE_DECLUSAGE_BLENDWEIGHT]     = "BLENDWEIGHT",
 152     [NINE_DECLUSAGE_BLENDINDICES]    = "BLENDINDICES",
 153     [NINE_DECLUSAGE_NORMAL]          = "NORMAL",
 154     [NINE_DECLUSAGE_PSIZE]           = "PSIZE",
 155     [NINE_DECLUSAGE_TEXCOORD]        = "TEXCOORD",
 156     [NINE_DECLUSAGE_TANGENT]         = "TANGENT",
 157     [NINE_DECLUSAGE_BINORMAL]        = "BINORMAL",
 158     [NINE_DECLUSAGE_TESSFACTOR]      = "TESSFACTOR",
 159     [NINE_DECLUSAGE_POSITIONT]       = "POSITIONT",
 160     [NINE_DECLUSAGE_COLOR]           = "DIFFUSE",
 161     [NINE_DECLUSAGE_DEPTH]           = "DEPTH",
 162     [NINE_DECLUSAGE_FOG]             = "FOG",
 163     [NINE_DECLUSAGE_NONE]            = "(NONE)",
 164 };
 165 static inline const char *
 166 nine_declusage_name(unsigned ndcl)
 167 {
 168     return nine_declusage_names[ndcl % NINE_DECLUSAGE_COUNT];
 169 }
 170
 171 HRESULT
 172 NineVertexDeclaration9_ctor( struct NineVertexDeclaration9 *This,
 173                              struct NineUnknownParams *pParams,
 174                              const D3DVERTEXELEMENT9 *pElements )
 175 {
 176     const D3DCAPS9 *caps;
 177     unsigned i, nelems;
 178     DBG("This=%p pParams=%p pElements=%p\n", This, pParams, pElements);
 179
 180     /* wine */
 181     for (nelems = 0;
 182          pElements[nelems].Stream != 0xFF;
 183          ++nelems) {
 184         user_assert(pElements[nelems].Type != D3DDECLTYPE_UNUSED, E_FAIL);
 185         user_assert(!(pElements[nelems].Offset & 3), E_FAIL);
 186     }
 187
 188     caps = NineDevice9_GetCaps(pParams->device);
 189     user_assert(nelems <= caps->MaxStreams, D3DERR_INVALIDCALL);
 190
 191     HRESULT hr = NineUnknown_ctor(&This->base, pParams);
 192     if (FAILED(hr)) { return hr; }
 193
 194     This->nelems = nelems;
 195     This->decls = CALLOC(This->nelems+1, sizeof(D3DVERTEXELEMENT9));
 196     This->elems = CALLOC(This->nelems, sizeof(struct pipe_vertex_element));
 197     This->usage_map = CALLOC(This->nelems, sizeof(uint16_t));
 198     if (!This->decls || !This->elems || !This->usage_map) { return E_OUTOFMEMORY; }
 199     memcpy(This->decls, pElements, sizeof(D3DVERTEXELEMENT9)*(This->nelems+1));
 200
 201     for (i = 0; i < This->nelems; ++i) {
 202         uint16_t usage = nine_d3d9_to_nine_declusage(This->decls[i].Usage,
 203                                                      This->decls[i].UsageIndex);
 204         This->usage_map[i] = usage;
 205
 206         if (This->decls[i].Usage == D3DDECLUSAGE_POSITIONT)
 207             This->position_t = TRUE;
 208
 209         This->elems[i].src_offset = This->decls[i].Offset;
 210         This->elems[i].instance_divisor = 0;
 211         This->elems[i].vertex_buffer_index = This->decls[i].Stream;
 212         This->elems[i].src_format = decltype_format(This->decls[i].Type);
 213         /* XXX Remember Method (tesselation), Usage, UsageIndex */
 214
 215         DBG("VERTEXELEMENT[%u]: Stream=%u Offset=%u Type=%s DeclUsage=%s%d\n", i,
 216             This->decls[i].Stream,
 217             This->decls[i].Offset,
 218             util_format_name(This->elems[i].src_format),
 219             nine_declusage_name(usage),
 220             usage / NINE_DECLUSAGE_COUNT);
 221     }
 222
 223     return D3D_OK;
 224 }
 225
 226 void
 227 NineVertexDeclaration9_dtor( struct NineVertexDeclaration9 *This )
 228 {
 229     FREE(This->decls);
 230     FREE(This->elems);
 231     FREE(This->usage_map);
 232
 233     NineUnknown_dtor(&This->base);
 234 }
 235
 236 HRESULT WINAPI
 237 NineVertexDeclaration9_GetDeclaration( struct NineVertexDeclaration9 *This,
 238                                        D3DVERTEXELEMENT9 *pElement,
 239                                        UINT *pNumElements )
 240 {
 241     if (!pElement) {
 242         user_assert(pNumElements, D3DERR_INVALIDCALL);
 243         *pNumElements = This->nelems+1;
 244         return D3D_OK;
 245     }
 246     if (pNumElements) { *pNumElements = This->nelems+1; }
 247     memcpy(pElement, This->decls, sizeof(D3DVERTEXELEMENT9)*(This->nelems+1));
 248     return D3D_OK;
 249 }
 250
 251 IDirect3DVertexDeclaration9Vtbl NineVertexDeclaration9_vtable = {
 252     (void *)NineUnknown_QueryInterface,
 253     (void *)NineUnknown_AddRef,
 254     (void *)NineUnknown_Release,
 255     (void *)NineUnknown_GetDevice, /* actually part of VertexDecl9 iface */
 256     (void *)NineVertexDeclaration9_GetDeclaration
 257 };
 258
 259 static const GUID *NineVertexDeclaration9_IIDs[] = {
 260     &IID_IDirect3DVertexDeclaration9,
 261     &IID_IUnknown,
 262     NULL
 263 };
 264
 265 HRESULT
 266 NineVertexDeclaration9_new( struct NineDevice9 *pDevice,
 267                             const D3DVERTEXELEMENT9 *pElements,
 268                             struct NineVertexDeclaration9 **ppOut )
 269 {
 270     NINE_DEVICE_CHILD_NEW(VertexDeclaration9, ppOut, /* args */ pDevice, pElements);
 271 }
 272
 273 HRESULT
 274 NineVertexDeclaration9_new_from_fvf( struct NineDevice9 *pDevice,
 275                                      DWORD FVF,
 276                                      struct NineVertexDeclaration9 **ppOut )
 277 {
 278     D3DVERTEXELEMENT9 elems[16], decl_end = D3DDECL_END();
 279     unsigned texcount, i, betas, nelems = 0;
 280     BYTE beta_index = 0xFF;
 281
 282     switch (FVF & D3DFVF_POSITION_MASK) {
 283         case D3DFVF_XYZ: /* simple XYZ */
 284         case D3DFVF_XYZB1:
 285         case D3DFVF_XYZB2:
 286         case D3DFVF_XYZB3:
 287         case D3DFVF_XYZB4:
 288         case D3DFVF_XYZB5: /* XYZ with beta values */
 289             elems[nelems].Type = D3DDECLTYPE_FLOAT3;
 290             elems[nelems].Usage = D3DDECLUSAGE_POSITION;
 291             elems[nelems].UsageIndex = 0;
 292             ++nelems;
 293             /* simple XYZ has no beta values. break. */
 294             if ((FVF & D3DFVF_POSITION_MASK) == D3DFVF_XYZ) { break; }
 295
 296             betas = (((FVF & D3DFVF_XYZB5)-D3DFVF_XYZB1)>>1)+1;
 297             if (FVF & D3DFVF_LASTBETA_D3DCOLOR) {
 298                 beta_index = D3DDECLTYPE_D3DCOLOR;
 299             } else if (FVF & D3DFVF_LASTBETA_UBYTE4) {
 300                 beta_index = D3DDECLTYPE_UBYTE4;
 301             } else if ((FVF & D3DFVF_XYZB5) == D3DFVF_XYZB5) {
 302                 beta_index = D3DDECLTYPE_FLOAT1;
 303             }
 304             if (beta_index != 0xFF) { --betas; }
 305
 306             if (betas > 0) {
 307                 switch (betas) {
 308                     case 1: elems[nelems].Type = D3DDECLTYPE_FLOAT1; break;
 309                     case 2: elems[nelems].Type = D3DDECLTYPE_FLOAT2; break;
 310                     case 3: elems[nelems].Type = D3DDECLTYPE_FLOAT3; break;
 311                     case 4: elems[nelems].Type = D3DDECLTYPE_FLOAT4; break;
 312                     default:
 313                         assert(!"Implementation error!");
 314                 }
 315                 elems[nelems].Usage = D3DDECLUSAGE_BLENDWEIGHT;
 316                 elems[nelems].UsageIndex = 0;
 317                 ++nelems;
 318             }
 319
 320             if (beta_index != 0xFF) {
 321                 elems[nelems].Type = beta_index;
 322                 elems[nelems].Usage = D3DDECLUSAGE_BLENDINDICES;
 323                 elems[nelems].UsageIndex = 0;
 324                 ++nelems;
 325             }
 326             break;
 327
 328         case D3DFVF_XYZW: /* simple XYZW */
 329         case D3DFVF_XYZRHW: /* pretransformed XYZW */
 330             elems[nelems].Type = D3DDECLTYPE_FLOAT4;
 331             elems[nelems].Usage =
 332                 ((FVF & D3DFVF_POSITION_MASK) == D3DFVF_XYZW) ?
 333                 D3DDECLUSAGE_POSITION : D3DDECLUSAGE_POSITIONT;
 334             elems[nelems].UsageIndex = 0;
 335             ++nelems;
 336             break;
 337
 338         default:
 339             (void)user_error(!"Position doesn't match any known combination");
 340     }
 341
 342     /* normals, psize and colors */
 343     if (FVF & D3DFVF_NORMAL) {
 344         elems[nelems].Type = D3DDECLTYPE_FLOAT3;
 345         elems[nelems].Usage = D3DDECLUSAGE_NORMAL;
 346         elems[nelems].UsageIndex = 0;
 347         ++nelems;
 348     }
 349     if (FVF & D3DFVF_PSIZE) {
 350         elems[nelems].Type = D3DDECLTYPE_FLOAT1;
 351         elems[nelems].Usage = D3DDECLUSAGE_PSIZE;
 352         elems[nelems].UsageIndex = 0;
 353         ++nelems;
 354     }
 355     if (FVF & D3DFVF_DIFFUSE) {
 356         elems[nelems].Type = D3DDECLTYPE_D3DCOLOR;
 357         elems[nelems].Usage = D3DDECLUSAGE_COLOR;
 358         elems[nelems].UsageIndex = 0;
 359         ++nelems;
 360     }
 361     if (FVF & D3DFVF_SPECULAR) {
 362         elems[nelems].Type = D3DDECLTYPE_D3DCOLOR;
 363         elems[nelems].Usage = D3DDECLUSAGE_COLOR;
 364         elems[nelems].UsageIndex = 1;
 365         ++nelems;
 366     }
 367
 368     /* textures */
 369     texcount = (FVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
 370     if (user_error(texcount <= 8)) { texcount = 8; }
 371
 372     for (i = 0; i < texcount; ++i) {
 373         switch ((FVF >> (16+i*2)) & 0x3) {
 374             case D3DFVF_TEXTUREFORMAT1:
 375                 elems[nelems].Type = D3DDECLTYPE_FLOAT1;
 376                 break;
 377
 378             case D3DFVF_TEXTUREFORMAT2:
 379                 elems[nelems].Type = D3DDECLTYPE_FLOAT2;
 380                 break;
 381
 382             case D3DFVF_TEXTUREFORMAT3:
 383                 elems[nelems].Type = D3DDECLTYPE_FLOAT3;
 384                 break;
 385
 386             case D3DFVF_TEXTUREFORMAT4:
 387                 elems[nelems].Type = D3DDECLTYPE_FLOAT4;
 388                 break;
 389
 390             default:
 391                 assert(!"Implementation error!");
 392         }
 393         elems[nelems].Usage = D3DDECLUSAGE_TEXCOORD;
 394         elems[nelems].UsageIndex = i;
 395         ++nelems;
 396     }
 397
 398     /* fill out remaining data */
 399     for (i = 0; i < nelems; ++i) {
 400         elems[i].Stream = 0;
 401         elems[i].Offset = (i == 0) ? 0 : (elems[i-1].Offset +
 402                                           decltype_size(elems[i-1].Type));
 403         elems[i].Method = D3DDECLMETHOD_DEFAULT;
 404     }
 405     elems[nelems++] = decl_end;
 406
 407     NINE_DEVICE_CHILD_NEW(VertexDeclaration9, ppOut, /* args */ pDevice, elems);
 408 }
 409
 410 /* ProcessVertices runs stream output into a temporary buffer to capture
 411  * all outputs.
 412  * Now we have to convert them to the format and order set by the vertex
 413  * declaration, for which we use u_translate.
 414  * This is necessary if the vertex declaration contains elements using a
 415  * non float32 format, because stream output only supports f32/u32/s32.
 416  */
 417 HRESULT
 418 NineVertexDeclaration9_ConvertStreamOutput(
 419     struct NineVertexDeclaration9 *This,
 420     struct NineVertexBuffer9 *pDstBuf,
 421     UINT DestIndex,
 422     UINT VertexCount,
 423     struct pipe_resource *pSrcBuf,
 424     const struct pipe_stream_output_info *so )
 425 {
 426     struct pipe_context *pipe = This->base.device->pipe;
 427     struct pipe_transfer *transfer = NULL;
 428     struct translate *translate;
 429     struct translate_key transkey;
 430     struct pipe_box box;
 431     HRESULT hr;
 432     unsigned i;
 433     void *src_map;
 434     void *dst_map;
 435
 436     DBG("This=%p pDstBuf=%p DestIndex=%u VertexCount=%u pSrcBuf=%p so=%p\n",
 437         This, pDstBuf, DestIndex, VertexCount, pSrcBuf, so);
 438
 439     transkey.output_stride = 0;
 440     for (i = 0; i < This->nelems; ++i) {
 441         enum pipe_format format;
 442
 443         switch (so->output[i].num_components) {
 444         case 1: format = PIPE_FORMAT_R32_FLOAT; break;
 445         case 2: format = PIPE_FORMAT_R32G32_FLOAT; break;
 446         case 3: format = PIPE_FORMAT_R32G32B32_FLOAT; break;
 447         default:
 448             assert(so->output[i].num_components == 4);
 449             format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 450             break;
 451         }
 452         transkey.element[i].type = TRANSLATE_ELEMENT_NORMAL;
 453         transkey.element[i].input_format = format;
 454         transkey.element[i].input_buffer = 0;
 455         transkey.element[i].input_offset = so->output[i].dst_offset * 4;
 456         transkey.element[i].instance_divisor = 0;
 457
 458         transkey.element[i].output_format = This->elems[i].src_format;
 459         transkey.element[i].output_offset = This->elems[i].src_offset;
 460         transkey.output_stride +=
 461             util_format_get_blocksize(This->elems[i].src_format);
 462
 463         assert(!(transkey.output_stride & 3));
 464     }
 465     transkey.nr_elements = This->nelems;
 466
 467     translate = translate_create(&transkey);
 468     if (!translate)
 469         return E_OUTOFMEMORY;
 470
 471     hr = NineVertexBuffer9_Lock(pDstBuf,
 472                                 transkey.output_stride * DestIndex,
 473                                 transkey.output_stride * VertexCount,
 474                                 &dst_map, D3DLOCK_DISCARD);
 475     if (FAILED(hr))
 476         goto out;
 477
 478     src_map = pipe->transfer_map(pipe, pSrcBuf, 0, PIPE_TRANSFER_READ, &box,
 479                                  &transfer);
 480     if (!src_map) {
 481         hr = D3DERR_DRIVERINTERNALERROR;
 482         goto out;
 483     }
 484     translate->set_buffer(translate, 0, src_map, so->stride[0], ~0);
 485
 486     translate->run(translate, 0, VertexCount, 0, 0, dst_map);
 487
 488     NineVertexBuffer9_Unlock(pDstBuf);
 489 out:
 490     if (transfer)
 491         pipe->transfer_unmap(pipe, transfer);
 492     translate->release(translate); /* TODO: cache these */
 493     return hr;
 494 }