vertexdeclaration.c File Reference

#include "d3d8_private.h"

Include dependency graph for vertexdeclaration.c:

Go to the source code of this file.

Macros
#define	D3DVSDT_TYPE_TO_STR(u)   case u: return #u
#define	D3DVSDE_REGISTER_TO_STR(u)   case u: return #u

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3d8)
static const char *	debug_d3dvsdt_type (D3DVSDT_TYPE d3dvsdt_type)
static const char *	debug_d3dvsde_register (D3DVSDE_REGISTER d3dvsde_register)
size_t	parse_token (const DWORD *pToken)
void	load_local_constants (const DWORD *d3d8_elements, struct wined3d_shader *wined3d_vertex_shader)
static UINT	convert_to_wined3d_declaration (const DWORD *d3d8_elements, DWORD *d3d8_elements_size, struct wined3d_vertex_element **wined3d_elements, DWORD *stream_map)
static void STDMETHODCALLTYPE	d3d8_vertexdeclaration_wined3d_object_destroyed (void *parent)
void	d3d8_vertex_declaration_destroy (struct d3d8_vertex_declaration *declaration)
HRESULT	d3d8_vertex_declaration_init (struct d3d8_vertex_declaration *declaration, struct d3d8_device *device, const DWORD *elements, DWORD shader_handle)
HRESULT	d3d8_vertex_declaration_init_fvf (struct d3d8_vertex_declaration *declaration, struct d3d8_device *device, DWORD fvf)

Variables
static const size_t	wined3d_type_sizes []
static enum wined3d_format_id	wined3d_format_lookup []
struct {
BYTE   usage
BYTE   usage_idx
}	wined3d_usage_lookup []
static const struct wined3d_parent_ops	d3d8_vertexdeclaration_wined3d_parent_ops

Macro Definition Documentation

D3DVSDE_REGISTER_TO_STR

#define D3DVSDE_REGISTER_TO_STR

(

u

)

case u: return #u

D3DVSDT_TYPE_TO_STR

#define D3DVSDT_TYPE_TO_STR

(

u

)

case u: return #u

Function Documentation

convert_to_wined3d_declaration()

static UINT convert_to_wined3d_declaration ( const DWORD *  d3d8_elements, DWORD *  d3d8_elements_size, struct wined3d_vertex_element **  wined3d_elements, DWORD *  stream_map  )

static

Definition at line 250 of file vertexdeclaration.c.

{
    struct wined3d_vertex_element *element;
    const DWORD *token = d3d8_elements;
    D3DVSD_TOKENTYPE token_type;
    unsigned int element_count = 0;
    WORD stream = 0;
    int offset = 0;
 
    TRACE("d3d8_elements %p, d3d8_elements_size %p, wined3d_elements %p\n", d3d8_elements, d3d8_elements_size, wined3d_elements);
 
    *stream_map = 0;
    /* 128 should be enough for anyone... */
    *wined3d_elements = calloc(128, sizeof(**wined3d_elements));
    while (D3DVSD_END() != *token)
    {
        token_type = ((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT);
 
        if (token_type == D3DVSD_TOKEN_STREAM && !(*token & D3DVSD_STREAMTESSMASK))
        {
            stream = ((*token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT);
            offset = 0;
        } else if (token_type == D3DVSD_TOKEN_STREAMDATA && !(*token & D3DVSD_DATALOADTYPEMASK)) {
            DWORD type = ((*token & D3DVSD_DATATYPEMASK) >> D3DVSD_DATATYPESHIFT);
            DWORD reg  = ((*token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
 
            TRACE("Adding element %d:\n", element_count);
 
            element = *wined3d_elements + element_count++;
            element->format = wined3d_format_lookup[type];
            element->input_slot = stream;
            element->offset = offset;
            element->output_slot = reg;
            element->input_slot_class = WINED3D_INPUT_PER_VERTEX_DATA;
            element->instance_data_step_rate = 0;
            element->method = WINED3D_DECL_METHOD_DEFAULT;
            element->usage = wined3d_usage_lookup[reg].usage;
            element->usage_idx = wined3d_usage_lookup[reg].usage_idx;
 
            *stream_map |= 1u << stream;
 
            offset += wined3d_type_sizes[type];
        } else if (token_type == D3DVSD_TOKEN_STREAMDATA && (*token & D3DVSD_DATALOADTYPEMASK)) {
            TRACE(" 0x%08lx SKIP(%lu)\n", *token, (*token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
            offset += sizeof(DWORD) * ((*token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT);
        }
 
        if (element_count >= 127) {
            ERR("More than 127 elements?\n");
            break;
        }
 
        token += parse_token(token);
    }
 
    *d3d8_elements_size = (++token - d3d8_elements) * sizeof(DWORD);
 
    return element_count;
}

Referenced by d3d8_vertex_declaration_init(), and vertexdeclaration_init().

d3d8_vertex_declaration_destroy()

void d3d8_vertex_declaration_destroy

(

struct d3d8_vertex_declaration *

declaration

)

Definition at line 318 of file vertexdeclaration.c.

{
    TRACE("declaration %p.\n", declaration);
 
    wined3d_vertex_declaration_decref(declaration->wined3d_vertex_declaration);
}

Referenced by d3d8_device_get_fvf_declaration(), d3d8_device_Release(), d3d8_vertex_shader_init(), and d3d8_vertexshader_wined3d_object_destroyed().

d3d8_vertex_declaration_init()

HRESULT d3d8_vertex_declaration_init	(	struct d3d8_vertex_declaration *	declaration,
		struct d3d8_device *	device,
		const DWORD *	elements,
		DWORD	shader_handle
	)

Definition at line 330 of file vertexdeclaration.c.

{
    struct wined3d_vertex_element *wined3d_elements;
    UINT wined3d_element_count;
    HRESULT hr;
 
    declaration->shader_handle = shader_handle;
 
    wined3d_element_count = convert_to_wined3d_declaration(elements, &declaration->elements_size,
            &wined3d_elements, &declaration->stream_map);
    if (!(declaration->elements = malloc(declaration->elements_size)))
    {
        ERR("Failed to allocate vertex declaration elements memory.\n");
        free(wined3d_elements);
        return E_OUTOFMEMORY;
    }
 
    memcpy(declaration->elements, elements, declaration->elements_size);
 
    wined3d_mutex_lock();
    hr = wined3d_vertex_declaration_create(device->wined3d_device, wined3d_elements, wined3d_element_count,
            declaration, &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
    wined3d_mutex_unlock();
    free(wined3d_elements);
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d vertex declaration, hr %#lx.\n", hr);
        free(declaration->elements);
        if (hr == E_INVALIDARG)
            hr = E_FAIL;
        return hr;
    }
 
    return D3D_OK;
}

Referenced by d3d8_vertexshader_create_vertexdeclaration().

d3d8_vertex_declaration_init_fvf()

HRESULT d3d8_vertex_declaration_init_fvf	(	struct d3d8_vertex_declaration *	declaration,
		struct d3d8_device *	device,
		DWORD	fvf
	)

Definition at line 367 of file vertexdeclaration.c.

{
    HRESULT hr;
 
    declaration->elements = NULL;
    declaration->elements_size = 0;
    declaration->stream_map = 1;
    declaration->shader_handle = fvf;
 
    hr = wined3d_vertex_declaration_create_from_fvf(device->wined3d_device, fvf, declaration,
            &d3d8_vertexdeclaration_wined3d_parent_ops, &declaration->wined3d_vertex_declaration);
    if (FAILED(hr))
    {
        WARN("Failed to create wined3d vertex declaration, hr %#lx.\n", hr);
        if (hr == E_INVALIDARG)
            hr = E_FAIL;
        return hr;
    }
 
    return D3D_OK;
}

Referenced by d3d8_device_get_fvf_declaration().

d3d8_vertexdeclaration_wined3d_object_destroyed()

static void STDMETHODCALLTYPE d3d8_vertexdeclaration_wined3d_object_destroyed ( void *  parent )

static

Definition at line 311 of file vertexdeclaration.c.

{
    struct d3d8_vertex_declaration *declaration = parent;
    free(declaration->elements);
    free(declaration);
}

debug_d3dvsde_register()

static const char * debug_d3dvsde_register ( D3DVSDE_REGISTER  d3dvsde_register )

static

Definition at line 43 of file vertexdeclaration.c.

{
    switch (d3dvsde_register)
    {
#define D3DVSDE_REGISTER_TO_STR(u) case u: return #u
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDWEIGHT);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_BLENDINDICES);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_PSIZE);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_DIFFUSE);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_SPECULAR);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD0);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD1);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD2);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD3);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD4);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD5);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD6);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_TEXCOORD7);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_POSITION2);
        D3DVSDE_REGISTER_TO_STR(D3DVSDE_NORMAL2);
#undef D3DVSDE_REGISTER_TO_STR
        default:
            FIXME("Unrecognized D3DVSDE_REGISTER %#x\n", d3dvsde_register);
            return "unrecognized";
    }
}

Referenced by parse_token().

debug_d3dvsdt_type()

static const char * debug_d3dvsdt_type ( D3DVSDT_TYPE  d3dvsdt_type )

static

Definition at line 23 of file vertexdeclaration.c.

{
    switch (d3dvsdt_type)
    {
#define D3DVSDT_TYPE_TO_STR(u) case u: return #u
        D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT1);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT2);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT3);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_FLOAT4);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_D3DCOLOR);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_UBYTE4);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT2);
        D3DVSDT_TYPE_TO_STR(D3DVSDT_SHORT4);
#undef D3DVSDT_TYPE_TO_STR
        default:
            FIXME("Unrecognized D3DVSDT_TYPE %#x\n", d3dvsdt_type);
            return "unrecognized";
    }
}

Referenced by parse_token().

load_local_constants()

void load_local_constants	(	const DWORD *	d3d8_elements,
		struct wined3d_shader *	wined3d_vertex_shader
	)

Definition at line 146 of file vertexdeclaration.c.

{
    const DWORD *token = d3d8_elements;
 
    while (*token != D3DVSD_END())
    {
        if (((*token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) == D3DVSD_TOKEN_CONSTMEM)
        {
            DWORD count = ((*token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
            DWORD constant_idx = ((*token & D3DVSD_CONSTADDRESSMASK) >> D3DVSD_CONSTADDRESSSHIFT);
            HRESULT hr;
 
            if (TRACE_ON(d3d8))
            {
                DWORD i;
                for (i = 0; i < count; ++i)
                {
                    TRACE("c[%lu] = (%8f, %8f, %8f, %8f)\n",
                            constant_idx,
                            *(const float *)(token + i * 4 + 1),
                            *(const float *)(token + i * 4 + 2),
                            *(const float *)(token + i * 4 + 3),
                            *(const float *)(token + i * 4 + 4));
                }
            }
            hr = wined3d_shader_set_local_constants_float(wined3d_vertex_shader,
                    constant_idx, (const float *)token + 1, count);
            if (FAILED(hr)) ERR("Failed setting shader constants\n");
        }
 
        token += parse_token(token);
    }
}

Referenced by d3d8_vertex_shader_init().

parse_token()

size_t parse_token

(

const DWORD *

pToken

)

Definition at line 72 of file vertexdeclaration.c.

{
    const DWORD token = *pToken;
    size_t tokenlen = 1;
 
    switch ((token & D3DVSD_TOKENTYPEMASK) >> D3DVSD_TOKENTYPESHIFT) { /* maybe a macro to inverse ... */
        case D3DVSD_TOKEN_NOP:
            TRACE(" 0x%08lx NOP()\n", token);
            break;
 
        case D3DVSD_TOKEN_STREAM:
            if (token & D3DVSD_STREAMTESSMASK)
            {
                TRACE(" 0x%08lx STREAM_TESS()\n", token);
            } else {
                TRACE(" 0x%08lx STREAM(%lu)\n", token, ((token & D3DVSD_STREAMNUMBERMASK) >> D3DVSD_STREAMNUMBERSHIFT));
            }
            break;
 
        case D3DVSD_TOKEN_STREAMDATA:
            if (token & 0x10000000)
            {
                TRACE(" 0x%08lx SKIP(%lu)\n", token, ((token & D3DVSD_SKIPCOUNTMASK) >> D3DVSD_SKIPCOUNTSHIFT));
            } else {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
                DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
                TRACE(" 0x%08lx REG(%s, %s)\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
            }
            break;
 
        case D3DVSD_TOKEN_TESSELLATOR:
            if (token & 0x10000000)
            {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)  >> D3DVSD_DATATYPESHIFT);
                DWORD reg = ((token & D3DVSD_VERTEXREGMASK) >> D3DVSD_VERTEXREGSHIFT);
                TRACE(" 0x%08lx TESSUV(%s) as %s\n", token, debug_d3dvsde_register(reg), debug_d3dvsdt_type(type));
            } else {
                DWORD type = ((token & D3DVSD_DATATYPEMASK)    >> D3DVSD_DATATYPESHIFT);
                DWORD regout = ((token & D3DVSD_VERTEXREGMASK)   >> D3DVSD_VERTEXREGSHIFT);
                DWORD regin = ((token & D3DVSD_VERTEXREGINMASK) >> D3DVSD_VERTEXREGINSHIFT);
                TRACE(" 0x%08lx TESSNORMAL(%s, %s) as %s\n", token, debug_d3dvsde_register(regin),
                        debug_d3dvsde_register(regout), debug_d3dvsdt_type(type));
            }
            break;
 
        case D3DVSD_TOKEN_CONSTMEM:
            {
                DWORD count = ((token & D3DVSD_CONSTCOUNTMASK)   >> D3DVSD_CONSTCOUNTSHIFT);
                tokenlen = (4 * count) + 1;
            }
            break;
 
        case D3DVSD_TOKEN_EXT:
            {
                DWORD count = ((token & D3DVSD_CONSTCOUNTMASK) >> D3DVSD_CONSTCOUNTSHIFT);
                DWORD extinfo = ((token & D3DVSD_EXTINFOMASK)    >> D3DVSD_EXTINFOSHIFT);
                TRACE(" 0x%08lx EXT(%lu, %lu)\n", token, count, extinfo);
                /* todo ... print extension */
                tokenlen = count + 1;
            }
            break;
 
        case D3DVSD_TOKEN_END:
            TRACE(" 0x%08lx END()\n", token);
            break;
 
        default:
            TRACE(" 0x%08lx UNKNOWN\n", token);
            /* arg error */
    }
 
    return tokenlen;
}

Referenced by convert_to_wined3d_declaration(), d3d8_vertex_shader_init(), and load_local_constants().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

d3d8

)

Variable Documentation

d3d8_vertexdeclaration_wined3d_parent_ops

const struct wined3d_parent_ops d3d8_vertexdeclaration_wined3d_parent_ops

static

Initial value:

=
{
    d3d8_vertexdeclaration_wined3d_object_destroyed,
}

Definition at line 325 of file vertexdeclaration.c.

Referenced by d3d8_vertex_declaration_init(), and d3d8_vertex_declaration_init_fvf().

usage

BYTE usage

(

void

)

Definition at line 225 of file vertexdeclaration.c.

Referenced by append_decl_element().

usage_idx

BYTE usage_idx

Definition at line 226 of file vertexdeclaration.c.

Referenced by allocate_semantic_register(), append_decl_element(), d3dbc_write_semantic_dcl(), find_ps_builtin_semantics(), fixed_get_input(), generate_vsir_signature_entry(), record_declaration(), shader_print_dcl_usage(), shader_signature_from_usage(), sm1_usage_from_semantic_name(), and vs_find_builtin_varyings().

wined3d_format_lookup

enum wined3d_format_id wined3d_format_lookup[]

static

Initial value:

=
{
        WINED3DFMT_R32_FLOAT,
        WINED3DFMT_R32G32_FLOAT,
        WINED3DFMT_R32G32B32_FLOAT,
        WINED3DFMT_R32G32B32A32_FLOAT,
      WINED3DFMT_B8G8R8A8_UNORM,
        WINED3DFMT_R8G8B8A8_UINT,
        WINED3DFMT_R16G16_SINT,
        WINED3DFMT_R16G16B16A16_SINT,
       WINED3DFMT_R8G8B8A8_UNORM,
       WINED3DFMT_R16G16_SNORM,
       WINED3DFMT_R16G16B16A16_SNORM,
      WINED3DFMT_R16G16_UNORM,
      WINED3DFMT_R16G16B16A16_UNORM,
         WINED3DFMT_R10G10B10X2_UINT,
         WINED3DFMT_R10G10B10X2_SNORM,
     WINED3DFMT_R16G16_FLOAT,
     WINED3DFMT_R16G16B16A16_FLOAT,
}

Definition at line 202 of file vertexdeclaration.c.

Referenced by convert_to_wined3d_declaration().

wined3d_type_sizes

const size_t wined3d_type_sizes[]

static

Initial value:

=
{
        1 * sizeof(float),
        2 * sizeof(float),
        3 * sizeof(float),
        4 * sizeof(float),
      4 * sizeof(BYTE),
        4 * sizeof(BYTE),
        2 * sizeof(short int),
        4 * sizeof(short int),
       4 * sizeof(BYTE),
       2 * sizeof(short int),
       4 * sizeof(short int),
      2 * sizeof(short int),
      4 * sizeof(short int),
         3 * sizeof(short int),
         3 * sizeof(short int),
     2 * sizeof(short int),
     4 * sizeof(short int)
}

Definition at line 181 of file vertexdeclaration.c.

Referenced by convert_to_wined3d_declaration().

const struct { ... } wined3d_usage_lookup[]

Initial value:

=
{
          {WINED3D_DECL_USAGE_POSITION,      0},
       {WINED3D_DECL_USAGE_BLEND_WEIGHT,  0},
      {WINED3D_DECL_USAGE_BLEND_INDICES, 0},
            {WINED3D_DECL_USAGE_NORMAL,        0},
             {WINED3D_DECL_USAGE_PSIZE,         0},
           {WINED3D_DECL_USAGE_COLOR,         0},
          {WINED3D_DECL_USAGE_COLOR,         1},
         {WINED3D_DECL_USAGE_TEXCOORD,      0},
         {WINED3D_DECL_USAGE_TEXCOORD,      1},
         {WINED3D_DECL_USAGE_TEXCOORD,      2},
         {WINED3D_DECL_USAGE_TEXCOORD,      3},
         {WINED3D_DECL_USAGE_TEXCOORD,      4},
         {WINED3D_DECL_USAGE_TEXCOORD,      5},
         {WINED3D_DECL_USAGE_TEXCOORD,      6},
         {WINED3D_DECL_USAGE_TEXCOORD,      7},
         {WINED3D_DECL_USAGE_POSITION,      1},
           {WINED3D_DECL_USAGE_NORMAL,        1},
}

Referenced by convert_to_wined3d_declaration().