#include <stdio.h>
#include <float.h>
#include <limits.h>
#include "wine/test.h"
#include "d3dx9.h"
#include "initguid.h"
#include "rmxftmpl.h"
#include "rmxfguid.h"

Include dependency graph for mesh.c:

Go to the source code of this file.

Classes
struct	vertex

struct	test_context

struct	mesh

struct	sincos_table

struct	dynamic_array

struct	point2d

struct	outline

struct	outline_array

struct	glyphinfo

struct	udec3

struct	dec3n

Macros
#define	COBJMACROS

#define	NAN __port_nan()

#define	TRACECALLBACK if(winetest_debug > 1) trace

#define	admitted_error 0.0001f

#define	compare_vertex_sizes(type, exp)

#define	compare_float(got, exp)

#define	check_floats(got, exp, dim) check_floats_(__LINE__, "", got, exp, dim)

#define	check_vertex_buffer(mesh, vertices, num_vertices, fvf) check_vertex_buffer_(__LINE__, mesh, vertices, num_vertices, fvf)

#define	check_index_buffer(mesh, indices, num_indices, index_size) check_index_buffer_(__LINE__, mesh, indices, num_indices, index_size)

#define	check_matrix(got, expected) check_matrix_(__LINE__, got, expected)

#define	check_materials(got, got_count, expected, expected_count) check_materials_(__LINE__, got, got_count, expected, expected_count)

#define	check_generated_adjacency(mesh, got, epsilon) check_generated_adjacency_(__LINE__, mesh, got, epsilon)

#define	check_generated_effects(materials, num_materials, effects) check_generated_effects_(__LINE__, materials, num_materials, effects)

#define	EFFECT_TABLE_ENTRY(str, field) {str, sizeof(str), sizeof(materials->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}

#define	test_LoadMeshFromX(device, xfile_str, vertex_array, fvf, index_array, materials_array, check_adjacency)

Typedefs
typedef WORD	face[3]

Enumerations
enum	pointtype { POINTTYPE_CURVE = 0 , POINTTYPE_CORNER , POINTTYPE_CURVE_START , POINTTYPE_CURVE_END , POINTTYPE_CURVE_MIDDLE , POINTTYPE_CURVE = 0 , POINTTYPE_CORNER , POINTTYPE_CURVE_START , POINTTYPE_CURVE_END , POINTTYPE_CURVE_MIDDLE }

Functions
static float	__port_nan (void)

static BOOL	compare (FLOAT u, FLOAT v)

static BOOL	compare_vec3 (D3DXVECTOR3 u, D3DXVECTOR3 v)

static BOOL	compare_vec4 (D3DXVECTOR4 u, D3DXVECTOR4 v)

static void	check_floats_ (int line, const char prefix, const float got, const float *exp, int dim)

static BOOL	compare_face (face a, face b)

static struct test_context *	new_test_context (void)

static void	free_test_context (struct test_context *test_context)

static void	free_mesh (struct mesh *mesh)

static BOOL	new_mesh (struct mesh *mesh, DWORD number_of_vertices, DWORD number_of_faces)

static void	compare_mesh (const char name, ID3DXMesh d3dxmesh, struct mesh *mesh)

static void	D3DXBoundProbeTest (void)

static void	D3DXComputeBoundingBoxTest (void)

static void	D3DXComputeBoundingSphereTest (void)

static void	print_elements (const D3DVERTEXELEMENT9 *elements)

static void	compare_elements (const D3DVERTEXELEMENT9 elements, const D3DVERTEXELEMENT9 expected_elements, unsigned int line, unsigned int test_id)

static void	test_fvf_to_decl (DWORD test_fvf, const D3DVERTEXELEMENT9 expected_elements[], HRESULT expected_hr, unsigned int line, unsigned int test_id)

static void	test_decl_to_fvf (const D3DVERTEXELEMENT9 *decl, DWORD expected_fvf, HRESULT expected_hr, unsigned int line, unsigned int test_id)

static void	test_fvf_decl_conversion (void)

static void	D3DXGetFVFVertexSizeTest (void)

static void	D3DXIntersectTriTest (void)

static void	D3DXCreateMeshTest (void)

static void	D3DXCreateMeshFVFTest (void)

static void	check_vertex_buffer_ (int line, ID3DXMesh mesh, const void vertices, DWORD num_vertices, DWORD fvf)

static void	check_index_buffer_ (int line, ID3DXMesh mesh, const void indices, DWORD num_indices, DWORD index_size)

static void	check_matrix_ (int line, const D3DXMATRIX got, const D3DXMATRIX expected)

static void	check_colorvalue_ (int line, const char *prefix, const D3DCOLORVALUE got, const D3DCOLORVALUE expected)

static void	check_materials_ (int line, const D3DXMATERIAL got, DWORD got_count, const D3DXMATERIAL expected, DWORD expected_count)

static void	check_generated_adjacency_ (int line, ID3DXMesh mesh, const DWORD got, FLOAT epsilon)

static void	check_generated_effects_ (int line, const D3DXMATERIAL materials, DWORD num_materials, const D3DXEFFECTINSTANCE effects)

static char *	strdupA (const char *p)

static HRESULT CALLBACK	ID3DXAllocateHierarchyImpl_DestroyFrame (ID3DXAllocateHierarchy *iface, LPD3DXFRAME frame)

static HRESULT CALLBACK	ID3DXAllocateHierarchyImpl_CreateFrame (ID3DXAllocateHierarchy iface, const char name, D3DXFRAME **new_frame)

static HRESULT	destroy_mesh_container (LPD3DXMESHCONTAINER mesh_container)

static HRESULT CALLBACK	ID3DXAllocateHierarchyImpl_DestroyMeshContainer (ID3DXAllocateHierarchy *iface, LPD3DXMESHCONTAINER mesh_container)

static HRESULT CALLBACK	ID3DXAllocateHierarchyImpl_CreateMeshContainer (ID3DXAllocateHierarchy iface, const char name, const D3DXMESHDATA mesh_data, const D3DXMATERIAL materials, const D3DXEFFECTINSTANCE effects, DWORD num_materials, const DWORD adjacency, ID3DXSkinInfo skin_info, D3DXMESHCONTAINER *new_mesh_container)

static void	test_LoadMeshFromX_ (int line, IDirect3DDevice9 device, const char xfile_str, size_t xfile_strlen, const void vertices, DWORD num_vertices, DWORD fvf, const void indices, DWORD num_indices, size_t index_size, const D3DXMATERIAL *expected_materials, DWORD expected_num_materials, BOOL check_adjacency)

static void	D3DXLoadMeshTest (void)

static BOOL	compute_box (struct mesh *mesh, float width, float height, float depth)

static void	test_box (IDirect3DDevice9 *device, float width, float height, float depth)

static void	D3DXCreateBoxTest (void)

static BOOL	compute_polygon (struct mesh *mesh, float length, unsigned int sides)

static void	test_polygon (IDirect3DDevice9 *device, float length, unsigned int sides)

static void	D3DXCreatePolygonTest (void)

static void	free_sincos_table (struct sincos_table *sincos_table)

static BOOL	compute_sincos_table (struct sincos_table *sincos_table, float angle_start, float angle_step, int n)

static WORD	vertex_index (UINT slices, int slice, int stack)

static BOOL	compute_sphere (struct mesh *mesh, FLOAT radius, UINT slices, UINT stacks)

static void	test_sphere (IDirect3DDevice9 *device, FLOAT radius, UINT slices, UINT stacks)

static void	D3DXCreateSphereTest (void)

static BOOL	compute_cylinder (struct mesh *mesh, FLOAT radius1, FLOAT radius2, FLOAT length, UINT slices, UINT stacks)

static void	test_cylinder (IDirect3DDevice9 *device, FLOAT radius1, FLOAT radius2, FLOAT length, UINT slices, UINT stacks)

static void	D3DXCreateCylinderTest (void)

static BOOL	compute_torus (struct mesh *mesh, float innerradius, float outerradius, UINT sides, UINT rings)

static void	test_torus (IDirect3DDevice9 *device, float innerradius, float outerradius, UINT sides, UINT rings)

static void	D3DXCreateTorusTest (void)

static BOOL	reserve (struct dynamic_array *array, int count, int itemsize)

static struct point2d *	add_point (struct outline *array)

static struct outline *	add_outline (struct outline_array *array)

static D3DXVECTOR2 *	convert_fixed_to_float (POINTFX *pt, int count, float emsquare)

static HRESULT	add_bezier_points (struct outline outline, const D3DXVECTOR2 p1, const D3DXVECTOR2 p2, const D3DXVECTOR2 p3, float max_deviation)

static BOOL	is_direction_similar (D3DXVECTOR2 dir1, D3DXVECTOR2 dir2, float cos_theta)

static D3DXVECTOR2 *	unit_vec2 (D3DXVECTOR2 dir, const D3DXVECTOR2 pt1, const D3DXVECTOR2 *pt2)

static BOOL	attempt_line_merge (struct outline outline, int pt_index, const D3DXVECTOR2 nextpt, BOOL to_curve)

static HRESULT	create_outline (struct glyphinfo glyph, void raw_outline, int datasize, float max_deviation, float emsquare)

static void	free_outline (struct outline *outline)

static void	free_glyphinfo (struct glyphinfo *glyph)

static void	compute_text_mesh (struct mesh mesh, const char text, float deviation, float extrusion, float otmEMSquare, const struct glyphinfo *glyphs)

static void	compare_text_outline_mesh (const char name, ID3DXMesh d3dxmesh, struct mesh mesh, size_t textlen, float extrusion, const struct glyphinfo glyphs)

static void	test_createtext (IDirect3DDevice9 device, HDC hdc, const char text, float deviation, float extrusion)

static void	D3DXCreateTextTest (void)

static void	test_get_decl_length (void)

static void	test_get_decl_vertex_size (void)

static void	D3DXGenerateAdjacencyTest (void)

static void	test_update_semantics (void)

static void	test_create_skin_info (void)

static void	test_update_skinned_mesh (void)

static void	test_convert_adjacency_to_point_reps (void)

static void	test_convert_point_reps_to_adjacency (void)

static HRESULT	init_test_mesh (const DWORD num_faces, const DWORD num_vertices, const DWORD options, const D3DVERTEXELEMENT9 declaration, IDirect3DDevice9 device, ID3DXMesh *mesh_ptr, const void vertices, const DWORD vertex_size, const DWORD indices, const DWORD attributes)

static DWORD	init_udec3_dword (UINT x, UINT y, UINT z, UINT w)

static DWORD	init_dec3n_dword (INT x, INT y, INT z, INT w)

static struct udec3	dword_to_udec3 (DWORD d)

static struct dec3n	dword_to_dec3n (DWORD d)

static void	check_vertex_components (int line, int mesh_number, int vertex_number, BYTE got_ptr, const BYTE exp_ptr, D3DVERTEXELEMENT9 *declaration)

static void	test_weld_vertices (void)

static void	test_clone_mesh (void)

static void	test_valid_mesh (void)

static void	test_optimize_vertices (void)

static void	test_optimize_faces (void)

static HRESULT	clear_normals (ID3DXMesh *mesh)

static void	compare_normals (unsigned int line, const char test_name, ID3DXMesh mesh, const D3DXVECTOR3 *normals, unsigned int num_normals)

static HRESULT	compute_normals_D3DXComputeNormals (ID3DXMesh mesh, const DWORD adjacency)

static HRESULT	compute_normals_D3DXComputeTangentFrameEx (ID3DXMesh mesh, const DWORD adjacency)

static void	test_compute_normals (void)

static void	D3DXCreateAnimationControllerTest (void)

static void	D3DXCreateKeyframedAnimationSetTest (void)

static void	test_D3DXFrameFind (void)

static ID3DXFileData *	get_mesh_data (const void *memory, SIZE_T length)

static void	test_load_skin_mesh_from_xof (void)

	START_TEST (mesh)

Variables
static ID3DXAllocateHierarchyVtbl	ID3DXAllocateHierarchyImpl_Vtbl

static ID3DXAllocateHierarchy	alloc_hier = { &ID3DXAllocateHierarchyImpl_Vtbl }

Macro Definition Documentation

◆ admitted_error

#define admitted_error 0.0001f

Definition at line 46 of file mesh.c.

◆ check_floats

#define check_floats	(	got,
		exp,
		dim
	)	check_floats_(__LINE__, "", got, exp, dim)

Definition at line 74 of file mesh.c.

◆ check_generated_adjacency

#define check_generated_adjacency	(	mesh,
		got,
		epsilon
	)	check_generated_adjacency_(__LINE__, mesh, got, epsilon)

Definition at line 1712 of file mesh.c.

◆ check_generated_effects

#define check_generated_effects	(	materials,
		num_materials,
		effects
	)	check_generated_effects_(__LINE__, materials, num_materials, effects)

Definition at line 1742 of file mesh.c.

◆ check_index_buffer

#define check_index_buffer	(	mesh,
		indices,
		num_indices,
		index_size
	)	check_index_buffer_(__LINE__, mesh, indices, num_indices, index_size)

Definition at line 1629 of file mesh.c.

◆ check_materials

#define check_materials	(	got,
		got_count,
		expected,
		expected_count
	)	check_materials_(__LINE__, got, got_count, expected, expected_count)

Definition at line 1685 of file mesh.c.

◆ check_matrix

#define check_matrix	(	got,
		expected
	)	check_matrix_(__LINE__, got, expected)

Definition at line 1665 of file mesh.c.

◆ check_vertex_buffer

#define check_vertex_buffer	(	mesh,
		vertices,
		num_vertices,
		fvf
	)	check_vertex_buffer_(__LINE__, mesh, vertices, num_vertices, fvf)

Definition at line 1527 of file mesh.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file mesh.c.

◆ compare_float

#define compare_float	(	got,
		exp
	)

Value:

    do { \
        float _got = (got); \
        float _exp = (exp); \
        ok(_got == _exp, "Expected: %g, Got: %g\n", _exp, _got); \
    } while (0)

Definition at line 52 of file mesh.c.

◆ compare_vertex_sizes

#define compare_vertex_sizes	(	type,
		exp
	)

Value:

got=D3DXGetFVFVertexSize(type); \

ok(got==exp, "Expected: %d, Got: %d\n", exp, got);

D3DXGetFVFVertexSize

UINT WINAPI D3DXGetFVFVertexSize(DWORD FVF)

Definition: mesh.c:2289

type

GLuint GLuint GLsizei GLenum type

Definition: gl.h:1545

Definition at line 48 of file mesh.c.

◆ EFFECT_TABLE_ENTRY

#define EFFECT_TABLE_ENTRY	(	str,
		field
	)	{str, sizeof(str), sizeof(materials->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}

◆ NAN

#define NAN __port_nan()

Definition at line 39 of file mesh.c.

◆ test_LoadMeshFromX

#define test_LoadMeshFromX	(	device,
		xfile_str,
		vertex_array,
		fvf,
		index_array,
		materials_array,
		check_adjacency
	)

Value:

    test_LoadMeshFromX_(__LINE__, device, xfile_str, sizeof(xfile_str) - 1, vertex_array, ARRAY_SIZE(vertex_array), fvf, \
            index_array, ARRAY_SIZE(index_array), sizeof(*index_array), materials_array, ARRAY_SIZE(materials_array), \
            check_adjacency);

Definition at line 2012 of file mesh.c.

◆ TRACECALLBACK

#define TRACECALLBACK if(winetest_debug > 1) trace

Definition at line 44 of file mesh.c.

Typedef Documentation

◆ face

typedef WORD face[3]

Definition at line 103 of file mesh.c.

Enumeration Type Documentation

◆ pointtype

enum pointtype

Enumerator
POINTTYPE_CURVE
POINTTYPE_CORNER
POINTTYPE_CURVE_START
POINTTYPE_CURVE_END
POINTTYPE_CURVE_MIDDLE
POINTTYPE_CURVE
POINTTYPE_CORNER
POINTTYPE_CURVE_START
POINTTYPE_CURVE_END
POINTTYPE_CURVE_MIDDLE

Definition at line 3496 of file mesh.c.

               {
    POINTTYPE_CURVE = 0,
    POINTTYPE_CORNER,
    POINTTYPE_CURVE_START,
    POINTTYPE_CURVE_END,
    POINTTYPE_CURVE_MIDDLE,
};

Function Documentation

◆ __port_nan()

static float __port_nan ( void )

inlinestatic

Definition at line 34 of file mesh.c.

{
    static const unsigned __nan_bytes = 0x7fc00000;
    return *(const float *)&__nan_bytes;
}

◆ add_bezier_points()

static HRESULT add_bezier_points	(	struct outline *	outline,
		const D3DXVECTOR2 *	p1,
		const D3DXVECTOR2 *	p2,
		const D3DXVECTOR2 *	p3,
		float	max_deviation
	)

static

Definition at line 3586 of file mesh.c.

{
    D3DXVECTOR2 split1 = {0, 0}, split2 = {0, 0}, middle, vec;
    float deviation;
 
    D3DXVec2Scale(&split1, D3DXVec2Add(&split1, p1, p2), 0.5f);
    D3DXVec2Scale(&split2, D3DXVec2Add(&split2, p2, p3), 0.5f);
    D3DXVec2Scale(&middle, D3DXVec2Add(&middle, &split1, &split2), 0.5f);
 
    deviation = D3DXVec2Length(D3DXVec2Subtract(&vec, &middle, p2));
    if (deviation < max_deviation) {
        struct point2d *pt = add_point(outline);
        if (!pt) return E_OUTOFMEMORY;
        pt->pos = *p2;
        pt->corner = POINTTYPE_CURVE;
        /* the end point is omitted because the end line merges into the next segment of
         * the split bezier curve, and the end of the split bezier curve is added outside
         * this recursive function. */
    } else {
        HRESULT hr = add_bezier_points(outline, p1, &split1, &middle, max_deviation);
        if (hr != S_OK) return hr;
        hr = add_bezier_points(outline, &middle, &split2, p3, max_deviation);
        if (hr != S_OK) return hr;
    }
 
    return S_OK;
}

◆ add_outline()

static struct outline * add_outline ( struct outline_array * array )

static

Definition at line 3562 of file mesh.c.

{
    struct outline *item;
 
    if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
        return NULL;
 
    item = &array->items[array->count++];
    ZeroMemory(item, sizeof(*item));
    return item;
}

◆ add_point()

static struct point2d * add_point ( struct outline * array )

static

Definition at line 3550 of file mesh.c.

{
    struct point2d *item;
 
    if (!reserve((struct dynamic_array *)array, array->count + 1, sizeof(array->items[0])))
        return NULL;
 
    item = &array->items[array->count++];
    ZeroMemory(item, sizeof(*item));
    return item;
}

Referenced by add_bezier_points(), and create_outline().

◆ attempt_line_merge()

static BOOL attempt_line_merge	(	struct outline *	outline,
		int	pt_index,
		const D3DXVECTOR2 *	nextpt,
		BOOL	to_curve
	)

static

Definition at line 3627 of file mesh.c.

{
    D3DXVECTOR2 curdir, lastdir;
    struct point2d *prevpt, *pt;
    BOOL ret = FALSE;
    const float cos_half = cos(D3DXToRadian(0.5f));
 
    pt = &outline->items[pt_index];
    pt_index = (pt_index - 1 + outline->count) % outline->count;
    prevpt = &outline->items[pt_index];
 
    if (to_curve)
        pt->corner = pt->corner != POINTTYPE_CORNER ? POINTTYPE_CURVE_MIDDLE : POINTTYPE_CURVE_START;
 
    if (outline->count < 2)
        return FALSE;
 
    /* remove last point if the next line continues the last line */
    unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
    unit_vec2(&curdir, &pt->pos, nextpt);
    if (is_direction_similar(&lastdir, &curdir, cos_half))
    {
        outline->count--;
        if (pt->corner == POINTTYPE_CURVE_END)
            prevpt->corner = pt->corner;
        if (prevpt->corner == POINTTYPE_CURVE_END && to_curve)
            prevpt->corner = POINTTYPE_CURVE_MIDDLE;
        pt = prevpt;
 
        ret = TRUE;
        if (outline->count < 2)
            return ret;
 
        pt_index = (pt_index - 1 + outline->count) % outline->count;
        prevpt = &outline->items[pt_index];
        unit_vec2(&lastdir, &prevpt->pos, &pt->pos);
        unit_vec2(&curdir, &pt->pos, nextpt);
    }
    return ret;
}

◆ check_colorvalue_()

static void check_colorvalue_	(	int	line,
		const char *	prefix,
		const D3DCOLORVALUE	got,
		const D3DCOLORVALUE	expected
	)

static

Definition at line 1678 of file mesh.c.

{
    ok_(__FILE__,line)(expected.r == got.r && expected.g == got.g && expected.b == got.b && expected.a == got.a,
            "%sExpected (%g, %g, %g, %g), got (%g, %g, %g, %g)\n", prefix,
            expected.r, expected.g, expected.b, expected.a, got.r, got.g, got.b, got.a);
}

Referenced by check_materials_().

◆ check_floats_()

static void check_floats_	(	int	line,
		const char *	prefix,
		const float *	got,
		const float *	exp,
		int	dim
	)

static

Definition at line 75 of file mesh.c.

{
    int i;
    char exp_buffer[256] = "";
    char got_buffer[256] = "";
    char *exp_buffer_ptr = exp_buffer;
    char *got_buffer_ptr = got_buffer;
    BOOL equal = TRUE;
 
    for (i = 0; i < dim; i++) {
        if (i) {
            exp_buffer_ptr += sprintf(exp_buffer_ptr, ", ");
            got_buffer_ptr += sprintf(got_buffer_ptr, ", ");
        }
        equal = equal && compare(*exp, *got);
        exp_buffer_ptr += sprintf(exp_buffer_ptr, "%g", *exp);
        got_buffer_ptr += sprintf(got_buffer_ptr, "%g", *got);
        exp++; got++;
    }
    ok_(__FILE__,line)(equal, "%sExpected (%s), got (%s)", prefix, exp_buffer, got_buffer);
}

Referenced by check_vertex_buffer_().

◆ check_generated_adjacency_()

static void check_generated_adjacency_	(	int	line,
		ID3DXMesh *	mesh,
		const DWORD *	got,
		FLOAT	epsilon
	)

static

Definition at line 1713 of file mesh.c.

{
    DWORD *expected;
    DWORD num_faces = mesh->lpVtbl->GetNumFaces(mesh);
    HRESULT hr;
 
    expected = HeapAlloc(GetProcessHeap(), 0, num_faces * sizeof(DWORD) * 3);
    if (!expected) {
        skip_(__FILE__, line)("Out of memory\n");
        return;
    }
    hr = mesh->lpVtbl->GenerateAdjacency(mesh, epsilon, expected);
    ok_(__FILE__, line)(hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr);
    if (SUCCEEDED(hr))
    {
        int i;
        for (i = 0; i < num_faces; i++)
        {
            ok_(__FILE__, line)(expected[i * 3] == got[i * 3] &&
                    expected[i * 3 + 1] == got[i * 3 + 1] &&
                    expected[i * 3 + 2] == got[i * 3 + 2],
                    "Face %u adjacencies: Expected (%u, %u, %u), got (%u, %u, %u)\n", i,
                    expected[i * 3], expected[i * 3 + 1], expected[i * 3 + 2],
                    got[i * 3], got[i * 3 + 1], got[i * 3 + 2]);
        }
    }
    HeapFree(GetProcessHeap(), 0, expected);
}

Referenced by test_LoadMeshFromX_().

◆ check_generated_effects_()

static void check_generated_effects_	(	int	line,
		const D3DXMATERIAL *	materials,
		DWORD	num_materials,
		const D3DXEFFECTINSTANCE *	effects
	)

static

Definition at line 1744 of file mesh.c.

{
    int i;
    static const struct {
        const char *name;
        DWORD name_size;
        DWORD num_bytes;
        DWORD value_offset;
    } params[] = {
#define EFFECT_TABLE_ENTRY(str, field) \
    {str, sizeof(str), sizeof(materials->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}
        EFFECT_TABLE_ENTRY("Diffuse", Diffuse),
        EFFECT_TABLE_ENTRY("Power", Power),
        EFFECT_TABLE_ENTRY("Specular", Specular),
        EFFECT_TABLE_ENTRY("Emissive", Emissive),
        EFFECT_TABLE_ENTRY("Ambient", Ambient),
#undef EFFECT_TABLE_ENTRY
    };
 
    if (!num_materials) {
        ok_(__FILE__, line)(effects == NULL, "Expected NULL effects, got %p\n", effects);
        return;
    }
    for (i = 0; i < num_materials; i++)
    {
        int j;
        DWORD expected_num_defaults = ARRAY_SIZE(params) + (materials[i].pTextureFilename ? 1 : 0);
 
        ok_(__FILE__,line)(expected_num_defaults == effects[i].NumDefaults,
                "effect[%u] NumDefaults: Expected %u, got %u\n", i,
                expected_num_defaults, effects[i].NumDefaults);
        for (j = 0; j < min(ARRAY_SIZE(params), effects[i].NumDefaults); j++)
        {
            int k;
            D3DXEFFECTDEFAULT *got_param = &effects[i].pDefaults[j];
            ok_(__FILE__,line)(!strcmp(params[j].name, got_param->pParamName),
               "effect[%u].pDefaults[%u].pParamName: Expected '%s', got '%s'\n", i, j,
               params[j].name, got_param->pParamName);
            ok_(__FILE__,line)(D3DXEDT_FLOATS == got_param->Type,
               "effect[%u].pDefaults[%u].Type: Expected %u, got %u\n", i, j,
               D3DXEDT_FLOATS, got_param->Type);
            ok_(__FILE__,line)(params[j].num_bytes == got_param->NumBytes,
               "effect[%u].pDefaults[%u].NumBytes: Expected %u, got %u\n", i, j,
               params[j].num_bytes, got_param->NumBytes);
            for (k = 0; k < min(params[j].num_bytes, got_param->NumBytes) / 4; k++)
            {
                FLOAT expected = ((FLOAT*)((BYTE*)&materials[i] + params[j].value_offset))[k];
                FLOAT got = ((FLOAT*)got_param->pValue)[k];
                ok_(__FILE__,line)(compare(expected, got),
                   "effect[%u].pDefaults[%u] float value %u: Expected %g, got %g\n", i, j, k, expected, got);
            }
        }
        if (effects[i].NumDefaults > ARRAY_SIZE(params)) {
            D3DXEFFECTDEFAULT *got_param = &effects[i].pDefaults[j];
            static const char *expected_name = "Texture0@Name";
 
            ok_(__FILE__,line)(!strcmp(expected_name, got_param->pParamName),
               "effect[%u].pDefaults[%u].pParamName: Expected '%s', got '%s'\n", i, j,
               expected_name, got_param->pParamName);
            ok_(__FILE__,line)(D3DXEDT_STRING == got_param->Type,
               "effect[%u].pDefaults[%u].Type: Expected %u, got %u\n", i, j,
               D3DXEDT_STRING, got_param->Type);
            if (materials[i].pTextureFilename) {
                ok_(__FILE__,line)(strlen(materials[i].pTextureFilename) + 1 == got_param->NumBytes,
                   "effect[%u] texture filename length: Expected %u, got %u\n", i,
                   (DWORD)strlen(materials[i].pTextureFilename) + 1, got_param->NumBytes);
                ok_(__FILE__,line)(!strcmp(materials[i].pTextureFilename, got_param->pValue),
                   "effect[%u] texture filename: Expected '%s', got '%s'\n", i,
                   materials[i].pTextureFilename, (char*)got_param->pValue);
            }
        }
    }
}

Referenced by test_LoadMeshFromX_().

◆ check_index_buffer_()

static void check_index_buffer_	(	int	line,
		ID3DXMesh *	mesh,
		const void *	indices,
		DWORD	num_indices,
		DWORD	index_size
	)

static

Definition at line 1631 of file mesh.c.

{
    DWORD mesh_index_size = (mesh->lpVtbl->GetOptions(mesh) & D3DXMESH_32BIT) ? 4 : 2;
    DWORD mesh_num_indices = mesh->lpVtbl->GetNumFaces(mesh) * 3;
    const void *mesh_indices;
    HRESULT hr;
    DWORD i;
 
    ok_(__FILE__,line)(index_size == mesh_index_size,
        "Expected index size %u, got %u\n", index_size, mesh_index_size);
    ok_(__FILE__,line)(num_indices == mesh_num_indices,
        "Expected %u indices, got %u\n", num_indices, mesh_num_indices);
 
    hr = mesh->lpVtbl->LockIndexBuffer(mesh, D3DLOCK_READONLY, (void**)&mesh_indices);
    ok_(__FILE__,line)(hr == D3D_OK, "LockIndexBuffer returned %x, expected %x (D3D_OK)\n", hr, D3D_OK);
    if (FAILED(hr))
        return;
 
    if (mesh_index_size == index_size) {
        for (i = 0; i < min(num_indices, mesh_num_indices); i++)
        {
            if (index_size == 4)
                ok_(__FILE__,line)(*(DWORD*)indices == *(DWORD*)mesh_indices,
                    "Index[%u]: expected %u, got %u\n", i, *(DWORD*)indices, *(DWORD*)mesh_indices);
            else
                ok_(__FILE__,line)(*(WORD*)indices == *(WORD*)mesh_indices,
                    "Index[%u]: expected %u, got %u\n", i, *(WORD*)indices, *(WORD*)mesh_indices);
            indices = (BYTE*)indices + index_size;
            mesh_indices = (BYTE*)mesh_indices + index_size;
        }
    }
    mesh->lpVtbl->UnlockIndexBuffer(mesh);
}

Referenced by test_LoadMeshFromX_().

◆ check_materials_()

static void check_materials_	(	int	line,
		const D3DXMATERIAL *	got,
		DWORD	got_count,
		const D3DXMATERIAL *	expected,
		DWORD	expected_count
	)

static

Definition at line 1687 of file mesh.c.

{
    int i;
    ok_(__FILE__,line)(expected_count == got_count, "Expected %u materials, got %u\n", expected_count, got_count);
    if (!expected) {
        ok_(__FILE__,line)(got == NULL, "Expected NULL material ptr, got %p\n", got);
        return;
    }
    for (i = 0; i < min(expected_count, got_count); i++)
    {
        if (!expected[i].pTextureFilename)
            ok_(__FILE__,line)(got[i].pTextureFilename == NULL,
                    "Expected NULL pTextureFilename, got %p\n", got[i].pTextureFilename);
        else
            ok_(__FILE__,line)(!strcmp(expected[i].pTextureFilename, got[i].pTextureFilename),
                    "Expected '%s' for pTextureFilename, got '%s'\n", expected[i].pTextureFilename, got[i].pTextureFilename);
        check_colorvalue_(line, "Diffuse: ", got[i].MatD3D.Diffuse, expected[i].MatD3D.Diffuse);
        check_colorvalue_(line, "Ambient: ", got[i].MatD3D.Ambient, expected[i].MatD3D.Ambient);
        check_colorvalue_(line, "Specular: ", got[i].MatD3D.Specular, expected[i].MatD3D.Specular);
        check_colorvalue_(line, "Emissive: ", got[i].MatD3D.Emissive, expected[i].MatD3D.Emissive);
        ok_(__FILE__,line)(expected[i].MatD3D.Power == got[i].MatD3D.Power,
                "Power: Expected %g, got %g\n", expected[i].MatD3D.Power, got[i].MatD3D.Power);
    }
}

Referenced by test_LoadMeshFromX_().

◆ check_matrix_()

static void check_matrix_	(	int	line,
		const D3DXMATRIX *	got,
		const D3DXMATRIX *	expected
	)

static

Definition at line 1666 of file mesh.c.

{
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            ok_(__FILE__,line)(compare(U(*expected).m[i][j], U(*got).m[i][j]),
                    "matrix[%u][%u]: expected %g, got %g\n",
                    i, j, U(*expected).m[i][j], U(*got).m[i][j]);
        }
    }
}

◆ check_vertex_buffer_()

static void check_vertex_buffer_	(	int	line,
		ID3DXMesh *	mesh,
		const void *	vertices,
		DWORD	num_vertices,
		DWORD	fvf
	)

static

Definition at line 1529 of file mesh.c.

{
    DWORD mesh_num_vertices = mesh->lpVtbl->GetNumVertices(mesh);
    DWORD mesh_fvf = mesh->lpVtbl->GetFVF(mesh);
    const void *mesh_vertices;
    HRESULT hr;
 
    ok_(__FILE__,line)(fvf == mesh_fvf, "expected FVF %x, got %x\n", fvf, mesh_fvf);
    ok_(__FILE__,line)(num_vertices == mesh_num_vertices,
       "Expected %u vertices, got %u\n", num_vertices, mesh_num_vertices);
 
    hr = mesh->lpVtbl->LockVertexBuffer(mesh, D3DLOCK_READONLY, (void**)&mesh_vertices);
    ok_(__FILE__,line)(hr == D3D_OK, "LockVertexBuffer returned %x, expected %x (D3D_OK)\n", hr, D3D_OK);
    if (FAILED(hr))
        return;
 
    if (mesh_fvf == fvf) {
        DWORD vertex_size = D3DXGetFVFVertexSize(fvf), i;
 
        for (i = 0; i < min(num_vertices, mesh_num_vertices); i++)
        {
            const FLOAT *exp_float = vertices;
            const FLOAT *got_float = mesh_vertices;
            DWORD texcount;
            DWORD pos_dim = 0;
            int j;
            BOOL last_beta_dword = FALSE;
            char prefix[128];
 
            switch (fvf & D3DFVF_POSITION_MASK) {
                case D3DFVF_XYZ: pos_dim = 3; break;
                case D3DFVF_XYZRHW: pos_dim = 4; break;
                case D3DFVF_XYZB1:
                case D3DFVF_XYZB2:
                case D3DFVF_XYZB3:
                case D3DFVF_XYZB4:
                case D3DFVF_XYZB5:
                    pos_dim = (fvf & D3DFVF_POSITION_MASK) - D3DFVF_XYZB1 + 1;
                    if (fvf & (D3DFVF_LASTBETA_UBYTE4 | D3DFVF_LASTBETA_D3DCOLOR))
                    {
                        pos_dim--;
                        last_beta_dword = TRUE;
                    }
                    break;
                case D3DFVF_XYZW: pos_dim = 4; break;
            }
            sprintf(prefix, "vertex[%u] position, ", i);
            check_floats_(line, prefix, got_float, exp_float, pos_dim);
            exp_float += pos_dim;
            got_float += pos_dim;
 
            if (last_beta_dword) {
                ok_(__FILE__,line)(*(DWORD*)exp_float == *(DWORD*)got_float,
                    "Vertex[%u]: Expected last beta %08x, got %08x\n", i, *(DWORD*)exp_float, *(DWORD*)got_float);
                exp_float++;
                got_float++;
            }
 
            if (fvf & D3DFVF_NORMAL) {
                sprintf(prefix, "vertex[%u] normal, ", i);
                check_floats_(line, prefix, got_float, exp_float, 3);
                exp_float += 3;
                got_float += 3;
            }
            if (fvf & D3DFVF_PSIZE) {
                ok_(__FILE__,line)(compare(*exp_float, *got_float),
                        "Vertex[%u]: Expected psize %g, got %g\n", i, *exp_float, *got_float);
                exp_float++;
                got_float++;
            }
            if (fvf & D3DFVF_DIFFUSE) {
                ok_(__FILE__,line)(*(DWORD*)exp_float == *(DWORD*)got_float,
                    "Vertex[%u]: Expected diffuse %08x, got %08x\n", i, *(DWORD*)exp_float, *(DWORD*)got_float);
                exp_float++;
                got_float++;
            }
            if (fvf & D3DFVF_SPECULAR) {
                ok_(__FILE__,line)(*(DWORD*)exp_float == *(DWORD*)got_float,
                    "Vertex[%u]: Expected specular %08x, got %08x\n", i, *(DWORD*)exp_float, *(DWORD*)got_float);
                exp_float++;
                got_float++;
            }
 
            texcount = (fvf & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT;
            for (j = 0; j < texcount; j++) {
                DWORD dim = (((fvf >> (16 + 2 * j)) + 1) & 0x03) + 1;
                sprintf(prefix, "vertex[%u] texture, ", i);
                check_floats_(line, prefix, got_float, exp_float, dim);
                exp_float += dim;
                got_float += dim;
            }
 
            vertices = (BYTE*)vertices + vertex_size;
            mesh_vertices = (BYTE*)mesh_vertices + vertex_size;
        }
    }
 
    mesh->lpVtbl->UnlockVertexBuffer(mesh);
}

Referenced by test_LoadMeshFromX_().

◆ check_vertex_components()

static void check_vertex_components	(	int	line,
		int	mesh_number,
		int	vertex_number,
		BYTE *	got_ptr,
		const BYTE *	exp_ptr,
		D3DVERTEXELEMENT9 *	declaration
	)

static

Definition at line 6592 of file mesh.c.

{
    const char *usage_strings[] =
    {
        "position",
        "blend weight",
        "blend indices",
        "normal",
        "point size",
        "texture coordinates",
        "tangent",
        "binormal",
        "tessellation factor",
        "position transformed",
        "color",
        "fog",
        "depth",
        "sample"
    };
    D3DVERTEXELEMENT9 *decl_ptr;
    const float PRECISION = 1e-5f;
 
    for (decl_ptr = declaration; decl_ptr->Stream != 0xFF; decl_ptr++)
    {
        switch (decl_ptr->Type)
        {
            case D3DDECLTYPE_FLOAT1:
            {
                FLOAT *got = (FLOAT*)(got_ptr + decl_ptr->Offset);
                FLOAT *exp = (FLOAT*)(exp_ptr + decl_ptr->Offset);
                FLOAT diff = fabsf(*got - *exp);
                ok_(__FILE__,line)(diff <= PRECISION, "Mesh %d: Got %f for vertex %d %s, expected %f.\n",
                    mesh_number, *got, vertex_number, usage_strings[decl_ptr->Usage], *exp);
                break;
            }
            case D3DDECLTYPE_FLOAT2:
            {
                D3DXVECTOR2 *got = (D3DXVECTOR2*)(got_ptr + decl_ptr->Offset);
                D3DXVECTOR2 *exp = (D3DXVECTOR2*)(exp_ptr + decl_ptr->Offset);
                FLOAT diff = max(fabsf(got->x - exp->x), fabsf(got->y - exp->y));
                ok_(__FILE__,line)(diff <= PRECISION, "Mesh %d: Got (%f, %f) for vertex %d %s, expected (%f, %f).\n",
                    mesh_number, got->x, got->y, vertex_number, usage_strings[decl_ptr->Usage], exp->x, exp->y);
                break;
            }
            case D3DDECLTYPE_FLOAT3:
            {
                D3DXVECTOR3 *got = (D3DXVECTOR3*)(got_ptr + decl_ptr->Offset);
                D3DXVECTOR3 *exp = (D3DXVECTOR3*)(exp_ptr + decl_ptr->Offset);
                FLOAT diff = max(fabsf(got->x - exp->x), fabsf(got->y - exp->y));
                diff = max(diff, fabsf(got->z - exp->z));
                ok_(__FILE__,line)(diff <= PRECISION, "Mesh %d: Got (%f, %f, %f) for vertex %d %s, expected (%f, %f, %f).\n",
                    mesh_number, got->x, got->y, got->z, vertex_number, usage_strings[decl_ptr->Usage], exp->x, exp->y, exp->z);
                break;
            }
            case D3DDECLTYPE_FLOAT4:
            {
                D3DXVECTOR4 *got = (D3DXVECTOR4*)(got_ptr + decl_ptr->Offset);
                D3DXVECTOR4 *exp = (D3DXVECTOR4*)(exp_ptr + decl_ptr->Offset);
                FLOAT diff = max(fabsf(got->x - exp->x), fabsf(got->y - exp->y));
                diff = max(diff, fabsf(got->z - exp->z));
                diff = max(diff, fabsf(got->w - exp->w));
                ok_(__FILE__,line)(diff <= PRECISION, "Mesh %d: Got (%f, %f, %f, %f) for vertex %d %s, expected (%f, %f, %f, %f).\n",
                    mesh_number, got->x, got->y, got->z, got->w, vertex_number, usage_strings[decl_ptr->Usage], exp->x, exp->y, exp->z, got->w);
                break;
            }
            case D3DDECLTYPE_D3DCOLOR:
            {
                BYTE *got = got_ptr + decl_ptr->Offset;
                const BYTE *exp = exp_ptr + decl_ptr->Offset;
                BOOL same_color = got[0] == exp[0] && got[1] == exp[1]
                                  && got[2] == exp[2] && got[3] == exp[3];
                const char *color_types[] = {"diffuse", "specular", "undefined color"};
                BYTE usage_index = decl_ptr->UsageIndex;
                if (usage_index > 1) usage_index = 2;
                ok_(__FILE__,line)(same_color, "Mesh %d: Got (%u, %u, %u, %u) for vertex %d %s, expected (%u, %u, %u, %u).\n",
                    mesh_number, got[0], got[1], got[2], got[3], vertex_number, color_types[usage_index], exp[0], exp[1], exp[2], exp[3]);
                break;
            }
            case D3DDECLTYPE_UBYTE4:
            case D3DDECLTYPE_UBYTE4N:
            {
                BYTE *got = got_ptr + decl_ptr->Offset;
                const BYTE *exp = exp_ptr + decl_ptr->Offset;
                BOOL same = got[0] == exp[0] && got[1] == exp[1]
                            && got[2] == exp[2] && got[3] == exp[3];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%u, %u, %u, %u) for vertex %d %s, expected (%u, %u, %u, %u).\n",
                    mesh_number, got[0], got[1], got[2], got[3], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1], exp[2], exp[3]);
                break;
            }
            case D3DDECLTYPE_SHORT2:
            case D3DDECLTYPE_SHORT2N:
            {
                SHORT *got = (SHORT*)(got_ptr + decl_ptr->Offset);
                SHORT *exp = (SHORT*)(exp_ptr + decl_ptr->Offset);
                BOOL same = got[0] == exp[0] && got[1] == exp[1];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%hd, %hd) for vertex %d %s, expected (%hd, %hd).\n",
                    mesh_number, got[0], got[1], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1]);
                break;
            }
            case D3DDECLTYPE_SHORT4:
            case D3DDECLTYPE_SHORT4N:
            {
                SHORT *got = (SHORT*)(got_ptr + decl_ptr->Offset);
                SHORT *exp = (SHORT*)(exp_ptr + decl_ptr->Offset);
                BOOL same = got[0] == exp[0] && got[1] == exp[1]
                            && got[2] == exp[2] && got[3] == exp[3];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%hd, %hd, %hd, %hd) for vertex %d %s, expected (%hd, %hd, %hd, %hd).\n",
                    mesh_number, got[0], got[1], got[2], got[3], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1], exp[2], exp[3]);
                break;
            }
            case D3DDECLTYPE_USHORT2N:
            {
                USHORT *got = (USHORT*)(got_ptr + decl_ptr->Offset);
                USHORT *exp = (USHORT*)(exp_ptr + decl_ptr->Offset);
                BOOL same = got[0] == exp[0] && got[1] == exp[1];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%hu, %hu) for vertex %d %s, expected (%hu, %hu).\n",
                    mesh_number, got[0], got[1], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1]);
                break;
            }
            case D3DDECLTYPE_USHORT4N:
            {
                USHORT *got = (USHORT*)(got_ptr + decl_ptr->Offset);
                USHORT *exp = (USHORT*)(exp_ptr + decl_ptr->Offset);
                BOOL same = got[0] == exp[0] && got[1] == exp[1]
                            && got[2] == exp[2] && got[3] == exp[3];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%hu, %hu, %hu, %hu) for vertex %d %s, expected (%hu, %hu, %hu, %hu).\n",
                    mesh_number, got[0], got[1], got[2], got[3], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1], exp[2], exp[3]);
                break;
            }
            case D3DDECLTYPE_UDEC3:
            {
                DWORD *got = (DWORD*)(got_ptr + decl_ptr->Offset);
                DWORD *exp = (DWORD*)(exp_ptr + decl_ptr->Offset);
                BOOL same = memcmp(got, exp, sizeof(*got)) == 0;
                struct udec3 got_udec3 = dword_to_udec3(*got);
                struct udec3 exp_udec3 = dword_to_udec3(*exp);
                ok_(__FILE__,line)(same, "Mesh %d: Got (%u, %u, %u, %u) for vertex %d %s, expected (%u, %u, %u, %u).\n",
                    mesh_number, got_udec3.x, got_udec3.y, got_udec3.z, got_udec3.w, vertex_number, usage_strings[decl_ptr->Usage], exp_udec3.x, exp_udec3.y, exp_udec3.z, exp_udec3.w);
 
                break;
            }
            case D3DDECLTYPE_DEC3N:
            {
                DWORD *got = (DWORD*)(got_ptr + decl_ptr->Offset);
                DWORD *exp = (DWORD*)(exp_ptr + decl_ptr->Offset);
                BOOL same = memcmp(got, exp, sizeof(*got)) == 0;
                struct dec3n got_dec3n = dword_to_dec3n(*got);
                struct dec3n exp_dec3n = dword_to_dec3n(*exp);
                ok_(__FILE__,line)(same, "Mesh %d: Got (%d, %d, %d, %d) for vertex %d %s, expected (%d, %d, %d, %d).\n",
                    mesh_number, got_dec3n.x, got_dec3n.y, got_dec3n.z, got_dec3n.w, vertex_number, usage_strings[decl_ptr->Usage], exp_dec3n.x, exp_dec3n.y, exp_dec3n.z, exp_dec3n.w);
                break;
            }
            case D3DDECLTYPE_FLOAT16_2:
            {
                WORD *got = (WORD*)(got_ptr + decl_ptr->Offset);
                WORD *exp = (WORD*)(exp_ptr + decl_ptr->Offset);
                BOOL same = got[0] == exp[0] && got[1] == exp[1];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%hx, %hx) for vertex %d %s, expected (%hx, %hx).\n",
                    mesh_number, got[0], got[1], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1]);
                break;
            }
            case D3DDECLTYPE_FLOAT16_4:
            {
                WORD *got = (WORD*)(got_ptr + decl_ptr->Offset);
                WORD *exp = (WORD*)(exp_ptr + decl_ptr->Offset);
                BOOL same = got[0] == exp[0] && got[1] == exp[1]
                            && got[2] == exp[2] && got[3] == exp[3];
                ok_(__FILE__,line)(same, "Mesh %d: Got (%hx, %hx, %hx, %hx) for vertex %d %s, expected (%hx, %hx, %hx, %hx).\n",
                    mesh_number, got[0], got[1], got[2], got[3], vertex_number, usage_strings[decl_ptr->Usage], exp[0], exp[1], exp[3], exp[4]);
                break;
            }
            default:
                break;
        }
    }
}

Referenced by test_clone_mesh(), and test_weld_vertices().

◆ clear_normals()

static HRESULT clear_normals ( ID3DXMesh * mesh )

static

Definition at line 10693 of file mesh.c.

{
    HRESULT hr;
    BYTE *vertices;
    size_t normal_size;
    DWORD i, num_vertices, vertex_stride;
    const D3DXVECTOR4 normal = {NAN, NAN, NAN, NAN};
    D3DVERTEXELEMENT9 *normal_declaration = NULL;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
 
    if (FAILED(hr = mesh->lpVtbl->GetDeclaration(mesh, declaration)))
        return hr;
 
    for (i = 0; declaration[i].Stream != 0xff; i++)
    {
        if (declaration[i].Usage == D3DDECLUSAGE_NORMAL && !declaration[i].UsageIndex)
        {
            normal_declaration = &declaration[i];
            break;
        }
    }
 
    if (!normal_declaration)
        return D3DERR_INVALIDCALL;
 
    if (normal_declaration->Type == D3DDECLTYPE_FLOAT3)
    {
        normal_size = sizeof(D3DXVECTOR3);
    }
    else if (normal_declaration->Type == D3DDECLTYPE_FLOAT4)
    {
        normal_size = sizeof(D3DXVECTOR4);
    }
    else
    {
        trace("Cannot clear normals\n");
        return E_NOTIMPL;
    }
 
    num_vertices = mesh->lpVtbl->GetNumVertices(mesh);
    vertex_stride = mesh->lpVtbl->GetNumBytesPerVertex(mesh);
 
    if (FAILED(hr = mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void **)&vertices)))
        return hr;
 
    vertices += normal_declaration->Offset;
 
    for (i = 0; i < num_vertices; i++, vertices += vertex_stride)
        memcpy(vertices, &normal, normal_size);
 
    return mesh->lpVtbl->UnlockVertexBuffer(mesh);
}

Referenced by test_compute_normals().

◆ compare()

static BOOL compare	(	FLOAT	u,
		FLOAT	v
	)

static

Definition at line 59 of file mesh.c.

{
    return (fabs(u-v) < admitted_error);
}

◆ compare_elements()

static void compare_elements	(	const D3DVERTEXELEMENT9 *	elements,
		const D3DVERTEXELEMENT9 *	expected_elements,
		unsigned int	line,
		unsigned int	test_id
	)

static

Definition at line 610 of file mesh.c.

{
    D3DVERTEXELEMENT9 last = D3DDECL_END();
    unsigned int i;
 
    for (i = 0; i < MAX_FVF_DECL_SIZE; i++)
    {
        int end1 = memcmp(&elements[i], &last, sizeof(last));
        int end2 = memcmp(&expected_elements[i], &last, sizeof(last));
        int status;
 
        if (!end1 && !end2) break;
 
        status = !end1 ^ !end2;
        ok(!status, "Line %u, test %u: Mismatch in size, test declaration is %s than expected.\n",
                line, test_id, end1 ? "shorter" : "longer");
        if (status)
        {
            print_elements(elements);
            break;
        }
 
        status = memcmp(&elements[i], &expected_elements[i], sizeof(D3DVERTEXELEMENT9));
        ok(!status, "Line %u, test %u: Mismatch in element %u.\n", line, test_id, i);
        if (status)
        {
            print_elements(elements);
            break;
        }
    }
}

Referenced by test_create_skin_info(), test_fvf_to_decl(), and test_load_skin_mesh_from_xof().

◆ compare_face()

static BOOL compare_face	(	face	a,
		face	b
	)

static

Definition at line 105 of file mesh.c.

{
    return (a[0]==b[0] && a[1] == b[1] && a[2] == b[2]);
}

Referenced by compare_mesh().

◆ compare_mesh()

static void compare_mesh	(	const char *	name,
		ID3DXMesh *	d3dxmesh,
		struct mesh *	mesh
	)

static

Definition at line 235 of file mesh.c.

{
    HRESULT hr;
    DWORD number_of_vertices, number_of_faces;
    IDirect3DVertexBuffer9 *vertex_buffer;
    IDirect3DIndexBuffer9 *index_buffer;
    D3DVERTEXBUFFER_DESC vertex_buffer_description;
    D3DINDEXBUFFER_DESC index_buffer_description;
    struct vertex *vertices;
    face *faces;
    int expected, i;
 
    number_of_vertices = d3dxmesh->lpVtbl->GetNumVertices(d3dxmesh);
    ok(number_of_vertices == mesh->number_of_vertices, "Test %s, result %u, expected %d\n",
       name, number_of_vertices, mesh->number_of_vertices);
 
    number_of_faces = d3dxmesh->lpVtbl->GetNumFaces(d3dxmesh);
    ok(number_of_faces == mesh->number_of_faces, "Test %s, result %u, expected %d\n",
       name, number_of_faces, mesh->number_of_faces);
 
    /* vertex buffer */
    hr = d3dxmesh->lpVtbl->GetVertexBuffer(d3dxmesh, &vertex_buffer);
    ok(hr == D3D_OK, "Test %s, result %x, expected 0 (D3D_OK)\n", name, hr);
 
    if (hr != D3D_OK)
    {
        skip("Couldn't get vertex buffer\n");
    }
    else
    {
        hr = IDirect3DVertexBuffer9_GetDesc(vertex_buffer, &vertex_buffer_description);
        ok(hr == D3D_OK, "Test %s, result %x, expected 0 (D3D_OK)\n", name, hr);
 
        if (hr != D3D_OK)
        {
            skip("Couldn't get vertex buffer description\n");
        }
        else
        {
            ok(vertex_buffer_description.Format == D3DFMT_VERTEXDATA, "Test %s, result %x, expected %x (D3DFMT_VERTEXDATA)\n",
               name, vertex_buffer_description.Format, D3DFMT_VERTEXDATA);
            ok(vertex_buffer_description.Type == D3DRTYPE_VERTEXBUFFER, "Test %s, result %x, expected %x (D3DRTYPE_VERTEXBUFFER)\n",
               name, vertex_buffer_description.Type, D3DRTYPE_VERTEXBUFFER);
            ok(vertex_buffer_description.Usage == 0, "Test %s, result %x, expected %x\n", name, vertex_buffer_description.Usage, 0);
            ok(vertex_buffer_description.Pool == D3DPOOL_MANAGED, "Test %s, result %x, expected %x (D3DPOOL_MANAGED)\n",
               name, vertex_buffer_description.Pool, D3DPOOL_MANAGED);
            ok(vertex_buffer_description.FVF == mesh->fvf, "Test %s, result %x, expected %x\n",
               name, vertex_buffer_description.FVF, mesh->fvf);
            if (mesh->fvf == 0)
            {
                expected = number_of_vertices * mesh->vertex_size;
            }
            else
            {
                expected = number_of_vertices * D3DXGetFVFVertexSize(mesh->fvf);
            }
            ok(vertex_buffer_description.Size == expected, "Test %s, result %x, expected %x\n",
               name, vertex_buffer_description.Size, expected);
        }
 
        /* specify offset and size to avoid potential overruns */
        hr = IDirect3DVertexBuffer9_Lock(vertex_buffer, 0, number_of_vertices * sizeof(D3DXVECTOR3) * 2,
                (void **)&vertices, D3DLOCK_DISCARD);
        ok(hr == D3D_OK, "Test %s, result %x, expected 0 (D3D_OK)\n", name, hr);
 
        if (hr != D3D_OK)
        {
            skip("Couldn't lock vertex buffer\n");
        }
        else
        {
            for (i = 0; i < number_of_vertices; i++)
            {
                ok(compare_vec3(vertices[i].position, mesh->vertices[i].position),
                   "Test %s, vertex position %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i,
                   vertices[i].position.x, vertices[i].position.y, vertices[i].position.z,
                   mesh->vertices[i].position.x, mesh->vertices[i].position.y, mesh->vertices[i].position.z);
                ok(compare_vec3(vertices[i].normal, mesh->vertices[i].normal),
                   "Test %s, vertex normal %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i,
                   vertices[i].normal.x, vertices[i].normal.y, vertices[i].normal.z,
                   mesh->vertices[i].normal.x, mesh->vertices[i].normal.y, mesh->vertices[i].normal.z);
            }
 
            IDirect3DVertexBuffer9_Unlock(vertex_buffer);
        }
 
        IDirect3DVertexBuffer9_Release(vertex_buffer);
    }
 
    /* index buffer */
    hr = d3dxmesh->lpVtbl->GetIndexBuffer(d3dxmesh, &index_buffer);
    ok(hr == D3D_OK, "Test %s, result %x, expected 0 (D3D_OK)\n", name, hr);
 
    if (!index_buffer)
    {
        skip("Couldn't get index buffer\n");
    }
    else
    {
        hr = IDirect3DIndexBuffer9_GetDesc(index_buffer, &index_buffer_description);
        ok(hr == D3D_OK, "Test %s, result %x, expected 0 (D3D_OK)\n", name, hr);
 
        if (hr != D3D_OK)
        {
            skip("Couldn't get index buffer description\n");
        }
        else
        {
            ok(index_buffer_description.Format == D3DFMT_INDEX16, "Test %s, result %x, expected %x (D3DFMT_INDEX16)\n",
               name, index_buffer_description.Format, D3DFMT_INDEX16);
            ok(index_buffer_description.Type == D3DRTYPE_INDEXBUFFER, "Test %s, result %x, expected %x (D3DRTYPE_INDEXBUFFER)\n",
               name, index_buffer_description.Type, D3DRTYPE_INDEXBUFFER);
            ok(index_buffer_description.Usage == 0, "Test %s, result %#x, expected %#x.\n",
                    name, index_buffer_description.Usage, 0);
            ok(index_buffer_description.Pool == D3DPOOL_MANAGED, "Test %s, result %x, expected %x (D3DPOOL_MANAGED)\n",
               name, index_buffer_description.Pool, D3DPOOL_MANAGED);
            expected = number_of_faces * sizeof(WORD) * 3;
            ok(index_buffer_description.Size == expected, "Test %s, result %x, expected %x\n",
               name, index_buffer_description.Size, expected);
        }
 
        /* specify offset and size to avoid potential overruns */
        hr = IDirect3DIndexBuffer9_Lock(index_buffer, 0, number_of_faces * sizeof(WORD) * 3,
                (void **)&faces, D3DLOCK_DISCARD);
        ok(hr == D3D_OK, "Test %s, result %x, expected 0 (D3D_OK)\n", name, hr);
 
        if (hr != D3D_OK)
        {
            skip("Couldn't lock index buffer\n");
        }
        else
        {
            for (i = 0; i < number_of_faces; i++)
            {
                ok(compare_face(faces[i], mesh->faces[i]),
                   "Test %s, face %d, result (%u, %u, %u), expected (%u, %u, %u)\n", name, i,
                   faces[i][0], faces[i][1], faces[i][2],
                   mesh->faces[i][0], mesh->faces[i][1], mesh->faces[i][2]);
            }
 
            IDirect3DIndexBuffer9_Unlock(index_buffer);
        }
 
        IDirect3DIndexBuffer9_Release(index_buffer);
    }
}

Referenced by D3DXCreateMeshFVFTest(), D3DXCreateMeshTest(), test_box(), test_cylinder(), test_polygon(), test_sphere(), and test_torus().

◆ compare_normals()

static void compare_normals	(	unsigned int	line,
		const char *	test_name,
		ID3DXMesh *	mesh,
		const D3DXVECTOR3 *	normals,
		unsigned int	num_normals
	)

static

Definition at line 10746 of file mesh.c.

{
    unsigned int i;
    BYTE *vertices;
    DWORD num_vertices, vertex_stride;
    D3DVERTEXELEMENT9 *normal_declaration = NULL;
    D3DVERTEXELEMENT9 declaration[MAX_FVF_DECL_SIZE] = {D3DDECL_END()};
 
    if (FAILED(mesh->lpVtbl->GetDeclaration(mesh, declaration)))
    {
        ok_(__FILE__, line)(0, "%s: Failed to get declaration\n", test_name);
        return;
    }
 
    for (i = 0; declaration[i].Stream != 0xff; i++)
    {
        if (declaration[i].Usage == D3DDECLUSAGE_NORMAL && !declaration[i].UsageIndex)
        {
            normal_declaration = &declaration[i];
            break;
        }
    }
 
    if (!normal_declaration)
    {
        ok_(__FILE__, line)(0, "%s: Mesh has no normals\n", test_name);
        return;
    }
 
    if (normal_declaration->Type != D3DDECLTYPE_FLOAT3 && normal_declaration->Type != D3DDECLTYPE_FLOAT4)
    {
        ok_(__FILE__, line)(0, "%s: Mesh has invalid normals type\n", test_name);
        return;
    }
 
    num_vertices = mesh->lpVtbl->GetNumVertices(mesh);
    vertex_stride = mesh->lpVtbl->GetNumBytesPerVertex(mesh);
 
    ok_(__FILE__, line)(num_vertices == num_normals, "%s: Expected %u vertices, got %u\n", test_name,
            num_normals, num_vertices);
 
    if (FAILED(mesh->lpVtbl->LockVertexBuffer(mesh, 0, (void **)&vertices)))
    {
        ok_(__FILE__, line)(0, "%s: Failed to compare normals\n", test_name);
        return;
    }
 
    vertices += normal_declaration->Offset;
 
    for (i = 0; i < min(num_vertices, num_normals); i++, vertices += vertex_stride)
    {
        if (normal_declaration->Type == D3DDECLTYPE_FLOAT3)
        {
            const D3DXVECTOR3 *n = (D3DXVECTOR3 *)vertices;
            ok_(__FILE__, line)(compare_vec3(*n, normals[i]),
                    "%s: normal %2u, expected (%f, %f, %f), got (%f, %f, %f)\n",
                    test_name, i, normals[i].x, normals[i].y, normals[i].z, n->x, n->y, n->z);
        }
        else
        {
            const D3DXVECTOR4 *n = (D3DXVECTOR4 *)vertices;
            const D3DXVECTOR4 normal = {normals[i].x, normals[i].y, normals[i].z, 1.0f};
            ok_(__FILE__, line)(compare_vec4(*n, normal),
                    "%s: normal %2u, expected (%f, %f, %f, %f), got (%f, %f, %f, %f)\n",
                    test_name, i, normals[i].x, normals[i].y, normals[i].z, 1.0f,
                    n->x, n->y, n->z, n->w);
        }
    }
 
    mesh->lpVtbl->UnlockVertexBuffer(mesh);
}

Referenced by test_compute_normals().

◆ compare_text_outline_mesh()

static void compare_text_outline_mesh	(	const char *	name,
		ID3DXMesh *	d3dxmesh,
		struct mesh *	mesh,
		size_t	textlen,
		float	extrusion,
		const struct glyphinfo *	glyphs
	)

static

Definition at line 3977 of file mesh.c.

{
    HRESULT hr;
    DWORD number_of_vertices, number_of_faces;
    IDirect3DVertexBuffer9 *vertex_buffer = NULL;
    IDirect3DIndexBuffer9 *index_buffer = NULL;
    D3DVERTEXBUFFER_DESC vertex_buffer_description;
    D3DINDEXBUFFER_DESC index_buffer_description;
    struct vertex *vertices = NULL;
    face *faces = NULL;
    int expected, i;
    int vtx_idx1, face_idx1, vtx_idx2, face_idx2;
 
    number_of_vertices = d3dxmesh->lpVtbl->GetNumVertices(d3dxmesh);
    number_of_faces = d3dxmesh->lpVtbl->GetNumFaces(d3dxmesh);
 
    hr = d3dxmesh->lpVtbl->GetVertexBuffer(d3dxmesh, &vertex_buffer);
    ok(hr == D3D_OK, "Test %s, unexpected hr %#x.\n", name, hr);
    hr = IDirect3DVertexBuffer9_GetDesc(vertex_buffer, &vertex_buffer_description);
    ok(hr == D3D_OK, "Test %s, unexpected hr %#x.\n", name, hr);
    ok(vertex_buffer_description.Format == D3DFMT_VERTEXDATA, "Test %s, unexpected format %u.\n",
            name, vertex_buffer_description.Format);
    ok(vertex_buffer_description.Type == D3DRTYPE_VERTEXBUFFER, "Test %s, unexpected resource type %u.\n",
            name, vertex_buffer_description.Type);
    ok(!vertex_buffer_description.Usage, "Test %s, unexpected usage %#x.\n", name, vertex_buffer_description.Usage);
    ok(vertex_buffer_description.Pool == D3DPOOL_MANAGED, "Test %s, unexpected pool %u.\n",
            name, vertex_buffer_description.Pool);
    ok(vertex_buffer_description.FVF == mesh->fvf, "Test %s, unexpected FVF %#x (expected %#x).\n",
            name, vertex_buffer_description.FVF, mesh->fvf);
    if (!mesh->fvf)
        expected = number_of_vertices * mesh->vertex_size;
    else
        expected = number_of_vertices * D3DXGetFVFVertexSize(mesh->fvf);
    ok(vertex_buffer_description.Size == expected, "Test %s, unexpected size %u (expected %u).\n",
            name, vertex_buffer_description.Size, expected);
 
    hr = d3dxmesh->lpVtbl->GetIndexBuffer(d3dxmesh, &index_buffer);
    ok(hr == D3D_OK, "Test %s, unexpected hr %#x.\n", name, hr);
    hr = IDirect3DIndexBuffer9_GetDesc(index_buffer, &index_buffer_description);
    ok(hr == D3D_OK, "Test %s, unexpected hr %#x.\n", name, hr);
    ok(index_buffer_description.Format == D3DFMT_INDEX16, "Test %s, unexpected format %u.\n",
            name, index_buffer_description.Format);
    ok(index_buffer_description.Type == D3DRTYPE_INDEXBUFFER, "Test %s, unexpected resource type %u.\n",
            name, index_buffer_description.Type);
    ok(!index_buffer_description.Usage, "Test %s, unexpected usage %#x.\n",
            name, index_buffer_description.Usage);
    ok(index_buffer_description.Pool == D3DPOOL_MANAGED, "Test %s, unexpected pool %u.\n",
            name, index_buffer_description.Pool);
    expected = number_of_faces * sizeof(WORD) * 3;
    ok(index_buffer_description.Size == expected, "Test %s, unexpected size %u.\n",
            name, index_buffer_description.Size);
 
    hr = IDirect3DVertexBuffer9_Lock(vertex_buffer, 0, number_of_vertices * sizeof(D3DXVECTOR3) * 2,
            (void **)&vertices, D3DLOCK_DISCARD);
    ok(hr == D3D_OK, "Test %s, unexpected hr %#x.\n", name, hr);
    hr = IDirect3DIndexBuffer9_Lock(index_buffer, 0, number_of_faces * sizeof(WORD) * 3,
            (void **)&faces, D3DLOCK_DISCARD);
    ok(hr == D3D_OK, "Test %s, unexpected hr %#x.\n", name, hr);
    face_idx1 = 0;
    vtx_idx2 = 0;
    face_idx2 = 0;
    vtx_idx1 = 0;
    for (i = 0; i < textlen; i++)
    {
        int nb_outline_vertices1, nb_outline_faces1;
        int nb_outline_vertices2, nb_outline_faces2;
        int nb_back_vertices, nb_back_faces;
        int first_vtx1, first_vtx2;
        int first_face1, first_face2;
        int j;
 
        first_vtx1 = vtx_idx1;
        first_vtx2 = vtx_idx2;
        /* Glyphs without outlines do not generate any vertices. */
        if (glyphs[i].outlines.count > 0)
        {
            for (; vtx_idx1 < number_of_vertices; vtx_idx1++)
            {
                if (vertices[vtx_idx1].normal.z != 0)
                    break;
            }
 
            for (; vtx_idx2 < mesh->number_of_vertices; vtx_idx2++)
            {
                if (mesh->vertices[vtx_idx2].normal.z != 0)
                    break;
            }
        }
        nb_outline_vertices1 = vtx_idx1 - first_vtx1;
        nb_outline_vertices2 = vtx_idx2 - first_vtx2;
        ok(nb_outline_vertices1 == nb_outline_vertices2,
           "Test %s, glyph %d, outline vertex count result %d, expected %d\n", name, i,
           nb_outline_vertices1, nb_outline_vertices2);
 
        for (j = 0; j < min(nb_outline_vertices1, nb_outline_vertices2); j++)
        {
            vtx_idx1 = first_vtx1 + j;
            vtx_idx2 = first_vtx2 + j;
            ok(compare_vec3(vertices[vtx_idx1].position, mesh->vertices[vtx_idx2].position),
               "Test %s, glyph %d, vertex position %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i, vtx_idx1,
               vertices[vtx_idx1].position.x, vertices[vtx_idx1].position.y, vertices[vtx_idx1].position.z,
               mesh->vertices[vtx_idx2].position.x, mesh->vertices[vtx_idx2].position.y, mesh->vertices[vtx_idx2].position.z);
            ok(compare_vec3(vertices[vtx_idx1].normal, mesh->vertices[first_vtx2 + j].normal),
               "Test %s, glyph %d, vertex normal %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i, vtx_idx1,
               vertices[vtx_idx1].normal.x, vertices[vtx_idx1].normal.y, vertices[vtx_idx1].normal.z,
               mesh->vertices[vtx_idx2].normal.x, mesh->vertices[vtx_idx2].normal.y, mesh->vertices[vtx_idx2].normal.z);
        }
        vtx_idx1 = first_vtx1 + nb_outline_vertices1;
        vtx_idx2 = first_vtx2 + nb_outline_vertices2;
 
        first_face1 = face_idx1;
        first_face2 = face_idx2;
        for (; face_idx1 < number_of_faces; face_idx1++)
        {
            if (faces[face_idx1][0] >= vtx_idx1 ||
                faces[face_idx1][1] >= vtx_idx1 ||
                faces[face_idx1][2] >= vtx_idx1)
                break;
        }
        for (; face_idx2 < mesh->number_of_faces; face_idx2++)
        {
            if (mesh->faces[face_idx2][0] >= vtx_idx2 ||
                mesh->faces[face_idx2][1] >= vtx_idx2 ||
                mesh->faces[face_idx2][2] >= vtx_idx2)
                break;
        }
        nb_outline_faces1 = face_idx1 - first_face1;
        nb_outline_faces2 = face_idx2 - first_face2;
        ok(nb_outline_faces1 == nb_outline_faces2,
           "Test %s, glyph %d, outline face count result %d, expected %d\n", name, i,
           nb_outline_faces1, nb_outline_faces2);
 
        for (j = 0; j < min(nb_outline_faces1, nb_outline_faces2); j++)
        {
            face_idx1 = first_face1 + j;
            face_idx2 = first_face2 + j;
            ok(faces[face_idx1][0] - first_vtx1 == mesh->faces[face_idx2][0] - first_vtx2 &&
               faces[face_idx1][1] - first_vtx1 == mesh->faces[face_idx2][1] - first_vtx2 &&
               faces[face_idx1][2] - first_vtx1 == mesh->faces[face_idx2][2] - first_vtx2,
               "Test %s, glyph %d, face %d, result (%d, %d, %d), expected (%d, %d, %d)\n", name, i, face_idx1,
               faces[face_idx1][0], faces[face_idx1][1], faces[face_idx1][2],
               mesh->faces[face_idx2][0] - first_vtx2 + first_vtx1,
               mesh->faces[face_idx2][1] - first_vtx2 + first_vtx1,
               mesh->faces[face_idx2][2] - first_vtx2 + first_vtx1);
        }
        face_idx1 = first_face1 + nb_outline_faces1;
        face_idx2 = first_face2 + nb_outline_faces2;
 
        /* partial test on back vertices and faces  */
        first_vtx1 = vtx_idx1;
        for (; vtx_idx1 < number_of_vertices; vtx_idx1++) {
            struct vertex vtx;
 
            if (vertices[vtx_idx1].normal.z != 1.0f)
                break;
 
            vtx.position.z = 0.0f;
            vtx.normal.x = 0.0f;
            vtx.normal.y = 0.0f;
            vtx.normal.z = 1.0f;
            ok(compare(vertices[vtx_idx1].position.z, vtx.position.z),
               "Test %s, glyph %d, vertex position.z %d, result %g, expected %g\n", name, i, vtx_idx1,
               vertices[vtx_idx1].position.z, vtx.position.z);
            ok(compare_vec3(vertices[vtx_idx1].normal, vtx.normal),
               "Test %s, glyph %d, vertex normal %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i, vtx_idx1,
               vertices[vtx_idx1].normal.x, vertices[vtx_idx1].normal.y, vertices[vtx_idx1].normal.z,
               vtx.normal.x, vtx.normal.y, vtx.normal.z);
        }
        nb_back_vertices = vtx_idx1 - first_vtx1;
        first_face1 = face_idx1;
        for (; face_idx1 < number_of_faces; face_idx1++)
        {
            const D3DXVECTOR3 *vtx1, *vtx2, *vtx3;
            D3DXVECTOR3 normal;
            D3DXVECTOR3 v1 = {0, 0, 0};
            D3DXVECTOR3 v2 = {0, 0, 0};
            D3DXVECTOR3 forward = {0.0f, 0.0f, 1.0f};
 
            if (faces[face_idx1][0] >= vtx_idx1 ||
                faces[face_idx1][1] >= vtx_idx1 ||
                faces[face_idx1][2] >= vtx_idx1)
                break;
 
            vtx1 = &vertices[faces[face_idx1][0]].position;
            vtx2 = &vertices[faces[face_idx1][1]].position;
            vtx3 = &vertices[faces[face_idx1][2]].position;
 
            D3DXVec3Subtract(&v1, vtx2, vtx1);
            D3DXVec3Subtract(&v2, vtx3, vtx2);
            D3DXVec3Cross(&normal, &v1, &v2);
            D3DXVec3Normalize(&normal, &normal);
            ok(!D3DXVec3Length(&normal) || compare_vec3(normal, forward),
               "Test %s, glyph %d, face %d normal, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i, face_idx1,
               normal.x, normal.y, normal.z, forward.x, forward.y, forward.z);
        }
        nb_back_faces = face_idx1 - first_face1;
 
        /* compare front and back faces & vertices */
        if (extrusion == 0.0f) {
            /* Oddly there are only back faces in this case */
            nb_back_vertices /= 2;
            nb_back_faces /= 2;
            face_idx1 -= nb_back_faces;
            vtx_idx1 -= nb_back_vertices;
        }
        for (j = 0; j < nb_back_vertices; j++)
        {
            struct vertex vtx = vertices[first_vtx1];
            vtx.position.z = -extrusion;
            vtx.normal.x = 0.0f;
            vtx.normal.y = 0.0f;
            vtx.normal.z = extrusion == 0.0f ? 1.0f : -1.0f;
            ok(compare_vec3(vertices[vtx_idx1].position, vtx.position),
               "Test %s, glyph %d, vertex position %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i, vtx_idx1,
               vertices[vtx_idx1].position.x, vertices[vtx_idx1].position.y, vertices[vtx_idx1].position.z,
               vtx.position.x, vtx.position.y, vtx.position.z);
            ok(compare_vec3(vertices[vtx_idx1].normal, vtx.normal),
               "Test %s, glyph %d, vertex normal %d, result (%g, %g, %g), expected (%g, %g, %g)\n", name, i, vtx_idx1,
               vertices[vtx_idx1].normal.x, vertices[vtx_idx1].normal.y, vertices[vtx_idx1].normal.z,
               vtx.normal.x, vtx.normal.y, vtx.normal.z);
            vtx_idx1++;
            first_vtx1++;
        }
        for (j = 0; j < nb_back_faces; j++)
        {
            int f1, f2;
            if (extrusion == 0.0f) {
                f1 = 1;
                f2 = 2;
            } else {
                f1 = 2;
                f2 = 1;
            }
            ok(faces[face_idx1][0] == faces[first_face1][0] + nb_back_vertices &&
               faces[face_idx1][1] == faces[first_face1][f1] + nb_back_vertices &&
               faces[face_idx1][2] == faces[first_face1][f2] + nb_back_vertices,
               "Test %s, glyph %d, face %d, result (%d, %d, %d), expected (%d, %d, %d)\n", name, i, face_idx1,
               faces[face_idx1][0], faces[face_idx1][1], faces[face_idx1][2],
               faces[first_face1][0] - nb_back_faces,
               faces[first_face1][f1] - nb_back_faces,
               faces[first_face1][f2] - nb_back_faces);
            first_face1++;
            face_idx1++;
        }
 
        /* skip to the outline for the next glyph */
        for (; vtx_idx2 < mesh->number_of_vertices; vtx_idx2++) {
            if (mesh->vertices[vtx_idx2].normal.z == 0)
                break;
        }
        for (; face_idx2 < mesh->number_of_faces; face_idx2++)
        {
            if (mesh->faces[face_idx2][0] >= vtx_idx2 ||
                mesh->faces[face_idx2][1] >= vtx_idx2 ||
                mesh->faces[face_idx2][2] >= vtx_idx2) break;
        }
    }
 
    IDirect3DIndexBuffer9_Unlock(index_buffer);
    IDirect3DVertexBuffer9_Unlock(vertex_buffer);
    IDirect3DIndexBuffer9_Release(index_buffer);
    IDirect3DVertexBuffer9_Release(vertex_buffer);
}

Referenced by test_createtext().

◆ compare_vec3()

static BOOL compare_vec3	(	D3DXVECTOR3	u,
		D3DXVECTOR3	v
	)

static

Definition at line 64 of file mesh.c.

{
    return ( compare(u.x, v.x) && compare(u.y, v.y) && compare(u.z, v.z) );
}

Referenced by compare_mesh(), compare_normals(), compare_text_outline_mesh(), D3DXComputeBoundingBoxTest(), and D3DXComputeBoundingSphereTest().

◆ compare_vec4()

static BOOL compare_vec4	(	D3DXVECTOR4	u,
		D3DXVECTOR4	v
	)

static

Definition at line 69 of file mesh.c.

{
    return compare(u.x, v.x) && compare(u.y, v.y) && compare(u.z, v.z) && compare(u.w, v.w);
}

Referenced by compare_normals().

◆ compute_box()

static BOOL compute_box	(	struct mesh *	mesh,
		float	width,
		float	height,
		float	depth
	)

static

Definition at line 2574 of file mesh.c.

{
    unsigned int i, face;
    static const D3DXVECTOR3 unit_box[] =
    {
        {-1.0f, -1.0f, -1.0f}, {-1.0f, -1.0f,  1.0f}, {-1.0f,  1.0f,  1.0f}, {-1.0f,  1.0f, -1.0f},
        {-1.0f,  1.0f, -1.0f}, {-1.0f,  1.0f,  1.0f}, { 1.0f,  1.0f,  1.0f}, { 1.0f,  1.0f, -1.0f},
        { 1.0f,  1.0f, -1.0f}, { 1.0f,  1.0f,  1.0f}, { 1.0f, -1.0f,  1.0f}, { 1.0f, -1.0f, -1.0f},
        {-1.0f, -1.0f,  1.0f}, {-1.0f, -1.0f, -1.0f}, { 1.0f, -1.0f, -1.0f}, { 1.0f, -1.0f,  1.0f},
        {-1.0f, -1.0f,  1.0f}, { 1.0f, -1.0f,  1.0f}, { 1.0f,  1.0f,  1.0f}, {-1.0f,  1.0f,  1.0f},
        {-1.0f, -1.0f, -1.0f}, {-1.0f,  1.0f, -1.0f}, { 1.0f,  1.0f, -1.0f}, { 1.0f, -1.0f, -1.0f}
    };
    static const D3DXVECTOR3 normals[] =
    {
        {-1.0f,  0.0f, 0.0f}, { 0.0f, 1.0f, 0.0f}, { 1.0f, 0.0f,  0.0f},
        { 0.0f, -1.0f, 0.0f}, { 0.0f, 0.0f, 1.0f}, { 0.0f, 0.0f, -1.0f}
    };
 
    if (!new_mesh(mesh, 24, 12))
    {
        return FALSE;
    }
 
    width /= 2.0f;
    height /= 2.0f;
    depth /= 2.0f;
 
    for (i = 0; i < 24; i++)
    {
        mesh->vertices[i].position.x = width * unit_box[i].x;
        mesh->vertices[i].position.y = height * unit_box[i].y;
        mesh->vertices[i].position.z = depth * unit_box[i].z;
        mesh->vertices[i].normal.x = normals[i / 4].x;
        mesh->vertices[i].normal.y = normals[i / 4].y;
        mesh->vertices[i].normal.z = normals[i / 4].z;
    }
 
    face = 0;
    for (i = 0; i < 12; i++)
    {
        mesh->faces[i][0] = face++;
        mesh->faces[i][1] = face++;
        mesh->faces[i][2] = (i % 2) ? face - 4 : face;
    }
 
    return TRUE;
}

Referenced by test_box().

◆ compute_cylinder()

static BOOL compute_cylinder	(	struct mesh *	mesh,
		FLOAT	radius1,
		FLOAT	radius2,
		FLOAT	length,
		UINT	slices,
		UINT	stacks
	)

static

Definition at line 3104 of file mesh.c.

{
    float theta_step, theta_start;
    struct sincos_table theta;
    FLOAT delta_radius, radius, radius_step;
    FLOAT z, z_step, z_normal;
    DWORD number_of_vertices, number_of_faces;
    DWORD vertex, face;
    int slice, stack;
 
    /* theta = angle on xy plane wrt x axis */
    theta_step = -2 * D3DX_PI / slices;
    theta_start = D3DX_PI / 2;
 
    if (!compute_sincos_table(&theta, theta_start, theta_step, slices))
    {
        return FALSE;
    }
 
    number_of_vertices = 2 + (slices * (3 + stacks));
    number_of_faces = 2 * slices + stacks * (2 * slices);
 
    if (!new_mesh(mesh, number_of_vertices, number_of_faces))
    {
        free_sincos_table(&theta);
        return FALSE;
    }
 
    vertex = 0;
    face = 0;
 
    delta_radius = radius1 - radius2;
    radius = radius1;
    radius_step = delta_radius / stacks;
 
    z = -length / 2;
    z_step = length / stacks;
    z_normal = delta_radius / length;
    if (isnan(z_normal))
    {
        z_normal = 0.0f;
    }
 
    mesh->vertices[vertex].normal.x = 0.0f;
    mesh->vertices[vertex].normal.y = 0.0f;
    mesh->vertices[vertex].normal.z = -1.0f;
    mesh->vertices[vertex].position.x = 0.0f;
    mesh->vertices[vertex].position.y = 0.0f;
    mesh->vertices[vertex++].position.z = z;
 
    for (slice = 0; slice < slices; slice++, vertex++)
    {
        mesh->vertices[vertex].normal.x = 0.0f;
        mesh->vertices[vertex].normal.y = 0.0f;
        mesh->vertices[vertex].normal.z = -1.0f;
        mesh->vertices[vertex].position.x = radius * theta.cos[slice];
        mesh->vertices[vertex].position.y = radius * theta.sin[slice];
        mesh->vertices[vertex].position.z = z;
 
        if (slice > 0)
        {
            mesh->faces[face][0] = 0;
            mesh->faces[face][1] = slice;
            mesh->faces[face++][2] = slice + 1;
        }
    }
 
    mesh->faces[face][0] = 0;
    mesh->faces[face][1] = slice;
    mesh->faces[face++][2] = 1;
 
    for (stack = 1; stack <= stacks+1; stack++)
    {
        for (slice = 0; slice < slices; slice++, vertex++)
        {
            mesh->vertices[vertex].normal.x = theta.cos[slice];
            mesh->vertices[vertex].normal.y = theta.sin[slice];
            mesh->vertices[vertex].normal.z = z_normal;
            D3DXVec3Normalize(&mesh->vertices[vertex].normal, &mesh->vertices[vertex].normal);
            mesh->vertices[vertex].position.x = radius * theta.cos[slice];
            mesh->vertices[vertex].position.y = radius * theta.sin[slice];
            mesh->vertices[vertex].position.z = z;
 
            if (stack > 1 && slice > 0)
            {
                mesh->faces[face][0] = vertex_index(slices, slice-1, stack-1);
                mesh->faces[face][1] = vertex_index(slices, slice-1, stack);
                mesh->faces[face++][2] = vertex_index(slices, slice, stack-1);
 
                mesh->faces[face][0] = vertex_index(slices, slice, stack-1);
                mesh->faces[face][1] = vertex_index(slices, slice-1, stack);
                mesh->faces[face++][2] = vertex_index(slices, slice, stack);
            }
        }
 
        if (stack > 1)
        {
            mesh->faces[face][0] = vertex_index(slices, slice-1, stack-1);
            mesh->faces[face][1] = vertex_index(slices, slice-1, stack);
            mesh->faces[face++][2] = vertex_index(slices, 0, stack-1);
 
            mesh->faces[face][0] = vertex_index(slices, 0, stack-1);
            mesh->faces[face][1] = vertex_index(slices, slice-1, stack);
            mesh->faces[face++][2] = vertex_index(slices, 0, stack);
        }
 
        if (stack < stacks + 1)
        {
            z += z_step;
            radius -= radius_step;
        }
    }
 
    for (slice = 0; slice < slices; slice++, vertex++)
    {
        mesh->vertices[vertex].normal.x = 0.0f;
        mesh->vertices[vertex].normal.y = 0.0f;
        mesh->vertices[vertex].normal.z = 1.0f;
        mesh->vertices[vertex].position.x = radius * theta.cos[slice];
        mesh->vertices[vertex].position.y = radius * theta.sin[slice];
        mesh->vertices[vertex].position.z = z;
 
        if (slice > 0)
        {
            mesh->faces[face][0] = vertex_index(slices, slice-1, stack);
            mesh->faces[face][1] = number_of_vertices - 1;
            mesh->faces[face++][2] = vertex_index(slices, slice, stack);
        }
    }
 
    mesh->vertices[vertex].position.x = 0.0f;
    mesh->vertices[vertex].position.y = 0.0f;
    mesh->vertices[vertex].position.z = z;
    mesh->vertices[vertex].normal.x = 0.0f;
    mesh->vertices[vertex].normal.y = 0.0f;
    mesh->vertices[vertex].normal.z = 1.0f;
 
    mesh->faces[face][0] = vertex_index(slices, slice-1, stack);
    mesh->faces[face][1] = number_of_vertices - 1;
    mesh->faces[face][2] = vertex_index(slices, 0, stack);
 
    free_sincos_table(&theta);
 
    return TRUE;
}

Referenced by test_cylinder().

◆ compute_normals_D3DXComputeNormals()

static HRESULT compute_normals_D3DXComputeNormals	(	ID3DXMesh *	mesh,
		const DWORD *	adjacency
	)

static

Definition at line 10819 of file mesh.c.

{
    return D3DXComputeNormals((ID3DXBaseMesh *)mesh, adjacency);
}

Referenced by test_compute_normals().

◆ compute_normals_D3DXComputeTangentFrameEx()

static HRESULT compute_normals_D3DXComputeTangentFrameEx	(	ID3DXMesh *	mesh,
		const DWORD *	adjacency
	)

static

Definition at line 10824 of file mesh.c.

{
    return D3DXComputeTangentFrameEx(mesh, D3DX_DEFAULT, 0, D3DX_DEFAULT, 0, D3DX_DEFAULT, 0,
            D3DDECLUSAGE_NORMAL, 0, D3DXTANGENT_GENERATE_IN_PLACE | D3DXTANGENT_CALCULATE_NORMALS,
            adjacency, -1.01f, -0.01f, -1.01f, NULL, NULL);
}

Referenced by test_compute_normals().

◆ compute_polygon()

static BOOL compute_polygon	(	struct mesh *	mesh,
		float	length,
		unsigned int	sides
	)

static

Definition at line 2708 of file mesh.c.

{
    unsigned int i;
    float angle, scale;
 
    if (!new_mesh(mesh, sides + 1, sides))
        return FALSE;
 
    angle = D3DX_PI / sides;
    scale = 0.5f * length / sinf(angle);
    angle *= 2.0f;
 
    mesh->vertices[0].position.x = 0.0f;
    mesh->vertices[0].position.y = 0.0f;
    mesh->vertices[0].position.z = 0.0f;
    mesh->vertices[0].normal.x = 0.0f;
    mesh->vertices[0].normal.y = 0.0f;
    mesh->vertices[0].normal.z = 1.0f;
 
    for (i = 0; i < sides; ++i)
    {
        mesh->vertices[i + 1].position.x = cosf(angle * i) * scale;
        mesh->vertices[i + 1].position.y = sinf(angle * i) * scale;
        mesh->vertices[i + 1].position.z = 0.0f;
        mesh->vertices[i + 1].normal.x = 0.0f;
        mesh->vertices[i + 1].normal.y = 0.0f;
        mesh->vertices[i + 1].normal.z = 1.0f;
 
        mesh->faces[i][0] = 0;
        mesh->faces[i][1] = i + 1;
        mesh->faces[i][2] = i + 2;
    }
 
    mesh->faces[sides - 1][2] = 1;
 
    return TRUE;
}

Referenced by test_polygon().

◆ compute_sincos_table()

static BOOL compute_sincos_table	(	struct sincos_table *	sincos_table,
		float	angle_start,
		float	angle_step,
		int	n
	)

static

Definition at line 2855 of file mesh.c.

{
    float angle;
    int i;
 
    sincos_table->sin = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*sincos_table->sin));
    if (!sincos_table->sin)
    {
        return FALSE;
    }
    sincos_table->cos = HeapAlloc(GetProcessHeap(), 0, n * sizeof(*sincos_table->cos));
    if (!sincos_table->cos)
    {
        HeapFree(GetProcessHeap(), 0, sincos_table->sin);
        return FALSE;
    }
 
    angle = angle_start;
    for (i = 0; i < n; i++)
    {
        sincos_table->sin[i] = sin(angle);
        sincos_table->cos[i] = cos(angle);
        angle += angle_step;
    }
 
    return TRUE;
}

◆ compute_sphere()

static BOOL compute_sphere	(	struct mesh *	mesh,
		FLOAT	radius,
		UINT	slices,
		UINT	stacks
	)

static

Definition at line 2889 of file mesh.c.

{
    float theta_step, theta_start;
    struct sincos_table theta;
    float phi_step, phi_start;
    struct sincos_table phi;
    DWORD number_of_vertices, number_of_faces;
    DWORD vertex, face;
    int slice, stack;
 
    /* theta = angle on xy plane wrt x axis */
    theta_step = D3DX_PI / stacks;
    theta_start = theta_step;
 
    /* phi = angle on xz plane wrt z axis */
    phi_step = -2 * D3DX_PI / slices;
    phi_start = D3DX_PI / 2;
 
    if (!compute_sincos_table(&theta, theta_start, theta_step, stacks))
    {
        return FALSE;
    }
    if (!compute_sincos_table(&phi, phi_start, phi_step, slices))
    {
        free_sincos_table(&theta);
        return FALSE;
    }
 
    number_of_vertices = 2 + slices * (stacks-1);
    number_of_faces = 2 * slices + (stacks - 2) * (2 * slices);
 
    if (!new_mesh(mesh, number_of_vertices, number_of_faces))
    {
        free_sincos_table(&phi);
        free_sincos_table(&theta);
        return FALSE;
    }
 
    vertex = 0;
    face = 0;
 
    mesh->vertices[vertex].normal.x = 0.0f;
    mesh->vertices[vertex].normal.y = 0.0f;
    mesh->vertices[vertex].normal.z = 1.0f;
    mesh->vertices[vertex].position.x = 0.0f;
    mesh->vertices[vertex].position.y = 0.0f;
    mesh->vertices[vertex].position.z = radius;
    vertex++;
 
    for (stack = 0; stack < stacks - 1; stack++)
    {
        for (slice = 0; slice < slices; slice++)
        {
            mesh->vertices[vertex].normal.x = theta.sin[stack] * phi.cos[slice];
            mesh->vertices[vertex].normal.y = theta.sin[stack] * phi.sin[slice];
            mesh->vertices[vertex].normal.z = theta.cos[stack];
            mesh->vertices[vertex].position.x = radius * theta.sin[stack] * phi.cos[slice];
            mesh->vertices[vertex].position.y = radius * theta.sin[stack] * phi.sin[slice];
            mesh->vertices[vertex].position.z = radius * theta.cos[stack];
            vertex++;
 
            if (slice > 0)
            {
                if (stack == 0)
                {
                    /* top stack is triangle fan */
                    mesh->faces[face][0] = 0;
                    mesh->faces[face][1] = slice + 1;
                    mesh->faces[face][2] = slice;
                    face++;
                }
                else
                {
                    /* stacks in between top and bottom are quad strips */
                    mesh->faces[face][0] = vertex_index(slices, slice-1, stack-1);
                    mesh->faces[face][1] = vertex_index(slices, slice, stack-1);
                    mesh->faces[face][2] = vertex_index(slices, slice-1, stack);
                    face++;
 
                    mesh->faces[face][0] = vertex_index(slices, slice, stack-1);
                    mesh->faces[face][1] = vertex_index(slices, slice, stack);
                    mesh->faces[face][2] = vertex_index(slices, slice-1, stack);
                    face++;
                }
            }
        }
 
        if (stack == 0)
        {
            mesh->faces[face][0] = 0;
            mesh->faces[face][1] = 1;
            mesh->faces[face][2] = slice;
            face++;
        }
        else
        {
            mesh->faces[face][0] = vertex_index(slices, slice-1, stack-1);
            mesh->faces[face][1] = vertex_index(slices, 0, stack-1);
            mesh->faces[face][2] = vertex_index(slices, slice-1, stack);
            face++;
 
            mesh->faces[face][0] = vertex_index(slices, 0, stack-1);
            mesh->faces[face][1] = vertex_index(slices, 0, stack);
            mesh->faces[face][2] = vertex_index(slices, slice-1, stack);
            face++;
        }
    }
 
    mesh->vertices[vertex].position.x = 0.0f;
    mesh->vertices[vertex].position.y = 0.0f;
    mesh->vertices[vertex].position.z = -radius;
    mesh->vertices[vertex].normal.x = 0.0f;
    mesh->vertices[vertex].normal.y = 0.0f;
    mesh->vertices[vertex].normal.z = -1.0f;
 
    /* bottom stack is triangle fan */
    for (slice = 1; slice < slices; slice++)
    {
        mesh->faces[face][0] = vertex_index(slices, slice-1, stack-1);
        mesh->faces[face][1] = vertex_index(slices, slice, stack-1);
        mesh->faces[face][2] = vertex;
        face++;
    }
 
    mesh->faces[face][0] = vertex_index(slices, slice-1, stack-1);
    mesh->faces[face][1] = vertex_index(slices, 0, stack-1);
    mesh->faces[face][2] = vertex;
 
    free_sincos_table(&phi);
    free_sincos_table(&theta);
 
    return TRUE;
}

Referenced by test_sphere().

◆ compute_text_mesh()

static void compute_text_mesh	(	struct mesh *	mesh,
		const char *	text,
		float	deviation,
		float	extrusion,
		float	otmEMSquare,
		const struct glyphinfo *	glyphs
	)

static

Definition at line 3833 of file mesh.c.

{
    DWORD nb_vertices, nb_faces;
    DWORD nb_corners, nb_outline_points;
    int textlen = 0;
    int i;
    struct vertex *vertex_ptr;
    face *face_ptr;
 
    textlen = strlen(text);
 
    /* corner points need an extra vertex for the different side faces normals */
    nb_corners = 0;
    nb_outline_points = 0;
    for (i = 0; i < textlen; i++)
    {
        int j;
        for (j = 0; j < glyphs[i].outlines.count; j++)
        {
            int k;
            struct outline *outline = &glyphs[i].outlines.items[j];
            nb_outline_points += outline->count;
            nb_corners++; /* first outline point always repeated as a corner */
            for (k = 1; k < outline->count; k++)
                if (outline->items[k].corner)
                    nb_corners++;
        }
    }
 
    nb_vertices = (nb_outline_points + nb_corners) * 2 + textlen;
    nb_faces = nb_outline_points * 2;
 
    ok(new_mesh(mesh, nb_vertices, nb_faces), "Failed to create reference text mesh.\n");
 
    /* convert 2D vertices and faces into 3D mesh */
    vertex_ptr = mesh->vertices;
    face_ptr = mesh->faces;
    for (i = 0; i < textlen; i++)
    {
        int j;
 
        /* side vertices and faces */
        for (j = 0; j < glyphs[i].outlines.count; j++)
        {
            struct vertex *outline_vertices = vertex_ptr;
            struct outline *outline = &glyphs[i].outlines.items[j];
            int k;
            struct point2d *prevpt = &outline->items[outline->count - 1];
            struct point2d *pt = &outline->items[0];
 
            for (k = 1; k <= outline->count; k++)
            {
                struct vertex vtx;
                struct point2d *nextpt = &outline->items[k % outline->count];
                WORD vtx_idx = vertex_ptr - mesh->vertices;
                D3DXVECTOR2 vec;
 
                if (pt->corner == POINTTYPE_CURVE_START)
                    D3DXVec2Subtract(&vec, &pt->pos, &prevpt->pos);
                else if (pt->corner)
                    D3DXVec2Subtract(&vec, &nextpt->pos, &pt->pos);
                else
                    D3DXVec2Subtract(&vec, &nextpt->pos, &prevpt->pos);
                D3DXVec2Normalize(&vec, &vec);
                vtx.normal.x = -vec.y;
                vtx.normal.y = vec.x;
                vtx.normal.z = 0;
 
                vtx.position.x = pt->pos.x + glyphs[i].offset_x;
                vtx.position.y = pt->pos.y;
                vtx.position.z = 0;
                *vertex_ptr++ = vtx;
 
                vtx.position.z = -extrusion;
                *vertex_ptr++ = vtx;
 
                vtx.position.x = nextpt->pos.x + glyphs[i].offset_x;
                vtx.position.y = nextpt->pos.y;
                if (pt->corner && nextpt->corner && nextpt->corner != POINTTYPE_CURVE_END) {
                    vtx.position.z = -extrusion;
                    *vertex_ptr++ = vtx;
                    vtx.position.z = 0;
                    *vertex_ptr++ = vtx;
 
                    (*face_ptr)[0] = vtx_idx;
                    (*face_ptr)[1] = vtx_idx + 2;
                    (*face_ptr)[2] = vtx_idx + 1;
                    face_ptr++;
 
                    (*face_ptr)[0] = vtx_idx;
                    (*face_ptr)[1] = vtx_idx + 3;
                    (*face_ptr)[2] = vtx_idx + 2;
                    face_ptr++;
                } else {
                    if (nextpt->corner) {
                        if (nextpt->corner == POINTTYPE_CURVE_END) {
                            struct point2d *nextpt2 = &outline->items[(k + 1) % outline->count];
                            D3DXVec2Subtract(&vec, &nextpt2->pos, &nextpt->pos);
                        } else {
                            D3DXVec2Subtract(&vec, &nextpt->pos, &pt->pos);
                        }
                        D3DXVec2Normalize(&vec, &vec);
                        vtx.normal.x = -vec.y;
                        vtx.normal.y = vec.x;
 
                        vtx.position.z = 0;
                        *vertex_ptr++ = vtx;
                        vtx.position.z = -extrusion;
                        *vertex_ptr++ = vtx;
                    }
 
                    (*face_ptr)[0] = vtx_idx;
                    (*face_ptr)[1] = vtx_idx + 3;
                    (*face_ptr)[2] = vtx_idx + 1;
                    face_ptr++;
 
                    (*face_ptr)[0] = vtx_idx;
                    (*face_ptr)[1] = vtx_idx + 2;
                    (*face_ptr)[2] = vtx_idx + 3;
                    face_ptr++;
                }
 
                prevpt = pt;
                pt = nextpt;
            }
            if (!pt->corner) {
                *vertex_ptr++ = *outline_vertices++;
                *vertex_ptr++ = *outline_vertices++;
            }
        }
 
        /* FIXME: compute expected faces */
        /* Add placeholder to separate glyph outlines */
        vertex_ptr->position.x = 0;
        vertex_ptr->position.y = 0;
        vertex_ptr->position.z = 0;
        vertex_ptr->normal.x = 0;
        vertex_ptr->normal.y = 0;
        vertex_ptr->normal.z = 1;
        vertex_ptr++;
    }
}

Referenced by test_createtext().

◆ compute_torus()

static BOOL compute_torus	(	struct mesh *	mesh,
		float	innerradius,
		float	outerradius,
		UINT	sides,
		UINT	rings
	)

static

Definition at line 3355 of file mesh.c.

{
    float phi, phi_step, sin_phi, cos_phi;
    float theta, theta_step, sin_theta, cos_theta;
    unsigned int numvert, numfaces, i, j;
 
    numvert = sides * rings;
    numfaces = numvert * 2;
 
    if (!new_mesh(mesh, numvert, numfaces))
        return FALSE;
 
    phi_step = D3DX_PI / sides * 2.0f;
    theta_step = D3DX_PI / rings * -2.0f;
 
    theta = 0.0f;
 
    for (i = 0; i < rings; ++i)
    {
        phi = 0.0f;
 
        cos_theta = cosf(theta);
        sin_theta = sinf(theta);
 
        for (j = 0; j < sides; ++j)
        {
            sin_phi = sinf(phi);
            cos_phi = cosf(phi);
 
            mesh->vertices[i * sides + j].position.x = (innerradius * cos_phi + outerradius) * cos_theta;
            mesh->vertices[i * sides + j].position.y = (innerradius * cos_phi + outerradius) * sin_theta;
            mesh->vertices[i * sides + j].position.z = innerradius * sin_phi;
            mesh->vertices[i * sides + j].normal.x = cos_phi * cos_theta;
            mesh->vertices[i * sides + j].normal.y = cos_phi * sin_theta;
            mesh->vertices[i * sides + j].normal.z = sin_phi;
 
            phi += phi_step;
        }
 
        theta += theta_step;
    }
 
    for (i = 0; i < numfaces - sides * 2; ++i)
    {
        mesh->faces[i][0] = i % 2 ? i / 2 + sides : i / 2;
        mesh->faces[i][1] = (i / 2 + 1) % sides ? i / 2 + 1 : i / 2 + 1 - sides;
        mesh->faces[i][2] = (i + 1) % (sides * 2) ? (i + 1) / 2 + sides : (i + 1) / 2;
    }
 
    for (j = 0; i < numfaces; ++i, ++j)
    {
        mesh->faces[i][0] = i % 2 ? j / 2 : i / 2;
        mesh->faces[i][1] = (i / 2 + 1) % sides ? i / 2 + 1 : i / 2 + 1 - sides;
        mesh->faces[i][2] = i == numfaces - 1 ? 0 : (j + 1) / 2;
    }
 
    return TRUE;
}

Referenced by test_torus().

◆ convert_fixed_to_float()

static D3DXVECTOR2 * convert_fixed_to_float	(	POINTFX *	pt,
		int	count,
		float	emsquare
	)

inlinestatic

Definition at line 3574 of file mesh.c.

{
    D3DXVECTOR2 *ret = (D3DXVECTOR2*)pt;
    while (count--) {
        D3DXVECTOR2 *pt_flt = (D3DXVECTOR2*)pt;
        pt_flt->x = (pt->x.value + pt->x.fract / (float)0x10000) / emsquare;
        pt_flt->y = (pt->y.value + pt->y.fract / (float)0x10000) / emsquare;
        pt++;
    }
    return ret;
}

◆ create_outline()

static HRESULT create_outline	(	struct glyphinfo *	glyph,
		void *	raw_outline,
		int	datasize,
		float	max_deviation,
		float	emsquare
	)

static

Definition at line 3671 of file mesh.c.

{
    const float cos_45 = cos(D3DXToRadian(45.0f));
    const float cos_90 = cos(D3DXToRadian(90.0f));
    TTPOLYGONHEADER *header = (TTPOLYGONHEADER *)raw_outline;
 
    while ((char *)header < (char *)raw_outline + datasize)
    {
        TTPOLYCURVE *curve = (TTPOLYCURVE *)(header + 1);
        struct point2d *lastpt, *pt;
        D3DXVECTOR2 lastdir;
        D3DXVECTOR2 *pt_flt;
        int j;
        struct outline *outline = add_outline(&glyph->outlines);
 
        if (!outline)
            return E_OUTOFMEMORY;
 
        pt = add_point(outline);
        if (!pt)
            return E_OUTOFMEMORY;
        pt_flt = convert_fixed_to_float(&header->pfxStart, 1, emsquare);
        pt->pos = *pt_flt;
        pt->corner = POINTTYPE_CORNER;
 
        if (header->dwType != TT_POLYGON_TYPE)
            trace("Unknown header type %d\n", header->dwType);
 
        while ((char *)curve < (char *)header + header->cb)
        {
            D3DXVECTOR2 bezier_start = outline->items[outline->count - 1].pos;
            BOOL to_curve = curve->wType != TT_PRIM_LINE && curve->cpfx > 1;
 
            if (!curve->cpfx) {
                curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
                continue;
            }
 
            pt_flt = convert_fixed_to_float(curve->apfx, curve->cpfx, emsquare);
 
            attempt_line_merge(outline, outline->count - 1, &pt_flt[0], to_curve);
 
            if (to_curve)
            {
                HRESULT hr;
                int count = curve->cpfx;
                j = 0;
 
                while (count > 2)
                {
                    D3DXVECTOR2 bezier_end;
 
                    D3DXVec2Scale(&bezier_end, D3DXVec2Add(&bezier_end, &pt_flt[j], &pt_flt[j+1]), 0.5f);
                    hr = add_bezier_points(outline, &bezier_start, &pt_flt[j], &bezier_end, max_deviation);
                    if (hr != S_OK)
                        return hr;
                    bezier_start = bezier_end;
                    count--;
                    j++;
                }
                hr = add_bezier_points(outline, &bezier_start, &pt_flt[j], &pt_flt[j+1], max_deviation);
                if (hr != S_OK)
                    return hr;
 
                pt = add_point(outline);
                if (!pt)
                    return E_OUTOFMEMORY;
                j++;
                pt->pos = pt_flt[j];
                pt->corner = POINTTYPE_CURVE_END;
            } else {
                for (j = 0; j < curve->cpfx; j++)
                {
                    pt = add_point(outline);
                    if (!pt)
                        return E_OUTOFMEMORY;
                    pt->pos = pt_flt[j];
                    pt->corner = POINTTYPE_CORNER;
                }
            }
 
            curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
        }
 
        /* remove last point if the next line continues the last line */
        if (outline->count >= 3) {
            BOOL to_curve;
 
            lastpt = &outline->items[outline->count - 1];
            pt = &outline->items[0];
            if (pt->pos.x == lastpt->pos.x && pt->pos.y == lastpt->pos.y) {
                if (lastpt->corner == POINTTYPE_CURVE_END)
                {
                    if (pt->corner == POINTTYPE_CURVE_START)
                        pt->corner = POINTTYPE_CURVE_MIDDLE;
                    else
                        pt->corner = POINTTYPE_CURVE_END;
                }
                outline->count--;
            } else {
                /* outline closed with a line from end to start point */
                attempt_line_merge(outline, outline->count - 1, &pt->pos, FALSE);
            }
            lastpt = &outline->items[0];
            to_curve = lastpt->corner != POINTTYPE_CORNER && lastpt->corner != POINTTYPE_CURVE_END;
            if (lastpt->corner == POINTTYPE_CURVE_START)
                lastpt->corner = POINTTYPE_CORNER;
            pt = &outline->items[1];
            if (attempt_line_merge(outline, 0, &pt->pos, to_curve))
                *lastpt = outline->items[outline->count];
        }
 
        lastpt = &outline->items[outline->count - 1];
        pt = &outline->items[0];
        unit_vec2(&lastdir, &lastpt->pos, &pt->pos);
        for (j = 0; j < outline->count; j++)
        {
            D3DXVECTOR2 curdir;
 
            lastpt = pt;
            pt = &outline->items[(j + 1) % outline->count];
            unit_vec2(&curdir, &lastpt->pos, &pt->pos);
 
            switch (lastpt->corner)
            {
                case POINTTYPE_CURVE_START:
                case POINTTYPE_CURVE_END:
                    if (!is_direction_similar(&lastdir, &curdir, cos_45))
                        lastpt->corner = POINTTYPE_CORNER;
                    break;
                case POINTTYPE_CURVE_MIDDLE:
                    if (!is_direction_similar(&lastdir, &curdir, cos_90))
                        lastpt->corner = POINTTYPE_CORNER;
                    else
                        lastpt->corner = POINTTYPE_CURVE;
                    break;
                default:
                    break;
            }
            lastdir = curdir;
        }
 
        header = (TTPOLYGONHEADER *)((char *)header + header->cb);
    }
    return S_OK;
}

◆ D3DXBoundProbeTest()

static void D3DXBoundProbeTest ( void )

static

Definition at line 382 of file mesh.c.

{
    BOOL result;
    D3DXVECTOR3 bottom_point, center, top_point, raydirection, rayposition;
    FLOAT radius;
 
/*____________Test the Box case___________________________*/
    bottom_point.x = -3.0f; bottom_point.y = -2.0f; bottom_point.z = -1.0f;
    top_point.x = 7.0f; top_point.y = 8.0f; top_point.z = 9.0f;
 
    raydirection.x = -4.0f; raydirection.y = -5.0f; raydirection.z = -6.0f;
    rayposition.x = 5.0f; rayposition.y = 5.0f; rayposition.z = 11.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == TRUE, "expected TRUE, received FALSE\n");
 
    raydirection.x = 4.0f; raydirection.y = 5.0f; raydirection.z = 6.0f;
    rayposition.x = 5.0f; rayposition.y = 5.0f; rayposition.z = 11.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == FALSE, "expected FALSE, received TRUE\n");
 
    rayposition.x = -4.0f; rayposition.y = 1.0f; rayposition.z = -2.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == TRUE, "expected TRUE, received FALSE\n");
 
    bottom_point.x = 1.0f; bottom_point.y = 0.0f; bottom_point.z = 0.0f;
    top_point.x = 1.0f; top_point.y = 0.0f; top_point.z = 0.0f;
    rayposition.x = 0.0f; rayposition.y = 1.0f; rayposition.z = 0.0f;
    raydirection.x = 0.0f; raydirection.y = 3.0f; raydirection.z = 0.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == FALSE, "expected FALSE, received TRUE\n");
 
    bottom_point.x = 1.0f; bottom_point.y = 2.0f; bottom_point.z = 3.0f;
    top_point.x = 10.0f; top_point.y = 15.0f; top_point.z = 20.0f;
 
    raydirection.x = 7.0f; raydirection.y = 8.0f; raydirection.z = 9.0f;
    rayposition.x = 3.0f; rayposition.y = 7.0f; rayposition.z = -6.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == TRUE, "expected TRUE, received FALSE\n");
 
    bottom_point.x = 0.0f; bottom_point.y = 0.0f; bottom_point.z = 0.0f;
    top_point.x = 1.0f; top_point.y = 1.0f; top_point.z = 1.0f;
 
    raydirection.x = 0.0f; raydirection.y = 1.0f; raydirection.z = .0f;
    rayposition.x = -3.0f; rayposition.y = 0.0f; rayposition.z = 0.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == FALSE, "expected FALSE, received TRUE\n");
 
    raydirection.x = 1.0f; raydirection.y = 0.0f; raydirection.z = .0f;
    rayposition.x = -3.0f; rayposition.y = 0.0f; rayposition.z = 0.0f;
    result = D3DXBoxBoundProbe(&bottom_point, &top_point, &rayposition, &raydirection);
    ok(result == TRUE, "expected TRUE, received FALSE\n");
 
/*____________Test the Sphere case________________________*/
    radius = sqrt(77.0f);
    center.x = 1.0f; center.y = 2.0f; center.z = 3.0f;
    raydirection.x = 2.0f; raydirection.y = -4.0f; raydirection.z = 2.0f;
    rayposition.x = 5.0f; rayposition.y = 5.0f; rayposition.z = 9.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == TRUE, "Got unexpected result %#x.\n", result);
 
    rayposition.x = 45.0f; rayposition.y = -75.0f; rayposition.z = 49.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == FALSE, "Got unexpected result %#x.\n", result);
 
    raydirection.x = -2.0f; raydirection.y = 4.0f; raydirection.z = -2.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == TRUE, "Got unexpected result %#x.\n", result);
 
    rayposition.x = 5.0f; rayposition.y = 11.0f; rayposition.z = 9.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == FALSE, "Got unexpected result %#x.\n", result);
 
    raydirection.x = 2.0f; raydirection.y = -4.0f; raydirection.z = 2.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == FALSE, "Got unexpected result %#x.\n", result);
 
    radius = 1.0f;
    rayposition.x = 2.0f; rayposition.y = 2.0f; rayposition.z = 3.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == FALSE, "Got unexpected result %#x.\n", result);
 
    raydirection.x = 0.0f; raydirection.y = 0.0f; raydirection.z = 1.0f;
    result = D3DXSphereBoundProbe(&center, radius, &rayposition, &raydirection);
    ok(result == TRUE, "Got unexpected result %#x.\n", result);
 
    if (0)
    {
        /* All these crash on native. */
        D3DXSphereBoundProbe(&center, radius, &rayposition, NULL);
        D3DXSphereBoundProbe(&center, radius, NULL, &raydirection);
        D3DXSphereBoundProbe(NULL, radius, &rayposition, &raydirection);
    }
}

Referenced by START_TEST().

◆ D3DXComputeBoundingBoxTest()

static void D3DXComputeBoundingBoxTest ( void )

static

Definition at line 476 of file mesh.c.

{
    D3DXVECTOR3 exp_max, exp_min, got_max, got_min, vertex[5];
    HRESULT hr;
 
    vertex[0].x = 1.0f; vertex[0].y = 1.0f; vertex[0].z = 1.0f;
    vertex[1].x = 1.0f; vertex[1].y = 1.0f; vertex[1].z = 1.0f;
    vertex[2].x = 1.0f; vertex[2].y = 1.0f; vertex[2].z = 1.0f;
    vertex[3].x = 1.0f; vertex[3].y = 1.0f; vertex[3].z = 1.0f;
    vertex[4].x = 9.0f; vertex[4].y = 9.0f; vertex[4].z = 9.0f;
 
    exp_min.x = 1.0f; exp_min.y = 1.0f; exp_min.z = 1.0f;
    exp_max.x = 9.0f; exp_max.y = 9.0f; exp_max.z = 9.0f;
 
    hr = D3DXComputeBoundingBox(&vertex[3],2,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_min,&got_max);
 
    ok( hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr);
    ok( compare_vec3(exp_min,got_min), "Expected min: (%f, %f, %f), got: (%f, %f, %f)\n", exp_min.x,exp_min.y,exp_min.z,got_min.x,got_min.y,got_min.z);
    ok( compare_vec3(exp_max,got_max), "Expected max: (%f, %f, %f), got: (%f, %f, %f)\n", exp_max.x,exp_max.y,exp_max.z,got_max.x,got_max.y,got_max.z);
 
/*________________________*/
 
    vertex[0].x = 2.0f; vertex[0].y = 5.9f; vertex[0].z = -1.2f;
    vertex[1].x = -1.87f; vertex[1].y = 7.9f; vertex[1].z = 7.4f;
    vertex[2].x = 7.43f; vertex[2].y = -0.9f; vertex[2].z = 11.9f;
    vertex[3].x = -6.92f; vertex[3].y = 6.3f; vertex[3].z = -3.8f;
    vertex[4].x = 11.4f; vertex[4].y = -8.1f; vertex[4].z = 4.5f;
 
    exp_min.x = -6.92f; exp_min.y = -8.1f; exp_min.z = -3.80f;
    exp_max.x = 11.4f; exp_max.y = 7.90f; exp_max.z = 11.9f;
 
    hr = D3DXComputeBoundingBox(&vertex[0],5,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_min,&got_max);
 
    ok( hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr);
    ok( compare_vec3(exp_min,got_min), "Expected min: (%f, %f, %f), got: (%f, %f, %f)\n", exp_min.x,exp_min.y,exp_min.z,got_min.x,got_min.y,got_min.z);
    ok( compare_vec3(exp_max,got_max), "Expected max: (%f, %f, %f), got: (%f, %f, %f)\n", exp_max.x,exp_max.y,exp_max.z,got_max.x,got_max.y,got_max.z);
 
/*________________________*/
 
    vertex[0].x = 2.0f; vertex[0].y = 5.9f; vertex[0].z = -1.2f;
    vertex[1].x = -1.87f; vertex[1].y = 7.9f; vertex[1].z = 7.4f;
    vertex[2].x = 7.43f; vertex[2].y = -0.9f; vertex[2].z = 11.9f;
    vertex[3].x = -6.92f; vertex[3].y = 6.3f; vertex[3].z = -3.8f;
    vertex[4].x = 11.4f; vertex[4].y = -8.1f; vertex[4].z = 4.5f;
 
    exp_min.x = -6.92f; exp_min.y = -0.9f; exp_min.z = -3.8f;
    exp_max.x = 7.43f; exp_max.y = 7.90f; exp_max.z = 11.9f;
 
    hr = D3DXComputeBoundingBox(&vertex[0],4,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_min,&got_max);
 
    ok( hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr);
    ok( compare_vec3(exp_min,got_min), "Expected min: (%f, %f, %f), got: (%f, %f, %f)\n", exp_min.x,exp_min.y,exp_min.z,got_min.x,got_min.y,got_min.z);
    ok( compare_vec3(exp_max,got_max), "Expected max: (%f, %f, %f), got: (%f, %f, %f)\n", exp_max.x,exp_max.y,exp_max.z,got_max.x,got_max.y,got_max.z);
 
/*________________________*/
    hr = D3DXComputeBoundingBox(NULL,5,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_min,&got_max);
    ok( hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %#x\n", hr);
 
/*________________________*/
    hr = D3DXComputeBoundingBox(&vertex[3],5,D3DXGetFVFVertexSize(D3DFVF_XYZ),NULL,&got_max);
    ok( hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %#x\n", hr);
 
/*________________________*/
    hr = D3DXComputeBoundingBox(&vertex[3],5,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_min,NULL);
    ok( hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %#x\n", hr);
}

Referenced by START_TEST().

◆ D3DXComputeBoundingSphereTest()

static void D3DXComputeBoundingSphereTest ( void )

static

Definition at line 543 of file mesh.c.

{
    D3DXVECTOR3 exp_cen, got_cen, vertex[5];
    FLOAT exp_rad, got_rad;
    HRESULT hr;
 
    vertex[0].x = 1.0f; vertex[0].y = 1.0f; vertex[0].z = 1.0f;
    vertex[1].x = 1.0f; vertex[1].y = 1.0f; vertex[1].z = 1.0f;
    vertex[2].x = 1.0f; vertex[2].y = 1.0f; vertex[2].z = 1.0f;
    vertex[3].x = 1.0f; vertex[3].y = 1.0f; vertex[3].z = 1.0f;
    vertex[4].x = 9.0f; vertex[4].y = 9.0f; vertex[4].z = 9.0f;
 
    exp_rad = 6.928203f;
    exp_cen.x = 5.0; exp_cen.y = 5.0; exp_cen.z = 5.0;
 
    hr = D3DXComputeBoundingSphere(&vertex[3],2,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_cen,&got_rad);
 
    ok( hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr);
    ok( compare(exp_rad, got_rad), "Expected radius: %f, got radius: %f\n", exp_rad, got_rad);
    ok( compare_vec3(exp_cen,got_cen), "Expected center: (%f, %f, %f), got center: (%f, %f, %f)\n", exp_cen.x,exp_cen.y,exp_cen.z,got_cen.x,got_cen.y,got_cen.z);
 
/*________________________*/
 
    vertex[0].x = 2.0f; vertex[0].y = 5.9f; vertex[0].z = -1.2f;
    vertex[1].x = -1.87f; vertex[1].y = 7.9f; vertex[1].z = 7.4f;
    vertex[2].x = 7.43f; vertex[2].y = -0.9f; vertex[2].z = 11.9f;
    vertex[3].x = -6.92f; vertex[3].y = 6.3f; vertex[3].z = -3.8f;
    vertex[4].x = 11.4f; vertex[4].y = -8.1f; vertex[4].z = 4.5f;
 
    exp_rad = 13.707883f;
    exp_cen.x = 2.408f; exp_cen.y = 2.22f; exp_cen.z = 3.76f;
 
    hr = D3DXComputeBoundingSphere(&vertex[0],5,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_cen,&got_rad);
 
    ok( hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr);
    ok( compare(exp_rad, got_rad), "Expected radius: %f, got radius: %f\n", exp_rad, got_rad);
    ok( compare_vec3(exp_cen,got_cen), "Expected center: (%f, %f, %f), got center: (%f, %f, %f)\n", exp_cen.x,exp_cen.y,exp_cen.z,got_cen.x,got_cen.y,got_cen.z);
 
/*________________________*/
    hr = D3DXComputeBoundingSphere(NULL,5,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_cen,&got_rad);
    ok( hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %#x\n", hr);
 
/*________________________*/
    hr = D3DXComputeBoundingSphere(&vertex[3],5,D3DXGetFVFVertexSize(D3DFVF_XYZ),NULL,&got_rad);
    ok( hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %#x\n", hr);
 
/*________________________*/
    hr = D3DXComputeBoundingSphere(&vertex[3],5,D3DXGetFVFVertexSize(D3DFVF_XYZ),&got_cen,NULL);
    ok( hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %#x\n", hr);
}

Referenced by START_TEST().

◆ D3DXCreateAnimationControllerTest()

static void D3DXCreateAnimationControllerTest ( void )

static

Definition at line 11260 of file mesh.c.

{
    HRESULT hr;
    ID3DXAnimationController *animation;
    UINT value;
 
    hr = D3DXCreateAnimationController(0, 0, 0, 0, NULL);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
 
    animation = (void*)0xdeadbeef;
    hr = D3DXCreateAnimationController(0, 1, 1, 1, &animation);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
    ok(animation == (void*)0xdeadbeef, "Got unexpected animation %p.\n", animation);
 
    animation = (void*)0xdeadbeef;
    hr = D3DXCreateAnimationController(1, 0, 1, 1, &animation);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
    ok(animation == (void*)0xdeadbeef, "Got unexpected animation %p.\n", animation);
 
    animation = (void*)0xdeadbeef;
    hr = D3DXCreateAnimationController(1, 1, 0, 1, &animation);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
    ok(animation == (void*)0xdeadbeef, "Got unexpected animation %p.\n", animation);
 
    animation = (void*)0xdeadbeef;
    hr = D3DXCreateAnimationController(1, 1, 1, 0, &animation);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
    ok(animation == (void*)0xdeadbeef, "Got unexpected animation %p.\n", animation);
 
    hr = D3DXCreateAnimationController(1, 1, 1, 1, &animation);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
 
    value = animation->lpVtbl->GetMaxNumAnimationOutputs(animation);
    ok(value == 1, "Got unexpected value %u.\n", value);
 
    value = animation->lpVtbl->GetMaxNumAnimationSets(animation);
    ok(value == 1, "Got unexpected value %u.\n", value);
 
    value = animation->lpVtbl->GetMaxNumTracks(animation);
    ok(value == 1, "Got unexpected value %u.\n", value);
 
    value = animation->lpVtbl->GetMaxNumEvents(animation);
    ok(value == 1, "Got unexpected value %u.\n", value);
 
    animation->lpVtbl->Release(animation);
 
    hr = D3DXCreateAnimationController(100, 101, 102, 103, &animation);
    ok(hr == D3D_OK, "Got unexpected hr returned %#x.\n", hr);
 
    value = animation->lpVtbl->GetMaxNumAnimationOutputs(animation);
    ok(value == 100, "Got unexpected value %u.\n", value);
 
    value = animation->lpVtbl->GetMaxNumAnimationSets(animation);
    ok(value == 101, "Got unexpected value %u.\n", value);
 
    value = animation->lpVtbl->GetMaxNumTracks(animation);
    ok(value == 102, "Got unexpected value %u.\n", value);
 
    value = animation->lpVtbl->GetMaxNumEvents(animation);
    ok(value == 103, "Got unexpected value %u.\n", value);
 
    animation->lpVtbl->Release(animation);
}

Referenced by START_TEST().

◆ D3DXCreateBoxTest()

static void D3DXCreateBoxTest ( void )

static

Definition at line 2653 of file mesh.c.

{
    HRESULT hr;
    IDirect3DDevice9* device;
    ID3DXMesh* box;
    ID3DXBuffer* ppBuffer;
    DWORD *buffer;
    static const DWORD adjacency[36]=
        {6, 9, 1, 2, 10, 0,
         1, 9, 3, 4, 10, 2,
         3, 8, 5, 7, 11, 4,
         0, 11, 7, 5, 8, 6,
         7, 4, 9, 2, 0, 8,
         1, 3, 11, 5, 6, 10};
    unsigned int i;
    struct test_context *test_context;
 
    if (!(test_context = new_test_context()))
    {
        skip("Couldn't create test context\n");
        return;
    }
    device = test_context->device;
 
    hr = D3DXCreateBox(device,2.0f,20.0f,4.9f,NULL, &ppBuffer);
    ok(hr==D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, received %#x\n", hr);
 
    hr = D3DXCreateBox(NULL,22.0f,20.0f,4.9f,&box, &ppBuffer);
    ok(hr==D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, received %#x\n", hr);
 
    hr = D3DXCreateBox(device,-2.0f,20.0f,4.9f,&box, &ppBuffer);
    ok(hr==D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, received %#x\n", hr);
 
    hr = D3DXCreateBox(device,22.0f,-20.0f,4.9f,&box, &ppBuffer);
    ok(hr==D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, received %#x\n", hr);
 
    hr = D3DXCreateBox(device,22.0f,20.0f,-4.9f,&box, &ppBuffer);
    ok(hr==D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, received %#x\n", hr);
 
    ppBuffer = NULL;
    hr = D3DXCreateBox(device,10.9f,20.0f,4.9f,&box, &ppBuffer);
    ok(hr==D3D_OK, "Expected D3D_OK, received %#x\n", hr);
 
    buffer = ID3DXBuffer_GetBufferPointer(ppBuffer);
    for(i=0; i<36; i++)
        ok(adjacency[i]==buffer[i], "expected adjacency %d: %#x, received %#x\n",i,adjacency[i], buffer[i]);
 
    box->lpVtbl->Release(box);
    ID3DXBuffer_Release(ppBuffer);
 
    test_box(device, 10.9f, 20.0f, 4.9f);
 
    free_test_context(test_context);
}

Referenced by START_TEST().

◆ D3DXCreateCylinderTest()

static void D3DXCreateCylinderTest ( void )

static

Definition at line 3282 of file mesh.c.

{
    HRESULT hr;
    IDirect3DDevice9* device;
    ID3DXMesh* cylinder = NULL;
    struct test_context *test_context;
 
    hr = D3DXCreateCylinder(NULL, 0.0f, 0.0f, 0.0f, 0, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    hr = D3DXCreateCylinder(NULL, 1.0f, 1.0f, 1.0f, 2, 1, &cylinder, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    if (!(test_context = new_test_context()))
    {
        skip("Couldn't create test context\n");
        return;
    }
    device = test_context->device;
 
    hr = D3DXCreateCylinder(device, -0.1f, 1.0f, 1.0f, 2, 1, &cylinder, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    hr = D3DXCreateCylinder(device, 0.0f, 1.0f, 1.0f, 2, 1, &cylinder, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n",hr);
 
    if (SUCCEEDED(hr) && cylinder)
    {
        cylinder->lpVtbl->Release(cylinder);
    }
 
    hr = D3DXCreateCylinder(device, 1.0f, -0.1f, 1.0f, 2, 1, &cylinder, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    hr = D3DXCreateCylinder(device, 1.0f, 0.0f, 1.0f, 2, 1, &cylinder, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n",hr);
 
    if (SUCCEEDED(hr) && cylinder)
    {
        cylinder->lpVtbl->Release(cylinder);
    }
 
    hr = D3DXCreateCylinder(device, 1.0f, 1.0f, -0.1f, 2, 1, &cylinder, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    /* Test with length == 0.0f succeeds */
    hr = D3DXCreateCylinder(device, 1.0f, 1.0f, 0.0f, 2, 1, &cylinder, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n",hr);
 
    if (SUCCEEDED(hr) && cylinder)
    {
        cylinder->lpVtbl->Release(cylinder);
    }
 
    hr = D3DXCreateCylinder(device, 1.0f, 1.0f, 1.0f, 1, 1, &cylinder, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    hr = D3DXCreateCylinder(device, 1.0f, 1.0f, 1.0f, 2, 0, &cylinder, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    hr = D3DXCreateCylinder(device, 1.0f, 1.0f, 1.0f, 2, 1, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n",hr,D3DERR_INVALIDCALL);
 
    test_cylinder(device, 0.0f, 0.0f, 0.0f, 2, 1);
    test_cylinder(device, 1.0f, 1.0f, 1.0f, 2, 1);
    test_cylinder(device, 1.0f, 1.0f, 2.0f, 3, 4);
    test_cylinder(device, 3.0f, 2.0f, 4.0f, 3, 4);
    test_cylinder(device, 2.0f, 3.0f, 4.0f, 3, 4);
    test_cylinder(device, 3.0f, 4.0f, 5.0f, 11, 20);
 
    free_test_context(test_context);
}

Referenced by START_TEST().

◆ D3DXCreateKeyframedAnimationSetTest()

static void D3DXCreateKeyframedAnimationSetTest ( void )

static

Definition at line 11324 of file mesh.c.

{
    ID3DXKeyframedAnimationSet *set;
    D3DXPLAYBACK_TYPE type;
    unsigned int count;
    const char *name;
    HRESULT hr;
 
    hr = D3DXCreateKeyframedAnimationSet("wine_bottle", 5.0, D3DXPLAY_LOOP, 0, 0, NULL, &set);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
 
    hr = D3DXCreateKeyframedAnimationSet("wine_bottle", 5.0, D3DXPLAY_LOOP, 10, 0, NULL, &set);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
 
    name = set->lpVtbl->GetName(set);
    ok(!strcmp(name, "wine_bottle"), "Got unexpected name %s.\n", debugstr_a(name));
 
    type = set->lpVtbl->GetPlaybackType(set);
    ok(type == D3DXPLAY_LOOP, "Got unexpected value %u.\n", type);
 
    count = set->lpVtbl->GetNumAnimations(set);
    ok(!count, "Got unexpected value %u.\n", count);
 
    set->lpVtbl->Release(set);
}

Referenced by START_TEST().

◆ D3DXCreateMeshFVFTest()

static void D3DXCreateMeshFVFTest ( void )

static

Definition at line 1408 of file mesh.c.

{
    HRESULT hr;
    IDirect3DDevice9 *device, *test_device;
    ID3DXMesh *d3dxmesh;
    int i, size;
    D3DVERTEXELEMENT9 test_decl[MAX_FVF_DECL_SIZE];
    DWORD options;
    struct mesh mesh;
    struct test_context *test_context;
 
    static const D3DVERTEXELEMENT9 decl[] =
    {
        {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
        {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
        D3DDECL_END(),
    };
 
    hr = D3DXCreateMeshFVF(0, 0, 0, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateMeshFVF(1, 3, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, NULL, &d3dxmesh);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    test_context = new_test_context();
    if (!test_context)
    {
        skip("Couldn't create test context\n");
        return;
    }
    device = test_context->device;
 
    hr = D3DXCreateMeshFVF(0, 3, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, &d3dxmesh);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateMeshFVF(1, 0, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, &d3dxmesh);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateMeshFVF(1, 3, 0, D3DFVF_XYZ | D3DFVF_NORMAL, device, &d3dxmesh);
    ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
 
    if (hr == D3D_OK)
    {
        d3dxmesh->lpVtbl->Release(d3dxmesh);
    }
 
    hr = D3DXCreateMeshFVF(1, 3, D3DXMESH_MANAGED, 0xdeadbeef, device, &d3dxmesh);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateMeshFVF(1, 3, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateMeshFVF(1, 3, D3DXMESH_MANAGED, D3DFVF_XYZ | D3DFVF_NORMAL, device, &d3dxmesh);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 
    if (hr == D3D_OK)
    {
        /* device */
        hr = d3dxmesh->lpVtbl->GetDevice(d3dxmesh, NULL);
        ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
        hr = d3dxmesh->lpVtbl->GetDevice(d3dxmesh, &test_device);
        ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
        ok(test_device == device, "Got result %p, expected %p\n", test_device, device);
 
        if (hr == D3D_OK)
        {
            IDirect3DDevice9_Release(device);
        }
 
        /* declaration */
        hr = d3dxmesh->lpVtbl->GetDeclaration(d3dxmesh, NULL);
        ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
        hr = d3dxmesh->lpVtbl->GetDeclaration(d3dxmesh, test_decl);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 
        if (hr == D3D_OK)
        {
            size = ARRAY_SIZE(decl);
            for (i = 0; i < size - 1; i++)
            {
                ok(test_decl[i].Stream == decl[i].Stream, "Returned stream %d, expected %d\n", test_decl[i].Stream, decl[i].Stream);
                ok(test_decl[i].Type == decl[i].Type, "Returned type %d, expected %d\n", test_decl[i].Type, decl[i].Type);
                ok(test_decl[i].Method == decl[i].Method, "Returned method %d, expected %d\n", test_decl[i].Method, decl[i].Method);
                ok(test_decl[i].Usage == decl[i].Usage, "Returned usage %d, expected %d\n", test_decl[i].Usage, decl[i].Usage);
                ok(test_decl[i].UsageIndex == decl[i].UsageIndex, "Returned usage index %d, expected %d\n",
                   test_decl[i].UsageIndex, decl[i].UsageIndex);
                ok(test_decl[i].Offset == decl[i].Offset, "Returned offset %d, expected %d\n", test_decl[i].Offset, decl[i].Offset);
            }
            ok(decl[size-1].Stream == 0xFF, "Returned too long vertex declaration\n"); /* end element */
        }
 
        /* options */
        options = d3dxmesh->lpVtbl->GetOptions(d3dxmesh);
        ok(options == D3DXMESH_MANAGED, "Got result %x, expected %x (D3DXMESH_MANAGED)\n", options, D3DXMESH_MANAGED);
 
        /* rest */
        if (!new_mesh(&mesh, 3, 1))
        {
            skip("Couldn't create mesh\n");
        }
        else
        {
            memset(mesh.vertices, 0, mesh.number_of_vertices * sizeof(*mesh.vertices));
            memset(mesh.faces, 0, mesh.number_of_faces * sizeof(*mesh.faces));
            mesh.fvf = D3DFVF_XYZ | D3DFVF_NORMAL;
 
            compare_mesh(

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ admitted_error

◆ check_floats

◆ check_generated_adjacency

◆ check_generated_effects

◆ check_index_buffer

◆ check_materials

◆ check_matrix

◆ check_vertex_buffer

◆ COBJMACROS

◆ compare_float

◆ compare_vertex_sizes

◆ EFFECT_TABLE_ENTRY

◆ NAN

◆ test_LoadMeshFromX

◆ TRACECALLBACK

Typedef Documentation

◆ face

Enumeration Type Documentation

◆ pointtype

Function Documentation

◆ __port_nan()

◆ add_bezier_points()

◆ add_outline()

◆ add_point()

◆ attempt_line_merge()

◆ check_colorvalue_()

◆ check_floats_()

◆ check_generated_adjacency_()

◆ check_generated_effects_()

◆ check_index_buffer_()

◆ check_materials_()

◆ check_matrix_()

◆ check_vertex_buffer_()

◆ check_vertex_components()

◆ clear_normals()

◆ compare()

◆ compare_elements()

◆ compare_face()

◆ compare_mesh()

◆ compare_normals()

◆ compare_text_outline_mesh()

◆ compare_vec3()

◆ compare_vec4()

◆ compute_box()

◆ compute_cylinder()

◆ compute_normals_D3DXComputeNormals()

◆ compute_normals_D3DXComputeTangentFrameEx()

◆ compute_polygon()

◆ compute_sincos_table()

◆ compute_sphere()

◆ compute_text_mesh()

◆ compute_torus()

◆ convert_fixed_to_float()

◆ create_outline()

◆ D3DXBoundProbeTest()

◆ D3DXComputeBoundingBoxTest()

◆ D3DXComputeBoundingSphereTest()

◆ D3DXCreateAnimationControllerTest()

◆ D3DXCreateBoxTest()

◆ D3DXCreateCylinderTest()

◆ D3DXCreateKeyframedAnimationSetTest()

◆ D3DXCreateMeshFVFTest()