420 lines
11 KiB
C++
420 lines
11 KiB
C++
#include "GeneralLoader.h"
|
|
#include "../Definitions/GraphicalDefinition.h"
|
|
#include "../Model/ModelInfo.h"
|
|
#include "../Core/Core.h"
|
|
#include <fstream>
|
|
#include <string>
|
|
|
|
#define DANFILEVERSIONMAJOR 1
|
|
#define DANFILEVERSIONMINOR 1
|
|
|
|
#define FILEHEADERSIZE 8
|
|
#define VERTEXHEADERSIZE 4
|
|
#define VERTEXSIZE 88
|
|
|
|
|
|
|
|
///
|
|
enum HeaderType
|
|
{
|
|
VERTEXHEADER = 0, ///<
|
|
INDEXHEADER = 1, ///<
|
|
MATERIALHEADER = 2, ///<
|
|
SKELETONHEADER = 3, ///<
|
|
ANIMATIONHEADER = 4 ///<
|
|
};
|
|
|
|
///
|
|
struct FileHeader
|
|
{
|
|
unsigned int versionMajor; ///<
|
|
unsigned int versionMinor; ///<
|
|
|
|
///
|
|
FileHeader(char* data)
|
|
{
|
|
char* memPos = data; //
|
|
|
|
memcpy(&versionMajor, memPos, sizeof(unsigned int));
|
|
memPos += 4;
|
|
memcpy(&versionMinor, memPos, sizeof(unsigned int));
|
|
}
|
|
};
|
|
|
|
///
|
|
struct VertexHeader
|
|
{
|
|
unsigned int numVertices;
|
|
|
|
///
|
|
VertexHeader(char* data)
|
|
{
|
|
memcpy(&numVertices, data, sizeof(unsigned int));
|
|
}
|
|
};
|
|
|
|
///
|
|
typedef Oyster::Graphics::Definitions::FinalVertex Vertex;
|
|
|
|
///
|
|
struct IndexHeader
|
|
{
|
|
unsigned int numIndices;
|
|
|
|
///
|
|
IndexHeader(char* data)
|
|
{
|
|
memcpy(&numIndices, data, sizeof(unsigned int));
|
|
}
|
|
};
|
|
|
|
///
|
|
struct MaterialHeader
|
|
{
|
|
unsigned int diffuseMapPathLength;
|
|
char* diffuseMapPath;
|
|
|
|
unsigned int normalMapPathLength;
|
|
char* normalMapPath;
|
|
/*
|
|
///
|
|
MaterialHeader(char* data)
|
|
{
|
|
char* memPos = data; //
|
|
|
|
memcpy(&diffuseMapPathLength, memPos, sizeof(unsigned int));
|
|
memPos += 4;
|
|
|
|
diffuseMapPath = new char[diffuseMapPathLength];
|
|
memcpy(diffuseMapPath, memPos, diffuseMapPathLength);
|
|
memPos += diffuseMapPathLength;
|
|
|
|
memcpy(&normalMapPathLength, memPos, sizeof(unsigned int));
|
|
memPos += 4;
|
|
|
|
normalMapPath = new char[normalMapPathLength];
|
|
memcpy(normalMapPath, memPos, normalMapPathLength);
|
|
memPos += normalMapPathLength;
|
|
}
|
|
*/
|
|
};
|
|
|
|
///
|
|
struct SkeletonHeader
|
|
{
|
|
unsigned int numBones;
|
|
|
|
///
|
|
SkeletonHeader(char* data)
|
|
{
|
|
memcpy(&numBones, data, sizeof(unsigned int));
|
|
}
|
|
};
|
|
|
|
///
|
|
struct AnimationHeader
|
|
{
|
|
unsigned int numAnims;
|
|
|
|
|
|
AnimationHeader(char* data)
|
|
{
|
|
memcpy(&numAnims, data, sizeof(unsigned int));
|
|
}
|
|
};
|
|
|
|
///
|
|
void Oyster::Graphics::Loading::UnloadDAN(void* data)
|
|
{
|
|
Model::ModelInfo* info = (Model::ModelInfo*) data;
|
|
SAFE_DELETE(info->Vertices);
|
|
if(info->Indexed)
|
|
{
|
|
SAFE_DELETE(info->Indecies);
|
|
}
|
|
if(info->Animated)
|
|
{
|
|
//clean animation
|
|
delete[] info->bones;
|
|
for(int a = 0; a < info->AnimationCount; ++a)
|
|
{
|
|
for(int x = 0; x < info->Animations[a].Bones; ++x)
|
|
{
|
|
delete[] info->Animations[a].Keyframes[x];
|
|
}
|
|
delete[] info->Animations[a].Frames;
|
|
delete[] info->Animations[a].Keyframes;
|
|
}
|
|
delete[] info->Animations;
|
|
}
|
|
for(int i =0;i<info->Material.size();++i)
|
|
{
|
|
Core::loader.ReleaseResource(info->Material[i]);
|
|
}
|
|
delete info;
|
|
}
|
|
|
|
static wchar_t* charToWChar(const char* text)
|
|
{
|
|
// Convert to a wchar_t*
|
|
size_t origsize = strlen(text) + 1;
|
|
size_t convertedChars = 0;
|
|
wchar_t* wcstring = new wchar_t[origsize];
|
|
mbstowcs_s(&convertedChars, wcstring, origsize, text, _TRUNCATE);
|
|
return wcstring;
|
|
}
|
|
|
|
static void ReadData(void* Destination, std::ifstream& file, int size)
|
|
{
|
|
char* buffer = new char[size];
|
|
file.read(buffer,size);
|
|
memcpy(Destination,buffer,size);
|
|
delete[] buffer;
|
|
}
|
|
|
|
///
|
|
void* Oyster::Graphics::Loading::LoadDAN(const wchar_t filename[])
|
|
{
|
|
//
|
|
Oyster::Graphics::Model::ModelInfo* modelInfo = new Oyster::Graphics::Model::ModelInfo();
|
|
modelInfo->Indexed = false;
|
|
modelInfo->Animated = false;
|
|
// Open file in binary mode
|
|
std::ifstream danFile;
|
|
danFile.open(filename, std::ios::binary);
|
|
if (!danFile.is_open())
|
|
return NULL;
|
|
|
|
// Read file header
|
|
char* buffer = new char[sizeof(FileHeader)];
|
|
danFile.read(buffer, sizeof(FileHeader));
|
|
FileHeader fileHeader(buffer);
|
|
delete[] buffer; // ( note: may crash here.)
|
|
|
|
// If problem with compatability then close file and return from method
|
|
if (fileHeader.versionMajor != DANFILEVERSIONMAJOR)
|
|
{
|
|
danFile.close();
|
|
return NULL;
|
|
}
|
|
|
|
// Read the .dan-file
|
|
while (!danFile.eof())
|
|
{
|
|
// read header type
|
|
unsigned int headerType;
|
|
ReadData(&headerType,danFile,4);
|
|
|
|
// handle header type
|
|
switch ((HeaderType)headerType)
|
|
{
|
|
// vertex header
|
|
case HeaderType::VERTEXHEADER:
|
|
{
|
|
// Fetch vertex header, number of vertices
|
|
buffer = new char[4];
|
|
danFile.read(buffer, 4);
|
|
VertexHeader vertexHeader(buffer);
|
|
delete[] buffer; // ( note: may crash here.)
|
|
|
|
// Fetch all vertices
|
|
unsigned int bufferSize = VERTEXSIZE * vertexHeader.numVertices;
|
|
buffer = new char[bufferSize];
|
|
danFile.read(buffer, bufferSize);
|
|
|
|
// Do the deed
|
|
Oyster::Graphics::Core::Buffer* vertexBuffer = new Oyster::Graphics::Core::Buffer();
|
|
Oyster::Graphics::Core::Buffer::BUFFER_INIT_DESC bufferInitDesc;
|
|
bufferInitDesc.ElementSize = sizeof(Vertex);
|
|
bufferInitDesc.InitData = buffer;
|
|
bufferInitDesc.NumElements = vertexHeader.numVertices;
|
|
bufferInitDesc.Type = Oyster::Graphics::Core::Buffer::BUFFER_TYPE::VERTEX_BUFFER;
|
|
bufferInitDesc.Usage = Oyster::Graphics::Core::Buffer::BUFFER_USAGE::BUFFER_DEFAULT;
|
|
vertexBuffer->Init(bufferInitDesc);
|
|
modelInfo->VertexCount = vertexHeader.numVertices;
|
|
modelInfo->Vertices = vertexBuffer;
|
|
|
|
|
|
delete[] buffer; // ( note: may crash here.)
|
|
|
|
break;
|
|
}
|
|
case HeaderType::INDEXHEADER:
|
|
{
|
|
// Fetch vertex header, number of vertices
|
|
buffer = new char[4];
|
|
danFile.read(buffer, 4);
|
|
IndexHeader indexHeader(buffer);
|
|
delete[] buffer; // ( note: may crash here.)
|
|
|
|
// Fetch all indices
|
|
unsigned int* indices = new unsigned int[indexHeader.numIndices];
|
|
unsigned int bufferSize = sizeof(unsigned int) * indexHeader.numIndices;
|
|
|
|
|
|
ReadData(indices,danFile,bufferSize);
|
|
|
|
// Do the deed
|
|
Oyster::Graphics::Core::Buffer* indexBuffer = new Oyster::Graphics::Core::Buffer();
|
|
Oyster::Graphics::Core::Buffer::BUFFER_INIT_DESC bufferInitDesc;
|
|
bufferInitDesc.ElementSize = sizeof(unsigned int);
|
|
bufferInitDesc.InitData = indices;
|
|
bufferInitDesc.NumElements = indexHeader.numIndices;
|
|
bufferInitDesc.Type = Oyster::Graphics::Core::Buffer::BUFFER_TYPE::INDEX_BUFFER;
|
|
bufferInitDesc.Usage = Oyster::Graphics::Core::Buffer::BUFFER_USAGE::BUFFER_DEFAULT;
|
|
indexBuffer->Init(bufferInitDesc);
|
|
modelInfo->IndexCount = indexHeader.numIndices;
|
|
modelInfo->Indecies = indexBuffer;
|
|
modelInfo->Indexed = true;
|
|
|
|
delete[] indices; // ( note: may crash here.)
|
|
|
|
break;
|
|
}
|
|
// material header
|
|
case HeaderType::MATERIALHEADER:
|
|
{
|
|
// Fetch material header, 2 texture path strings
|
|
MaterialHeader materialHeader;
|
|
|
|
//read difuse map name length
|
|
ReadData(&materialHeader.diffuseMapPathLength,danFile,4);
|
|
|
|
//read diffuse map name
|
|
materialHeader.diffuseMapPath = new char[materialHeader.diffuseMapPathLength+1];
|
|
ReadData(materialHeader.diffuseMapPath,danFile,materialHeader.diffuseMapPathLength);
|
|
//null terminate
|
|
materialHeader.diffuseMapPath[materialHeader.diffuseMapPathLength] = 0;
|
|
|
|
//read normal map name length
|
|
ReadData(&materialHeader.normalMapPathLength,danFile,4);
|
|
|
|
//read difuse map name
|
|
materialHeader.normalMapPath = new char[materialHeader.normalMapPathLength + 1];
|
|
ReadData(materialHeader.normalMapPath,danFile,materialHeader.normalMapPathLength);
|
|
materialHeader.normalMapPath[materialHeader.normalMapPathLength] = 0;
|
|
|
|
//load diffuse map
|
|
wchar_t* path = charToWChar(materialHeader.diffuseMapPath);
|
|
ID3D11ShaderResourceView* diffuseMap = (ID3D11ShaderResourceView*)Core::loader.LoadResource((Core::texturePath + path).c_str(), Oyster::Graphics::Loading::LoadTexture, Oyster::Graphics::Loading::UnloadTexture);
|
|
delete[] path;
|
|
|
|
//load normal map
|
|
path = charToWChar(materialHeader.normalMapPath);
|
|
ID3D11ShaderResourceView* normalMap = (ID3D11ShaderResourceView*)Core::loader.LoadResource((Core::texturePath + path).c_str(), Oyster::Graphics::Loading::LoadTexture, Oyster::Graphics::Loading::UnloadTexture);
|
|
delete[] path;
|
|
|
|
//add to model
|
|
modelInfo->Material.push_back(diffuseMap);
|
|
modelInfo->Material.push_back(normalMap);
|
|
|
|
//clean up
|
|
delete[] materialHeader.diffuseMapPath;
|
|
delete[] materialHeader.normalMapPath;
|
|
|
|
break;
|
|
}
|
|
|
|
// skeleton header
|
|
case HeaderType::SKELETONHEADER:
|
|
{
|
|
// Fetch Skeleton header, number of Bones
|
|
buffer = new char[4];
|
|
danFile.read(buffer, 4);
|
|
SkeletonHeader skeletonHeader(buffer);
|
|
delete[] buffer; // ( note: may crash here.)
|
|
|
|
//array for bone data
|
|
Oyster::Graphics::Model::Bone* bones = new Oyster::Graphics::Model::Bone[skeletonHeader.numBones];
|
|
|
|
//read bones
|
|
ReadData(bones,danFile,skeletonHeader.numBones * sizeof(Oyster::Graphics::Model::Bone));
|
|
|
|
|
|
//read skeleton Hiarchy
|
|
|
|
modelInfo->BoneCount = skeletonHeader.numBones;
|
|
modelInfo->bones = bones;
|
|
|
|
break;
|
|
}
|
|
// animation header
|
|
case HeaderType::ANIMATIONHEADER:
|
|
{
|
|
//get num anims
|
|
buffer = new char[4];
|
|
danFile.read(buffer, 4);
|
|
AnimationHeader animationHeader(buffer);
|
|
delete[] buffer;
|
|
|
|
Oyster::Graphics::Model::Animation* anims = new Oyster::Graphics::Model::Animation[animationHeader.numAnims];
|
|
|
|
for(int a = 0; a < animationHeader.numAnims; ++a)
|
|
{
|
|
//read name of animation
|
|
int nameLength;
|
|
|
|
|
|
ReadData(&nameLength,danFile,4);
|
|
|
|
char* name = new char[nameLength + 1];
|
|
ReadData(name,danFile,nameLength);
|
|
name[nameLength] = 0;
|
|
|
|
wchar_t* wName = charToWChar(name);
|
|
anims[a].name = std::wstring(wName);
|
|
delete[] wName;
|
|
delete name;
|
|
|
|
//read nr of bones in animation
|
|
ReadData(&anims[a].Bones,danFile,4);
|
|
|
|
//read duration
|
|
ReadData(&anims[a].duration,danFile,8);
|
|
|
|
//create Frame array and Bone part of KeyFrameArray;
|
|
anims[a].Frames = new int[anims[a].Bones];
|
|
anims[a].Keyframes = new Oyster::Graphics::Model::Frame*[anims[a].Bones];
|
|
|
|
//loop per bone and gather data
|
|
for(int b = 0; b < anims[a].Bones; ++b)
|
|
{
|
|
|
|
//read bone index
|
|
int boneIndex;
|
|
ReadData(&boneIndex,danFile,4);
|
|
|
|
//read nr of frames per bone
|
|
ReadData(&anims[a].Frames[b],danFile,4);
|
|
|
|
//create frame matrix
|
|
anims[a].Keyframes[b] = new Oyster::Graphics::Model::Frame[anims[a].Frames[b]];
|
|
|
|
|
|
for(int f = 0; f < anims[a].Frames[b]; ++f)
|
|
{
|
|
//write index of bone
|
|
anims[a].Keyframes[b][f].bone.Parent = boneIndex;
|
|
|
|
//read bone transform
|
|
ReadData(&anims[a].Keyframes[b][f].bone.Relative, danFile, sizeof(Math::Matrix));
|
|
|
|
ReadData(&anims[a].Keyframes[b][f].time,danFile,sizeof(double));
|
|
}
|
|
}
|
|
}
|
|
modelInfo->AnimationCount = animationHeader.numAnims;
|
|
modelInfo->Animations = anims;
|
|
modelInfo->Animated = true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// close file
|
|
danFile.close();
|
|
|
|
// Set modelinfo as output data
|
|
return modelInfo;
|
|
} |