[2/5] d3dx9: Generate effect instances from materials for mesh loading. (try 2)

[Dylan Smith]

---
try 2: Used a loop driven table as Matteo Bruni suggested.
---
 dlls/d3dx9_36/mesh.c |  106 +++++++++++++++++++++++++++++++++++++++++++++++--
 1 files changed, 101 insertions(+), 5 deletions(-)

diff --git a/dlls/d3dx9_36/mesh.c b/dlls/d3dx9_36/mesh.c
index fa32797..917be06 100644
--- a/dlls/d3dx9_36/mesh.c
+++ b/dlls/d3dx9_36/mesh.c
@@ -2267,6 +2267,96 @@ truncated_data_error:
     return E_FAIL;
 }
 
+static HRESULT generate_effects(ID3DXBuffer *materials, DWORD num_materials,
+                                ID3DXBuffer **effects)
+{
+    HRESULT hr;
+    D3DXEFFECTINSTANCE *effect_ptr;
+    BYTE *out_ptr;
+    static const char diffuse_paramname[] = "Diffuse";
+    static const char power_paramname[] = "Power";
+    static const char specular_paramname[] = "Specular";
+    static const char emissive_paramname[] = "Emissive";
+    static const char ambient_paramname[] = "Ambient";
+    static const DWORD basic_paramname_sizes = sizeof(diffuse_paramname) +
+                                               sizeof(power_paramname) +
+                                               sizeof(specular_paramname) +
+                                               sizeof(emissive_paramname) +
+                                               sizeof(ambient_paramname);
+    static const char texture_paramname[] = "Texture0 at Name";
+    D3DXMATERIAL *material_ptr = ID3DXBuffer_GetBufferPointer(materials);
+    DWORD buffer_size = num_materials * sizeof(D3DXEFFECTINSTANCE);
+    int i;
+
+    for (i = 0; i < num_materials; i++)
+    {
+        buffer_size += 5 * sizeof(D3DXEFFECTDEFAULT) + basic_paramname_sizes;
+        buffer_size += 4 * sizeof(D3DCOLORVALUE) + sizeof(FLOAT);
+        if (material_ptr->pTextureFilename) {
+            buffer_size += sizeof(D3DXEFFECTDEFAULT) + strlen(material_ptr->pTextureFilename) + 1;
+            buffer_size += sizeof(texture_paramname);
+        }
+        material_ptr++;
+    }
+
+    hr = D3DXCreateBuffer(buffer_size, effects);
+    if (FAILED(hr)) return hr;
+    effect_ptr = ID3DXBuffer_GetBufferPointer(*effects);
+    out_ptr = (BYTE*)(effect_ptr + num_materials);
+
+    material_ptr = ID3DXBuffer_GetBufferPointer(materials);
+    for (i = 0; i < num_materials; i++)
+    {
+        static const struct {
+            const char *param_name;
+            DWORD name_size;
+            DWORD num_bytes;
+            DWORD value_offset;
+        } material_effects[] = {
+#define EFFECT_TABLE_ENTRY(str, field) \
+    {str, sizeof(str), sizeof(material_ptr->MatD3D.field), offsetof(D3DXMATERIAL, MatD3D.field)}
+            EFFECT_TABLE_ENTRY(diffuse_paramname, Diffuse),
+            EFFECT_TABLE_ENTRY(power_paramname, Power),
+            EFFECT_TABLE_ENTRY(specular_paramname, Specular),
+            EFFECT_TABLE_ENTRY(emissive_paramname, Emissive),
+            EFFECT_TABLE_ENTRY(ambient_paramname, Ambient),
+#undef EFFECT_TABLE_ENTRY
+        };
+        int j;
+        D3DXEFFECTDEFAULT *defaults = (D3DXEFFECTDEFAULT*)out_ptr;
+
+        effect_ptr->pDefaults = defaults;
+        effect_ptr->NumDefaults = material_ptr->pTextureFilename ? 6 : 5;
+        out_ptr = (BYTE*)(effect_ptr->pDefaults + effect_ptr->NumDefaults);
+
+        for (j = 0; j < sizeof(material_effects)/sizeof(material_effects[0]); j++)
+        {
+            defaults->pParamName = (LPSTR)out_ptr;
+            strcpy(defaults->pParamName, material_effects[j].param_name);
+            defaults->pValue = defaults->pParamName + material_effects[j].name_size;
+            defaults->Type = D3DXEDT_FLOATS;
+            defaults->NumBytes = material_effects[j].num_bytes;
+            memcpy(defaults->pValue, (BYTE*)material_ptr + material_effects[j].value_offset, defaults->NumBytes);
+            out_ptr = (BYTE*)defaults->pValue + defaults->NumBytes;
+            defaults++;
+        }
+
+        if (material_ptr->pTextureFilename) {
+            defaults->pParamName = (LPSTR)out_ptr;
+            strcpy(defaults->pParamName, texture_paramname);
+            defaults->pValue = defaults->pParamName + sizeof(texture_paramname);
+            defaults->Type = D3DXEDT_STRING;
+            defaults->NumBytes = strlen(material_ptr->pTextureFilename) + 1;
+            strcpy(defaults->pValue, material_ptr->pTextureFilename);
+            out_ptr = (BYTE*)defaults->pValue + defaults->NumBytes;
+        }
+        material_ptr++;
+        effect_ptr++;
+    }
+
+    return D3D_OK;
+}
+
 /* change to D3DXLoadSkinMeshFromXof when ID3DXFileData is implemented */
 static HRESULT load_skin_mesh_from_xof(IDirectXFileData *filedata,
                                        DWORD options,
@@ -2285,6 +2375,7 @@ static HRESULT load_skin_mesh_from_xof(IDirectXFileData *filedata,
     ID3DXMesh *d3dxmesh = NULL;
     ID3DXBuffer *adjacency = NULL;
     ID3DXBuffer *materials = NULL;
+    ID3DXBuffer *effects = NULL;
     struct vertex_duplication {
         DWORD normal_index;
         struct list entry;
@@ -2434,7 +2525,7 @@ static HRESULT load_skin_mesh_from_xof(IDirectXFileData *filedata,
         if (FAILED(hr)) goto cleanup;
     }
 
-    if (mesh_data.num_materials && materials_out) {
+    if (mesh_data.num_materials && (materials_out || effects_out)) {
         DWORD buffer_size = mesh_data.num_materials * sizeof(D3DXMATERIAL);
         char *strings_out_ptr;
         D3DXMATERIAL *materials_ptr;
@@ -2460,9 +2551,13 @@ static HRESULT load_skin_mesh_from_xof(IDirectXFileData *filedata,
     }
 
     if (mesh_data.num_materials && effects_out) {
-        FIXME("Effect instance generation not supported.\n");
-        hr = E_NOTIMPL;
-        goto cleanup;
+        hr = generate_effects(materials, mesh_data.num_materials, &effects);
+        if (FAILED(hr)) goto cleanup;
+
+        if (!materials_out) {
+            ID3DXBuffer_Release(materials);
+            materials = NULL;
+        }
     }
 
     if (adjacency_out) {
@@ -2476,7 +2571,7 @@ static HRESULT load_skin_mesh_from_xof(IDirectXFileData *filedata,
     if (adjacency_out) *adjacency_out = adjacency;
     if (num_materials_out) *num_materials_out = mesh_data.num_materials;
     if (materials_out) *materials_out = materials;
-    if (effects_out) *effects_out = NULL;
+    if (effects_out) *effects_out = effects;
     if (skin_info_out) *skin_info_out = NULL;
 
     hr = D3D_OK;
@@ -2485,6 +2580,7 @@ cleanup:
         if (d3dxmesh) IUnknown_Release(d3dxmesh);
         if (adjacency) ID3DXBuffer_Release(adjacency);
         if (materials) ID3DXBuffer_Release(materials);
+        if (effects) ID3DXBuffer_Release(effects);
     }
     HeapFree(GetProcessHeap(), 0, mesh_data.vertices);
     HeapFree(GetProcessHeap(), 0, mesh_data.num_tri_per_face);
-- 
1.7.4.1