796 строки
31 KiB
C++
796 строки
31 KiB
C++
//--------------------------------------------------------------------------------------
|
|
// File: ModelLoadSDKMESH.cpp
|
|
//
|
|
// Copyright (c) Microsoft Corporation.
|
|
// Licensed under the MIT License.
|
|
//
|
|
// http://go.microsoft.com/fwlink/?LinkID=615561
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#include "Model.h"
|
|
|
|
#include "Effects.h"
|
|
#include "VertexTypes.h"
|
|
|
|
#include "DirectXHelpers.h"
|
|
#include "PlatformHelpers.h"
|
|
#include "BinaryReader.h"
|
|
#include "DescriptorHeap.h"
|
|
#include "CommonStates.h"
|
|
|
|
#include "SDKMesh.h"
|
|
|
|
using namespace DirectX;
|
|
using Microsoft::WRL::ComPtr;
|
|
|
|
namespace
|
|
{
|
|
enum : unsigned int
|
|
{
|
|
PER_VERTEX_COLOR = 0x1,
|
|
SKINNING = 0x2,
|
|
DUAL_TEXTURE = 0x4,
|
|
NORMAL_MAPS = 0x8,
|
|
BIASED_VERTEX_NORMALS = 0x10,
|
|
USES_OBSOLETE_DEC3N = 0x20,
|
|
};
|
|
|
|
int GetUniqueTextureIndex(const wchar_t* textureName, std::map<std::wstring, int>& textureDictionary)
|
|
{
|
|
if (textureName == nullptr || !textureName[0])
|
|
return -1;
|
|
|
|
auto i = textureDictionary.find(textureName);
|
|
if (i == std::cend(textureDictionary))
|
|
{
|
|
int index = static_cast<int>(textureDictionary.size());
|
|
textureDictionary[textureName] = index;
|
|
return index;
|
|
}
|
|
else
|
|
{
|
|
return i->second;
|
|
}
|
|
}
|
|
|
|
inline XMFLOAT3 GetMaterialColor(float r, float g, float b, bool srgb) noexcept
|
|
{
|
|
if (srgb)
|
|
{
|
|
XMVECTOR v = XMVectorSet(r, g, b, 1.f);
|
|
v = XMColorSRGBToRGB(v);
|
|
|
|
XMFLOAT3 result;
|
|
XMStoreFloat3(&result, v);
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
return XMFLOAT3(r, g, b);
|
|
}
|
|
}
|
|
|
|
template<size_t sizeOfBuffer>
|
|
inline void ASCIIToWChar(wchar_t (&buffer)[sizeOfBuffer], const char *ascii)
|
|
{
|
|
MultiByteToWideChar(CP_UTF8, 0, ascii, -1, buffer, sizeOfBuffer);
|
|
}
|
|
|
|
void InitMaterial(
|
|
const DXUT::SDKMESH_MATERIAL& mh,
|
|
unsigned int flags,
|
|
_Out_ Model::ModelMaterialInfo& m,
|
|
_Inout_ std::map<std::wstring, int32_t>& textureDictionary,
|
|
bool srgb)
|
|
{
|
|
wchar_t matName[DXUT::MAX_MATERIAL_NAME] = {};
|
|
ASCIIToWChar(matName, mh.Name);
|
|
|
|
wchar_t diffuseName[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(diffuseName, mh.DiffuseTexture);
|
|
|
|
wchar_t specularName[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(specularName, mh.SpecularTexture);
|
|
|
|
wchar_t normalName[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(normalName, mh.NormalTexture);
|
|
|
|
if ((flags & DUAL_TEXTURE) && !mh.SpecularTexture[0])
|
|
{
|
|
DebugTrace("WARNING: Material '%s' has multiple texture coords but not multiple textures\n", mh.Name);
|
|
flags &= ~static_cast<unsigned int>(DUAL_TEXTURE);
|
|
}
|
|
|
|
if (mh.NormalTexture[0])
|
|
{
|
|
flags |= NORMAL_MAPS;
|
|
}
|
|
|
|
m = {};
|
|
m.name = matName;
|
|
m.perVertexColor = (flags & PER_VERTEX_COLOR) != 0;
|
|
m.enableSkinning = (flags & SKINNING) != 0;
|
|
m.enableDualTexture = (flags & DUAL_TEXTURE) != 0;
|
|
m.enableNormalMaps = (flags & NORMAL_MAPS) != 0;
|
|
m.biasedVertexNormals = (flags & BIASED_VERTEX_NORMALS) != 0;
|
|
|
|
if (mh.Ambient.x == 0 && mh.Ambient.y == 0 && mh.Ambient.z == 0 && mh.Ambient.w == 0
|
|
&& mh.Diffuse.x == 0 && mh.Diffuse.y == 0 && mh.Diffuse.z == 0 && mh.Diffuse.w == 0)
|
|
{
|
|
// SDKMESH material color block is uninitalized; assume defaults
|
|
m.diffuseColor = XMFLOAT3(1.f, 1.f, 1.f);
|
|
m.alphaValue = 1.f;
|
|
}
|
|
else
|
|
{
|
|
m.ambientColor = GetMaterialColor(mh.Ambient.x, mh.Ambient.y, mh.Ambient.z, srgb);
|
|
m.diffuseColor = GetMaterialColor(mh.Diffuse.x, mh.Diffuse.y, mh.Diffuse.z, srgb);
|
|
m.emissiveColor = GetMaterialColor(mh.Emissive.x, mh.Emissive.y, mh.Emissive.z, srgb);
|
|
|
|
if (mh.Diffuse.w != 1.f && mh.Diffuse.w != 0.f)
|
|
{
|
|
m.alphaValue = mh.Diffuse.w;
|
|
}
|
|
else
|
|
m.alphaValue = 1.f;
|
|
|
|
if (mh.Power > 0)
|
|
{
|
|
m.specularPower = mh.Power;
|
|
m.specularColor = XMFLOAT3(mh.Specular.x, mh.Specular.y, mh.Specular.z);
|
|
}
|
|
}
|
|
|
|
m.diffuseTextureIndex = GetUniqueTextureIndex(diffuseName, textureDictionary);
|
|
m.specularTextureIndex = GetUniqueTextureIndex(specularName, textureDictionary);
|
|
m.normalTextureIndex = GetUniqueTextureIndex(normalName, textureDictionary);
|
|
|
|
m.samplerIndex = (m.diffuseTextureIndex == -1) ? -1 : static_cast<int>(CommonStates::SamplerIndex::AnisotropicWrap);
|
|
m.samplerIndex2 = (flags & DUAL_TEXTURE) ? static_cast<int>(CommonStates::SamplerIndex::AnisotropicWrap) : -1;
|
|
}
|
|
|
|
void InitMaterial(
|
|
const DXUT::SDKMESH_MATERIAL_V2& mh,
|
|
unsigned int flags,
|
|
_Out_ Model::ModelMaterialInfo& m,
|
|
_Inout_ std::map<std::wstring, int>& textureDictionary)
|
|
{
|
|
wchar_t matName[DXUT::MAX_MATERIAL_NAME] = {};
|
|
ASCIIToWChar(matName, mh.Name);
|
|
|
|
wchar_t albedoTexture[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(albedoTexture, mh.AlbedoTexture);
|
|
|
|
wchar_t normalName[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(normalName, mh.NormalTexture);
|
|
|
|
wchar_t rmaName[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(rmaName, mh.RMATexture);
|
|
|
|
wchar_t emissiveName[DXUT::MAX_TEXTURE_NAME] = {};
|
|
ASCIIToWChar(emissiveName, mh.EmissiveTexture);
|
|
|
|
m = {};
|
|
m.name = matName;
|
|
m.perVertexColor = false;
|
|
m.enableSkinning = (flags & SKINNING) != 0;
|
|
m.enableDualTexture = false;
|
|
m.enableNormalMaps = true;
|
|
m.biasedVertexNormals = (flags & BIASED_VERTEX_NORMALS) != 0;
|
|
m.alphaValue = (mh.Alpha == 0.f) ? 1.f : mh.Alpha;
|
|
|
|
m.diffuseTextureIndex = GetUniqueTextureIndex(albedoTexture, textureDictionary);
|
|
m.specularTextureIndex = GetUniqueTextureIndex(rmaName, textureDictionary);
|
|
m.normalTextureIndex = GetUniqueTextureIndex(normalName, textureDictionary);
|
|
m.emissiveTextureIndex = GetUniqueTextureIndex(emissiveName, textureDictionary);
|
|
|
|
m.samplerIndex = m.samplerIndex2 = static_cast<int>(CommonStates::SamplerIndex::AnisotropicWrap);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Direct3D 9 Vertex Declaration to Direct3D 12 Input Layout mapping
|
|
|
|
static_assert(D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT >= 32, "SDKMESH supports decls up to 32 entries");
|
|
|
|
unsigned int GetInputLayoutDesc(
|
|
_In_reads_(32) const DXUT::D3DVERTEXELEMENT9 decl[],
|
|
ModelMeshPart::InputLayoutCollection& inputDesc)
|
|
{
|
|
static const D3D12_INPUT_ELEMENT_DESC s_elements[] =
|
|
{
|
|
{ "SV_Position", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "COLOR", 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "BINORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "BLENDINDICES", 0, DXGI_FORMAT_R8G8B8A8_UINT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
{ "BLENDWEIGHT", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
|
|
};
|
|
|
|
using namespace DXUT;
|
|
|
|
uint32_t offset = 0;
|
|
uint32_t texcoords = 0;
|
|
unsigned int flags = 0;
|
|
|
|
bool posfound = false;
|
|
|
|
for (size_t index = 0; index < DXUT::MAX_VERTEX_ELEMENTS; ++index)
|
|
{
|
|
if (decl[index].Usage == 0xFF)
|
|
break;
|
|
|
|
if (decl[index].Type == D3DDECLTYPE_UNUSED)
|
|
break;
|
|
|
|
if (decl[index].Offset != offset)
|
|
break;
|
|
|
|
if (decl[index].Usage == D3DDECLUSAGE_POSITION)
|
|
{
|
|
if (decl[index].Type == D3DDECLTYPE_FLOAT3)
|
|
{
|
|
inputDesc.push_back(s_elements[0]);
|
|
offset += 12;
|
|
posfound = true;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else if (decl[index].Usage == D3DDECLUSAGE_NORMAL
|
|
|| decl[index].Usage == D3DDECLUSAGE_TANGENT
|
|
|| decl[index].Usage == D3DDECLUSAGE_BINORMAL)
|
|
{
|
|
size_t base = 1;
|
|
if (decl[index].Usage == D3DDECLUSAGE_TANGENT)
|
|
base = 3;
|
|
else if (decl[index].Usage == D3DDECLUSAGE_BINORMAL)
|
|
base = 4;
|
|
|
|
D3D12_INPUT_ELEMENT_DESC desc = s_elements[base];
|
|
|
|
bool unk = false;
|
|
switch (decl[index].Type)
|
|
{
|
|
case D3DDECLTYPE_FLOAT3: assert(desc.Format == DXGI_FORMAT_R32G32B32_FLOAT); offset += 12; break;
|
|
case D3DDECLTYPE_UBYTE4N: desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; flags |= BIASED_VERTEX_NORMALS; offset += 4; break;
|
|
case D3DDECLTYPE_SHORT4N: desc.Format = DXGI_FORMAT_R16G16B16A16_SNORM; offset += 8; break;
|
|
case D3DDECLTYPE_FLOAT16_4: desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; offset += 8; break;
|
|
case D3DDECLTYPE_DXGI_R10G10B10A2_UNORM: desc.Format = DXGI_FORMAT_R10G10B10A2_UNORM; flags |= BIASED_VERTEX_NORMALS; offset += 4; break;
|
|
case D3DDECLTYPE_DXGI_R11G11B10_FLOAT: desc.Format = DXGI_FORMAT_R11G11B10_FLOAT; flags |= BIASED_VERTEX_NORMALS; offset += 4; break;
|
|
case D3DDECLTYPE_DXGI_R8G8B8A8_SNORM: desc.Format = DXGI_FORMAT_R8G8B8A8_SNORM; offset += 4; break;
|
|
|
|
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
|
case D3DDECLTYPE_DEC3N: desc.Format = DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM; offset += 4; break;
|
|
case (32 + DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM): desc.Format = DXGI_FORMAT_R10G10B10_SNORM_A2_UNORM; offset += 4; break;
|
|
#else
|
|
case D3DDECLTYPE_DEC3N: desc.Format = DXGI_FORMAT_R10G10B10A2_UNORM; flags |= USES_OBSOLETE_DEC3N; offset += 4; break;
|
|
#endif
|
|
|
|
default:
|
|
unk = true;
|
|
break;
|
|
}
|
|
|
|
if (unk)
|
|
break;
|
|
|
|
inputDesc.push_back(desc);
|
|
}
|
|
else if (decl[index].Usage == D3DDECLUSAGE_COLOR)
|
|
{
|
|
D3D12_INPUT_ELEMENT_DESC desc = s_elements[2];
|
|
|
|
bool unk = false;
|
|
switch (decl[index].Type)
|
|
{
|
|
case D3DDECLTYPE_FLOAT4: desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; offset += 16; break;
|
|
case D3DDECLTYPE_D3DCOLOR: assert(desc.Format == DXGI_FORMAT_B8G8R8A8_UNORM); offset += 4; break;
|
|
case D3DDECLTYPE_UBYTE4N: desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; offset += 4; break;
|
|
case D3DDECLTYPE_FLOAT16_4: desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; offset += 8; break;
|
|
case D3DDECLTYPE_DXGI_R10G10B10A2_UNORM: desc.Format = DXGI_FORMAT_R10G10B10A2_UNORM; offset += 4; break;
|
|
case D3DDECLTYPE_DXGI_R11G11B10_FLOAT: desc.Format = DXGI_FORMAT_R11G11B10_FLOAT; offset += 4; break;
|
|
|
|
default:
|
|
unk = true;
|
|
break;
|
|
}
|
|
|
|
if (unk)
|
|
break;
|
|
|
|
flags |= PER_VERTEX_COLOR;
|
|
|
|
inputDesc.push_back(desc);
|
|
}
|
|
else if (decl[index].Usage == D3DDECLUSAGE_TEXCOORD)
|
|
{
|
|
D3D12_INPUT_ELEMENT_DESC desc = s_elements[5];
|
|
desc.SemanticIndex = decl[index].UsageIndex;
|
|
|
|
bool unk = false;
|
|
switch (decl[index].Type)
|
|
{
|
|
case D3DDECLTYPE_FLOAT1: desc.Format = DXGI_FORMAT_R32_FLOAT; offset += 4; break;
|
|
case D3DDECLTYPE_FLOAT2: assert(desc.Format == DXGI_FORMAT_R32G32_FLOAT); offset += 8; break;
|
|
case D3DDECLTYPE_FLOAT3: desc.Format = DXGI_FORMAT_R32G32B32_FLOAT; offset += 12; break;
|
|
case D3DDECLTYPE_FLOAT4: desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; offset += 16; break;
|
|
case D3DDECLTYPE_FLOAT16_2: desc.Format = DXGI_FORMAT_R16G16_FLOAT; offset += 4; break;
|
|
case D3DDECLTYPE_FLOAT16_4: desc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; offset += 8; break;
|
|
|
|
default:
|
|
unk = true;
|
|
break;
|
|
}
|
|
|
|
if (unk)
|
|
break;
|
|
|
|
++texcoords;
|
|
|
|
inputDesc.push_back(desc);
|
|
}
|
|
else if (decl[index].Usage == D3DDECLUSAGE_BLENDINDICES)
|
|
{
|
|
if (decl[index].Type == D3DDECLTYPE_UBYTE4)
|
|
{
|
|
flags |= SKINNING;
|
|
inputDesc.push_back(s_elements[6]);
|
|
offset += 4;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else if (decl[index].Usage == D3DDECLUSAGE_BLENDWEIGHT)
|
|
{
|
|
if (decl[index].Type == D3DDECLTYPE_UBYTE4N)
|
|
{
|
|
flags |= SKINNING;
|
|
inputDesc.push_back(s_elements[7]);
|
|
offset += 4;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (!posfound)
|
|
throw std::runtime_error("SV_Position is required");
|
|
|
|
if (texcoords == 2)
|
|
{
|
|
flags |= DUAL_TEXTURE;
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
}
|
|
|
|
//======================================================================================
|
|
// Model Loader
|
|
//======================================================================================
|
|
|
|
_Use_decl_annotations_
|
|
std::unique_ptr<Model> DirectX::Model::CreateFromSDKMESH(
|
|
ID3D12Device* device,
|
|
const uint8_t* meshData,
|
|
size_t idataSize,
|
|
ModelLoaderFlags flags)
|
|
{
|
|
if (!meshData)
|
|
throw std::invalid_argument("meshData cannot be null");
|
|
|
|
uint64_t dataSize = idataSize;
|
|
|
|
// File Headers
|
|
if (dataSize < sizeof(DXUT::SDKMESH_HEADER))
|
|
throw std::runtime_error("End of file");
|
|
auto header = reinterpret_cast<const DXUT::SDKMESH_HEADER*>(meshData);
|
|
|
|
size_t headerSize = sizeof(DXUT::SDKMESH_HEADER)
|
|
+ header->NumVertexBuffers * sizeof(DXUT::SDKMESH_VERTEX_BUFFER_HEADER)
|
|
+ header->NumIndexBuffers * sizeof(DXUT::SDKMESH_INDEX_BUFFER_HEADER);
|
|
if (header->HeaderSize != headerSize)
|
|
throw std::runtime_error("Not a valid SDKMESH file");
|
|
|
|
if (dataSize < header->HeaderSize)
|
|
throw std::runtime_error("End of file");
|
|
|
|
if (header->Version != DXUT::SDKMESH_FILE_VERSION && header->Version != DXUT::SDKMESH_FILE_VERSION_V2)
|
|
throw std::runtime_error("Not a supported SDKMESH version");
|
|
|
|
if (header->IsBigEndian)
|
|
throw std::runtime_error("Loading BigEndian SDKMESH files not supported");
|
|
|
|
if (!header->NumMeshes)
|
|
throw std::runtime_error("No meshes found");
|
|
|
|
if (!header->NumVertexBuffers)
|
|
throw std::runtime_error("No vertex buffers found");
|
|
|
|
if (!header->NumIndexBuffers)
|
|
throw std::runtime_error("No index buffers found");
|
|
|
|
if (!header->NumTotalSubsets)
|
|
throw std::runtime_error("No subsets found");
|
|
|
|
if (!header->NumMaterials)
|
|
throw std::runtime_error("No materials found");
|
|
|
|
// Sub-headers
|
|
if (dataSize < header->VertexStreamHeadersOffset
|
|
|| (dataSize < (header->VertexStreamHeadersOffset + uint64_t(header->NumVertexBuffers) * sizeof(DXUT::SDKMESH_VERTEX_BUFFER_HEADER))))
|
|
throw std::runtime_error("End of file");
|
|
auto vbArray = reinterpret_cast<const DXUT::SDKMESH_VERTEX_BUFFER_HEADER*>(meshData + header->VertexStreamHeadersOffset);
|
|
|
|
if (dataSize < header->IndexStreamHeadersOffset
|
|
|| (dataSize < (header->IndexStreamHeadersOffset + uint64_t(header->NumIndexBuffers) * sizeof(DXUT::SDKMESH_INDEX_BUFFER_HEADER))))
|
|
throw std::runtime_error("End of file");
|
|
auto ibArray = reinterpret_cast<const DXUT::SDKMESH_INDEX_BUFFER_HEADER*>(meshData + header->IndexStreamHeadersOffset);
|
|
|
|
if (dataSize < header->MeshDataOffset
|
|
|| (dataSize < (header->MeshDataOffset + uint64_t(header->NumMeshes) * sizeof(DXUT::SDKMESH_MESH))))
|
|
throw std::runtime_error("End of file");
|
|
auto meshArray = reinterpret_cast<const DXUT::SDKMESH_MESH*>(meshData + header->MeshDataOffset);
|
|
|
|
if (dataSize < header->SubsetDataOffset
|
|
|| (dataSize < (header->SubsetDataOffset + uint64_t(header->NumTotalSubsets) * sizeof(DXUT::SDKMESH_SUBSET))))
|
|
throw std::runtime_error("End of file");
|
|
auto subsetArray = reinterpret_cast<const DXUT::SDKMESH_SUBSET*>(meshData + header->SubsetDataOffset);
|
|
|
|
const DXUT::SDKMESH_FRAME* frameArray = nullptr;
|
|
if (header->NumFrames > 0)
|
|
{
|
|
if (dataSize < header->FrameDataOffset
|
|
|| (dataSize < (header->FrameDataOffset + uint64_t(header->NumFrames) * sizeof(DXUT::SDKMESH_FRAME))))
|
|
throw std::runtime_error("End of file");
|
|
|
|
if (flags & ModelLoader_IncludeBones)
|
|
{
|
|
frameArray = reinterpret_cast<const DXUT::SDKMESH_FRAME*>(meshData + header->FrameDataOffset);
|
|
}
|
|
}
|
|
|
|
if (dataSize < header->MaterialDataOffset
|
|
|| (dataSize < (header->MaterialDataOffset + uint64_t(header->NumMaterials) * sizeof(DXUT::SDKMESH_MATERIAL))))
|
|
throw std::runtime_error("End of file");
|
|
|
|
const DXUT::SDKMESH_MATERIAL* materialArray = nullptr;
|
|
const DXUT::SDKMESH_MATERIAL_V2* materialArray_v2 = nullptr;
|
|
if (header->Version == DXUT::SDKMESH_FILE_VERSION_V2)
|
|
{
|
|
materialArray_v2 = reinterpret_cast<const DXUT::SDKMESH_MATERIAL_V2*>(meshData + header->MaterialDataOffset);
|
|
}
|
|
else
|
|
{
|
|
materialArray = reinterpret_cast<const DXUT::SDKMESH_MATERIAL*>(meshData + header->MaterialDataOffset);
|
|
}
|
|
|
|
// Buffer data
|
|
uint64_t bufferDataOffset = header->HeaderSize + header->NonBufferDataSize;
|
|
if ((dataSize < bufferDataOffset)
|
|
|| (dataSize < bufferDataOffset + header->BufferDataSize))
|
|
throw std::runtime_error("End of file");
|
|
const uint8_t* bufferData = meshData + bufferDataOffset;
|
|
|
|
// Create vertex buffers
|
|
std::vector<std::shared_ptr<ModelMeshPart::InputLayoutCollection>> vbDecls;
|
|
vbDecls.resize(header->NumVertexBuffers);
|
|
|
|
std::vector<unsigned int> materialFlags;
|
|
materialFlags.resize(header->NumVertexBuffers);
|
|
|
|
bool dec3nwarning = false;
|
|
for (size_t j = 0; j < header->NumVertexBuffers; ++j)
|
|
{
|
|
auto& vh = vbArray[j];
|
|
|
|
if (vh.SizeBytes > UINT32_MAX)
|
|
throw std::runtime_error("VB too large");
|
|
|
|
if (!(flags & ModelLoader_AllowLargeModels))
|
|
{
|
|
if (vh.SizeBytes > (D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM * 1024u * 1024u))
|
|
throw std::runtime_error("VB too large for DirectX 12");
|
|
}
|
|
|
|
if (dataSize < vh.DataOffset
|
|
|| (dataSize < vh.DataOffset + vh.SizeBytes))
|
|
throw std::runtime_error("End of file");
|
|
|
|
vbDecls[j] = std::make_shared<ModelMeshPart::InputLayoutCollection>();
|
|
unsigned int ilflags = GetInputLayoutDesc(vh.Decl, *vbDecls[j].get());
|
|
|
|
if (flags & ModelLoader_DisableSkinning)
|
|
{
|
|
ilflags &= ~static_cast<unsigned int>(SKINNING);
|
|
}
|
|
|
|
if (ilflags & SKINNING)
|
|
{
|
|
ilflags &= ~static_cast<unsigned int>(DUAL_TEXTURE);
|
|
}
|
|
if (ilflags & USES_OBSOLETE_DEC3N)
|
|
{
|
|
dec3nwarning = true;
|
|
}
|
|
|
|
materialFlags[j] = ilflags;
|
|
}
|
|
|
|
if (dec3nwarning)
|
|
{
|
|
DebugTrace("WARNING: Vertex declaration uses legacy Direct3D 9 D3DDECLTYPE_DEC3N which has no DXGI equivalent\n"
|
|
" (treating as DXGI_FORMAT_R10G10B10A2_UNORM which is not a signed format)\n");
|
|
}
|
|
|
|
// Validate index buffers
|
|
for (size_t j = 0; j < header->NumIndexBuffers; ++j)
|
|
{
|
|
auto& ih = ibArray[j];
|
|
|
|
if (ih.SizeBytes > UINT32_MAX)
|
|
throw std::runtime_error("IB too large");
|
|
|
|
if (!(flags & ModelLoader_AllowLargeModels))
|
|
{
|
|
if (ih.SizeBytes > (D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM * 1024u * 1024u))
|
|
throw std::runtime_error("IB too large for DirectX 12");
|
|
}
|
|
|
|
if (dataSize < ih.DataOffset
|
|
|| (dataSize < ih.DataOffset + ih.SizeBytes))
|
|
throw std::runtime_error("End of file");
|
|
|
|
if (ih.IndexType != DXUT::IT_16BIT && ih.IndexType != DXUT::IT_32BIT)
|
|
throw std::runtime_error("Invalid index buffer type found");
|
|
}
|
|
|
|
// Create meshes
|
|
std::vector<ModelMaterialInfo> materials;
|
|
materials.resize(header->NumMaterials);
|
|
|
|
std::map<std::wstring, int> textureDictionary;
|
|
|
|
auto model = std::make_unique<Model>();
|
|
model->meshes.reserve(header->NumMeshes);
|
|
|
|
uint32_t partCount = 0;
|
|
|
|
for (size_t meshIndex = 0; meshIndex < header->NumMeshes; ++meshIndex)
|
|
{
|
|
auto& mh = meshArray[meshIndex];
|
|
|
|
if (!mh.NumSubsets
|
|
|| !mh.NumVertexBuffers
|
|
|| mh.IndexBuffer >= header->NumIndexBuffers
|
|
|| mh.VertexBuffers[0] >= header->NumVertexBuffers)
|
|
throw std::out_of_range("Invalid mesh found");
|
|
|
|
// mh.NumVertexBuffers is sometimes not what you'd expect, so we skip validating it
|
|
|
|
if (dataSize < mh.SubsetOffset
|
|
|| (dataSize < mh.SubsetOffset + uint64_t(mh.NumSubsets) * sizeof(uint32_t)))
|
|
throw std::runtime_error("End of file");
|
|
|
|
auto subsets = reinterpret_cast<const uint32_t*>(meshData + mh.SubsetOffset);
|
|
|
|
const uint32_t* influences = nullptr;
|
|
if (mh.NumFrameInfluences > 0)
|
|
{
|
|
if (dataSize < mh.FrameInfluenceOffset
|
|
|| (dataSize < mh.FrameInfluenceOffset + uint64_t(mh.NumFrameInfluences) * sizeof(uint32_t)))
|
|
throw std::runtime_error("End of file");
|
|
|
|
if (flags & ModelLoader_IncludeBones)
|
|
{
|
|
influences = reinterpret_cast<const uint32_t*>(meshData + mh.FrameInfluenceOffset);
|
|
}
|
|
}
|
|
|
|
auto mesh = std::make_shared<ModelMesh>();
|
|
wchar_t meshName[DXUT::MAX_MESH_NAME] = {};
|
|
ASCIIToWChar(meshName, mh.Name);
|
|
|
|
mesh->name = meshName;
|
|
|
|
// Extents
|
|
mesh->boundingBox.Center = mh.BoundingBoxCenter;
|
|
mesh->boundingBox.Extents = mh.BoundingBoxExtents;
|
|
BoundingSphere::CreateFromBoundingBox(mesh->boundingSphere, mesh->boundingBox);
|
|
|
|
if (influences)
|
|
{
|
|
mesh->boneInfluences.resize(mh.NumFrameInfluences);
|
|
memcpy(mesh->boneInfluences.data(), influences, sizeof(uint32_t) * mh.NumFrameInfluences);
|
|
}
|
|
|
|
// Create subsets
|
|
for (size_t j = 0; j < mh.NumSubsets; ++j)
|
|
{
|
|
auto sIndex = subsets[j];
|
|
if (sIndex >= header->NumTotalSubsets)
|
|
throw std::out_of_range("Invalid mesh found");
|
|
|
|
auto& subset = subsetArray[sIndex];
|
|
|
|
D3D_PRIMITIVE_TOPOLOGY primType;
|
|
switch (subset.PrimitiveType)
|
|
{
|
|
case DXUT::PT_TRIANGLE_LIST: primType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; break;
|
|
case DXUT::PT_TRIANGLE_STRIP: primType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; break;
|
|
case DXUT::PT_LINE_LIST: primType = D3D_PRIMITIVE_TOPOLOGY_LINELIST; break;
|
|
case DXUT::PT_LINE_STRIP: primType = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP; break;
|
|
case DXUT::PT_POINT_LIST: primType = D3D_PRIMITIVE_TOPOLOGY_POINTLIST; break;
|
|
case DXUT::PT_TRIANGLE_LIST_ADJ: primType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ; break;
|
|
case DXUT::PT_TRIANGLE_STRIP_ADJ: primType = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ; break;
|
|
case DXUT::PT_LINE_LIST_ADJ: primType = D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ; break;
|
|
case DXUT::PT_LINE_STRIP_ADJ: primType = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ; break;
|
|
|
|
case DXUT::PT_QUAD_PATCH_LIST:
|
|
case DXUT::PT_TRIANGLE_PATCH_LIST:
|
|
throw std::runtime_error("Direct3D9 era tessellation not supported");
|
|
|
|
default:
|
|
throw std::runtime_error("Unknown primitive type");
|
|
}
|
|
|
|
if (subset.MaterialID >= header->NumMaterials)
|
|
throw std::out_of_range("Invalid mesh found");
|
|
|
|
auto& mat = materials[subset.MaterialID];
|
|
|
|
const size_t vi = mh.VertexBuffers[0];
|
|
if (materialArray_v2)
|
|
{
|
|
InitMaterial(
|
|
materialArray_v2[subset.MaterialID],
|
|
materialFlags[vi],
|
|
mat,
|
|
textureDictionary);
|
|
}
|
|
else
|
|
{
|
|
InitMaterial(
|
|
materialArray[subset.MaterialID],
|
|
materialFlags[vi],
|
|
mat,
|
|
textureDictionary,
|
|
(flags & ModelLoader_MaterialColorsSRGB) != 0);
|
|
}
|
|
|
|
auto part = new ModelMeshPart(partCount++);
|
|
|
|
const auto& vh = vbArray[mh.VertexBuffers[0]];
|
|
const auto& ih = ibArray[mh.IndexBuffer];
|
|
|
|
part->indexCount = static_cast<uint32_t>(subset.IndexCount);
|
|
part->startIndex = static_cast<uint32_t>(subset.IndexStart);
|
|
part->vertexOffset = static_cast<int32_t>(subset.VertexStart);
|
|
part->vertexStride = static_cast<uint32_t>(vh.StrideBytes);
|
|
part->vertexCount = static_cast<uint32_t>(subset.VertexCount);
|
|
part->primitiveType = primType;
|
|
part->indexFormat = (ibArray[mh.IndexBuffer].IndexType == DXUT::IT_32BIT) ? DXGI_FORMAT_R32_UINT : DXGI_FORMAT_R16_UINT;
|
|
|
|
// Vertex data
|
|
auto verts = bufferData + (vh.DataOffset - bufferDataOffset);
|
|
auto vbytes = static_cast<size_t>(vh.SizeBytes);
|
|
part->vertexBufferSize = static_cast<uint32_t>(vh.SizeBytes);
|
|
part->vertexBuffer = GraphicsMemory::Get(device).Allocate(vbytes);
|
|
memcpy(part->vertexBuffer.Memory(), verts, vbytes);
|
|
|
|
// Index data
|
|
auto indices = bufferData + (ih.DataOffset - bufferDataOffset);
|
|
auto ibytes = static_cast<size_t>(ih.SizeBytes);
|
|
part->indexBufferSize = static_cast<uint32_t>(ih.SizeBytes);
|
|
part->indexBuffer = GraphicsMemory::Get(device).Allocate(ibytes);
|
|
memcpy(part->indexBuffer.Memory(), indices, ibytes);
|
|
|
|
part->materialIndex = subset.MaterialID;
|
|
part->vbDecl = vbDecls[mh.VertexBuffers[0]];
|
|
|
|
if (mat.alphaValue < 1.0f)
|
|
mesh->alphaMeshParts.emplace_back(part);
|
|
else
|
|
mesh->opaqueMeshParts.emplace_back(part);
|
|
}
|
|
|
|
model->meshes.emplace_back(mesh);
|
|
}
|
|
|
|
// Copy the materials and texture names into contiguous arrays
|
|
model->materials = std::move(materials);
|
|
model->textureNames.resize(textureDictionary.size());
|
|
for (auto texture = std::cbegin(textureDictionary); texture != std::cend(textureDictionary); ++texture)
|
|
{
|
|
model->textureNames[static_cast<size_t>(texture->second)] = texture->first;
|
|
}
|
|
|
|
// Load model bones (if present and requested)
|
|
if (frameArray)
|
|
{
|
|
static_assert(DXUT::INVALID_FRAME == ModelBone::c_Invalid, "ModelBone invalid type mismatch");
|
|
|
|
ModelBone::Collection bones;
|
|
bones.reserve(header->NumFrames);
|
|
auto transforms = ModelBone::MakeArray(header->NumFrames);
|
|
|
|
for (uint32_t j = 0; j < header->NumFrames; ++j)
|
|
{
|
|
ModelBone bone(
|
|
frameArray[j].ParentFrame,
|
|
frameArray[j].ChildFrame,
|
|
frameArray[j].SiblingFrame);
|
|
|
|
wchar_t boneName[DXUT::MAX_FRAME_NAME] = {};
|
|
ASCIIToWChar(boneName, frameArray[j].Name);
|
|
bone.name = boneName;
|
|
bones.emplace_back(bone);
|
|
|
|
transforms[j] = XMLoadFloat4x4(&frameArray[j].Matrix);
|
|
|
|
uint32_t index = frameArray[j].Mesh;
|
|
if (index != DXUT::INVALID_MESH)
|
|
{
|
|
if (index >= model->meshes.size())
|
|
{
|
|
throw std::out_of_range("Invalid mesh index found in frame data");
|
|
}
|
|
|
|
if (model->meshes[index]->boneIndex == ModelBone::c_Invalid)
|
|
{
|
|
// Bind the first bone that links to a given mesh
|
|
model->meshes[index]->boneIndex = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::swap(model->bones, bones);
|
|
|
|
// Compute inverse bind pose matrices for the model
|
|
auto bindPose = ModelBone::MakeArray(header->NumFrames);
|
|
model->CopyAbsoluteBoneTransforms(header->NumFrames, transforms.get(), bindPose.get());
|
|
|
|
auto invBoneTransforms = ModelBone::MakeArray(header->NumFrames);
|
|
for (size_t j = 0; j < header->NumFrames; ++j)
|
|
{
|
|
invBoneTransforms[j] = XMMatrixInverse(nullptr, bindPose[j]);
|
|
}
|
|
|
|
std::swap(model->boneMatrices, transforms);
|
|
std::swap(model->invBindPoseMatrices, invBoneTransforms);
|
|
}
|
|
|
|
return model;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
_Use_decl_annotations_
|
|
std::unique_ptr<Model> DirectX::Model::CreateFromSDKMESH(
|
|
ID3D12Device* device,
|
|
const wchar_t* szFileName,
|
|
ModelLoaderFlags flags)
|
|
{
|
|
size_t dataSize = 0;
|
|
std::unique_ptr<uint8_t[]> data;
|
|
HRESULT hr = BinaryReader::ReadEntireFile(szFileName, data, &dataSize);
|
|
if (FAILED(hr))
|
|
{
|
|
DebugTrace("ERROR: CreateFromSDKMESH failed (%08X) loading '%ls'\n",
|
|
static_cast<unsigned int>(hr), szFileName);
|
|
throw std::runtime_error("CreateFromSDKMESH");
|
|
}
|
|
|
|
auto model = CreateFromSDKMESH(device, data.get(), dataSize, flags);
|
|
|
|
model->name = szFileName;
|
|
|
|
return model;
|
|
}
|