|
|
@@ -53,186 +53,209 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
#include <sstream> // ostringstream
|
|
|
|
|
|
namespace Assimp {
|
|
|
+namespace FBX {
|
|
|
+
|
|
|
// constructors for single element properties
|
|
|
|
|
|
-FBX::Property::Property(bool v)
|
|
|
- : type('C'), data(1)
|
|
|
-{
|
|
|
- data = {uint8_t(v)};
|
|
|
+FBXExportProperty::FBXExportProperty(bool v)
|
|
|
+: type('C')
|
|
|
+, data(1) {
|
|
|
+ data = {
|
|
|
+ uint8_t(v)
|
|
|
+ };
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(int16_t v) : type('Y'), data(2)
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(int16_t v)
|
|
|
+: type('Y')
|
|
|
+, data(2) {
|
|
|
uint8_t* d = data.data();
|
|
|
(reinterpret_cast<int16_t*>(d))[0] = v;
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(int32_t v) : type('I'), data(4)
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(int32_t v)
|
|
|
+: type('I')
|
|
|
+, data(4) {
|
|
|
uint8_t* d = data.data();
|
|
|
(reinterpret_cast<int32_t*>(d))[0] = v;
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(float v) : type('F'), data(4)
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(float v)
|
|
|
+: type('F')
|
|
|
+, data(4) {
|
|
|
uint8_t* d = data.data();
|
|
|
(reinterpret_cast<float*>(d))[0] = v;
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(double v) : type('D'), data(8)
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(double v)
|
|
|
+: type('D')
|
|
|
+, data(8) {
|
|
|
uint8_t* d = data.data();
|
|
|
(reinterpret_cast<double*>(d))[0] = v;
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(int64_t v) : type('L'), data(8)
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(int64_t v)
|
|
|
+: type('L')
|
|
|
+, data(8) {
|
|
|
uint8_t* d = data.data();
|
|
|
(reinterpret_cast<int64_t*>(d))[0] = v;
|
|
|
}
|
|
|
|
|
|
-
|
|
|
// constructors for array-type properties
|
|
|
|
|
|
-FBX::Property::Property(const char* c, bool raw)
|
|
|
- : Property(std::string(c), raw)
|
|
|
-{}
|
|
|
+FBXExportProperty::FBXExportProperty(const char* c, bool raw)
|
|
|
+: FBXExportProperty(std::string(c), raw) {
|
|
|
+ // empty
|
|
|
+}
|
|
|
|
|
|
// strings can either be saved as "raw" (R) data, or "string" (S) data
|
|
|
-FBX::Property::Property(const std::string& s, bool raw)
|
|
|
- : type(raw ? 'R' : 'S'), data(s.size())
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(const std::string& s, bool raw)
|
|
|
+: type(raw ? 'R' : 'S')
|
|
|
+, data(s.size()) {
|
|
|
for (size_t i = 0; i < s.size(); ++i) {
|
|
|
data[i] = uint8_t(s[i]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(const std::vector<uint8_t>& r)
|
|
|
- : type('R'), data(r)
|
|
|
-{}
|
|
|
+FBXExportProperty::FBXExportProperty(const std::vector<uint8_t>& r)
|
|
|
+: type('R')
|
|
|
+, data(r) {
|
|
|
+ // empty
|
|
|
+}
|
|
|
|
|
|
-FBX::Property::Property(const std::vector<int32_t>& va)
|
|
|
- : type('i'), data(4*va.size())
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(const std::vector<int32_t>& va)
|
|
|
+: type('i')
|
|
|
+, data(4 * va.size() ) {
|
|
|
int32_t* d = reinterpret_cast<int32_t*>(data.data());
|
|
|
- for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
|
|
|
+ for (size_t i = 0; i < va.size(); ++i) {
|
|
|
+ d[i] = va[i];
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(const std::vector<int64_t>& va)
|
|
|
- : type('l'), data(8*va.size())
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(const std::vector<int64_t>& va)
|
|
|
+: type('l')
|
|
|
+, data(8 * va.size()) {
|
|
|
int64_t* d = reinterpret_cast<int64_t*>(data.data());
|
|
|
- for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
|
|
|
+ for (size_t i = 0; i < va.size(); ++i) {
|
|
|
+ d[i] = va[i];
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(const std::vector<float>& va)
|
|
|
- : type('f'), data(4*va.size())
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(const std::vector<float>& va)
|
|
|
+: type('f')
|
|
|
+, data(4 * va.size()) {
|
|
|
float* d = reinterpret_cast<float*>(data.data());
|
|
|
- for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
|
|
|
+ for (size_t i = 0; i < va.size(); ++i) {
|
|
|
+ d[i] = va[i];
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(const std::vector<double>& va)
|
|
|
- : type('d'), data(8*va.size())
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(const std::vector<double>& va)
|
|
|
+: type('d')
|
|
|
+, data(8 * va.size()) {
|
|
|
double* d = reinterpret_cast<double*>(data.data());
|
|
|
- for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
|
|
|
+ for (size_t i = 0; i < va.size(); ++i) {
|
|
|
+ d[i] = va[i];
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-FBX::Property::Property(const aiMatrix4x4& vm)
|
|
|
- : type('d'), data(8*16)
|
|
|
-{
|
|
|
+FBXExportProperty::FBXExportProperty(const aiMatrix4x4& vm)
|
|
|
+: type('d')
|
|
|
+, data(8 * 16) {
|
|
|
double* d = reinterpret_cast<double*>(data.data());
|
|
|
for (unsigned int c = 0; c < 4; ++c) {
|
|
|
for (unsigned int r = 0; r < 4; ++r) {
|
|
|
- d[4*c+r] = vm[r][c];
|
|
|
+ d[4 * c + r] = vm[r][c];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// public member functions
|
|
|
|
|
|
-size_t FBX::Property::size()
|
|
|
-{
|
|
|
+size_t FBXExportProperty::size() {
|
|
|
switch (type) {
|
|
|
- case 'C': case 'Y': case 'I': case 'F': case 'D': case 'L':
|
|
|
- return data.size() + 1;
|
|
|
- case 'S': case 'R':
|
|
|
- return data.size() + 5;
|
|
|
- case 'i': case 'd':
|
|
|
- return data.size() + 13;
|
|
|
- default:
|
|
|
- throw DeadlyExportError("Requested size on property of unknown type");
|
|
|
+ case 'C':
|
|
|
+ case 'Y':
|
|
|
+ case 'I':
|
|
|
+ case 'F':
|
|
|
+ case 'D':
|
|
|
+ case 'L':
|
|
|
+ return data.size() + 1;
|
|
|
+ case 'S':
|
|
|
+ case 'R':
|
|
|
+ return data.size() + 5;
|
|
|
+ case 'i':
|
|
|
+ case 'd':
|
|
|
+ return data.size() + 13;
|
|
|
+ default:
|
|
|
+ throw DeadlyExportError("Requested size on property of unknown type");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void FBX::Property::DumpBinary(Assimp::StreamWriterLE &s)
|
|
|
-{
|
|
|
+void FBXExportProperty::DumpBinary(Assimp::StreamWriterLE& s) {
|
|
|
s.PutU1(type);
|
|
|
uint8_t* d = data.data();
|
|
|
size_t N;
|
|
|
switch (type) {
|
|
|
- case 'C': s.PutU1(*(reinterpret_cast<uint8_t*>(d))); return;
|
|
|
- case 'Y': s.PutI2(*(reinterpret_cast<int16_t*>(d))); return;
|
|
|
- case 'I': s.PutI4(*(reinterpret_cast<int32_t*>(d))); return;
|
|
|
- case 'F': s.PutF4(*(reinterpret_cast<float*>(d))); return;
|
|
|
- case 'D': s.PutF8(*(reinterpret_cast<double*>(d))); return;
|
|
|
- case 'L': s.PutI8(*(reinterpret_cast<int64_t*>(d))); return;
|
|
|
- case 'S':
|
|
|
- case 'R':
|
|
|
- s.PutU4(uint32_t(data.size()));
|
|
|
- for (size_t i = 0; i < data.size(); ++i) { s.PutU1(data[i]); }
|
|
|
- return;
|
|
|
- case 'i':
|
|
|
- N = data.size() / 4;
|
|
|
- s.PutU4(uint32_t(N)); // number of elements
|
|
|
- s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
- // TODO: compress if large?
|
|
|
- s.PutU4(uint32_t(data.size())); // data size
|
|
|
- for (size_t i = 0; i < N; ++i) {
|
|
|
- s.PutI4((reinterpret_cast<int32_t*>(d))[i]);
|
|
|
- }
|
|
|
- return;
|
|
|
- case 'l':
|
|
|
- N = data.size() / 8;
|
|
|
- s.PutU4(uint32_t(N)); // number of elements
|
|
|
- s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
- // TODO: compress if large?
|
|
|
- s.PutU4(uint32_t(data.size())); // data size
|
|
|
- for (size_t i = 0; i < N; ++i) {
|
|
|
- s.PutI8((reinterpret_cast<int64_t*>(d))[i]);
|
|
|
- }
|
|
|
- return;
|
|
|
- case 'f':
|
|
|
- N = data.size() / 4;
|
|
|
- s.PutU4(uint32_t(N)); // number of elements
|
|
|
- s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
- // TODO: compress if large?
|
|
|
- s.PutU4(uint32_t(data.size())); // data size
|
|
|
- for (size_t i = 0; i < N; ++i) {
|
|
|
- s.PutF4((reinterpret_cast<float*>(d))[i]);
|
|
|
- }
|
|
|
- return;
|
|
|
- case 'd':
|
|
|
- N = data.size() / 8;
|
|
|
- s.PutU4(uint32_t(N)); // number of elements
|
|
|
- s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
- // TODO: compress if large?
|
|
|
- s.PutU4(uint32_t(data.size())); // data size
|
|
|
- for (size_t i = 0; i < N; ++i) {
|
|
|
- s.PutF8((reinterpret_cast<double*>(d))[i]);
|
|
|
- }
|
|
|
- return;
|
|
|
- default:
|
|
|
- std::ostringstream err;
|
|
|
- err << "Tried to dump property with invalid type '";
|
|
|
- err << type << "'!";
|
|
|
- throw DeadlyExportError(err.str());
|
|
|
+ case 'C': s.PutU1(*(reinterpret_cast<uint8_t*>(d))); return;
|
|
|
+ case 'Y': s.PutI2(*(reinterpret_cast<int16_t*>(d))); return;
|
|
|
+ case 'I': s.PutI4(*(reinterpret_cast<int32_t*>(d))); return;
|
|
|
+ case 'F': s.PutF4(*(reinterpret_cast<float*>(d))); return;
|
|
|
+ case 'D': s.PutF8(*(reinterpret_cast<double*>(d))); return;
|
|
|
+ case 'L': s.PutI8(*(reinterpret_cast<int64_t*>(d))); return;
|
|
|
+ case 'S':
|
|
|
+ case 'R':
|
|
|
+ s.PutU4(uint32_t(data.size()));
|
|
|
+ for (size_t i = 0; i < data.size(); ++i) { s.PutU1(data[i]); }
|
|
|
+ return;
|
|
|
+ case 'i':
|
|
|
+ N = data.size() / 4;
|
|
|
+ s.PutU4(uint32_t(N)); // number of elements
|
|
|
+ s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
+ // TODO: compress if large?
|
|
|
+ s.PutU4(uint32_t(data.size())); // data size
|
|
|
+ for (size_t i = 0; i < N; ++i) {
|
|
|
+ s.PutI4((reinterpret_cast<int32_t*>(d))[i]);
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ case 'l':
|
|
|
+ N = data.size() / 8;
|
|
|
+ s.PutU4(uint32_t(N)); // number of elements
|
|
|
+ s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
+ // TODO: compress if large?
|
|
|
+ s.PutU4(uint32_t(data.size())); // data size
|
|
|
+ for (size_t i = 0; i < N; ++i) {
|
|
|
+ s.PutI8((reinterpret_cast<int64_t*>(d))[i]);
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ case 'f':
|
|
|
+ N = data.size() / 4;
|
|
|
+ s.PutU4(uint32_t(N)); // number of elements
|
|
|
+ s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
+ // TODO: compress if large?
|
|
|
+ s.PutU4(uint32_t(data.size())); // data size
|
|
|
+ for (size_t i = 0; i < N; ++i) {
|
|
|
+ s.PutF4((reinterpret_cast<float*>(d))[i]);
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ case 'd':
|
|
|
+ N = data.size() / 8;
|
|
|
+ s.PutU4(uint32_t(N)); // number of elements
|
|
|
+ s.PutU4(0); // no encoding (1 would be zip-compressed)
|
|
|
+ // TODO: compress if large?
|
|
|
+ s.PutU4(uint32_t(data.size())); // data size
|
|
|
+ for (size_t i = 0; i < N; ++i) {
|
|
|
+ s.PutF8((reinterpret_cast<double*>(d))[i]);
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ default:
|
|
|
+ std::ostringstream err;
|
|
|
+ err << "Tried to dump property with invalid type '";
|
|
|
+ err << type << "'!";
|
|
|
+ throw DeadlyExportError(err.str());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void FBX::Property::DumpAscii(Assimp::StreamWriterLE &outstream, int indent)
|
|
|
-{
|
|
|
+void FBXExportProperty::DumpAscii(Assimp::StreamWriterLE& outstream, int indent) {
|
|
|
std::ostringstream ss;
|
|
|
ss.imbue(std::locale::classic());
|
|
|
ss.precision(15); // this seems to match official FBX SDK exports
|
|
|
@@ -240,8 +263,7 @@ void FBX::Property::DumpAscii(Assimp::StreamWriterLE &outstream, int indent)
|
|
|
outstream.PutString(ss.str());
|
|
|
}
|
|
|
|
|
|
-void FBX::Property::DumpAscii(std::ostream& s, int indent)
|
|
|
-{
|
|
|
+void FBXExportProperty::DumpAscii(std::ostream& s, int indent) {
|
|
|
// no writing type... or anything. just shove it into the stream.
|
|
|
uint8_t* d = data.data();
|
|
|
size_t N;
|
|
|
@@ -359,6 +381,9 @@ void FBX::Property::DumpAscii(std::ostream& s, int indent)
|
|
|
throw runtime_error(err.str());
|
|
|
}
|
|
|
}
|
|
|
-}
|
|
|
+
|
|
|
+} // Namespace FBX
|
|
|
+} // Namespace Assimp
|
|
|
+
|
|
|
#endif // ASSIMP_BUILD_NO_FBX_EXPORTER
|
|
|
#endif // ASSIMP_BUILD_NO_EXPORT
|
Kim Kulling