nick/WickedEngine
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
381d4163d4afa99722946668e9f334698835904d
WickedEngine/Editor/ModelImporter_GLTF.cpp
T
turanszkij 381d4163d4 updates
2018-09-04 18:05:23 +01:00

969 lines
28 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "ModelImporter.h"
#include "Utility/stb_image.h"
#define TINYGLTF_IMPLEMENTATION
#define TINYGLTF_NO_STB_IMAGE
#define TINYGLTF_NO_STB_IMAGE_WRITE
#include "tiny_gltf.h"
#include <fstream>
#include <sstream>
using namespace std;
using namespace wiGraphicsTypes;
using namespace wiSceneSystem;
using namespace wiECS;
// Transform the data from glTF space to engine-space:
const bool transform_to_LH = true;
namespace tinygltf
{
bool LoadImageData(Image *image, std::string *err, std::string *warn,
int req_width, int req_height, const unsigned char *bytes,
int size, void *)
{
(void)warn;
const int requiredComponents = 4;
int w, h, comp;
unsigned char *data = stbi_load_from_memory(bytes, size, &w, &h, &comp, requiredComponents);
if (!data) {
// NOTE: you can use `warn` instead of `err`
if (err) {
(*err) += "Unknown image format.\n";
}
return false;
}
if (w < 1 || h < 1) {
free(data);
if (err) {
(*err) += "Invalid image data.\n";
}
return false;
}
if (req_width > 0) {
if (req_width != w) {
free(data);
if (err) {
(*err) += "Image width mismatch.\n";
}
return false;
}
}
if (req_height > 0) {
if (req_height != h) {
free(data);
if (err) {
(*err) += "Image height mismatch.\n";
}
return false;
}
}
image->width = w;
image->height = h;
image->component = requiredComponents;
image->image.resize(static_cast<size_t>(w * h * image->component));
std::copy(data, data + w * h * image->component, image->image.begin());
free(data);
return true;
}
bool WriteImageData(const std::string *basepath, const std::string *filename,
Image *image, bool embedImages, void *)
{
assert(0); // TODO
return false;
}
}
void RegisterTexture2D(tinygltf::Image *image)
{
// We will load the texture2d by hand here and register to the resource manager
{
int width = image->width;
int height = image->height;
int channelCount = image->component;
const unsigned char* rgb = image->image.data();
if (rgb != nullptr)
{
TextureDesc desc;
desc.ArraySize = 1;
desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
desc.CPUAccessFlags = 0;
desc.Format = FORMAT_R8G8B8A8_UNORM;
desc.Height = static_cast<uint32_t>(height);
desc.Width = static_cast<uint32_t>(width);
desc.MipLevels = (UINT)log2(max(width, height));
desc.MiscFlags = 0;
desc.Usage = USAGE_DEFAULT;
UINT mipwidth = width;
SubresourceData* InitData = new SubresourceData[desc.MipLevels];
for (UINT mip = 0; mip < desc.MipLevels; ++mip)
{
InitData[mip].pSysMem = rgb;
InitData[mip].SysMemPitch = static_cast<UINT>(mipwidth * channelCount);
mipwidth = max(1, mipwidth / 2);
}
Texture2D* tex = new Texture2D;
tex->RequestIndependentShaderResourcesForMIPs(true);
tex->RequestIndependentUnorderedAccessResourcesForMIPs(true);
HRESULT hr = wiRenderer::GetDevice()->CreateTexture2D(&desc, InitData, &tex);
assert(SUCCEEDED(hr));
if (tex != nullptr)
{
wiRenderer::AddDeferredMIPGen(tex);
if (image->name.empty())
{
static UINT imgcounter = 0;
stringstream ss("");
ss << "gltfLoader_image" << imgcounter++;
image->name = ss.str();
}
// We loaded the texture2d, so register to the resource manager to be retrieved later:
wiResourceManager::GetGlobal()->Register(image->name, tex, wiResourceManager::IMAGE);
}
}
}
}
void LoadNode(tinygltf::Node* node, Entity parent, Entity modelEntity, tinygltf::Model& gltfModel, const vector<Entity>& materialArray, vector<Entity>& meshArray, vector<Entity>& armatureArray)
{
if (node == nullptr)
{
return;
}
Scene& scene = wiRenderer::GetScene();
ModelComponent& model = *scene.models.GetComponent(modelEntity);
Entity entity = INVALID_ENTITY;
if(node->mesh >= 0)
{
entity = scene.Entity_CreateObject(node->name);
ObjectComponent& object = *scene.objects.GetComponent(entity);
if (node->mesh < meshArray.size())
{
object.meshID = meshArray[node->mesh];
}
else
{
auto& x = gltfModel.meshes[node->mesh];
Entity meshEntity = scene.Entity_CreateMesh(x.name);
meshArray.push_back(meshEntity);
object.meshID = meshEntity;
MeshComponent& mesh = *scene.meshes.GetComponent(meshEntity);
mesh.renderable = true;
XMFLOAT3 min = XMFLOAT3(FLT_MAX, FLT_MAX, FLT_MAX);
XMFLOAT3 max = XMFLOAT3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
for (auto& prim : x.primitives)
{
assert(prim.indices >= 0);
// Fill indices:
const tinygltf::Accessor& accessor = gltfModel.accessors[prim.indices];
const tinygltf::BufferView& bufferView = gltfModel.bufferViews[accessor.bufferView];
const tinygltf::Buffer& buffer = gltfModel.buffers[bufferView.buffer];
int stride = accessor.ByteStride(bufferView);
size_t count = accessor.count;
size_t offset = mesh.indices.size();
mesh.indices.resize(offset + count);
const unsigned char* data = buffer.data.data() + accessor.byteOffset + bufferView.byteOffset;
if (stride == 1)
{
for (size_t i = 0; i < count; i += 3)
{
mesh.indices[offset + i + 0] = data[i + 0];
mesh.indices[offset + i + 1] = data[i + 1];
mesh.indices[offset + i + 2] = data[i + 2];
}
}
else if (stride == 2)
{
for (size_t i = 0; i < count; i += 3)
{
mesh.indices[offset + i + 0] = ((uint16_t*)data)[i + 0];
mesh.indices[offset + i + 1] = ((uint16_t*)data)[i + 1];
mesh.indices[offset + i + 2] = ((uint16_t*)data)[i + 2];
}
}
else if (stride == 4)
{
for (size_t i = 0; i < count; i += 3)
{
mesh.indices[offset + i + 0] = ((uint32_t*)data)[i + 0];
mesh.indices[offset + i + 1] = ((uint32_t*)data)[i + 1];
mesh.indices[offset + i + 2] = ((uint32_t*)data)[i + 2];
}
}
else
{
assert(0 && "unsupported index stride!");
}
// Create mesh subset:
MeshComponent::MeshSubset subset;
if (prim.material >= 0)
{
subset.materialID = materialArray[prim.material];
}
else
{
assert(0);
}
mesh.subsets.push_back(subset);
}
bool hasBoneWeights = false;
bool hasBoneIndices = false;
int matIndex = -1;
for (auto& prim : x.primitives)
{
matIndex++;
size_t offset = mesh.vertices_FULL.size();
for (auto& attr : prim.attributes)
{
const string& attr_name = attr.first;
int attr_data = attr.second;
const tinygltf::Accessor& accessor = gltfModel.accessors[attr_data];
const tinygltf::BufferView& bufferView = gltfModel.bufferViews[accessor.bufferView];
const tinygltf::Buffer& buffer = gltfModel.buffers[bufferView.buffer];
int stride = accessor.ByteStride(bufferView);
size_t count = accessor.count;
if (mesh.vertices_FULL.size() == offset)
{
mesh.vertices_FULL.resize(offset + count);
}
const unsigned char* data = buffer.data.data() + accessor.byteOffset + bufferView.byteOffset;
if (!attr_name.compare("POSITION"))
{
assert(stride == 12);
for (size_t i = 0; i < count; ++i)
{
XMFLOAT3 pos = ((XMFLOAT3*)data)[i];
if (transform_to_LH)
{
pos.z = -pos.z;
}
mesh.vertices_FULL[offset + i].pos = XMFLOAT4(pos.x, pos.y, pos.z, 0);
min = wiMath::Min(min, pos);
max = wiMath::Max(max, pos);
}
}
else if (!attr_name.compare("NORMAL"))
{
assert(stride == 12);
for (size_t i = 0; i < count; ++i)
{
const XMFLOAT3& nor = ((XMFLOAT3*)data)[i];
mesh.vertices_FULL[offset + i].nor.x = nor.x;
mesh.vertices_FULL[offset + i].nor.y = nor.y;
mesh.vertices_FULL[offset + i].nor.z = -nor.z;
}
}
else if (!attr_name.compare("TEXCOORD_0"))
{
assert(stride == 8);
for (size_t i = 0; i < count; ++i)
{
const XMFLOAT2& tex = ((XMFLOAT2*)data)[i];
mesh.vertices_FULL[offset + i].tex.x = tex.x;
mesh.vertices_FULL[offset + i].tex.y = tex.y;
mesh.vertices_FULL[offset + i].tex.z = (float)matIndex /*prim.material*/;
}
}
else if (!attr_name.compare("JOINTS_0"))
{
if (stride == 4)
{
hasBoneIndices = true;
struct JointTmp
{
uint8_t ind[4];
};
for (size_t i = 0; i < count; ++i)
{
const JointTmp& joint = ((JointTmp*)data)[i];
mesh.vertices_FULL[offset + i].ind.x = (float)joint.ind[0];
mesh.vertices_FULL[offset + i].ind.y = (float)joint.ind[1];
mesh.vertices_FULL[offset + i].ind.z = (float)joint.ind[2];
mesh.vertices_FULL[offset + i].ind.w = (float)joint.ind[3];
}
}
else if (stride == 8)
{
hasBoneIndices = true;
struct JointTmp
{
uint16_t ind[4];
};
for (size_t i = 0; i < count; ++i)
{
const JointTmp& joint = ((JointTmp*)data)[i];
mesh.vertices_FULL[offset + i].ind.x = (float)joint.ind[0];
mesh.vertices_FULL[offset + i].ind.y = (float)joint.ind[1];
mesh.vertices_FULL[offset + i].ind.z = (float)joint.ind[2];
mesh.vertices_FULL[offset + i].ind.w = (float)joint.ind[3];
}
}
else
{
assert(0);
}
}
else if (!attr_name.compare("WEIGHTS_0"))
{
hasBoneWeights = true;
assert(stride == 16);
for (size_t i = 0; i < count; ++i)
{
mesh.vertices_FULL[offset + i].wei = ((XMFLOAT4*)data)[i];
}
}
}
}
mesh.aabb.create(min, max);
mesh.CreateRenderData();
model.meshes.insert(meshEntity);
//if (!armatureArray.empty() && hasBoneIndices && hasBoneWeights)
//{
// mesh->armature = armatureArray[0]; // How to resolve?
// mesh->armatureName = mesh->armature->name;
//}
}
}
else if (node->camera >= 0)
{
if (node->name.empty())
{
static int camID = 0;
stringstream ss("");
ss << "cam" << camID++;
node->name = ss.str();
}
entity = scene.Entity_CreateCamera(node->name, (float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y, 0.1f, 800);
model.cameras.insert(entity);
}
if (entity == INVALID_ENTITY)
{
entity = CreateEntity();
scene.transforms.Create(entity);
}
TransformComponent& transform = *scene.transforms.GetComponent(entity);
if (!node->scale.empty())
{
transform.scale_local = XMFLOAT3((float)node->scale[0], (float)node->scale[1], (float)node->scale[2]);
}
if (!node->rotation.empty())
{
transform.rotation_local = XMFLOAT4((float)node->rotation[0], (float)node->rotation[1], (float)node->rotation[2], (float)node->rotation[3]);
}
if (!node->translation.empty())
{
transform.translation_local = XMFLOAT3((float)node->translation[0], (float)node->translation[1], (float)node->translation[2]);
}
transform.UpdateTransform();
if (parent != INVALID_ENTITY)
{
scene.Component_Attach(entity, parent);
}
if (!node->children.empty())
{
for (int child : node->children)
{
LoadNode(&gltfModel.nodes[child], entity, modelEntity, gltfModel, materialArray, meshArray, armatureArray);
}
}
}
Entity ImportModel_GLTF(const std::string& fileName)
{
string directory, name;
wiHelper::SplitPath(fileName, directory, name);
string extension = wiHelper::toUpper(wiHelper::GetExtensionFromFileName(name));
wiHelper::RemoveExtensionFromFileName(name);
tinygltf::Model gltfModel;
tinygltf::TinyGLTF loader;
std::string err;
std::string warn;
loader.SetImageLoader(tinygltf::LoadImageData, nullptr);
loader.SetImageWriter(tinygltf::WriteImageData, nullptr);
bool ret;
if (!extension.compare("GLTF"))
{
ret = loader.LoadASCIIFromFile(&gltfModel, &err, &warn, fileName);
}
else
{
ret = loader.LoadBinaryFromFile(&gltfModel, &err, &warn, fileName); // for binary glTF(.glb)
}
if (!ret) {
wiHelper::messageBox(err, "GLTF error!");
return INVALID_ENTITY;
}
vector<Entity> materialArray;
vector<Entity> armatureArray;
vector<Entity> meshArray;
Scene& scene = wiRenderer::GetScene();
Entity modelEntity = scene.Entity_CreateModel(name);
ModelComponent& model = *scene.models.GetComponent(modelEntity);
TransformComponent& model_transform = *scene.transforms.GetComponent(modelEntity);
model_transform.UpdateTransform(); // everything will be attached to this, so values need to be up to date
for (auto& x : gltfModel.materials)
{
Entity materialEntity = scene.Entity_CreateMaterial(x.name);
materialArray.push_back(materialEntity);
MaterialComponent& material = *scene.materials.GetComponent(materialEntity);
material.baseColor = XMFLOAT4(1, 1, 1, 1);
material.roughness = 1.0f;
material.metalness = 1.0f;
material.reflectance = 0.02f;
material.emissive = 0;
auto& baseColorTexture = x.values.find("baseColorTexture");
auto& metallicRoughnessTexture = x.values.find("metallicRoughnessTexture");
auto& normalTexture = x.additionalValues.find("normalTexture");
auto& emissiveTexture = x.additionalValues.find("emissiveTexture");
auto& occlusionTexture = x.additionalValues.find("occlusionTexture");
auto& baseColorFactor = x.values.find("baseColorFactor");
auto& roughnessFactor = x.values.find("roughnessFactor");
auto& metallicFactor = x.values.find("metallicFactor");
auto& emissiveFactor = x.additionalValues.find("emissiveFactor");
auto& alphaCutoff = x.additionalValues.find("alphaCutoff");
if (baseColorTexture != x.values.end())
{
auto& tex = gltfModel.textures[baseColorTexture->second.TextureIndex()];
auto& img = gltfModel.images[tex.source];
RegisterTexture2D(&img);
material.baseColorMapName = img.name;
}
else if(!gltfModel.images.empty())
{
// For some reason, we don't have diffuse texture, but have other textures
// I have a problem, because one model viewer displays textures on a model which has no basecolor set in its material...
// This is probably not how it should be (todo)
RegisterTexture2D(&gltfModel.images[0]);
material.baseColorMapName = gltfModel.images[0].name;
}
tinygltf::Image* img_nor = nullptr;
tinygltf::Image* img_met_rough = nullptr;
tinygltf::Image* img_emissive = nullptr;
if (normalTexture != x.additionalValues.end())
{
auto& tex = gltfModel.textures[normalTexture->second.TextureIndex()];
img_nor = &gltfModel.images[tex.source];
}
if (metallicRoughnessTexture != x.values.end())
{
auto& tex = gltfModel.textures[metallicRoughnessTexture->second.TextureIndex()];
img_met_rough = &gltfModel.images[tex.source];
}
if (emissiveTexture != x.additionalValues.end())
{
auto& tex = gltfModel.textures[emissiveTexture->second.TextureIndex()];
img_emissive = &gltfModel.images[tex.source];
}
// Now we will begin interleaving texture data to match engine layout:
if (img_nor != nullptr)
{
uint32_t* data32_roughness = nullptr;
if (img_met_rough != nullptr && img_met_rough->width == img_nor->width && img_met_rough->height == img_nor->height)
{
data32_roughness = (uint32_t*)img_met_rough->image.data();
}
else if (img_met_rough != nullptr)
{
wiBackLog::post("[gltf] Warning: there is a normalmap and roughness texture, but not the same size! Roughness will not be baked in!");
}
// Convert normal map:
uint32_t* data32 = (uint32_t*)img_nor->image.data();
for (int i = 0; i < img_nor->width * img_nor->height; ++i)
{
uint32_t pixel = data32[i];
float r = ((pixel >> 0) & 255) / 255.0f;
float g = ((pixel >> 8) & 255) / 255.0f;
float b = ((pixel >> 16) & 255) / 255.0f;
float a = ((pixel >> 24) & 255) / 255.0f;
// swap normal y direction:
g = 1 - g;
// reset roughness:
a = 1;
if (data32_roughness != nullptr)
{
// add roughness from texture (G):
a = ((data32_roughness[i] >> 8) & 255) / 255.0f;
a = max(1.0f / 255.0f, a); // disallow 0 roughness (but is it really a good idea to do it here???)
}
uint32_t rgba8 = 0;
rgba8 |= (uint32_t)(r * 255.0f) << 0;
rgba8 |= (uint32_t)(g * 255.0f) << 8;
rgba8 |= (uint32_t)(b * 255.0f) << 16;
rgba8 |= (uint32_t)(a * 255.0f) << 24;
data32[i] = rgba8;
}
RegisterTexture2D(img_nor);
material.normalMapName = img_nor->name;
}
if (img_met_rough != nullptr)
{
uint32_t* data32_emissive = nullptr;
if (img_emissive != nullptr && img_emissive->width == img_met_rough->width && img_emissive->height == img_met_rough->height)
{
data32_emissive = (uint32_t*)img_emissive->image.data();
}
uint32_t* data32 = (uint32_t*)img_met_rough->image.data();
for (int i = 0; i < img_met_rough->width * img_met_rough->height; ++i)
{
uint32_t pixel = data32[i];
float r = ((pixel >> 0) & 255) / 255.0f;
float g = ((pixel >> 8) & 255) / 255.0f;
float b = ((pixel >> 16) & 255) / 255.0f;
float a = ((pixel >> 24) & 255) / 255.0f;
float reflectance = 1;
float metalness = b;
float emissive = 0;
float sss = 1;
if (data32_emissive != nullptr)
{
// add emissive from texture (R):
// (Currently only supporting single channel emissive)
emissive = ((data32_emissive[i] >> 0) & 255) / 255.0f;
}
uint32_t rgba8 = 0;
rgba8 |= (uint32_t)(reflectance * 255.0f) << 0;
rgba8 |= (uint32_t)(metalness * 255.0f) << 8;
rgba8 |= (uint32_t)(emissive * 255.0f) << 16;
rgba8 |= (uint32_t)(sss * 255.0f) << 24;
data32[i] = rgba8;
}
RegisterTexture2D(img_met_rough);
material.surfaceMapName = img_met_rough->name;
}
else if (img_emissive != nullptr)
{
// No metalness texture, just emissive...
uint32_t* data32 = (uint32_t*)img_emissive->image.data();
if (data32 != nullptr)
{
for (int i = 0; i < img_emissive->width * img_emissive->height; ++i)
{
uint32_t pixel = data32[i];
float r = ((pixel >> 0) & 255) / 255.0f;
float g = ((pixel >> 8) & 255) / 255.0f;
float b = ((pixel >> 16) & 255) / 255.0f;
float a = ((pixel >> 24) & 255) / 255.0f;
float reflectance = 1;
float metalness = 1;
float emissive = r;
float sss = 1;
uint32_t rgba8 = 0;
rgba8 |= (uint32_t)(reflectance * 255.0f) << 0;
rgba8 |= (uint32_t)(metalness * 255.0f) << 8;
rgba8 |= (uint32_t)(emissive * 255.0f) << 16;
rgba8 |= (uint32_t)(sss * 255.0f) << 24;
data32[i] = rgba8;
}
RegisterTexture2D(img_emissive);
material.surfaceMapName = img_emissive->name;
}
}
// Retrieve textures by name:
if (!material.baseColorMapName.empty())
material.baseColorMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material.baseColorMapName);
if (!material.normalMapName.empty())
material.normalMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material.normalMapName);
if (!material.surfaceMapName.empty())
material.surfaceMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material.surfaceMapName);
if (baseColorFactor != x.values.end())
{
material.baseColor.x = static_cast<float>(baseColorFactor->second.ColorFactor()[0]);
material.baseColor.y = static_cast<float>(baseColorFactor->second.ColorFactor()[1]);
material.baseColor.z = static_cast<float>(baseColorFactor->second.ColorFactor()[2]);
}
if (roughnessFactor != x.values.end())
{
material.roughness = static_cast<float>(roughnessFactor->second.Factor());
}
if (metallicFactor != x.values.end())
{
material.metalness = static_cast<float>(metallicFactor->second.Factor());
}
if (emissiveFactor != x.additionalValues.end())
{
material.emissive = static_cast<float>(emissiveFactor->second.ColorFactor()[0]);
}
if (alphaCutoff != x.additionalValues.end())
{
material.alphaRef = 1 - static_cast<float>(alphaCutoff->second.Factor());
}
}
//for(auto& skin : gltfModel.skins)
//{
// Armature* armature = new Armature(skin.name);
// model->armatures.insert(armature);
// armatureArray.push_back(armature);
// const tinygltf::Node& skeleton_node = gltfModel.nodes[skin.skeleton];
// const size_t jointCount = skin.joints.size();
// armature->boneCollection.resize(jointCount);
// // Create bone collection:
// for (size_t i = 0; i < jointCount; ++i)
// {
// int jointIndex = skin.joints[i];
// const tinygltf::Node& joint_node = gltfModel.nodes[jointIndex];
// Bone* bone = new Bone(joint_node.name);
// if (bone->name.empty())
// {
// // GLTF might not contain bone names...
// stringstream ss("");
// ss << "Bone_" << i;
// bone->name = ss.str();
// }
// armature->boneCollection[i] = bone;
// if (!joint_node.scale.empty())
// {
// bone->scale_rest = XMFLOAT3((float)joint_node.scale[0], (float)joint_node.scale[1], (float)joint_node.scale[2]);
// }
// if (!joint_node.rotation.empty())
// {
// bone->rotation_rest = XMFLOAT4((float)joint_node.rotation[0], (float)joint_node.rotation[1], (float)joint_node.rotation[2], (float)joint_node.rotation[3]);
// }
// if (!joint_node.translation.empty())
// {
// bone->translation_rest = XMFLOAT3((float)joint_node.translation[0], (float)joint_node.translation[1], (float)joint_node.translation[2]);
// }
// XMVECTOR s = XMLoadFloat3(&bone->scale_rest);
// XMVECTOR r = XMLoadFloat4(&bone->rotation_rest);
// XMVECTOR t = XMLoadFloat3(&bone->translation_rest);
// XMMATRIX w =
// XMMatrixScalingFromVector(s)*
// XMMatrixRotationQuaternion(r)*
// XMMatrixTranslationFromVector(t)
// ;
// XMStoreFloat4x4(&bone->world_rest, w);
// }
// // Create bone name hierarchy:
// for (size_t i = 0; i < jointCount; ++i)
// {
// int jointIndex = skin.joints[i];
// const tinygltf::Node& joint_node = gltfModel.nodes[jointIndex];
// for (int childJointIndex : joint_node.children)
// {
// for (size_t j = 0; j < jointCount; ++j)
// {
// if (skin.joints[j] == childJointIndex)
// {
// armature->boneCollection[j]->parentName = armature->boneCollection[i]->name;
// break;
// }
// }
// }
// }
// if (transform_to_LH)
// {
// XMStoreFloat4x4(&armature->skinningRemap, XMMatrixScaling(1, 1, -1));
// }
// // Final hierarchy and extra matrices created here:
// armature->CreateFamily();
//}
const tinygltf::Scene &gltfScene = gltfModel.scenes[gltfModel.defaultScene];
for (size_t i = 0; i < gltfScene.nodes.size(); i++)
{
LoadNode(&gltfModel.nodes[gltfScene.nodes[i]], INVALID_ENTITY, modelEntity, gltfModel, materialArray, meshArray, armatureArray);
}
//int animID = 0;
//for (auto& anim : gltfModel.animations)
//{
// if (armatureArray.empty())
// {
// break;
// }
// Armature* armature = armatureArray[0];
// for (Bone* bone : armature->boneCollection)
// {
// bone->actionFrames.push_back(ActionFrames());
// }
// Action action;
// action.name = anim.name;
// if (action.name.empty())
// {
// stringstream ss("");
// ss << "Action_" << animID++;
// action.name = ss.str();
// }
// for (auto& channel : anim.channels)
// {
// const tinygltf::Node& target_node = gltfModel.nodes[channel.target_node];
// const tinygltf::AnimationSampler& sam = anim.samplers[channel.sampler];
// Bone* bone = nullptr;
// // Search for the armature + bone this animation belongs to:
// {
// const auto& skin = gltfModel.skins[0];
// const size_t jointCount = skin.joints.size();
// assert(armature->boneCollection.size() == jointCount);
// for (size_t i = 0; i < jointCount; ++i)
// {
// int jointIndex = skin.joints[i];
// if (jointIndex == channel.target_node)
// {
// bone = armature->boneCollection[i];
// break;
// }
// }
// }
// if (bone == nullptr)
// {
// assert(0 && "Corresponding bone not found!");
// continue;
// }
// vector<KeyFrame> keyframes;
// // AnimationSampler input = keyframe times
// {
// const tinygltf::Accessor& accessor = gltfModel.accessors[sam.input];
// const tinygltf::BufferView& bufferView = gltfModel.bufferViews[accessor.bufferView];
// const tinygltf::Buffer& buffer = gltfModel.buffers[bufferView.buffer];
// assert(accessor.componentType == TINYGLTF_COMPONENT_TYPE_FLOAT);
// int stride = accessor.ByteStride(bufferView);
// size_t count = accessor.count;
// keyframes.resize(count);
// const unsigned char* data = buffer.data.data() + accessor.byteOffset + bufferView.byteOffset;
// int firstFrame = INT_MAX;
// assert(stride == 4);
// for (size_t i = 0; i < count; ++i)
// {
// keyframes[i].frameI = (int)(((float*)data)[i] * 60); // !!! converting from time-base to frame-based !!!
// action.frameCount = max(action.frameCount, keyframes[i].frameI);
// firstFrame = min(firstFrame, keyframes[i].frameI);
// }
// // Cut out the empty part of the animation at the beginning:
// firstFrame = min(firstFrame, action.frameCount);
// for (size_t i = 0; i < count; ++i)
// {
// keyframes[i].frameI -= firstFrame;
// }
// action.frameCount -= firstFrame;
// }
// // AnimationSampler output = keyframe data
// {
// const tinygltf::Accessor& accessor = gltfModel.accessors[sam.output];
// const tinygltf::BufferView& bufferView = gltfModel.bufferViews[accessor.bufferView];
// const tinygltf::Buffer& buffer = gltfModel.buffers[bufferView.buffer];
// int stride = accessor.ByteStride(bufferView);
// size_t count = accessor.count;
// // Unfortunately, GLTF stores absolute values for animation nodes, but the engine needs relative
// // Absolute = animation * rest (so the rest matrix is baked into animation, this can't be blended like we do now)
// // Relative = animation (so we can blend all animation tracks however we want, then post multiply with the rest matrix after blending)
// const XMMATRIX invRest = XMMatrixInverse(nullptr, XMLoadFloat4x4(&bone->world_rest));
// const unsigned char* data = buffer.data.data() + accessor.byteOffset + bufferView.byteOffset;
// if (!channel.target_path.compare("scale"))
// {
// assert(stride == sizeof(XMFLOAT3));
// for (size_t i = 0; i < count; ++i)
// {
// const XMFLOAT3& sca = ((XMFLOAT3*)data)[i];
// //keyframes[i].data = XMFLOAT4(sca.x, sca.y, sca.z, 0);
// // Remove rest matrix from animation track:
// XMMATRIX mat = XMMatrixScalingFromVector(XMLoadFloat3(&sca));
// mat = mat * invRest;
// XMVECTOR s, r, t;
// XMMatrixDecompose(&s, &r, &t, mat);
// XMStoreFloat4(&keyframes[i].data, s);
// }
// bone->actionFrames.back().keyframesSca.insert(bone->actionFrames.back().keyframesSca.end(), keyframes.begin(), keyframes.end());
// }
// else if (!channel.target_path.compare("rotation"))
// {
// assert(stride == sizeof(XMFLOAT4));
// for (size_t i = 0; i < count; ++i)
// {
// const XMFLOAT4& rot = ((XMFLOAT4*)data)[i];
// //keyframes[i].data = rot;
// // Remove rest matrix from animation track:
// XMMATRIX mat = XMMatrixRotationQuaternion(XMLoadFloat4(&rot));
// mat = mat * invRest;
// XMVECTOR s, r, t;
// XMMatrixDecompose(&s, &r, &t, mat);
// XMStoreFloat4(&keyframes[i].data, r);
// }
// bone->actionFrames.back().keyframesRot.insert(bone->actionFrames.back().keyframesRot.end(), keyframes.begin(), keyframes.end());
// }
// else if (!channel.target_path.compare("translation"))
// {
// assert(stride == sizeof(XMFLOAT3));
// for (size_t i = 0; i < count; ++i)
// {
// const XMFLOAT3& tra = ((XMFLOAT3*)data)[i];
// //keyframes[i].data = XMFLOAT4(tra.x, tra.y, tra.z, 1);
// // Remove rest matrix from animation track:
// XMMATRIX mat = XMMatrixTranslationFromVector(XMLoadFloat3(&tra));
// mat = mat * invRest;
// XMVECTOR s, r, t;
// XMMatrixDecompose(&s, &r, &t, mat);
// XMStoreFloat4(&keyframes[i].data, t);
// }
// bone->actionFrames.back().keyframesPos.insert(bone->actionFrames.back().keyframesPos.end(), keyframes.begin(), keyframes.end());
// }
// else
// {
// assert(0);
// }
// }
// }
// armature->actions.push_back(action);
//}
//model->FinishLoading();
return modelEntity;
}
Reference in New Issue View Git Blame Copy Permalink