v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Code cleanup and some new unittests for edgecases.

pull/4705/head
Kim Kulling 2022-08-27 14:07:45 +02:00
parent 46e571e497
commit 14186bcd6b
4 changed files with 604 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

354
code/AssetLib/MMD/MMDPmdParser.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2022, assimp team Copyright (c) 2006-2022, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -48,19 +47,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <fstream> #include <fstream>
#include "MMDCpp14.h" #include "MMDCpp14.h"
namespace pmd namespace pmd {
{
class PmdHeader struct PmdHeader {
{
public:
std::string name; std::string name;
std::string name_english; std::string name_english;
std::string comment; std::string comment;
std::string comment_english; std::string comment_english;
bool Read(std::ifstream* stream) PmdHeader() = default;
{ ~PmdHeader() = default;
char buffer[256];
bool Read(std::ifstream *stream) {
if (stream == nullptr) {
return false;
}
char buffer[256] = {};
stream->read(buffer, 20); stream->read(buffer, 20);
name = std::string(buffer); name = std::string(buffer);
stream->read(buffer, 256); stream->read(buffer, 256);
@ -68,34 +70,39 @@ namespace pmd
return true; return true;
} }
bool ReadExtension(std::ifstream* stream) bool ReadExtension(std::ifstream *stream) {
{ if (stream == nullptr) {
char buffer[256]; return false;
}
char buffer[256] = {};
stream->read(buffer, 20); stream->read(buffer, 20);
name_english = std::string(buffer); name_english = std::string(buffer);
stream->read(buffer, 256); stream->read(buffer, 256);
comment_english = std::string(buffer); comment_english = std::string(buffer);
return true; return true;
} }
}; };
class PmdVertex struct PmdVertex {
{
public:
float position[3]; float position[3];
float normal[3]; float normal[3];
float uv[2]; float uv[2];
uint16_t bone_index[2]; uint16_t bone_index[2];
uint8_t bone_weight; uint8_t bone_weight;
bool edge_invisible; bool edge_invisible;
bool Read(std::ifstream* stream) PmdVertex() :
{ position{ 0.0f }, normal{ 0.0f }, uv{ 0.0f }, bone_index{ 0 }, bone_weight(0), edge_invisible(false) {}
~PmdVertex() = default;
bool Read(std::ifstream *stream) {
if (stream == nullptr) {
return false;
}
stream->read((char *)position, sizeof(float) * 3); stream->read((char *)position, sizeof(float) * 3);
stream->read((char *)normal, sizeof(float) * 3); stream->read((char *)normal, sizeof(float) * 3);
stream->read((char *)uv, sizeof(float) * 2); stream->read((char *)uv, sizeof(float) * 2);
@ -106,9 +113,7 @@ namespace pmd
} }
}; };
class PmdMaterial struct PmdMaterial {
{
public:
float diffuse[4]; float diffuse[4];
float power; float power;
float specular[3]; float specular[3];
@ -119,9 +124,18 @@ namespace pmd
std::string texture_filename; std::string texture_filename;
std::string sphere_filename; std::string sphere_filename;
bool Read(std::ifstream* stream) PmdMaterial() :
{ diffuse{ 0.0f }, power(0.0f), specular{ 0.0f }, ambient{ 0.0f }, toon_index(0), edge_flag(0), index_count(0), texture_filename(), sphere_filename() {}
char buffer[20];
~PmdMaterial() = default;
bool Read(std::ifstream *stream) {
if (stream == nullptr) {
return false;
}
constexpr size_t BufferSize = 20;
char buffer[BufferSize] = {};
stream->read((char *)&diffuse, sizeof(float) * 4); stream->read((char *)&diffuse, sizeof(float) * 4);
stream->read((char *)&power, sizeof(float)); stream->read((char *)&power, sizeof(float));
stream->read((char *)&specular, sizeof(float) * 3); stream->read((char *)&specular, sizeof(float) * 3);
@ -129,24 +143,22 @@ namespace pmd
stream->read((char *)&toon_index, sizeof(uint8_t)); stream->read((char *)&toon_index, sizeof(uint8_t));
stream->read((char *)&edge_flag, sizeof(uint8_t)); stream->read((char *)&edge_flag, sizeof(uint8_t));
stream->read((char *)&index_count, sizeof(uint32_t)); stream->read((char *)&index_count, sizeof(uint32_t));
stream->read((char*) &buffer, sizeof(char) * 20); stream->read((char *)&buffer, sizeof(char) * BufferSize);
char *pstar = strchr(buffer, '*'); char *pstar = strchr(buffer, '*');
if (nullptr == pstar) if (nullptr == pstar) {
{
texture_filename = std::string(buffer); texture_filename = std::string(buffer);
sphere_filename.clear(); sphere_filename.clear();
} } else {
else {
*pstar = 0; *pstar = 0;
texture_filename = std::string(buffer); texture_filename = std::string(buffer);
sphere_filename = std::string(pstar + 1); sphere_filename = std::string(pstar + 1);
} }
return true; return true;
} }
}; };
enum class BoneType : uint8_t enum class BoneType : uint8_t {
{
Rotation, Rotation,
RotationAndMove, RotationAndMove,
IkEffector, IkEffector,
@ -157,11 +169,10 @@ namespace pmd
Invisible, Invisible,
Twist, Twist,
RotationMovement RotationMovement
}; };
class PmdBone struct PmdBone {
{
public:
std::string name; std::string name;
std::string name_english; std::string name_english;
uint16_t parent_bone_index; uint16_t parent_bone_index;
@ -170,10 +181,18 @@ namespace pmd
uint16_t ik_parent_bone_index; uint16_t ik_parent_bone_index;
float bone_head_pos[3]; float bone_head_pos[3];
void Read(std::istream *stream) PmdBone() :
{ name(), name_english(), parent_bone_index(0), tail_pos_bone_index(0), bone_type(BoneType::Unknown), ik_parent_bone_index(0), bone_head_pos{ 0.0f } {}
char buffer[20];
stream->read(buffer, 20); ~PmdBone() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
constexpr size_t BufferSize = 20;
char buffer[BufferSize] = {};
stream->read(buffer, BufferSize);
name = std::string(buffer); name = std::string(buffer);
stream->read((char *)&parent_bone_index, sizeof(uint16_t)); stream->read((char *)&parent_bone_index, sizeof(uint16_t));
stream->read((char *)&tail_pos_bone_index, sizeof(uint16_t)); stream->read((char *)&tail_pos_bone_index, sizeof(uint16_t));
@ -182,25 +201,34 @@ namespace pmd
stream->read((char *)&bone_head_pos, sizeof(float) * 3); stream->read((char *)&bone_head_pos, sizeof(float) * 3);
} }
void ReadExpantion(std::istream *stream) void ReadExpantion(std::istream *stream) {
{ if (stream == nullptr) {
char buffer[20]; return;
stream->read(buffer, 20); }
constexpr size_t BufferSize = 20;
char buffer[BufferSize] = {};
stream->read(buffer, BufferSize);
name_english = std::string(buffer); name_english = std::string(buffer);
} }
}; };
class PmdIk struct PmdIk {
{
public:
uint16_t ik_bone_index; uint16_t ik_bone_index;
uint16_t target_bone_index; uint16_t target_bone_index;
uint16_t iterations; uint16_t iterations;
float angle_limit; float angle_limit;
std::vector<uint16_t> ik_child_bone_index; std::vector<uint16_t> ik_child_bone_index;
void Read(std::istream *stream) PmdIk() :
{ ik_child_bone_index(0), target_bone_index(0), iterations(0), angle_limit(0.0f) {}
~PmdIk() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
stream->read((char *)&ik_bone_index, sizeof(uint16_t)); stream->read((char *)&ik_bone_index, sizeof(uint16_t));
stream->read((char *)&target_bone_index, sizeof(uint16_t)); stream->read((char *)&target_bone_index, sizeof(uint16_t));
uint8_t ik_chain_length; uint8_t ik_chain_length;
@ -208,28 +236,31 @@ namespace pmd
stream->read((char *)&iterations, sizeof(uint16_t)); stream->read((char *)&iterations, sizeof(uint16_t));
stream->read((char *)&angle_limit, sizeof(float)); stream->read((char *)&angle_limit, sizeof(float));
ik_child_bone_index.resize(ik_chain_length); ik_child_bone_index.resize(ik_chain_length);
for (int i = 0; i < ik_chain_length; i++) for (int i = 0; i < ik_chain_length; i++) {
{
stream->read((char *)&ik_child_bone_index[i], sizeof(uint16_t)); stream->read((char *)&ik_child_bone_index[i], sizeof(uint16_t));
} }
} }
}; };
class PmdFaceVertex struct PmdFaceVertex {
{
public:
int vertex_index; int vertex_index;
float position[3]; float position[3];
void Read(std::istream *stream) PmdFaceVertex() :
{ vertex_index(0), position{ 0.0f } {}
~PmdFaceVertex() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
stream->read((char *)&vertex_index, sizeof(int)); stream->read((char *)&vertex_index, sizeof(int));
stream->read((char *)position, sizeof(float) * 3); stream->read((char *)position, sizeof(float) * 3);
} }
}; };
enum class FaceCategory : uint8_t enum class FaceCategory : uint8_t {
{
Base, Base,
Eyebrow, Eyebrow,
Eye, Eye,
@ -237,88 +268,105 @@ namespace pmd
Other Other
}; };
class PmdFace struct PmdFace {
{
public:
std::string name; std::string name;
FaceCategory type; FaceCategory type;
std::vector<PmdFaceVertex> vertices; std::vector<PmdFaceVertex> vertices;
std::string name_english; std::string name_english;
void Read(std::istream *stream) PmdFace() :
{ name(), type(FaceCategory::Other), vertices(), name_english() {}
char buffer[20];
stream->read(buffer, 20); ~PmdFace() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
constexpr size_t BufferSize = 20;
char buffer[BufferSize];
stream->read(buffer, BufferSize);
name = std::string(buffer); name = std::string(buffer);
int vertex_count; int vertex_count;
stream->read((char *)&vertex_count, sizeof(int)); stream->read((char *)&vertex_count, sizeof(int));
stream->read((char *)&type, sizeof(uint8_t)); stream->read((char *)&type, sizeof(uint8_t));
vertices.resize(vertex_count); vertices.resize(vertex_count);
for (int i = 0; i < vertex_count; i++) for (int i = 0; i < vertex_count; i++) {
{
vertices[i].Read(stream); vertices[i].Read(stream);
} }
} }
void ReadExpantion(std::istream *stream) void ReadExpantion(std::istream *stream) {
{ if (stream == nullptr) {
return;
}
char buffer[20]; char buffer[20];
stream->read(buffer, 20); stream->read(buffer, 20);
name_english = std::string(buffer); name_english = std::string(buffer);
} }
}; };
class PmdBoneDispName struct PmdBoneDispName {
{
public:
std::string bone_disp_name; std::string bone_disp_name;
std::string bone_disp_name_english; std::string bone_disp_name_english;
void Read(std::istream *stream) PmdBoneDispName() = default;
{
~PmdBoneDispName() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
char buffer[50]; char buffer[50];
stream->read(buffer, 50); stream->read(buffer, 50);
bone_disp_name = std::string(buffer); bone_disp_name = std::string(buffer);
bone_disp_name_english.clear(); bone_disp_name_english.clear();
} }
void ReadExpantion(std::istream *stream)
{ void ReadExpantion(std::istream *stream) {
if (stream == nullptr) {
return;
}
char buffer[50]; char buffer[50];
stream->read(buffer, 50); stream->read(buffer, 50);
bone_disp_name_english = std::string(buffer); bone_disp_name_english = std::string(buffer);
} }
}; };
class PmdBoneDisp struct PmdBoneDisp {
{
public:
uint16_t bone_index; uint16_t bone_index;
uint8_t bone_disp_index; uint8_t bone_disp_index;
void Read(std::istream *stream) PmdBoneDisp() :
{ bone_index(0), bone_disp_index(0) {}
~PmdBoneDisp() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
stream->read((char *)&bone_index, sizeof(uint16_t)); stream->read((char *)&bone_index, sizeof(uint16_t));
stream->read((char *)&bone_disp_index, sizeof(uint8_t)); stream->read((char *)&bone_disp_index, sizeof(uint8_t));
} }
}; };
enum class RigidBodyShape : uint8_t enum class RigidBodyShape : uint8_t {
{
Sphere = 0, Sphere = 0,
Box = 1, Box = 1,
Cpusel = 2 Cpusel = 2
}; };
enum class RigidBodyType : uint8_t enum class RigidBodyType : uint8_t {
{
BoneConnected = 0, BoneConnected = 0,
Physics = 1, Physics = 1,
ConnectedPhysics = 2 ConnectedPhysics = 2
}; };
class PmdRigidBody struct PmdRigidBody {
{
public:
std::string name; std::string name;
uint16_t related_bone_index; uint16_t related_bone_index;
uint8_t group_index; uint8_t group_index;
@ -334,8 +382,16 @@ namespace pmd
float friction; float friction;
RigidBodyType rigid_type; RigidBodyType rigid_type;
void Read(std::istream *stream) PmdRigidBody() :
{ name(), related_bone_index(0), group_index(0), mask(0), shape(RigidBodyShape::Box), size{ 0.0f }, position{ 0.0f }, weight(0.0f), linear_damping(0.0f), anglar_damping(0.0f), restitution(0.0f), friction(0.0f), rigid_type(RigidBodyType::BoneConnected) {}
~PmdRigidBody() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
char buffer[20]; char buffer[20];
stream->read(buffer, sizeof(char) * 20); stream->read(buffer, sizeof(char) * 20);
name = (std::string(buffer)); name = (std::string(buffer));
@ -355,9 +411,7 @@ namespace pmd
} }
}; };
class PmdConstraint struct PmdConstraint {
{
public:
std::string name; std::string name;
uint32_t rigid_body_index_a; uint32_t rigid_body_index_a;
uint32_t rigid_body_index_b; uint32_t rigid_body_index_b;
@ -370,8 +424,16 @@ namespace pmd
float linear_stiffness[3]; float linear_stiffness[3];
float angular_stiffness[3]; float angular_stiffness[3];
void Read(std::istream *stream) PmdConstraint() :
{ name(), rigid_body_index_a(0), rigid_body_index_b(0), position{ 0.0f }, orientation{ 0.0f }, linear_lower_limit{ 0.0f }, linear_upper_limit{ 0.0f }, angular_lower_limit{ 0.0f }, angular_upper_limit{ 0.0f }, linear_stiffness{ 0.0f }, angular_stiffness{ 0.0f } {}
~PmdConstraint() = default;
void Read(std::istream *stream) {
if (stream == nullptr) {
return;
}
char buffer[20]; char buffer[20];
stream->read(buffer, 20); stream->read(buffer, 20);
name = std::string(buffer); name = std::string(buffer);
@ -388,9 +450,7 @@ namespace pmd
} }
}; };
class PmdModel struct PmdModel {
{
public:
float version; float version;
PmdHeader header; PmdHeader header;
std::vector<PmdVertex> vertices; std::vector<PmdVertex> vertices;
@ -406,11 +466,18 @@ namespace pmd
std::vector<PmdRigidBody> rigid_bodies; std::vector<PmdRigidBody> rigid_bodies;
std::vector<PmdConstraint> constraints; std::vector<PmdConstraint> constraints;
static std::unique_ptr<PmdModel> LoadFromFile(const char *filename) PmdModel() :
{ version(0.0f) {}
~PmdModel() = default;
static std::unique_ptr<PmdModel> LoadFromFile(const char *filename) {
if (filename == nullptr) {
return nullptr;
}
std::ifstream stream(filename, std::ios::binary); std::ifstream stream(filename, std::ios::binary);
if (stream.fail()) if (stream.fail()) {
{
std::cerr << "could not open \"" << filename << "\"" << std::endl; std::cerr << "could not open \"" << filename << "\"" << std::endl;
return nullptr; return nullptr;
} }
@ -419,24 +486,21 @@ namespace pmd
return result; return result;
} }
static std::unique_ptr<PmdModel> LoadFromStream(std::ifstream *stream) static std::unique_ptr<PmdModel> LoadFromStream(std::ifstream *stream) {
{
auto result = mmd::make_unique<PmdModel>(); auto result = mmd::make_unique<PmdModel>();
char buffer[100]; char buffer[100];
// magic // magic
char magic[3]; char magic[3];
stream->read(magic, 3); stream->read(magic, 3);
if (magic[0] != 'P' || magic[1] != 'm' || magic[2] != 'd') if (magic[0] != 'P' || magic[1] != 'm' || magic[2] != 'd') {
{
std::cerr << "invalid file" << std::endl; std::cerr << "invalid file" << std::endl;
return nullptr; return nullptr;
} }
// version // version
stream->read((char *)&(result->version), sizeof(float)); stream->read((char *)&(result->version), sizeof(float));
if (result ->version != 1.0f) if (result->version != 1.0f) {
{
std::cerr << "invalid version" << std::endl; std::cerr << "invalid version" << std::endl;
return nullptr; return nullptr;
} }
@ -448,8 +512,7 @@ namespace pmd
uint32_t vertex_num; uint32_t vertex_num;
stream->read((char *)&vertex_num, sizeof(uint32_t)); stream->read((char *)&vertex_num, sizeof(uint32_t));
result->vertices.resize(vertex_num); result->vertices.resize(vertex_num);
for (uint32_t i = 0; i < vertex_num; i++) for (uint32_t i = 0; i < vertex_num; i++) {
{
result->vertices[i].Read(stream); result->vertices[i].Read(stream);
} }
@ -457,8 +520,7 @@ namespace pmd
uint32_t index_num; uint32_t index_num;
stream->read((char *)&index_num, sizeof(uint32_t)); stream->read((char *)&index_num, sizeof(uint32_t));
result->indices.resize(index_num); result->indices.resize(index_num);
for (uint32_t i = 0; i < index_num; i++) for (uint32_t i = 0; i < index_num; i++) {
{
stream->read((char *)&result->indices[i], sizeof(uint16_t)); stream->read((char *)&result->indices[i], sizeof(uint16_t));
} }
@ -466,8 +528,7 @@ namespace pmd
uint32_t material_num; uint32_t material_num;
stream->read((char *)&material_num, sizeof(uint32_t)); stream->read((char *)&material_num, sizeof(uint32_t));
result->materials.resize(material_num); result->materials.resize(material_num);
for (uint32_t i = 0; i < material_num; i++) for (uint32_t i = 0; i < material_num; i++) {
{
result->materials[i].Read(stream); result->materials[i].Read(stream);
} }
@ -475,8 +536,7 @@ namespace pmd
uint16_t bone_num; uint16_t bone_num;
stream->read((char *)&bone_num, sizeof(uint16_t)); stream->read((char *)&bone_num, sizeof(uint16_t));
result->bones.resize(bone_num); result->bones.resize(bone_num);
for (uint32_t i = 0; i < bone_num; i++) for (uint32_t i = 0; i < bone_num; i++) {
{
result->bones[i].Read(stream); result->bones[i].Read(stream);
} }
@ -484,8 +544,7 @@ namespace pmd
uint16_t ik_num; uint16_t ik_num;
stream->read((char *)&ik_num, sizeof(uint16_t)); stream->read((char *)&ik_num, sizeof(uint16_t));
result->iks.resize(ik_num); result->iks.resize(ik_num);
for (uint32_t i = 0; i < ik_num; i++) for (uint32_t i = 0; i < ik_num; i++) {
{
result->iks[i].Read(stream); result->iks[i].Read(stream);
} }
@ -493,8 +552,7 @@ namespace pmd
uint16_t face_num; uint16_t face_num;
stream->read((char *)&face_num, sizeof(uint16_t)); stream->read((char *)&face_num, sizeof(uint16_t));
result->faces.resize(face_num); result->faces.resize(face_num);
for (uint32_t i = 0; i < face_num; i++) for (uint32_t i = 0; i < face_num; i++) {
{
result->faces[i].Read(stream); result->faces[i].Read(stream);
} }
@ -502,8 +560,7 @@ namespace pmd
uint8_t face_frame_num; uint8_t face_frame_num;
stream->read((char *)&face_frame_num, sizeof(uint8_t)); stream->read((char *)&face_frame_num, sizeof(uint8_t));
result->faces_indices.resize(face_frame_num); result->faces_indices.resize(face_frame_num);
for (uint32_t i = 0; i < face_frame_num; i++) for (uint32_t i = 0; i < face_frame_num; i++) {
{
stream->read((char *)&result->faces_indices[i], sizeof(uint16_t)); stream->read((char *)&result->faces_indices[i], sizeof(uint16_t));
} }
@ -511,8 +568,7 @@ namespace pmd
uint8_t bone_disp_num; uint8_t bone_disp_num;
stream->read((char *)&bone_disp_num, sizeof(uint8_t)); stream->read((char *)&bone_disp_num, sizeof(uint8_t));
result->bone_disp_name.resize(bone_disp_num); result->bone_disp_name.resize(bone_disp_num);
for (uint32_t i = 0; i < bone_disp_num; i++) for (uint32_t i = 0; i < bone_disp_num; i++) {
{
result->bone_disp_name[i].Read(stream); result->bone_disp_name[i].Read(stream);
} }
@ -520,78 +576,66 @@ namespace pmd
uint32_t bone_frame_num; uint32_t bone_frame_num;
stream->read((char *)&bone_frame_num, sizeof(uint32_t)); stream->read((char *)&bone_frame_num, sizeof(uint32_t));
result->bone_disp.resize(bone_frame_num); result->bone_disp.resize(bone_frame_num);
for (uint32_t i = 0; i < bone_frame_num; i++) for (uint32_t i = 0; i < bone_frame_num; i++) {
{
result->bone_disp[i].Read(stream); result->bone_disp[i].Read(stream);
} }
// english name // english name
bool english; bool english;
stream->read((char *)&english, sizeof(char)); stream->read((char *)&english, sizeof(char));
if (english) if (english) {
{
result->header.ReadExtension(stream); result->header.ReadExtension(stream);
for (uint32_t i = 0; i < bone_num; i++) for (uint32_t i = 0; i < bone_num; i++) {
{
result->bones[i].ReadExpantion(stream); result->bones[i].ReadExpantion(stream);
} }
for (uint32_t i = 0; i < face_num; i++) for (uint32_t i = 0; i < face_num; i++) {
{ if (result->faces[i].type == pmd::FaceCategory::Base) {
if (result->faces[i].type == pmd::FaceCategory::Base)
{
continue; continue;
} }
result->faces[i].ReadExpantion(stream); result->faces[i].ReadExpantion(stream);
} }
for (uint32_t i = 0; i < result->bone_disp_name.size(); i++) for (uint32_t i = 0; i < result->bone_disp_name.size(); i++) {
{
result->bone_disp_name[i].ReadExpantion(stream); result->bone_disp_name[i].ReadExpantion(stream);
} }
} }
// toon textures // toon textures
if (stream->peek() == std::ios::traits_type::eof()) if (stream->peek() == std::ios::traits_type::eof()) {
{
result->toon_filenames.clear(); result->toon_filenames.clear();
} } else {
else {
result->toon_filenames.resize(10); result->toon_filenames.resize(10);
for (uint32_t i = 0; i < 10; i++) for (uint32_t i = 0; i < 10; i++) {
{
stream->read(buffer, 100); stream->read(buffer, 100);
result->toon_filenames[i] = std::string(buffer); result->toon_filenames[i] = std::string(buffer);
} }
} }
// physics // physics
if (stream->peek() == std::ios::traits_type::eof()) if (stream->peek() == std::ios::traits_type::eof()) {
{
result->rigid_bodies.clear(); result->rigid_bodies.clear();
result->constraints.clear(); result->constraints.clear();
} } else {
else {
uint32_t rigid_body_num; uint32_t rigid_body_num;
stream->read((char *)&rigid_body_num, sizeof(uint32_t)); stream->read((char *)&rigid_body_num, sizeof(uint32_t));
result->rigid_bodies.resize(rigid_body_num); result->rigid_bodies.resize(rigid_body_num);
for (uint32_t i = 0; i < rigid_body_num; i++) for (uint32_t i = 0; i < rigid_body_num; i++) {
{
result->rigid_bodies[i].Read(stream); result->rigid_bodies[i].Read(stream);
} }
uint32_t constraint_num; uint32_t constraint_num;
stream->read((char *)&constraint_num, sizeof(uint32_t)); stream->read((char *)&constraint_num, sizeof(uint32_t));
result->constraints.resize(constraint_num); result->constraints.resize(constraint_num);
for (uint32_t i = 0; i < constraint_num; i++) for (uint32_t i = 0; i < constraint_num; i++) {
{
result->constraints[i].Read(stream); result->constraints[i].Read(stream);
} }
} }
if (stream->peek() != std::ios::traits_type::eof()) if (stream->peek() != std::ios::traits_type::eof()) {
{
std::cerr << "there is unknown data" << std::endl; std::cerr << "there is unknown data" << std::endl;
} }
return result; return result;
} }
}; };
}
} // namespace pmd

17
code/Common/Base64.cpp
View File

@ -46,7 +46,7 @@ namespace Assimp {
namespace Base64 { namespace Base64 {
static const uint8_t tableDecodeBase64[128] = { static constexpr uint8_t tableDecodeBase64[128] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63,
@ -57,7 +57,7 @@ static const uint8_t tableDecodeBase64[128] = {
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0
}; };
static const char *tableEncodeBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; static constexpr char *tableEncodeBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
static inline char EncodeChar(uint8_t b) { static inline char EncodeChar(uint8_t b) {
return tableEncodeBase64[size_t(b)]; return tableEncodeBase64[size_t(b)];
@ -71,6 +71,11 @@ inline uint8_t DecodeChar(char c) {
} }
void Encode(const uint8_t *in, size_t inLength, std::string &out) { void Encode(const uint8_t *in, size_t inLength, std::string &out) {
if (in == nullptr || inLength==0) {
out.clear();
return;
}
size_t outLength = ((inLength + 2) / 3) * 4; size_t outLength = ((inLength + 2) / 3) * 4;
size_t j = out.size(); size_t j = out.size();
@ -115,8 +120,14 @@ std::string Encode(const std::vector<uint8_t> &in) {
} }
size_t Decode(const char *in, size_t inLength, uint8_t *&out) { size_t Decode(const char *in, size_t inLength, uint8_t *&out) {
if (in == nullptr) {
out = nullptr;
return 0;
}
if (inLength % 4 != 0) { if (inLength % 4 != 0) {
throw DeadlyImportError("Invalid base64 encoded data: \"", std::string(in, std::min(size_t(32), inLength)), "\", length:", inLength); throw DeadlyImportError("Invalid base64 encoded data: \"", std::string(in, std::min(size_t(32), inLength)),
"\", length:", inLength);
} }
if (inLength < 4) { if (inLength < 4) {

30
include/assimp/Base64.hpp
View File

@ -50,16 +50,38 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace Assimp { namespace Assimp {
namespace Base64 { namespace Base64 {
/// @brief Will encode the given /// @brief Will encode the given character buffer from UTF64 to ASCII
/// @param in /// @param in The UTF-64 buffer.
/// @param inLength /// @param inLength The size of the buffer
/// @param out /// @param out The encoded ASCII string.
void Encode(const uint8_t *in, size_t inLength, std::string &out); void Encode(const uint8_t *in, size_t inLength, std::string &out);
/// @brief Will encode the given character buffer from UTF64 to ASCII.
/// @param in A vector, which contains the buffer for encoding.
/// @param out The encoded ASCII string.
void Encode(const std::vector<uint8_t>& in, std::string &out); void Encode(const std::vector<uint8_t>& in, std::string &out);
/// @brief Will encode the given character buffer from UTF64 to ASCII.
/// @param in A vector, which contains the buffer for encoding.
/// @return The encoded ASCII string.
std::string Encode(const std::vector<uint8_t>& in); std::string Encode(const std::vector<uint8_t>& in);
/// @brief Will decode the given character buffer from ASCII to UTF64.
/// @param in The ASCII buffer to decode.
/// @param inLength The size of the buffer.
/// @param out The decoded buffer.
/// @return The new buffer size.
size_t Decode(const char *in, size_t inLength, uint8_t *&out); size_t Decode(const char *in, size_t inLength, uint8_t *&out);
/// @brief Will decode the given character buffer from ASCII to UTF64.
/// @param in The ASCII buffer to decode as a std::string.
/// @param out The decoded buffer.
/// @return The new buffer size.
size_t Decode(const std::string& in, std::vector<uint8_t>& out); size_t Decode(const std::string& in, std::vector<uint8_t>& out);
/// @brief Will decode the given character buffer from ASCII to UTF64.
/// @param in The ASCII string.
/// @return The decoded buffer in a vector.
std::vector<uint8_t> Decode(const std::string& in); std::vector<uint8_t> Decode(const std::string& in);
} // namespace Base64 } // namespace Base64

25
test/unit/Common/utBase64.cpp
View File

@ -47,14 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace std; using namespace std;
using namespace Assimp; using namespace Assimp;
class Base64Test : public ::testing::Test { class Base64Test : public ::testing::Test {};
public:
virtual void SetUp() {
}
virtual void TearDown() {
}
};
static const std::vector<uint8_t> assimpStringBinary = { 97, 115, 115, 105, 109, 112 }; static const std::vector<uint8_t> assimpStringBinary = { 97, 115, 115, 105, 109, 112 };
static const std::string assimpStringEncoded = "YXNzaW1w"; static const std::string assimpStringEncoded = "YXNzaW1w";
@ -65,8 +58,24 @@ TEST_F( Base64Test, encodeTest ) {
EXPECT_EQ( assimpStringEncoded, Base64::Encode(assimpStringBinary) ); EXPECT_EQ( assimpStringEncoded, Base64::Encode(assimpStringBinary) );
} }
TEST_F( Base64Test, encodeTestWithNullptr ) {
std::string out;
Base64::Encode(nullptr, 100u, out);
EXPECT_TRUE(out.empty());
Base64::Encode(&assimpStringBinary[0], 0u, out);
EXPECT_TRUE(out.empty());
}
TEST_F( Base64Test, decodeTest) { TEST_F( Base64Test, decodeTest) {
EXPECT_EQ( std::vector<uint8_t> {}, Base64::Decode("") ); EXPECT_EQ( std::vector<uint8_t> {}, Base64::Decode("") );
EXPECT_EQ( std::vector<uint8_t> { 86 }, Base64::Decode("Vg==") ); EXPECT_EQ( std::vector<uint8_t> { 86 }, Base64::Decode("Vg==") );
EXPECT_EQ( assimpStringBinary, Base64::Decode(assimpStringEncoded) ); EXPECT_EQ( assimpStringBinary, Base64::Decode(assimpStringEncoded) );
} }
TEST_F(Base64Test, decodeTestWithNullptr) {
uint8_t *out = nullptr;
size_t size = Base64::Decode(nullptr, 100u, out);
EXPECT_EQ(nullptr, out);
EXPECT_EQ(0u, size);
}