[PATCH 3/5] d3dx9/mesh: Make use of more proper types.
Matteo Bruni
wine at gitlab.winehq.org
Tue May 17 02:52:41 CDT 2022
From: Matteo Bruni <mbruni at codeweavers.com>
Signed-off-by: Matteo Bruni <mbruni at codeweavers.com>
---
dlls/d3dx9_36/mesh.c | 450 +++++++++++++++++++++++--------------------
1 file changed, 237 insertions(+), 213 deletions(-)
diff --git a/dlls/d3dx9_36/mesh.c b/dlls/d3dx9_36/mesh.c
index f74fba6e424..9871f62dfc4 100644
--- a/dlls/d3dx9_36/mesh.c
+++ b/dlls/d3dx9_36/mesh.c
@@ -1047,41 +1047,41 @@ cleanup:
* replaces it, then it contains the same number as the index itself, e.g.
* index 5 would contain 5. */
static HRESULT propagate_face_vertices(const DWORD *adjacency, DWORD *point_reps,
- const DWORD *indices, DWORD *new_indices, DWORD face, DWORD numfaces)
+ const uint32_t *indices, uint32_t *new_indices, unsigned int face_idx, unsigned int face_count)
{
- const unsigned int VERTS_PER_FACE = 3;
- DWORD edge, opp_edge;
- DWORD face_base = VERTS_PER_FACE * face;
+ unsigned int face_base = 3 * face_idx;
+ unsigned int edge, opp_edge;
- for (edge = 0; edge < VERTS_PER_FACE; edge++)
+ for (edge = 0; edge < 3; ++edge)
{
- DWORD adj_face = adjacency[face_base + edge];
- DWORD adj_face_base;
- DWORD i;
- if (adj_face == -1) /* No adjacent face. */
+ unsigned int adj_face = adjacency[face_base + edge];
+ unsigned int adj_face_base;
+ unsigned int i;
+
+ if (adj_face == ~0u) /* No adjacent face. */
continue;
- else if (adj_face >= numfaces)
+ else if (adj_face >= face_count)
{
- /* This throws exception on Windows */
- WARN("Index out of bounds. Got %d expected less than %d.\n",
- adj_face, numfaces);
+ /* This crashes on Windows. */
+ WARN("Index out of bounds. Got %u, expected less than %u.\n", adj_face, face_count);
return D3DERR_INVALIDCALL;
}
adj_face_base = 3 * adj_face;
/* Find opposite edge in adjacent face. */
- for (opp_edge = 0; opp_edge < VERTS_PER_FACE; opp_edge++)
+ for (opp_edge = 0; opp_edge < 3; ++opp_edge)
{
- DWORD opp_edge_index = adj_face_base + opp_edge;
- if (adjacency[opp_edge_index] == face)
+ unsigned int opp_edge_index = adj_face_base + opp_edge;
+
+ if (adjacency[opp_edge_index] == face_idx)
break; /* Found opposite edge. */
}
/* Replaces vertices in opposite edge with vertices from current edge. */
- for (i = 0; i < 2; i++)
+ for (i = 0; i < 2; ++i)
{
- DWORD from = face_base + (edge + (1 - i)) % VERTS_PER_FACE;
- DWORD to = adj_face_base + (opp_edge + i) % VERTS_PER_FACE;
+ unsigned int from = face_base + (edge + (1 - i)) % 3;
+ unsigned int to = adj_face_base + (opp_edge + i) % 3;
/* Propagate lowest index. */
if (new_indices[to] > new_indices[from])
@@ -1098,65 +1098,56 @@ static HRESULT propagate_face_vertices(const DWORD *adjacency, DWORD *point_reps
static HRESULT WINAPI d3dx9_mesh_ConvertAdjacencyToPointReps(ID3DXMesh *iface,
const DWORD *adjacency, DWORD *point_reps)
{
- struct d3dx9_mesh *This = impl_from_ID3DXMesh(iface);
+ struct d3dx9_mesh *mesh = impl_from_ID3DXMesh(iface);
+ uint16_t *indices_16bit = NULL;
+ uint32_t *new_indices = NULL;
+ uint32_t *indices = NULL;
+ unsigned int face, i;
HRESULT hr;
- DWORD face;
- DWORD i;
- DWORD *indices = NULL;
- WORD *indices_16bit = NULL;
- DWORD *new_indices = NULL;
- const unsigned int VERTS_PER_FACE = 3;
TRACE("iface %p, adjacency %p, point_reps %p.\n", iface, adjacency, point_reps);
if (!adjacency)
{
WARN("NULL adjacency.\n");
- hr = D3DERR_INVALIDCALL;
- goto cleanup;
+ return D3DERR_INVALIDCALL;
}
if (!point_reps)
{
WARN("NULL point_reps.\n");
- hr = D3DERR_INVALIDCALL;
- goto cleanup;
+ return D3DERR_INVALIDCALL;
}
- /* Should never happen as CreateMesh does not allow meshes with 0 faces */
- if (This->numfaces == 0)
+ /* Should never happen as CreateMesh does not allow meshes with 0 faces. */
+ if (!mesh->numfaces)
{
ERR("Number of faces was zero.\n");
- hr = D3DERR_INVALIDCALL;
- goto cleanup;
+ return D3DERR_INVALIDCALL;
}
- new_indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
- if (!new_indices)
- {
- hr = E_OUTOFMEMORY;
- goto cleanup;
- }
+ if (!(new_indices = HeapAlloc(GetProcessHeap(), 0, 3 * mesh->numfaces * sizeof(*indices))))
+ return E_OUTOFMEMORY;
- if (This->options & D3DXMESH_32BIT)
+ if (mesh->options & D3DXMESH_32BIT)
{
- hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices);
- if (FAILED(hr)) goto cleanup;
- memcpy(new_indices, indices, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
+ if (FAILED(hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void **)&indices)))
+ goto cleanup;
+ memcpy(new_indices, indices, 3 * mesh->numfaces * sizeof(*indices));
}
else
{
/* Make a widening copy of indices_16bit into indices and new_indices
- * in order to re-use the helper function */
- hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void**)&indices_16bit);
- if (FAILED(hr)) goto cleanup;
- indices = HeapAlloc(GetProcessHeap(), 0, VERTS_PER_FACE * This->numfaces * sizeof(*indices));
- if (!indices)
+ * in order to re-use the helper function. */
+ if (FAILED(hr = iface->lpVtbl->LockIndexBuffer(iface, D3DLOCK_READONLY, (void **)&indices_16bit)))
+ goto cleanup;
+
+ if (!(indices = HeapAlloc(GetProcessHeap(), 0, 3 * mesh->numfaces * sizeof(*indices))))
{
hr = E_OUTOFMEMORY;
goto cleanup;
}
- for (i = 0; i < VERTS_PER_FACE * This->numfaces; i++)
+ for (i = 0; i < 3 * mesh->numfaces; ++i)
{
new_indices[i] = indices_16bit[i];
indices[i] = indices_16bit[i];
@@ -1164,37 +1155,36 @@ static HRESULT WINAPI d3dx9_mesh_ConvertAdjacencyToPointReps(ID3DXMesh *iface,
}
/* Vertices are ordered sequentially in the point representation. */
- for (i = 0; i < This->numvertices; i++)
- {
+ for (i = 0; i < mesh->numvertices; ++i)
point_reps[i] = i;
- }
- /* Propagate vertices with low indices so as few vertices as possible
- * are used in the mesh.
- */
- for (face = 0; face < This->numfaces; face++)
+ /* Propagate vertices with low indices so as few vertices as possible are
+ * used in the mesh. */
+ for (face = 0; face < mesh->numfaces; ++face)
{
- hr = propagate_face_vertices(adjacency, point_reps, indices, new_indices, face, This->numfaces);
- if (FAILED(hr)) goto cleanup;
+ if (FAILED(hr = propagate_face_vertices(adjacency, point_reps, indices, new_indices, face, mesh->numfaces)))
+ goto cleanup;
}
- /* Go in opposite direction to catch all face orderings */
- for (face = 0; face < This->numfaces; face++)
+ /* Go in opposite direction to catch all face orderings. */
+ for (face = 0; face < mesh->numfaces; ++face)
{
- hr = propagate_face_vertices(adjacency, point_reps,
- indices, new_indices,
- (This->numfaces - 1) - face, This->numfaces);
- if (FAILED(hr)) goto cleanup;
+ if (FAILED(hr = propagate_face_vertices(adjacency, point_reps, indices, new_indices,
+ (mesh->numfaces - 1) - face, mesh->numfaces)))
+ goto cleanup;
}
hr = D3D_OK;
-cleanup:
- if (This->options & D3DXMESH_32BIT)
+
+ cleanup:
+ if (mesh->options & D3DXMESH_32BIT)
{
- if (indices) iface->lpVtbl->UnlockIndexBuffer(iface);
+ if (indices)
+ iface->lpVtbl->UnlockIndexBuffer(iface);
}
else
{
- if (indices_16bit) iface->lpVtbl->UnlockIndexBuffer(iface);
+ if (indices_16bit)
+ iface->lpVtbl->UnlockIndexBuffer(iface);
HeapFree(GetProcessHeap(), 0, indices);
}
HeapFree(GetProcessHeap(), 0, new_indices);
@@ -2604,18 +2594,18 @@ HRESULT WINAPI D3DXCreateMeshFVF(DWORD numfaces, DWORD numvertices, DWORD option
struct mesh_data {
- DWORD num_vertices;
- DWORD num_poly_faces;
- DWORD num_tri_faces;
+ unsigned int num_vertices;
+ unsigned int num_poly_faces;
+ unsigned int num_tri_faces;
D3DXVECTOR3 *vertices;
- DWORD *num_tri_per_face;
+ unsigned int *num_tri_per_face;
DWORD *indices;
DWORD fvf;
/* optional mesh data */
- DWORD num_normals;
+ unsigned int num_normals;
D3DXVECTOR3 *normals;
DWORD *normal_indices;
@@ -2623,12 +2613,12 @@ struct mesh_data {
DWORD *vertex_colors;
- DWORD num_materials;
+ unsigned int num_materials;
D3DXMATERIAL *materials;
DWORD *material_indices;
struct ID3DXSkinInfo *skin_info;
- DWORD nb_bones;
+ unsigned int bone_count;
};
static HRESULT parse_texture_filename(ID3DXFileData *filedata, char **filename_out)
@@ -2758,8 +2748,9 @@ err:
static void destroy_materials(struct mesh_data *mesh)
{
- DWORD i;
- for (i = 0; i < mesh->num_materials; i++)
+ unsigned int i;
+
+ for (i = 0; i < mesh->num_materials; ++i)
HeapFree(GetProcessHeap(), 0, mesh->materials[i].pTextureFilename);
HeapFree(GetProcessHeap(), 0, mesh->materials);
HeapFree(GetProcessHeap(), 0, mesh->material_indices);
@@ -2770,18 +2761,19 @@ static void destroy_materials(struct mesh_data *mesh)
static HRESULT parse_material_list(ID3DXFileData *filedata, struct mesh_data *mesh)
{
- HRESULT hr;
- SIZE_T data_size;
- const DWORD *data, *in_ptr;
- GUID type;
ID3DXFileData *child = NULL;
- DWORD num_materials;
- DWORD i;
+ unsigned int material_count;
+ const uint32_t *in_ptr;
SIZE_T nb_children;
+ SIZE_T data_size;
+ const void *data;
+ unsigned int i;
+ HRESULT hr;
+ GUID type;
destroy_materials(mesh);
- hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
+ hr = filedata->lpVtbl->Lock(filedata, &data_size, &data);
if (FAILED(hr)) return hr;
/* template MeshMaterialList {
@@ -2795,44 +2787,50 @@ static HRESULT parse_material_list(ID3DXFileData *filedata, struct mesh_data *me
in_ptr = data;
hr = E_FAIL;
- if (data_size < sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- num_materials = *in_ptr++;
- if (!num_materials) {
+ material_count = *in_ptr++;
+ if (!material_count) {
hr = D3D_OK;
goto end;
}
- if (data_size < 2 * sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < 2 * sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- if (*in_ptr++ != mesh->num_poly_faces) {
- WARN("number of material face indices (%u) doesn't match number of faces (%u)\n",
+ if (*in_ptr++ != mesh->num_poly_faces)
+ {
+ WARN("Number of material face indices (%u) doesn't match number of faces (%u).\n",
*(in_ptr - 1), mesh->num_poly_faces);
goto end;
}
- if (data_size < 2 * sizeof(DWORD) + mesh->num_poly_faces * sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < 2 * sizeof(uint32_t) + mesh->num_poly_faces * sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- for (i = 0; i < mesh->num_poly_faces; i++) {
- if (*in_ptr++ >= num_materials) {
- WARN("face %u: reference to undefined material %u (only %u materials)\n",
- i, *(in_ptr - 1), num_materials);
+ for (i = 0; i < mesh->num_poly_faces; ++i)
+ {
+ if (*in_ptr++ >= material_count)
+ {
+ WARN("Face %u: reference to undefined material %u (only %u materials).\n",
+ i, *(in_ptr - 1), material_count);
goto end;
}
}
- mesh->materials = HeapAlloc(GetProcessHeap(), 0, num_materials * sizeof(*mesh->materials));
+ mesh->materials = HeapAlloc(GetProcessHeap(), 0, material_count * sizeof(*mesh->materials));
mesh->material_indices = HeapAlloc(GetProcessHeap(), 0, mesh->num_poly_faces * sizeof(*mesh->material_indices));
if (!mesh->materials || !mesh->material_indices) {
hr = E_OUTOFMEMORY;
goto end;
}
- memcpy(mesh->material_indices, data + 2, mesh->num_poly_faces * sizeof(DWORD));
+ memcpy(mesh->material_indices, (const uint32_t *)data + 2, mesh->num_poly_faces * sizeof(uint32_t));
hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
if (FAILED(hr))
@@ -2847,9 +2845,11 @@ static HRESULT parse_material_list(ID3DXFileData *filedata, struct mesh_data *me
if (FAILED(hr))
goto end;
- if (IsEqualGUID(&type, &TID_D3DRMMaterial)) {
- if (mesh->num_materials >= num_materials) {
- WARN("more materials defined than declared\n");
+ if (IsEqualGUID(&type, &TID_D3DRMMaterial))
+ {
+ if (mesh->num_materials >= material_count)
+ {
+ WARN("%u materials defined, only %u declared.\n", mesh->num_materials, material_count);
hr = E_FAIL;
goto end;
}
@@ -2861,8 +2861,9 @@ static HRESULT parse_material_list(ID3DXFileData *filedata, struct mesh_data *me
IUnknown_Release(child);
child = NULL;
}
- if (num_materials != mesh->num_materials) {
- WARN("only %u of %u materials defined\n", num_materials, mesh->num_materials);
+ if (material_count != mesh->num_materials)
+ {
+ WARN("Only %u of %u materials defined.\n", material_count, mesh->num_materials);
hr = E_FAIL;
}
@@ -2875,14 +2876,14 @@ end:
static HRESULT parse_texture_coords(ID3DXFileData *filedata, struct mesh_data *mesh)
{
- HRESULT hr;
+ const uint32_t *data;
SIZE_T data_size;
- const BYTE *data;
+ HRESULT hr;
HeapFree(GetProcessHeap(), 0, mesh->tex_coords);
mesh->tex_coords = NULL;
- hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
+ hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void **)&data);
if (FAILED(hr)) return hr;
/* template Coords2d {
@@ -2897,18 +2898,21 @@ static HRESULT parse_texture_coords(ID3DXFileData *filedata, struct mesh_data *m
hr = E_FAIL;
- if (data_size < sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- if (*(DWORD*)data != mesh->num_vertices) {
- WARN("number of texture coordinates (%u) doesn't match number of vertices (%u)\n",
- *(DWORD*)data, mesh->num_vertices);
+ if (*data != mesh->num_vertices)
+ {
+ WARN("Number of texture coordinates (%u) doesn't match number of vertices (%u).\n",
+ *data, mesh->num_vertices);
goto end;
}
- data += sizeof(DWORD);
- if (data_size < sizeof(DWORD) + mesh->num_vertices * sizeof(*mesh->tex_coords)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ ++data;
+ if (data_size < sizeof(uint32_t) + mesh->num_vertices * sizeof(*mesh->tex_coords))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
@@ -2930,16 +2934,15 @@ end:
static HRESULT parse_vertex_colors(ID3DXFileData *filedata, struct mesh_data *mesh)
{
- HRESULT hr;
+ unsigned int color_count, i;
+ const uint32_t *data;
SIZE_T data_size;
- const BYTE *data;
- DWORD num_colors;
- DWORD i;
+ HRESULT hr;
HeapFree(GetProcessHeap(), 0, mesh->vertex_colors);
mesh->vertex_colors = NULL;
- hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
+ hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void **)&data);
if (FAILED(hr)) return hr;
/* template IndexedColor {
@@ -2954,18 +2957,20 @@ static HRESULT parse_vertex_colors(ID3DXFileData *filedata, struct mesh_data *me
hr = E_FAIL;
- if (data_size < sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- num_colors = *(DWORD*)data;
- data += sizeof(DWORD);
- if (data_size < sizeof(DWORD) + num_colors * (sizeof(DWORD) + sizeof(D3DCOLORVALUE))) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ color_count = *data;
+ ++data;
+ if (data_size < sizeof(uint32_t) + color_count * (sizeof(uint32_t) + sizeof(D3DCOLORVALUE)))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- mesh->vertex_colors = HeapAlloc(GetProcessHeap(), 0, mesh->num_vertices * sizeof(DWORD));
+ mesh->vertex_colors = HeapAlloc(GetProcessHeap(), 0, mesh->num_vertices * sizeof(uint32_t));
if (!mesh->vertex_colors) {
hr = E_OUTOFMEMORY;
goto end;
@@ -2973,18 +2978,20 @@ static HRESULT parse_vertex_colors(ID3DXFileData *filedata, struct mesh_data *me
for (i = 0; i < mesh->num_vertices; i++)
mesh->vertex_colors[i] = D3DCOLOR_ARGB(0, 0xff, 0xff, 0xff);
- for (i = 0; i < num_colors; i++)
+ for (i = 0; i < color_count; ++i)
{
D3DCOLORVALUE color;
- DWORD index = *(DWORD*)data;
- data += sizeof(DWORD);
- if (index >= mesh->num_vertices) {
- WARN("vertex color %u references undefined vertex %u (only %u vertices)\n",
- i, index, mesh->num_vertices);
+ unsigned int index = *data;
+
+ ++data;
+ if (index >= mesh->num_vertices)
+ {
+ WARN("Vertex color %u references undefined vertex %u (only %u vertices).\n",
+ i, index, mesh->num_vertices);
goto end;
}
memcpy(&color, data, sizeof(color));
- data += sizeof(color);
+ data += sizeof(color) / sizeof(*data);
color.r = min(1.0f, max(0.0f, color.r));
color.g = min(1.0f, max(0.0f, color.g));
color.b = min(1.0f, max(0.0f, color.b));
@@ -3006,12 +3013,12 @@ end:
static HRESULT parse_normals(ID3DXFileData *filedata, struct mesh_data *mesh)
{
- HRESULT hr;
+ unsigned int num_face_indices = mesh->num_poly_faces * 2 + mesh->num_tri_faces;
+ DWORD *index_out_ptr;
SIZE_T data_size;
const BYTE *data;
- DWORD *index_out_ptr;
- DWORD i;
- DWORD num_face_indices = mesh->num_poly_faces * 2 + mesh->num_tri_faces;
+ unsigned int i;
+ HRESULT hr;
HeapFree(GetProcessHeap(), 0, mesh->normals);
mesh->num_normals = 0;
@@ -3019,7 +3026,7 @@ static HRESULT parse_normals(ID3DXFileData *filedata, struct mesh_data *mesh)
mesh->normal_indices = NULL;
mesh->fvf |= D3DFVF_NORMAL;
- hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
+ hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void **)&data);
if (FAILED(hr)) return hr;
/* template Vector {
@@ -3041,20 +3048,22 @@ static HRESULT parse_normals(ID3DXFileData *filedata, struct mesh_data *mesh)
hr = E_FAIL;
- if (data_size < sizeof(DWORD) * 2) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < sizeof(uint32_t) * 2)
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- mesh->num_normals = *(DWORD*)data;
- data += sizeof(DWORD);
- if (data_size < sizeof(DWORD) * 2 + mesh->num_normals * sizeof(D3DXVECTOR3) +
- num_face_indices * sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ mesh->num_normals = *(uint32_t *)data;
+ data += sizeof(uint32_t);
+ if (data_size < sizeof(uint32_t) * 2 + mesh->num_normals * sizeof(D3DXVECTOR3) +
+ num_face_indices * sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
mesh->normals = HeapAlloc(GetProcessHeap(), 0, mesh->num_normals * sizeof(D3DXVECTOR3));
- mesh->normal_indices = HeapAlloc(GetProcessHeap(), 0, num_face_indices * sizeof(DWORD));
+ mesh->normal_indices = HeapAlloc(GetProcessHeap(), 0, num_face_indices * sizeof(uint32_t));
if (!mesh->normals || !mesh->normal_indices) {
hr = E_OUTOFMEMORY;
goto end;
@@ -3065,33 +3074,39 @@ static HRESULT parse_normals(ID3DXFileData *filedata, struct mesh_data *mesh)
for (i = 0; i < mesh->num_normals; i++)
D3DXVec3Normalize(&mesh->normals[i], &mesh->normals[i]);
- if (*(DWORD*)data != mesh->num_poly_faces) {
- WARN("number of face normals (%u) doesn't match number of faces (%u)\n",
- *(DWORD*)data, mesh->num_poly_faces);
+ if (*(uint32_t *)data != mesh->num_poly_faces)
+ {
+ WARN("Number of face normals (%u) doesn't match number of faces (%u).\n",
+ *(uint32_t *)data, mesh->num_poly_faces);
goto end;
}
- data += sizeof(DWORD);
+ data += sizeof(uint32_t);
index_out_ptr = mesh->normal_indices;
for (i = 0; i < mesh->num_poly_faces; i++)
{
- DWORD j;
- DWORD count = *(DWORD*)data;
- if (count != mesh->num_tri_per_face[i] + 2) {
- WARN("face %u: number of normals (%u) doesn't match number of vertices (%u)\n",
+ unsigned int count = *(uint32_t *)data;
+ unsigned int j;
+
+ if (count != mesh->num_tri_per_face[i] + 2)
+ {
+ WARN("Face %u: number of normals (%u) doesn't match number of vertices (%u).\n",
i, count, mesh->num_tri_per_face[i] + 2);
goto end;
}
- data += sizeof(DWORD);
+ data += sizeof(uint32_t);
+
+ for (j = 0; j < count; j++)
+ {
+ uint32_t normal_index = *(uint32_t *)data;
- for (j = 0; j < count; j++) {
- DWORD normal_index = *(DWORD*)data;
- if (normal_index >= mesh->num_normals) {
- WARN("face %u, normal index %u: reference to undefined normal %u (only %u normals)\n",
- i, j, normal_index, mesh->num_normals);
+ if (normal_index >= mesh->num_normals)
+ {
+ WARN("Face %u, normal index %u: reference to undefined normal %u (only %u normals).\n",
+ i, j, normal_index, mesh->num_normals);
goto end;
}
*index_out_ptr++ = normal_index;
- data += sizeof(DWORD);
+ data += sizeof(uint32_t);
}
}
@@ -3122,8 +3137,8 @@ static HRESULT parse_skin_mesh_info(ID3DXFileData *filedata, struct mesh_data *m
}
/* Skip nMaxSkinWeightsPerVertex and nMaxSkinWeightsPerFace */
data += 2 * sizeof(WORD);
- mesh_data->nb_bones = *(WORD*)data;
- hr = D3DXCreateSkinInfoFVF(mesh_data->num_vertices, mesh_data->fvf, mesh_data->nb_bones, &mesh_data->skin_info);
+ mesh_data->bone_count = *(WORD*)data;
+ hr = D3DXCreateSkinInfoFVF(mesh_data->num_vertices, mesh_data->fvf, mesh_data->bone_count, &mesh_data->skin_info);
} else {
const char *name;
DWORD nb_influences;
@@ -3161,15 +3176,15 @@ end:
static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data, DWORD provide_flags)
{
- HRESULT hr;
- SIZE_T data_size;
+ unsigned int skin_weights_info_count = 0;
+ ID3DXFileData *child = NULL;
const BYTE *data, *in_ptr;
DWORD *index_out_ptr;
+ SIZE_T child_count;
+ SIZE_T data_size;
+ unsigned int i;
+ HRESULT hr;
GUID type;
- ID3DXFileData *child = NULL;
- DWORD i;
- SIZE_T nb_children;
- DWORD nb_skin_weights_info = 0;
/*
* template Mesh {
@@ -3181,55 +3196,62 @@ static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data,
* }
*/
- hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void**)&data);
+ hr = filedata->lpVtbl->Lock(filedata, &data_size, (const void **)&data);
if (FAILED(hr)) return hr;
in_ptr = data;
hr = E_FAIL;
- if (data_size < sizeof(DWORD) * 2) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size < sizeof(uint32_t) * 2)
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- mesh_data->num_vertices = *(DWORD*)in_ptr;
- if (data_size < sizeof(DWORD) * 2 + mesh_data->num_vertices * sizeof(D3DXVECTOR3)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ mesh_data->num_vertices = *(uint32_t *)in_ptr;
+ if (data_size < sizeof(uint32_t) * 2 + mesh_data->num_vertices * sizeof(D3DXVECTOR3))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- in_ptr += sizeof(DWORD) + mesh_data->num_vertices * sizeof(D3DXVECTOR3);
+ in_ptr += sizeof(uint32_t) + mesh_data->num_vertices * sizeof(D3DXVECTOR3);
- mesh_data->num_poly_faces = *(DWORD*)in_ptr;
- in_ptr += sizeof(DWORD);
+ mesh_data->num_poly_faces = *(uint32_t *)in_ptr;
+ in_ptr += sizeof(uint32_t);
mesh_data->num_tri_faces = 0;
for (i = 0; i < mesh_data->num_poly_faces; i++)
{
- DWORD num_poly_vertices;
- DWORD j;
+ unsigned int poly_vertices_count;
+ unsigned int j;
- if (data_size - (in_ptr - data) < sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ if (data_size - (in_ptr - data) < sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- num_poly_vertices = *(DWORD*)in_ptr;
- in_ptr += sizeof(DWORD);
- if (data_size - (in_ptr - data) < num_poly_vertices * sizeof(DWORD)) {
- WARN("truncated data (%ld bytes)\n", data_size);
+ poly_vertices_count = *(uint32_t *)in_ptr;
+ in_ptr += sizeof(uint32_t);
+ if (data_size - (in_ptr - data) < poly_vertices_count * sizeof(uint32_t))
+ {
+ WARN("Truncated data (%Id bytes).\n", data_size);
goto end;
}
- if (num_poly_vertices < 3) {
- WARN("face %u has only %u vertices\n", i, num_poly_vertices);
+ if (poly_vertices_count < 3)
+ {
+ WARN("Face %u has only %u vertices.\n", i, poly_vertices_count);
goto end;
}
- for (j = 0; j < num_poly_vertices; j++) {
- if (*(DWORD*)in_ptr >= mesh_data->num_vertices) {
- WARN("face %u, index %u: undefined vertex %u (only %u vertices)\n",
- i, j, *(DWORD*)in_ptr, mesh_data->num_vertices);
+ for (j = 0; j < poly_vertices_count; j++)
+ {
+ if (*(uint32_t *)in_ptr >= mesh_data->num_vertices)
+ {
+ WARN("Face %u, index %u: undefined vertex %u (only %u vertices).\n",
+ i, j, *(uint32_t *)in_ptr, mesh_data->num_vertices);
goto end;
}
- in_ptr += sizeof(DWORD);
+ in_ptr += sizeof(uint32_t);
}
- mesh_data->num_tri_faces += num_poly_vertices - 2;
+ mesh_data->num_tri_faces += poly_vertices_count - 2;
}
mesh_data->fvf = D3DFVF_XYZ;
@@ -3245,30 +3267,31 @@ static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data,
goto end;
}
- in_ptr = data + sizeof(DWORD);
+ in_ptr = data + sizeof(uint32_t);
memcpy(mesh_data->vertices, in_ptr, mesh_data->num_vertices * sizeof(D3DXVECTOR3));
- in_ptr += mesh_data->num_vertices * sizeof(D3DXVECTOR3) + sizeof(DWORD);
+ in_ptr += mesh_data->num_vertices * sizeof(D3DXVECTOR3) + sizeof(uint32_t);
index_out_ptr = mesh_data->indices;
for (i = 0; i < mesh_data->num_poly_faces; i++)
{
- DWORD count;
+ unsigned int count;
- count = *(DWORD*)in_ptr;
- in_ptr += sizeof(DWORD);
+ count = *(uint32_t *)in_ptr;
+ in_ptr += sizeof(uint32_t);
mesh_data->num_tri_per_face[i] = count - 2;
- while (count--) {
- *index_out_ptr++ = *(DWORD*)in_ptr;
- in_ptr += sizeof(DWORD);
+ while (count--)
+ {
+ *index_out_ptr++ = *(uint32_t *)in_ptr;
+ in_ptr += sizeof(uint32_t);
}
}
- hr = filedata->lpVtbl->GetChildren(filedata, &nb_children);
+ hr = filedata->lpVtbl->GetChildren(filedata, &child_count);
if (FAILED(hr))
goto end;
- for (i = 0; i < nb_children; i++)
+ for (i = 0; i < child_count; i++)
{
hr = filedata->lpVtbl->GetChild(filedata, i, &child);
if (FAILED(hr))
@@ -3303,10 +3326,10 @@ static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data,
hr = E_FAIL;
goto end;
}
- hr = parse_skin_mesh_info(child, mesh_data, nb_skin_weights_info);
+ hr = parse_skin_mesh_info(child, mesh_data, skin_weights_info_count);
if (FAILED(hr))
goto end;
- nb_skin_weights_info++;
+ skin_weights_info_count++;
}
}
if (FAILED(hr))
@@ -3316,9 +3339,10 @@ static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data,
child = NULL;
}
- if (mesh_data->skin_info && (nb_skin_weights_info != mesh_data->nb_bones)) {
- WARN("Mismatch between nb skin weights info %u encountered and nb bones %u from skin mesh header\n",
- nb_skin_weights_info, mesh_data->nb_bones);
+ if (mesh_data->skin_info && (skin_weights_info_count != mesh_data->bone_count))
+ {
+ WARN("Mismatch between skin weights info count %u and bones count %u from skin mesh header.\n",
+ skin_weights_info_count, mesh_data->bone_count);
hr = E_FAIL;
goto end;
}
@@ -3326,7 +3350,7 @@ static HRESULT parse_mesh(ID3DXFileData *filedata, struct mesh_data *mesh_data,
if ((provide_flags & PROVIDE_SKININFO) && !mesh_data->skin_info)
{
if (FAILED(hr = D3DXCreateSkinInfoFVF(mesh_data->num_vertices, mesh_data->fvf,
- mesh_data->nb_bones, &mesh_data->skin_info)))
+ mesh_data->bone_count, &mesh_data->skin_info)))
goto end;
}
--
GitLab
https://gitlab.winehq.org/wine/wine/-/merge_requests/82
More information about the wine-devel
mailing list