void ezJSONWriter::AddVariableMat4(const char* szName, const ezMat4& value)
{
BeginVariable(szName);
WriteMat4(value);
EndVariable();
}
void ezJSONWriter::WriteVariant(const ezVariant& value)
{
switch (value.GetType())
{
case ezVariant::Type::Invalid:
//EZ_REPORT_FAILURE("Variant of Type 'Invalid' cannot be written as JSON.");
WriteNULL();
return;
case ezVariant::Type::Bool:
WriteBool(value.Get<bool>());
return;
case ezVariant::Type::Int8:
WriteInt32(value.Get<ezInt8>());
return;
case ezVariant::Type::UInt8:
WriteUInt32(value.Get<ezUInt8>());
return;
case ezVariant::Type::Int16:
WriteInt32(value.Get<ezInt16>());
return;
case ezVariant::Type::UInt16:
WriteUInt32(value.Get<ezUInt16>());
return;
case ezVariant::Type::Int32:
WriteInt32(value.Get<ezInt32>());
return;
case ezVariant::Type::UInt32:
WriteUInt32(value.Get<ezUInt32>());
return;
case ezVariant::Type::Int64:
WriteInt64(value.Get<ezInt64>());
return;
case ezVariant::Type::UInt64:
WriteUInt64(value.Get<ezUInt64>());
return;
case ezVariant::Type::Float:
WriteFloat(value.Get<float>());
return;
case ezVariant::Type::Double:
WriteDouble(value.Get<double>());
return;
case ezVariant::Type::Color:
WriteColor(value.Get<ezColor>());
return;
case ezVariant::Type::Vector2:
WriteVec2(value.Get<ezVec2>());
return;
case ezVariant::Type::Vector3:
WriteVec3(value.Get<ezVec3>());
return;
case ezVariant::Type::Vector4:
WriteVec4(value.Get<ezVec4>());
return;
case ezVariant::Type::Quaternion:
WriteQuat(value.Get<ezQuat>());
return;
case ezVariant::Type::Matrix3:
WriteMat3(value.Get<ezMat3>());
return;
case ezVariant::Type::Matrix4:
WriteMat4(value.Get<ezMat4>());
return;
case ezVariant::Type::String:
WriteString(value.Get<ezString>().GetData());
return;
case ezVariant::Type::Time:
WriteTime(value.Get<ezTime>());
return;
case ezVariant::Type::Uuid:
WriteUuid(value.Get<ezUuid>());
return;
default:
break;
}
EZ_REPORT_FAILURE("The Variant Type %i is not supported by ezJSONWriter::WriteVariant.", value.GetType());
}
void ObjectWriter::Write(std::string file_name) {
out.open((model_output_path + file_name).c_str(), std::ios::binary);
// Write Object Name
WriteUInt(object_name.size());
WriteString(object_name);
// Write Basic Transformation
std::vector<EG::Game::ObjectAttribute *> *transformation_attributes = object->GetAttributesByType(EG::Game::ObjectAttribute::OBJECT_ATTRIBUTE_BASIC_TRANSFORMATION);
EG::Game::ObjectAttributeBasicTransformation *transformation_attribute = static_cast<EG::Game::ObjectAttributeBasicTransformation *>(transformation_attributes->at(0));
WriteMat4(transformation_attribute->GetTransformation());
// Mesh/Material Attributes
std::vector<EG::Game::ObjectAttribute *> *mesh_attributes = object->GetAttributesByType(EG::Game::ObjectAttribute::OBJECT_ATTRIBUTE_RENDERING_MESH);
std::vector<EG::Game::ObjectAttribute *>::iterator mesh_attribute_iterator = mesh_attributes->begin();
WriteUInt(mesh_attributes->size());
while (mesh_attribute_iterator != mesh_attributes->end()){
EG::Game::ObjectAttributeRenderingMesh *mesh_attribute = static_cast<EG::Game::ObjectAttributeRenderingMesh *>(*mesh_attribute_iterator);
EG::Graphics::RenderingMaterial *material = mesh_attribute->GetMaterial();
EG::Graphics::Mesh *mesh = scene->GetMeshManager()->Get(mesh_attribute->GetMeshId());
// Material
if (material->HasTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_DECAL)) {
EG::Graphics::Texture *texture = scene->GetTextureManager()->GetTexture(material->GetTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_DECAL));
std::string image_out_path = (images_output_path + EG::Utility::StringMethods::GetFilenameFromPath(texture->GetFilePath()));
CopyFile(texture->GetFilePath(), image_out_path.c_str());
WriteBool(true);
WriteUInt(image_out_path.size());
WriteString(image_out_path);
}else{
WriteBool(false);
}
if (material->HasTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_NORMAL)){
EG::Graphics::Texture *texture = scene->GetTextureManager()->GetTexture(material->GetTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_NORMAL));
std::string image_out_path = (images_output_path + EG::Utility::StringMethods::GetFilenameFromPath(texture->GetFilePath()));
CopyFile(texture->GetFilePath(), image_out_path.c_str());
WriteBool(true);
WriteUInt(image_out_path.size());
WriteString(image_out_path);
}else{
WriteBool(false);
}
if (material->HasTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_HEIGHT)){
EG::Graphics::Texture *texture = scene->GetTextureManager()->GetTexture(material->GetTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_HEIGHT));
std::string image_out_path = (images_output_path + EG::Utility::StringMethods::GetFilenameFromPath(texture->GetFilePath()));
CopyFile(texture->GetFilePath(), image_out_path.c_str());
WriteBool(true);
WriteUInt(image_out_path.size());
WriteString(image_out_path);
}else{
WriteBool(false);
}
if (material->HasTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_SPECULAR)){
EG::Graphics::Texture *texture = scene->GetTextureManager()->GetTexture(material->GetTexture(EG::Graphics::RenderingMaterial::RENDERING_MATERIAL_TEXTURE_SPECULAR));
std::string image_out_path = (images_output_path + EG::Utility::StringMethods::GetFilenameFromPath(texture->GetFilePath()));
CopyFile(texture->GetFilePath(), image_out_path.c_str());
WriteBool(true);
WriteUInt(image_out_path.size());
WriteString(image_out_path);
}else{
WriteBool(false);
}
if (material->GetLit()){
WriteBool(true);
}else{
WriteBool(false);
}
if (material->GetCastsShadows()){
WriteBool(true);
}else{
WriteBool(false);
}
if (material->GetTranslucent()){
WriteBool(true);
}else{
WriteBool(false);
}
WriteFloat(material->GetAmbient());
WriteFloat(material->GetDiffuse());
WriteFloat(material->GetSpecular());
WriteFloat(material->GetSpecularExponent());
WriteVec4(material->GetColor());
// Mesh
WriteUInt(mesh_attribute->GetMeshId().size());
WriteString(mesh_attribute->GetMeshId());
WriteUInt(mesh->GetVertexCount());
WriteUInt(mesh->GetStride());
if (mesh->HasVertices()){
WriteBool(true);
float *d = mesh->GetVertices();
WriteFloatV(d, mesh->GetVertexCount() * 4);
} else {
WriteBool(false);
}
if (mesh->HasNormals()){
WriteBool(true);
float *d = mesh->GetNormals();
WriteFloatV(d, mesh->GetVertexCount() * 4);
} else {
WriteBool(false);
}
if (mesh->HasTexCoords()){
WriteBool(true);
float *d = mesh->GetTexCoords();
WriteFloatV(d, mesh->GetVertexCount() * 4);
} else {
WriteBool(false);
}
if (mesh->HasBinormals()){
WriteBool(true);
float *d = mesh->GetBinormals();
WriteFloatV(d, mesh->GetVertexCount() * 4);
} else {
WriteBool(false);
}
if (mesh->HasBitangents()){
WriteBool(true);
float *d = mesh->GetBitangents();
WriteFloatV(d, mesh->GetVertexCount() * 4);
} else {
WriteBool(false);
}
if (mesh->HasSkeleton()) {
WriteBool(true);
float *d = mesh->GetWeights();
WriteFloatV(d, mesh->GetVertexCount() * 4);
float *di = mesh->GetWeightVertexIndices();
WriteFloatV(di, mesh->GetVertexCount() * 4);
} else {
WriteBool(false);
}
// Animations
if (object->HasAttributesOfType(EG::Game::ObjectAttribute::OBJECT_ATTRIBUTE_CONTROL_ANIMATION)) {
WriteBool(true); // Has Animations
EG::Game::ObjectAttributeControlAnimationState *animation_attribute = static_cast<EG::Game::ObjectAttributeControlAnimationState *>(object->GetAttributesByType(EG::Game::ObjectAttribute::OBJECT_ATTRIBUTE_CONTROL_ANIMATION)->at(0));
EG::Dynamics::AnimationState *animation_state = animation_attribute->GetAnimationState();
EG::Dynamics::Animations *animations = animation_state->GetAnimations();
// Bind Pose Skeleton
EG::Dynamics::Skeleton *bind_pose = animations->GetBindPose();
std::map<unsigned int, EG::Dynamics::Bone *> *bones = bind_pose->GetBoneMap();
unsigned int bone_count = bind_pose->GetBones()->size();
WriteUInt(bone_count);
for (unsigned int i = 0; i < bone_count; i++) {
EG::Dynamics::Bone *bone = (*bones)[i];
WriteUInt(i); // Bone ID
if (bone->GetParent() != NULL) {
WriteUInt(bone->GetParent()->GetId());
} else {
WriteUInt(99999);
}
WriteMat4(bone->GetOffset());
}
// Animations
std::vector<std::string> animation_names = animations->GetAnimationNames();
WriteUInt(animation_names.size());
std::vector<std::string>::iterator aiter = animation_names.begin();
while (aiter != animation_names.end()) {
// Animation
std::string animation_name = (*aiter);
EG::Dynamics::Animation *animation = animations->Get(animation_name);
// Animation Name
WriteUInt(animation_name.size());
WriteString(animation_name);
WriteFloat(animation->GetDuration());
WriteUInt(animation->GetBoneCount());
std::map<unsigned int, std::vector<std::pair<float, glm::vec3> > > *positions = animation->GetPositions();
std::map<unsigned int, std::vector<std::pair<float, glm::vec3> > > *scalings = animation->GetScalings();
std::map<unsigned int, std::vector<std::pair<float, glm::quat> > > *rotations = animation->GetRotations();
for (unsigned int i = 0; i < animation->GetBoneCount(); i++) {
WriteUInt(i); // Bone ID
std::vector<std::pair<float, glm::vec3> > p = (*positions)[i];
std::vector<std::pair<float, glm::vec3> > s = (*scalings)[i];
std::vector<std::pair<float, glm::quat> > r = (*rotations)[i];
// Write Positions
WriteUInt(p.size());
for (unsigned int j = 0; j < p.size(); j++) {
WriteFloat(p[j].first);
WriteVec3(p[j].second);
}
// Write Scalings
WriteUInt(s.size());
for (unsigned int j = 0; j < s.size(); j++) {
WriteFloat(s[j].first);
WriteVec3(s[j].second);
}
// Write Rotations
WriteUInt(r.size());
for (unsigned int j = 0; j < r.size(); j++) {
WriteFloat(r[j].first);
WriteQuat(r[j].second);
}
}
++aiter;
}
} else {
WriteBool(false);
}
// Lights
// Particle Systems?
++mesh_attribute_iterator;
}
out.close();
}
