diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/LWO')
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.cpp | 609 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.h | 346 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOBLoader.cpp | 428 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOFileData.h | 638 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.cpp | 1422 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.h | 468 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/LWO/LWOMaterial.cpp | 844 |
7 files changed, 0 insertions, 4755 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.cpp b/src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.cpp deleted file mode 100644 index c2ee2d9..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.cpp +++ /dev/null @@ -1,609 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file LWOAnimation.cpp - * @brief LWOAnimationResolver utility class - * - * It's a very generic implementation of LightWave's system of - * component-wise-animated stuff. The one and only fully free - * implementation of LightWave envelopes of which I know. -*/ - -#if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER) && (!defined ASSIMP_BUILD_NO_LWS_IMPORTER) - -#include <functional> - -// internal headers -#include "LWOFileData.h" -#include <assimp/anim.h> - -using namespace Assimp; -using namespace Assimp::LWO; - -// ------------------------------------------------------------------------------------------------ -// Construct an animation resolver from a given list of envelopes -AnimResolver::AnimResolver(std::list<Envelope> &_envelopes, double tick) : - envelopes(_envelopes), - sample_rate(0.), - envl_x(), - envl_y(), - envl_z(), - end_x(), - end_y(), - end_z(), - flags(), - sample_delta() { - trans_x = trans_y = trans_z = nullptr; - rotat_x = rotat_y = rotat_z = nullptr; - scale_x = scale_y = scale_z = nullptr; - - first = last = 150392.; - - // find transformation envelopes - for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) { - - (*it).old_first = 0; - (*it).old_last = (*it).keys.size() - 1; - - if ((*it).keys.empty()) { - continue; - } - if ((int)(*it).type < 1 || (int)(*it).type>EnvelopeType_Unknown) { - continue; - } - switch ((*it).type) { - // translation - case LWO::EnvelopeType_Position_X: - trans_x = &*it; - break; - case LWO::EnvelopeType_Position_Y: - trans_y = &*it; - break; - case LWO::EnvelopeType_Position_Z: - trans_z = &*it; - break; - - // rotation - case LWO::EnvelopeType_Rotation_Heading: - rotat_x = &*it; - break; - case LWO::EnvelopeType_Rotation_Pitch: - rotat_y = &*it; - break; - case LWO::EnvelopeType_Rotation_Bank: - rotat_z = &*it; - break; - - // scaling - case LWO::EnvelopeType_Scaling_X: - scale_x = &*it; - break; - case LWO::EnvelopeType_Scaling_Y: - scale_y = &*it; - break; - case LWO::EnvelopeType_Scaling_Z: - scale_z = &*it; - break; - default: - continue; - }; - - // convert from seconds to ticks - for (std::vector<LWO::Key>::iterator d = (*it).keys.begin(); d != (*it).keys.end(); ++d) - (*d).time *= tick; - - // set default animation range (minimum and maximum time value for which we have a keyframe) - first = std::min(first, (*it).keys.front().time); - last = std::max(last, (*it).keys.back().time); - } - - // deferred setup of animation range to increase performance. - // typically the application will want to specify its own. - need_to_setup = true; -} - -// ------------------------------------------------------------------------------------------------ -// Reset all envelopes to their original contents -void AnimResolver::ClearAnimRangeSetup() { - for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) { - - (*it).keys.erase((*it).keys.begin(), (*it).keys.begin() + (*it).old_first); - (*it).keys.erase((*it).keys.begin() + (*it).old_last + 1, (*it).keys.end()); - } -} - -// ------------------------------------------------------------------------------------------------ -// Insert additional keys to match LWO's pre& post behaviors. -void AnimResolver::UpdateAnimRangeSetup() { - // XXX doesn't work yet (hangs if more than one envelope channels needs to be interpolated) - - for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) { - if ((*it).keys.empty()) continue; - - const double my_first = (*it).keys.front().time; - const double my_last = (*it).keys.back().time; - - const double delta = my_last - my_first; - const size_t old_size = (*it).keys.size(); - - const float value_delta = (*it).keys.back().value - (*it).keys.front().value; - - // NOTE: We won't handle reset, linear and constant here. - // See DoInterpolation() for their implementation. - - // process pre behavior - switch ((*it).pre) { - case LWO::PrePostBehaviour_OffsetRepeat: - case LWO::PrePostBehaviour_Repeat: - case LWO::PrePostBehaviour_Oscillate: { - const double start_time = delta - std::fmod(my_first - first, delta); - std::vector<LWO::Key>::iterator n = std::find_if((*it).keys.begin(), (*it).keys.end(), - [start_time](double t) { return start_time > t; }), - m; - - size_t ofs = 0; - if (n != (*it).keys.end()) { - // copy from here - don't use iterators, insert() would invalidate them - ofs = (*it).keys.end() - n; - (*it).keys.insert((*it).keys.begin(), ofs, LWO::Key()); - - std::copy((*it).keys.end() - ofs, (*it).keys.end(), (*it).keys.begin()); - } - - // do full copies. again, no iterators - const unsigned int num = (unsigned int)((my_first - first) / delta); - (*it).keys.resize((*it).keys.size() + num * old_size); - - n = (*it).keys.begin() + ofs; - bool reverse = false; - for (unsigned int i = 0; i < num; ++i) { - m = n + old_size * (i + 1); - std::copy(n, n + old_size, m); - const bool res = ((*it).pre == LWO::PrePostBehaviour_Oscillate); - reverse = !reverse; - if (res && reverse) { - std::reverse(m, m + old_size - 1); - } - } - - // update time values - n = (*it).keys.end() - (old_size + 1); - double cur_minus = delta; - unsigned int tt = 1; - for (const double tmp = delta * (num + 1); cur_minus <= tmp; cur_minus += delta, ++tt) { - m = (delta == tmp ? (*it).keys.begin() : n - (old_size + 1)); - for (; m != n; --n) { - (*n).time -= cur_minus; - - // offset repeat? add delta offset to key value - if ((*it).pre == LWO::PrePostBehaviour_OffsetRepeat) { - (*n).value += tt * value_delta; - } - } - } - break; - } - default: - // silence compiler warning - break; - } - - // process post behavior - switch ((*it).post) { - - case LWO::PrePostBehaviour_OffsetRepeat: - case LWO::PrePostBehaviour_Repeat: - case LWO::PrePostBehaviour_Oscillate: - - break; - - default: - // silence compiler warning - break; - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Extract bind pose matrix -void AnimResolver::ExtractBindPose(aiMatrix4x4 &out) { - // If we have no envelopes, return identity - if (envelopes.empty()) { - out = aiMatrix4x4(); - return; - } - aiVector3D angles, scaling(1.f, 1.f, 1.f), translation; - - if (trans_x) translation.x = trans_x->keys[0].value; - if (trans_y) translation.y = trans_y->keys[0].value; - if (trans_z) translation.z = trans_z->keys[0].value; - - if (rotat_x) angles.x = rotat_x->keys[0].value; - if (rotat_y) angles.y = rotat_y->keys[0].value; - if (rotat_z) angles.z = rotat_z->keys[0].value; - - if (scale_x) scaling.x = scale_x->keys[0].value; - if (scale_y) scaling.y = scale_y->keys[0].value; - if (scale_z) scaling.z = scale_z->keys[0].value; - - // build the final matrix - aiMatrix4x4 s, rx, ry, rz, t; - aiMatrix4x4::RotationZ(angles.z, rz); - aiMatrix4x4::RotationX(angles.y, rx); - aiMatrix4x4::RotationY(angles.x, ry); - aiMatrix4x4::Translation(translation, t); - aiMatrix4x4::Scaling(scaling, s); - out = t * ry * rx * rz * s; -} - -// ------------------------------------------------------------------------------------------------ -// Do a single interpolation on a channel -void AnimResolver::DoInterpolation(std::vector<LWO::Key>::const_iterator cur, - LWO::Envelope *envl, double time, float &fill) { - if (envl->keys.size() == 1) { - fill = envl->keys[0].value; - return; - } - - // check whether we're at the beginning of the animation track - if (cur == envl->keys.begin()) { - - // ok ... this depends on pre behaviour now - // we don't need to handle repeat&offset repeat&oszillate here, see UpdateAnimRangeSetup() - switch (envl->pre) { - case LWO::PrePostBehaviour_Linear: - DoInterpolation2(cur, cur + 1, time, fill); - return; - - case LWO::PrePostBehaviour_Reset: - fill = 0.f; - return; - - default: //case LWO::PrePostBehaviour_Constant: - fill = (*cur).value; - return; - } - } - // check whether we're at the end of the animation track - else if (cur == envl->keys.end() - 1 && time > envl->keys.rbegin()->time) { - // ok ... this depends on post behaviour now - switch (envl->post) { - case LWO::PrePostBehaviour_Linear: - DoInterpolation2(cur, cur - 1, time, fill); - return; - - case LWO::PrePostBehaviour_Reset: - fill = 0.f; - return; - - default: //case LWO::PrePostBehaviour_Constant: - fill = (*cur).value; - return; - } - } - - // Otherwise do a simple interpolation - DoInterpolation2(cur - 1, cur, time, fill); -} - -// ------------------------------------------------------------------------------------------------ -// Almost the same, except we won't handle pre/post conditions here -void AnimResolver::DoInterpolation2(std::vector<LWO::Key>::const_iterator beg, - std::vector<LWO::Key>::const_iterator end, double time, float &fill) { - switch ((*end).inter) { - - case LWO::IT_STEP: - // no interpolation at all - take the value of the last key - fill = (*beg).value; - return; - default: - - // silence compiler warning - break; - } - // linear interpolation - default - double duration = (*end).time - (*beg).time; - if (duration > 0.0) { - fill = (*beg).value + ((*end).value - (*beg).value) * (float)(((time - (*beg).time) / duration)); - } else { - fill = (*beg).value; - } -} - -// ------------------------------------------------------------------------------------------------ -// Subsample animation track by given key values -void AnimResolver::SubsampleAnimTrack(std::vector<aiVectorKey> & /*out*/, - double /*time*/, double /*sample_delta*/) { - //ai_assert(out.empty() && sample_delta); - - //const double time_start = out.back().mTime; - // for () -} - -// ------------------------------------------------------------------------------------------------ -// Track interpolation -void AnimResolver::InterpolateTrack(std::vector<aiVectorKey> &out, aiVectorKey &fill, double time) { - // subsample animation track? - if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) { - SubsampleAnimTrack(out, time, sample_delta); - } - - fill.mTime = time; - - // get x - if ((*cur_x).time == time) { - fill.mValue.x = (*cur_x).value; - - if (cur_x != envl_x->keys.end() - 1) /* increment x */ - ++cur_x; - else - end_x = true; - } else - DoInterpolation(cur_x, envl_x, time, (float &)fill.mValue.x); - - // get y - if ((*cur_y).time == time) { - fill.mValue.y = (*cur_y).value; - - if (cur_y != envl_y->keys.end() - 1) /* increment y */ - ++cur_y; - else - end_y = true; - } else - DoInterpolation(cur_y, envl_y, time, (float &)fill.mValue.y); - - // get z - if ((*cur_z).time == time) { - fill.mValue.z = (*cur_z).value; - - if (cur_z != envl_z->keys.end() - 1) /* increment z */ - ++cur_z; - else - end_x = true; - } else - DoInterpolation(cur_z, envl_z, time, (float &)fill.mValue.z); -} - -// ------------------------------------------------------------------------------------------------ -// Build linearly subsampled keys from three single envelopes, one for each component (x,y,z) -void AnimResolver::GetKeys(std::vector<aiVectorKey> &out, - LWO::Envelope *_envl_x, - LWO::Envelope *_envl_y, - LWO::Envelope *_envl_z, - unsigned int _flags) { - envl_x = _envl_x; - envl_y = _envl_y; - envl_z = _envl_z; - flags = _flags; - - // generate default channels if none are given - LWO::Envelope def_x, def_y, def_z; - LWO::Key key_dummy; - key_dummy.time = 0.f; - if ((envl_x && envl_x->type == LWO::EnvelopeType_Scaling_X) || - (envl_y && envl_y->type == LWO::EnvelopeType_Scaling_Y) || - (envl_z && envl_z->type == LWO::EnvelopeType_Scaling_Z)) { - key_dummy.value = 1.f; - } else - key_dummy.value = 0.f; - - if (!envl_x) { - envl_x = &def_x; - envl_x->keys.push_back(key_dummy); - } - if (!envl_y) { - envl_y = &def_y; - envl_y->keys.push_back(key_dummy); - } - if (!envl_z) { - envl_z = &def_z; - envl_z->keys.push_back(key_dummy); - } - - // guess how many keys we'll get - size_t reserve; - double sr = 1.; - if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) { - if (!sample_rate) - sr = 100.f; - else - sr = sample_rate; - sample_delta = 1.f / sr; - - reserve = (size_t)( - std::max(envl_x->keys.rbegin()->time, - std::max(envl_y->keys.rbegin()->time, envl_z->keys.rbegin()->time)) * - sr); - } else - reserve = std::max(envl_x->keys.size(), std::max(envl_x->keys.size(), envl_z->keys.size())); - out.reserve(reserve + (reserve >> 1)); - - // Iterate through all three arrays at once - it's tricky, but - // rather interesting to implement. - cur_x = envl_x->keys.begin(); - cur_y = envl_y->keys.begin(); - cur_z = envl_z->keys.begin(); - - end_x = end_y = end_z = false; - while (1) { - - aiVectorKey fill; - - if ((*cur_x).time == (*cur_y).time && (*cur_x).time == (*cur_z).time) { - - // we have a keyframe for all of them defined .. this means - // we don't need to interpolate here. - fill.mTime = (*cur_x).time; - - fill.mValue.x = (*cur_x).value; - fill.mValue.y = (*cur_y).value; - fill.mValue.z = (*cur_z).value; - - // subsample animation track - if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) { - //SubsampleAnimTrack(out,cur_x, cur_y, cur_z, d, sample_delta); - } - } - - // Find key with lowest time value - else if ((*cur_x).time <= (*cur_y).time && !end_x) { - - if ((*cur_z).time <= (*cur_x).time && !end_z) { - InterpolateTrack(out, fill, (*cur_z).time); - } else { - InterpolateTrack(out, fill, (*cur_x).time); - } - } else if ((*cur_z).time <= (*cur_y).time && !end_y) { - InterpolateTrack(out, fill, (*cur_y).time); - } else if (!end_y) { - // welcome on the server, y - InterpolateTrack(out, fill, (*cur_y).time); - } else { - // we have reached the end of at least 2 channels, - // only one is remaining. Extrapolate the 2. - if (end_y) { - InterpolateTrack(out, fill, (end_x ? (*cur_z) : (*cur_x)).time); - } else if (end_x) { - InterpolateTrack(out, fill, (end_z ? (*cur_y) : (*cur_z)).time); - } else { // if (end_z) - InterpolateTrack(out, fill, (end_y ? (*cur_x) : (*cur_y)).time); - } - } - double lasttime = fill.mTime; - out.push_back(fill); - - if (lasttime >= (*cur_x).time) { - if (cur_x != envl_x->keys.end() - 1) - ++cur_x; - else - end_x = true; - } - if (lasttime >= (*cur_y).time) { - if (cur_y != envl_y->keys.end() - 1) - ++cur_y; - else - end_y = true; - } - if (lasttime >= (*cur_z).time) { - if (cur_z != envl_z->keys.end() - 1) - ++cur_z; - else - end_z = true; - } - - if (end_x && end_y && end_z) /* finished? */ - break; - } - - if (flags & AI_LWO_ANIM_FLAG_START_AT_ZERO) { - for (std::vector<aiVectorKey>::iterator it = out.begin(); it != out.end(); ++it) - (*it).mTime -= first; - } -} - -// ------------------------------------------------------------------------------------------------ -// Extract animation channel -void AnimResolver::ExtractAnimChannel(aiNodeAnim **out, unsigned int /*= 0*/) { - *out = nullptr; - - //FIXME: crashes if more than one component is animated at different timings, to be resolved. - - // If we have no envelopes, return nullptr - if (envelopes.empty()) { - return; - } - - // We won't spawn an animation channel if we don't have at least one envelope with more than one keyframe defined. - const bool trans = ((trans_x && trans_x->keys.size() > 1) || (trans_y && trans_y->keys.size() > 1) || (trans_z && trans_z->keys.size() > 1)); - const bool rotat = ((rotat_x && rotat_x->keys.size() > 1) || (rotat_y && rotat_y->keys.size() > 1) || (rotat_z && rotat_z->keys.size() > 1)); - const bool scale = ((scale_x && scale_x->keys.size() > 1) || (scale_y && scale_y->keys.size() > 1) || (scale_z && scale_z->keys.size() > 1)); - if (!trans && !rotat && !scale) - return; - - // Allocate the output animation - aiNodeAnim *anim = *out = new aiNodeAnim(); - - // Setup default animation setup if necessary - if (need_to_setup) { - UpdateAnimRangeSetup(); - need_to_setup = false; - } - - // copy translation keys - if (trans) { - std::vector<aiVectorKey> keys; - GetKeys(keys, trans_x, trans_y, trans_z, flags); - - anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = static_cast<unsigned int>(keys.size())]; - std::copy(keys.begin(), keys.end(), anim->mPositionKeys); - } - - // copy rotation keys - if (rotat) { - std::vector<aiVectorKey> keys; - GetKeys(keys, rotat_x, rotat_y, rotat_z, flags); - - anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = static_cast<unsigned int>(keys.size())]; - - // convert heading, pitch, bank to quaternion - // mValue.x=Heading=Rot(Y), mValue.y=Pitch=Rot(X), mValue.z=Bank=Rot(Z) - // Lightwave's rotation order is ZXY - aiVector3D X(1.0, 0.0, 0.0); - aiVector3D Y(0.0, 1.0, 0.0); - aiVector3D Z(0.0, 0.0, 1.0); - for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) { - aiQuatKey &qk = anim->mRotationKeys[i]; - qk.mTime = keys[i].mTime; - qk.mValue = aiQuaternion(Y, keys[i].mValue.x) * aiQuaternion(X, keys[i].mValue.y) * aiQuaternion(Z, keys[i].mValue.z); - } - } - - // copy scaling keys - if (scale) { - std::vector<aiVectorKey> keys; - GetKeys(keys, scale_x, scale_y, scale_z, flags); - - anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = static_cast<unsigned int>(keys.size())]; - std::copy(keys.begin(), keys.end(), anim->mScalingKeys); - } -} - -#endif // no lwo or no lws diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.h b/src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.h deleted file mode 100644 index 1e419d4..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOAnimation.h +++ /dev/null @@ -1,346 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file LWOAnimation.h - * @brief LWOAnimationResolver utility class - * - * This is for all lightwave-related file format, not only LWO. - * LWS isthe main purpose. -*/ -#ifndef AI_LWO_ANIMATION_INCLUDED -#define AI_LWO_ANIMATION_INCLUDED - -// -#include <vector> -#include <list> - -struct aiNodeAnim; -struct aiVectorKey; - -namespace Assimp { -namespace LWO { - -// --------------------------------------------------------------------------- -/** \brief List of recognized LWO envelopes - */ -enum EnvelopeType -{ - EnvelopeType_Position_X = 0x1, - EnvelopeType_Position_Y = 0x2, - EnvelopeType_Position_Z = 0x3, - - EnvelopeType_Rotation_Heading = 0x4, - EnvelopeType_Rotation_Pitch = 0x5, - EnvelopeType_Rotation_Bank = 0x6, - - EnvelopeType_Scaling_X = 0x7, - EnvelopeType_Scaling_Y = 0x8, - EnvelopeType_Scaling_Z = 0x9, - - // -- currently not yet handled - EnvelopeType_Color_R = 0xa, - EnvelopeType_Color_G = 0xb, - EnvelopeType_Color_B = 0xc, - - EnvelopeType_Falloff_X = 0xd, - EnvelopeType_Falloff_Y = 0xe, - EnvelopeType_Falloff_Z = 0xf, - - EnvelopeType_Unknown -}; - -// --------------------------------------------------------------------------- -/** \brief List of recognized LWO interpolation modes - */ -enum InterpolationType -{ - IT_STEP, IT_LINE, IT_TCB, IT_HERM, IT_BEZI, IT_BEZ2 -}; - - -// --------------------------------------------------------------------------- -/** \brief List of recognized LWO pre or post range behaviours - */ -enum PrePostBehaviour -{ - PrePostBehaviour_Reset = 0x0, - PrePostBehaviour_Constant = 0x1, - PrePostBehaviour_Repeat = 0x2, - PrePostBehaviour_Oscillate = 0x3, - PrePostBehaviour_OffsetRepeat = 0x4, - PrePostBehaviour_Linear = 0x5 -}; - -// --------------------------------------------------------------------------- -/** \brief Data structure for a LWO animation keyframe - */ -struct Key { - Key() AI_NO_EXCEPT - : time() - , value() - , inter(IT_LINE) - , params() { - // empty - } - - //! Current time - double time; - - //! Current value - float value; - - //! How to interpolate this key with previous key? - InterpolationType inter; - - //! Interpolation parameters - float params[5]; - - - // for std::find() - operator double () { - return time; - } -}; - -// --------------------------------------------------------------------------- -/** \brief Data structure for a LWO animation envelope - */ -struct Envelope { - Envelope() AI_NO_EXCEPT - : index() - , type(EnvelopeType_Unknown) - , pre(PrePostBehaviour_Constant) - , post(PrePostBehaviour_Constant) - , old_first(0) - , old_last(0) { - // empty - } - - //! Index of this envelope - unsigned int index; - - //! Type of envelope - EnvelopeType type; - - //! Pre- and post-behavior - PrePostBehaviour pre,post; - - //! Keyframes for this envelope - std::vector<Key> keys; - - // temporary data for AnimResolver - size_t old_first,old_last; -}; - -// --------------------------------------------------------------------------- -//! @def AI_LWO_ANIM_FLAG_SAMPLE_ANIMS -//! Flag for AnimResolver, subsamples the input data with the rate specified -//! by AnimResolver::SetSampleRate(). -#define AI_LWO_ANIM_FLAG_SAMPLE_ANIMS 0x1 - - -// --------------------------------------------------------------------------- -//! @def AI_LWO_ANIM_FLAG_START_AT_ZERO -//! Flag for AnimResolver, ensures that the animations starts at zero. -#define AI_LWO_ANIM_FLAG_START_AT_ZERO 0x2 - -// --------------------------------------------------------------------------- -/** @brief Utility class to build Assimp animations from LWO envelopes. - * - * Used for both LWO and LWS (MOT also). - */ -class AnimResolver -{ -public: - - // ------------------------------------------------------------------ - /** @brief Construct an AnimResolver from a given list of envelopes - * @param envelopes Input envelopes. May be empty. - * @param Output tick rate, per second - * @note The input envelopes are possibly modified. - */ - AnimResolver(std::list<Envelope>& envelopes, double tick); - -public: - - // ------------------------------------------------------------------ - /** @brief Extract the bind-pose transformation matrix. - * @param out Receives bind-pose transformation matrix - */ - void ExtractBindPose(aiMatrix4x4& out); - - // ------------------------------------------------------------------ - /** @brief Extract a node animation channel - * @param out Receives a pointer to a newly allocated node anim. - * If there's just one keyframe defined, *out is set to nullptr and - * no animation channel is computed. - * @param flags Any combination of the AI_LWO_ANIM_FLAG_XXX flags. - */ - void ExtractAnimChannel(aiNodeAnim** out, unsigned int flags = 0); - - - // ------------------------------------------------------------------ - /** @brief Set the sampling rate for ExtractAnimChannel(). - * - * Non-linear interpolations are subsampled with this rate (keys - * per second). Closer sampling positions, if existent, are kept. - * The sampling rate defaults to 0, if this value is not changed and - * AI_LWO_ANIM_FLAG_SAMPLE_ANIMS is specified for ExtractAnimChannel(), - * the class finds a suitable sample rate by itself. - */ - void SetSampleRate(double sr) { - sample_rate = sr; - } - - // ------------------------------------------------------------------ - /** @brief Getter for SetSampleRate() - */ - double GetSampleRate() const { - return sample_rate; - } - - // ------------------------------------------------------------------ - /** @brief Set the animation time range - * - * @param first Time where the animation starts, in ticks - * @param last Time where the animation ends, in ticks - */ - void SetAnimationRange(double _first, double _last) { - first = _first; - last = _last; - - ClearAnimRangeSetup(); - UpdateAnimRangeSetup(); - } - -protected: - - // ------------------------------------------------------------------ - /** @brief Build linearly subsampled keys from 3 single envelopes - * @param out Receives output keys - * @param envl_x X-component envelope - * @param envl_y Y-component envelope - * @param envl_z Z-component envelope - * @param flags Any combination of the AI_LWO_ANIM_FLAG_XXX flags. - * @note Up to two input envelopes may be nullptr - */ - void GetKeys(std::vector<aiVectorKey>& out, - LWO::Envelope* envl_x, - LWO::Envelope* envl_y, - LWO::Envelope* envl_z, - unsigned int flags); - - // ------------------------------------------------------------------ - /** @brief Resolve a single animation key by applying the right - * interpolation to it. - * @param cur Current key - * @param envl Envelope working on - * @param time time to be interpolated - * @param fill Receives the interpolated output value. - */ - void DoInterpolation(std::vector<LWO::Key>::const_iterator cur, - LWO::Envelope* envl,double time, float& fill); - - // ------------------------------------------------------------------ - /** @brief Almost the same, except we won't handle pre/post - * conditions here. - * @see DoInterpolation - */ - void DoInterpolation2(std::vector<LWO::Key>::const_iterator beg, - std::vector<LWO::Key>::const_iterator end,double time, float& fill); - - // ------------------------------------------------------------------ - /** @brief Interpolate 2 tracks if one is given - * - * @param out Receives extra output keys - * @param key_out Primary output key - * @param time Time to interpolate for - */ - void InterpolateTrack(std::vector<aiVectorKey>& out, - aiVectorKey& key_out,double time); - - // ------------------------------------------------------------------ - /** @brief Subsample an animation track by a given sampling rate - * - * @param out Receives output keys. Last key at input defines the - * time where subsampling starts. - * @param time Time to end subsampling at - * @param sample_delta Time delta between two samples - */ - void SubsampleAnimTrack(std::vector<aiVectorKey>& out, - double time,double sample_delta); - - // ------------------------------------------------------------------ - /** @brief Delete all keys which we inserted to match anim setup - */ - void ClearAnimRangeSetup(); - - // ------------------------------------------------------------------ - /** @brief Insert extra keys to match LWO's pre and post behaviours - * in a given time range [first...last] - */ - void UpdateAnimRangeSetup(); - -private: - std::list<Envelope>& envelopes; - double sample_rate; - - LWO::Envelope* trans_x, *trans_y, *trans_z; - LWO::Envelope* rotat_x, *rotat_y, *rotat_z; - LWO::Envelope* scale_x, *scale_y, *scale_z; - - double first, last; - bool need_to_setup; - - // temporary storage - LWO::Envelope* envl_x, * envl_y, * envl_z; - std::vector<LWO::Key>::const_iterator cur_x,cur_y,cur_z; - bool end_x, end_y, end_z; - - unsigned int flags; - double sample_delta; -}; - -} // end namespace LWO -} // end namespace Assimp - -#endif // !! AI_LWO_ANIMATION_INCLUDED diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOBLoader.cpp b/src/mesh/assimp-master/code/AssetLib/LWO/LWOBLoader.cpp deleted file mode 100644 index 1fbd9b9..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOBLoader.cpp +++ /dev/null @@ -1,428 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file Implementation of the LWO importer class for the older LWOB - file formats, including materials */ - - -#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER - -// Internal headers -#include "LWOLoader.h" -using namespace Assimp; - - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOBFile() -{ - LE_NCONST uint8_t* const end = mFileBuffer + fileSize; - bool running = true; - while (running) - { - if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break; - const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) - { - throw DeadlyImportError("LWOB: Invalid chunk length"); - break; - } - uint8_t* const next = mFileBuffer+head.length; - switch (head.type) - { - // vertex list - case AI_LWO_PNTS: - { - if (!mCurLayer->mTempPoints.empty()) - ASSIMP_LOG_WARN("LWO: PNTS chunk encountered twice"); - else LoadLWOPoints(head.length); - break; - } - // face list - case AI_LWO_POLS: - { - - if (!mCurLayer->mFaces.empty()) - ASSIMP_LOG_WARN("LWO: POLS chunk encountered twice"); - else LoadLWOBPolygons(head.length); - break; - } - // list of tags - case AI_LWO_SRFS: - { - if (!mTags->empty()) - ASSIMP_LOG_WARN("LWO: SRFS chunk encountered twice"); - else LoadLWOTags(head.length); - break; - } - - // surface chunk - case AI_LWO_SURF: - { - LoadLWOBSurface(head.length); - break; - } - } - mFileBuffer = next; - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOBPolygons(unsigned int length) -{ - // first find out how many faces and vertices we'll finally need - LE_NCONST uint16_t* const end = (LE_NCONST uint16_t*)(mFileBuffer+length); - LE_NCONST uint16_t* cursor = (LE_NCONST uint16_t*)mFileBuffer; - - // perform endianness conversions -#ifndef AI_BUILD_BIG_ENDIAN - while (cursor < end)ByteSwap::Swap2(cursor++); - cursor = (LE_NCONST uint16_t*)mFileBuffer; -#endif - - unsigned int iNumFaces = 0,iNumVertices = 0; - CountVertsAndFacesLWOB(iNumVertices,iNumFaces,cursor,end); - - // allocate the output array and copy face indices - if (iNumFaces) - { - cursor = (LE_NCONST uint16_t*)mFileBuffer; - - mCurLayer->mFaces.resize(iNumFaces); - FaceList::iterator it = mCurLayer->mFaces.begin(); - CopyFaceIndicesLWOB(it,cursor,end); - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& faces, - LE_NCONST uint16_t*& cursor, const uint16_t* const end, unsigned int max) -{ - while (cursor < end && max--) - { - uint16_t numIndices; - // must have 2 shorts left for numIndices and surface - if (end - cursor < 2) { - throw DeadlyImportError("LWOB: Unexpected end of file"); - } - ::memcpy(&numIndices, cursor++, 2); - // must have enough left for indices and surface - if (end - cursor < (1 + numIndices)) { - throw DeadlyImportError("LWOB: Unexpected end of file"); - } - verts += numIndices; - faces++; - cursor += numIndices; - int16_t surface; - ::memcpy(&surface, cursor++, 2); - if (surface < 0) - { - // there are detail polygons - ::memcpy(&numIndices, cursor++, 2); - CountVertsAndFacesLWOB(verts,faces,cursor,end,numIndices); - } - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it, - LE_NCONST uint16_t*& cursor, - const uint16_t* const end, - unsigned int max) -{ - while (cursor < end && max--) - { - LWO::Face& face = *it;++it; - uint16_t numIndices; - ::memcpy(&numIndices, cursor++, 2); - face.mNumIndices = numIndices; - if(face.mNumIndices) - { - if (cursor + face.mNumIndices >= end) - { - break; - } - face.mIndices = new unsigned int[face.mNumIndices]; - for (unsigned int i = 0; i < face.mNumIndices;++i) { - unsigned int & mi = face.mIndices[i]; - uint16_t index; - ::memcpy(&index, cursor++, 2); - mi = index; - if (mi > mCurLayer->mTempPoints.size()) - { - ASSIMP_LOG_WARN("LWOB: face index is out of range"); - mi = (unsigned int)mCurLayer->mTempPoints.size()-1; - } - } - } else { - ASSIMP_LOG_WARN("LWOB: Face has 0 indices"); - } - int16_t surface; - ::memcpy(&surface, cursor++, 2); - if (surface < 0) - { - surface = -surface; - - // there are detail polygons. - uint16_t numPolygons; - ::memcpy(&numPolygons, cursor++, 2); - if (cursor < end) - { - CopyFaceIndicesLWOB(it,cursor,end,numPolygons); - } - } - face.surfaceIndex = surface-1; - } -} - -// ------------------------------------------------------------------------------------------------ -LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned int size) -{ - list.push_back(LWO::Texture()); - LWO::Texture* tex = &list.back(); - - std::string type; - GetS0(type,size); - const char* s = type.c_str(); - - if(strstr(s, "Image Map")) - { - // Determine mapping type - if(strstr(s, "Planar")) - tex->mapMode = LWO::Texture::Planar; - else if(strstr(s, "Cylindrical")) - tex->mapMode = LWO::Texture::Cylindrical; - else if(strstr(s, "Spherical")) - tex->mapMode = LWO::Texture::Spherical; - else if(strstr(s, "Cubic")) - tex->mapMode = LWO::Texture::Cubic; - else if(strstr(s, "Front")) - tex->mapMode = LWO::Texture::FrontProjection; - } - else - { - // procedural or gradient, not supported - ASSIMP_LOG_ERROR("LWOB: Unsupported legacy texture: ", type); - } - - return tex; -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOBSurface(unsigned int size) -{ - LE_NCONST uint8_t* const end = mFileBuffer + size; - - mSurfaces->push_back( LWO::Surface () ); - LWO::Surface& surf = mSurfaces->back(); - LWO::Texture *pTex = nullptr; - - GetS0(surf.mName,size); - bool running = true; - while (running) { - if (mFileBuffer + 6 >= end) - break; - - IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - - /* A single test file (sonycam.lwo) seems to have invalid surface chunks. - * I'm assuming it's the fault of a single, unknown exporter so there are - * probably THOUSANDS of them. Here's a dirty workaround: - * - * We don't break if the chunk limit is exceeded. Instead, we're computing - * how much storage is actually left and work with this value from now on. - */ - if (mFileBuffer + head.length > end) { - ASSIMP_LOG_ERROR("LWOB: Invalid surface chunk length. Trying to continue."); - head.length = (uint16_t) (end - mFileBuffer); - } - - uint8_t* const next = mFileBuffer+head.length; - switch (head.type) - { - // diffuse color - case AI_LWO_COLR: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,COLR,3); - surf.mColor.r = GetU1() / 255.0f; - surf.mColor.g = GetU1() / 255.0f; - surf.mColor.b = GetU1() / 255.0f; - break; - } - // diffuse strength ... - case AI_LWO_DIFF: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,DIFF,2); - surf.mDiffuseValue = GetU2() / 255.0f; - break; - } - // specular strength ... - case AI_LWO_SPEC: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPEC,2); - surf.mSpecularValue = GetU2() / 255.0f; - break; - } - // luminosity ... - case AI_LWO_LUMI: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LUMI,2); - surf.mLuminosity = GetU2() / 255.0f; - break; - } - // transparency - case AI_LWO_TRAN: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TRAN,2); - surf.mTransparency = GetU2() / 255.0f; - break; - } - // surface flags - case AI_LWO_FLAG: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,FLAG,2); - uint16_t flag = GetU2(); - if (flag & 0x4 ) surf.mMaximumSmoothAngle = 1.56207f; - if (flag & 0x8 ) surf.mColorHighlights = 1.f; - if (flag & 0x100) surf.bDoubleSided = true; - break; - } - // maximum smoothing angle - case AI_LWO_SMAN: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SMAN,4); - surf.mMaximumSmoothAngle = std::fabs( GetF4() ); - break; - } - // glossiness - case AI_LWO_GLOS: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,GLOS,2); - surf.mGlossiness = (float)GetU2(); - break; - } - // color texture - case AI_LWO_CTEX: - { - pTex = SetupNewTextureLWOB(surf.mColorTextures, - head.length); - break; - } - // diffuse texture - case AI_LWO_DTEX: - { - pTex = SetupNewTextureLWOB(surf.mDiffuseTextures, - head.length); - break; - } - // specular texture - case AI_LWO_STEX: - { - pTex = SetupNewTextureLWOB(surf.mSpecularTextures, - head.length); - break; - } - // bump texture - case AI_LWO_BTEX: - { - pTex = SetupNewTextureLWOB(surf.mBumpTextures, - head.length); - break; - } - // transparency texture - case AI_LWO_TTEX: - { - pTex = SetupNewTextureLWOB(surf.mOpacityTextures, - head.length); - break; - } - // texture path - case AI_LWO_TIMG: - { - if (pTex) { - GetS0(pTex->mFileName,head.length); - } else { - ASSIMP_LOG_WARN("LWOB: Unexpected TIMG chunk"); - } - break; - } - // texture strength - case AI_LWO_TVAL: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TVAL,1); - if (pTex) { - pTex->mStrength = (float)GetU1()/ 255.f; - } else { - ASSIMP_LOG_ERROR("LWOB: Unexpected TVAL chunk"); - } - break; - } - // texture flags - case AI_LWO_TFLG: - { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TFLG,2); - - if (nullptr != pTex) { - const uint16_t s = GetU2(); - if (s & 1) - pTex->majorAxis = LWO::Texture::AXIS_X; - else if (s & 2) - pTex->majorAxis = LWO::Texture::AXIS_Y; - else if (s & 4) - pTex->majorAxis = LWO::Texture::AXIS_Z; - - if (s & 16) { - ASSIMP_LOG_WARN("LWOB: Ignoring \'negate\' flag on texture"); - } - } - else { - ASSIMP_LOG_WARN("LWOB: Unexpected TFLG chunk"); - } - break; - } - } - mFileBuffer = next; - } -} - -#endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOFileData.h b/src/mesh/assimp-master/code/AssetLib/LWO/LWOFileData.h deleted file mode 100644 index f477f58..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOFileData.h +++ /dev/null @@ -1,638 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file LWOFileData.h - * @brief Defines chunk constants used by the LWO file format - -The chunks are taken from the official LightWave SDK headers. - -*/ -#ifndef AI_LWO_FILEDATA_INCLUDED -#define AI_LWO_FILEDATA_INCLUDED - -// STL headers -#include <list> -#include <vector> - -// public ASSIMP headers -#include <assimp/mesh.h> - -// internal headers -#include "AssetLib/LWO/LWOAnimation.h" -#include "Common/IFF.h" - -namespace Assimp { -namespace LWO { - -#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L', 'W', 'O', 'B') -#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L', 'W', 'O', '2') -#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L', 'X', 'O', 'B') - -// chunks specific to the LWOB format -#define AI_LWO_SRFS AI_IFF_FOURCC('S', 'R', 'F', 'S') -#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G') -#define AI_LWO_VLUM AI_IFF_FOURCC('V', 'L', 'U', 'M') -#define AI_LWO_VDIF AI_IFF_FOURCC('V', 'D', 'I', 'F') -#define AI_LWO_VSPC AI_IFF_FOURCC('V', 'S', 'P', 'C') -#define AI_LWO_RFLT AI_IFF_FOURCC('R', 'F', 'L', 'T') -#define AI_LWO_BTEX AI_IFF_FOURCC('B', 'T', 'E', 'X') -#define AI_LWO_CTEX AI_IFF_FOURCC('C', 'T', 'E', 'X') -#define AI_LWO_DTEX AI_IFF_FOURCC('D', 'T', 'E', 'X') -#define AI_LWO_LTEX AI_IFF_FOURCC('L', 'T', 'E', 'X') -#define AI_LWO_RTEX AI_IFF_FOURCC('R', 'T', 'E', 'X') -#define AI_LWO_STEX AI_IFF_FOURCC('S', 'T', 'E', 'X') -#define AI_LWO_TTEX AI_IFF_FOURCC('T', 'T', 'E', 'X') -#define AI_LWO_TFLG AI_IFF_FOURCC('T', 'F', 'L', 'G') -#define AI_LWO_TSIZ AI_IFF_FOURCC('T', 'S', 'I', 'Z') -#define AI_LWO_TCTR AI_IFF_FOURCC('T', 'C', 'T', 'R') -#define AI_LWO_TFAL AI_IFF_FOURCC('T', 'F', 'A', 'L') -#define AI_LWO_TVEL AI_IFF_FOURCC('T', 'V', 'E', 'L') -#define AI_LWO_TCLR AI_IFF_FOURCC('T', 'C', 'L', 'R') -#define AI_LWO_TVAL AI_IFF_FOURCC('T', 'V', 'A', 'L') -#define AI_LWO_TAMP AI_IFF_FOURCC('T', 'A', 'M', 'P') -#define AI_LWO_TIMG AI_IFF_FOURCC('T', 'I', 'M', 'G') -#define AI_LWO_TAAS AI_IFF_FOURCC('T', 'A', 'A', 'S') -#define AI_LWO_TREF AI_IFF_FOURCC('T', 'R', 'E', 'F') -#define AI_LWO_TOPC AI_IFF_FOURCC('T', 'O', 'P', 'C') -#define AI_LWO_SDAT AI_IFF_FOURCC('S', 'D', 'A', 'T') -#define AI_LWO_TFP0 AI_IFF_FOURCC('T', 'F', 'P', '0') -#define AI_LWO_TFP1 AI_IFF_FOURCC('T', 'F', 'P', '1') - -/* top-level chunks */ -#define AI_LWO_LAYR AI_IFF_FOURCC('L', 'A', 'Y', 'R') -#define AI_LWO_TAGS AI_IFF_FOURCC('T', 'A', 'G', 'S') -#define AI_LWO_PNTS AI_IFF_FOURCC('P', 'N', 'T', 'S') -#define AI_LWO_BBOX AI_IFF_FOURCC('B', 'B', 'O', 'X') -#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P') -#define AI_LWO_VMAD AI_IFF_FOURCC('V', 'M', 'A', 'D') -#define AI_LWO_POLS AI_IFF_FOURCC('P', 'O', 'L', 'S') -#define AI_LWO_PTAG AI_IFF_FOURCC('P', 'T', 'A', 'G') -#define AI_LWO_ENVL AI_IFF_FOURCC('E', 'N', 'V', 'L') -#define AI_LWO_CLIP AI_IFF_FOURCC('C', 'L', 'I', 'P') -#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F') -#define AI_LWO_DESC AI_IFF_FOURCC('D', 'E', 'S', 'C') -#define AI_LWO_TEXT AI_IFF_FOURCC('T', 'E', 'X', 'T') -#define AI_LWO_ICON AI_IFF_FOURCC('I', 'C', 'O', 'N') - -/* polygon types */ -#define AI_LWO_FACE AI_IFF_FOURCC('F', 'A', 'C', 'E') -#define AI_LWO_CURV AI_IFF_FOURCC('C', 'U', 'R', 'V') -#define AI_LWO_PTCH AI_IFF_FOURCC('P', 'T', 'C', 'H') -#define AI_LWO_MBAL AI_IFF_FOURCC('M', 'B', 'A', 'L') -#define AI_LWO_BONE AI_IFF_FOURCC('B', 'O', 'N', 'E') -#define AI_LWO_SUBD AI_IFF_FOURCC('S', 'U', 'B', 'D') - -/* polygon tags */ -#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F') -#define AI_LWO_PART AI_IFF_FOURCC('P', 'A', 'R', 'T') -#define AI_LWO_SMGP AI_IFF_FOURCC('S', 'M', 'G', 'P') - -/* envelopes */ -#define AI_LWO_PRE AI_IFF_FOURCC('P', 'R', 'E', ' ') -#define AI_LWO_POST AI_IFF_FOURCC('P', 'O', 'S', 'T') -#define AI_LWO_KEY AI_IFF_FOURCC('K', 'E', 'Y', ' ') -#define AI_LWO_SPAN AI_IFF_FOURCC('S', 'P', 'A', 'N') -#define AI_LWO_TCB AI_IFF_FOURCC('T', 'C', 'B', ' ') -#define AI_LWO_HERM AI_IFF_FOURCC('H', 'E', 'R', 'M') -#define AI_LWO_BEZI AI_IFF_FOURCC('B', 'E', 'Z', 'I') -#define AI_LWO_BEZ2 AI_IFF_FOURCC('B', 'E', 'Z', '2') -#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E') -#define AI_LWO_STEP AI_IFF_FOURCC('S', 'T', 'E', 'P') - -/* clips */ -#define AI_LWO_STIL AI_IFF_FOURCC('S', 'T', 'I', 'L') -#define AI_LWO_ISEQ AI_IFF_FOURCC('I', 'S', 'E', 'Q') -#define AI_LWO_ANIM AI_IFF_FOURCC('A', 'N', 'I', 'M') -#define AI_LWO_XREF AI_IFF_FOURCC('X', 'R', 'E', 'F') -#define AI_LWO_STCC AI_IFF_FOURCC('S', 'T', 'C', 'C') -#define AI_LWO_TIME AI_IFF_FOURCC('T', 'I', 'M', 'E') -#define AI_LWO_CONT AI_IFF_FOURCC('C', 'O', 'N', 'T') -#define AI_LWO_BRIT AI_IFF_FOURCC('B', 'R', 'I', 'T') -#define AI_LWO_SATR AI_IFF_FOURCC('S', 'A', 'T', 'R') -#define AI_LWO_HUE AI_IFF_FOURCC('H', 'U', 'E', ' ') -#define AI_LWO_GAMM AI_IFF_FOURCC('G', 'A', 'M', 'M') -#define AI_LWO_NEGA AI_IFF_FOURCC('N', 'E', 'G', 'A') -#define AI_LWO_IFLT AI_IFF_FOURCC('I', 'F', 'L', 'T') -#define AI_LWO_PFLT AI_IFF_FOURCC('P', 'F', 'L', 'T') - -/* surfaces */ -#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R') -#define AI_LWO_LUMI AI_IFF_FOURCC('L', 'U', 'M', 'I') -#define AI_LWO_DIFF AI_IFF_FOURCC('D', 'I', 'F', 'F') -#define AI_LWO_SPEC AI_IFF_FOURCC('S', 'P', 'E', 'C') -#define AI_LWO_GLOS AI_IFF_FOURCC('G', 'L', 'O', 'S') -#define AI_LWO_REFL AI_IFF_FOURCC('R', 'E', 'F', 'L') -#define AI_LWO_RFOP AI_IFF_FOURCC('R', 'F', 'O', 'P') -#define AI_LWO_RIMG AI_IFF_FOURCC('R', 'I', 'M', 'G') -#define AI_LWO_RSAN AI_IFF_FOURCC('R', 'S', 'A', 'N') -#define AI_LWO_TRAN AI_IFF_FOURCC('T', 'R', 'A', 'N') -#define AI_LWO_TROP AI_IFF_FOURCC('T', 'R', 'O', 'P') -#define AI_LWO_TIMG AI_IFF_FOURCC('T', 'I', 'M', 'G') -#define AI_LWO_RIND AI_IFF_FOURCC('R', 'I', 'N', 'D') -#define AI_LWO_TRNL AI_IFF_FOURCC('T', 'R', 'N', 'L') -#define AI_LWO_BUMP AI_IFF_FOURCC('B', 'U', 'M', 'P') -#define AI_LWO_SMAN AI_IFF_FOURCC('S', 'M', 'A', 'N') -#define AI_LWO_SIDE AI_IFF_FOURCC('S', 'I', 'D', 'E') -#define AI_LWO_CLRH AI_IFF_FOURCC('C', 'L', 'R', 'H') -#define AI_LWO_CLRF AI_IFF_FOURCC('C', 'L', 'R', 'F') -#define AI_LWO_ADTR AI_IFF_FOURCC('A', 'D', 'T', 'R') -#define AI_LWO_SHRP AI_IFF_FOURCC('S', 'H', 'R', 'P') -#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E') -#define AI_LWO_LSIZ AI_IFF_FOURCC('L', 'S', 'I', 'Z') -#define AI_LWO_ALPH AI_IFF_FOURCC('A', 'L', 'P', 'H') -#define AI_LWO_AVAL AI_IFF_FOURCC('A', 'V', 'A', 'L') -#define AI_LWO_GVAL AI_IFF_FOURCC('G', 'V', 'A', 'L') -#define AI_LWO_BLOK AI_IFF_FOURCC('B', 'L', 'O', 'K') -#define AI_LWO_VCOL AI_IFF_FOURCC('V', 'C', 'O', 'L') - -/* texture layer */ -#define AI_LWO_TYPE AI_IFF_FOURCC('T', 'Y', 'P', 'E') -#define AI_LWO_CHAN AI_IFF_FOURCC('C', 'H', 'A', 'N') -#define AI_LWO_NAME AI_IFF_FOURCC('N', 'A', 'M', 'E') -#define AI_LWO_ENAB AI_IFF_FOURCC('E', 'N', 'A', 'B') -#define AI_LWO_OPAC AI_IFF_FOURCC('O', 'P', 'A', 'C') -#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G') -#define AI_LWO_PROJ AI_IFF_FOURCC('P', 'R', 'O', 'J') -#define AI_LWO_STCK AI_IFF_FOURCC('S', 'T', 'C', 'K') -#define AI_LWO_TAMP AI_IFF_FOURCC('T', 'A', 'M', 'P') - -/* texture coordinates */ -#define AI_LWO_TMAP AI_IFF_FOURCC('T', 'M', 'A', 'P') -#define AI_LWO_AXIS AI_IFF_FOURCC('A', 'X', 'I', 'S') -#define AI_LWO_CNTR AI_IFF_FOURCC('C', 'N', 'T', 'R') -#define AI_LWO_SIZE AI_IFF_FOURCC('S', 'I', 'Z', 'E') -#define AI_LWO_ROTA AI_IFF_FOURCC('R', 'O', 'T', 'A') -#define AI_LWO_OREF AI_IFF_FOURCC('O', 'R', 'E', 'F') -#define AI_LWO_FALL AI_IFF_FOURCC('F', 'A', 'L', 'L') -#define AI_LWO_CSYS AI_IFF_FOURCC('C', 'S', 'Y', 'S') - -/* image map */ -#define AI_LWO_IMAP AI_IFF_FOURCC('I', 'M', 'A', 'P') -#define AI_LWO_IMAG AI_IFF_FOURCC('I', 'M', 'A', 'G') -#define AI_LWO_WRAP AI_IFF_FOURCC('W', 'R', 'A', 'P') -#define AI_LWO_WRPW AI_IFF_FOURCC('W', 'R', 'P', 'W') -#define AI_LWO_WRPH AI_IFF_FOURCC('W', 'R', 'P', 'H') -#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P') -#define AI_LWO_AAST AI_IFF_FOURCC('A', 'A', 'S', 'T') -#define AI_LWO_PIXB AI_IFF_FOURCC('P', 'I', 'X', 'B') - -/* procedural */ -#define AI_LWO_PROC AI_IFF_FOURCC('P', 'R', 'O', 'C') -#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R') -#define AI_LWO_VALU AI_IFF_FOURCC('V', 'A', 'L', 'U') -#define AI_LWO_FUNC AI_IFF_FOURCC('F', 'U', 'N', 'C') -#define AI_LWO_FTPS AI_IFF_FOURCC('F', 'T', 'P', 'S') -#define AI_LWO_ITPS AI_IFF_FOURCC('I', 'T', 'P', 'S') -#define AI_LWO_ETPS AI_IFF_FOURCC('E', 'T', 'P', 'S') - -/* gradient */ -#define AI_LWO_GRAD AI_IFF_FOURCC('G', 'R', 'A', 'D') -#define AI_LWO_GRST AI_IFF_FOURCC('G', 'R', 'S', 'T') -#define AI_LWO_GREN AI_IFF_FOURCC('G', 'R', 'E', 'N') -#define AI_LWO_PNAM AI_IFF_FOURCC('P', 'N', 'A', 'M') -#define AI_LWO_INAM AI_IFF_FOURCC('I', 'N', 'A', 'M') -#define AI_LWO_GRPT AI_IFF_FOURCC('G', 'R', 'P', 'T') -#define AI_LWO_FKEY AI_IFF_FOURCC('F', 'K', 'E', 'Y') -#define AI_LWO_IKEY AI_IFF_FOURCC('I', 'K', 'E', 'Y') - -/* shader */ -#define AI_LWO_SHDR AI_IFF_FOURCC('S', 'H', 'D', 'R') -#define AI_LWO_DATA AI_IFF_FOURCC('D', 'A', 'T', 'A') - -/* VMAP types */ -#define AI_LWO_TXUV AI_IFF_FOURCC('T', 'X', 'U', 'V') -#define AI_LWO_RGB AI_IFF_FOURCC('R', 'G', 'B', ' ') -#define AI_LWO_RGBA AI_IFF_FOURCC('R', 'G', 'B', 'A') -#define AI_LWO_WGHT AI_IFF_FOURCC('W', 'G', 'H', 'T') - -#define AI_LWO_MNVW AI_IFF_FOURCC('M', 'N', 'V', 'W') -#define AI_LWO_MORF AI_IFF_FOURCC('M', 'O', 'R', 'F') -#define AI_LWO_SPOT AI_IFF_FOURCC('S', 'P', 'O', 'T') -#define AI_LWO_PICK AI_IFF_FOURCC('P', 'I', 'C', 'K') - -// MODO extension - per-vertex normal vectors -#define AI_LWO_MODO_NORM AI_IFF_FOURCC('N', 'O', 'R', 'M') - -// --------------------------------------------------------------------------- -/** \brief Data structure for a face in a LWO file - * - * \note We can't use the code in SmoothingGroups.inl here - the mesh - * structures of 3DS/ASE and LWO are too different. - */ -struct Face : public aiFace { - //! Default construction - Face() AI_NO_EXCEPT - : surfaceIndex(0), - smoothGroup(0), - type(AI_LWO_FACE) { - // empty - } - - //! Construction from given type - explicit Face(uint32_t _type) : - surfaceIndex(0), smoothGroup(0), type(_type) {} - - //! Copy construction - Face(const Face &f) : - aiFace() { - *this = f; - } - - //! Zero-based index into tags chunk - unsigned int surfaceIndex; - - //! Smooth group this face is assigned to - unsigned int smoothGroup; - - //! Type of face - uint32_t type; - - //! Assignment operator - Face &operator=(const LWO::Face &f) { - aiFace::operator=(f); - surfaceIndex = f.surfaceIndex; - smoothGroup = f.smoothGroup; - type = f.type; - return *this; - } -}; - -// --------------------------------------------------------------------------- -/** \brief Base structure for all vertex map representations - */ -struct VMapEntry { - explicit VMapEntry(unsigned int _dims) : - dims(_dims) {} - - virtual ~VMapEntry() {} - - //! allocates memory for the vertex map - virtual void Allocate(unsigned int num) { - if (!rawData.empty()) - return; // return if already allocated - - const unsigned int m = num * dims; - rawData.reserve(m + (m >> 2u)); // 25% as extra storage for VMADs - rawData.resize(m, 0.f); - abAssigned.resize(num, false); - } - - std::string name; - unsigned int dims; - - std::vector<float> rawData; - std::vector<bool> abAssigned; -}; - -// --------------------------------------------------------------------------- -/** \brief Represents an extra vertex color channel - */ -struct VColorChannel : public VMapEntry { - VColorChannel() : - VMapEntry(4) {} - - //! need to overwrite this function - the alpha channel must - //! be initialized to 1.0 by default - virtual void Allocate(unsigned int num) { - if (!rawData.empty()) - return; // return if already allocated - - unsigned int m = num * dims; - rawData.reserve(m + (m >> 2u)); // 25% as extra storage for VMADs - rawData.resize(m); - - for (aiColor4D *p = (aiColor4D *)&rawData[0]; p < (aiColor4D *)&rawData[m - 1]; ++p) - p->a = 1.f; - - abAssigned.resize(num, false); - } -}; - -// --------------------------------------------------------------------------- -/** \brief Represents an extra vertex UV channel - */ -struct UVChannel : public VMapEntry { - UVChannel() : - VMapEntry(2) {} -}; - -// --------------------------------------------------------------------------- -/** \brief Represents a weight map - */ -struct WeightChannel : public VMapEntry { - WeightChannel() : - VMapEntry(1) {} -}; - -// --------------------------------------------------------------------------- -/** \brief Represents a vertex-normals channel (MODO extension) - */ -struct NormalChannel : public VMapEntry { - NormalChannel() : - VMapEntry(3) {} -}; - -// --------------------------------------------------------------------------- -/** \brief Data structure for a LWO file texture - */ -struct Texture { - // we write the enum values out here to make debugging easier ... - enum BlendType { - Normal = 0, - Subtractive = 1, - Difference = 2, - Multiply = 3, - Divide = 4, - Alpha = 5, - TextureDispl = 6, - Additive = 7 - }; - - enum MappingMode { - Planar = 0, - Cylindrical = 1, - Spherical = 2, - Cubic = 3, - FrontProjection = 4, - UV = 5 - }; - - enum Axes { - AXIS_X = 0, - AXIS_Y = 1, - AXIS_Z = 2 - }; - - enum Wrap { - RESET = 0, - REPEAT = 1, - MIRROR = 2, - EDGE = 3 - }; - - Texture() : - mClipIdx(UINT_MAX), mStrength(1.0f), type(), mUVChannelIndex("unknown"), mRealUVIndex(UINT_MAX), enabled(true), blendType(Additive), bCanUse(true), mapMode(UV), majorAxis(AXIS_X), wrapAmountH(1.0f), wrapAmountW(1.0f), wrapModeWidth(REPEAT), wrapModeHeight(REPEAT), ordinal("\x00") {} - - //! File name of the texture - std::string mFileName; - - //! Clip index - unsigned int mClipIdx; - - //! Strength of the texture - blend factor - float mStrength; - - uint32_t type; // type of the texture - - //! Name of the corresponding UV channel - std::string mUVChannelIndex; - unsigned int mRealUVIndex; - - //! is the texture enabled? - bool enabled; - - //! blend type - BlendType blendType; - - //! are we able to use the texture? - bool bCanUse; - - //! mapping mode - MappingMode mapMode; - - //! major axis for planar, cylindrical, spherical projections - Axes majorAxis; - - //! wrap amount for cylindrical and spherical projections - float wrapAmountH, wrapAmountW; - - //! wrapping mode for the texture - Wrap wrapModeWidth, wrapModeHeight; - - //! ordinal string of the texture - std::string ordinal; -}; - -// --------------------------------------------------------------------------- -/** \brief Data structure for a LWO file clip - */ -struct Clip { - enum Type { - STILL, - SEQ, - REF, - UNSUPPORTED - } type; - - Clip() : - type(UNSUPPORTED), clipRef(), idx(0), negate(false) {} - - //! path to the base texture - - std::string path; - - //! reference to another CLIP - unsigned int clipRef; - - //! index of the clip - unsigned int idx; - - //! Negate the clip? - bool negate; -}; - -// --------------------------------------------------------------------------- -/** \brief Data structure for a LWO file shader - * - * Later - */ -struct Shader { - Shader() : - ordinal("\x00"), functionName("unknown"), enabled(true) {} - - std::string ordinal; - std::string functionName; - bool enabled; -}; - -typedef std::list<Texture> TextureList; -typedef std::list<Shader> ShaderList; - -// --------------------------------------------------------------------------- -/** \brief Data structure for a LWO file surface (= material) - */ -struct Surface { - Surface() : - mColor(0.78431f, 0.78431f, 0.78431f), bDoubleSided(false), mDiffuseValue(1.f), mSpecularValue(0.f), mTransparency(0.f), mGlossiness(0.4f), mLuminosity(0.f), mColorHighlights(0.f), mMaximumSmoothAngle(0.f) // 0 == not specified, no smoothing - , - mVCMap(), - mVCMapType(AI_LWO_RGBA), - mIOR(1.f) // vakuum - , - mBumpIntensity(1.f), - mWireframe(false), - mAdditiveTransparency(0.f) {} - - //! Name of the surface - std::string mName; - - //! Color of the surface - aiColor3D mColor; - - //! true for two-sided materials - bool bDoubleSided; - - //! Various material parameters - float mDiffuseValue, mSpecularValue, mTransparency, mGlossiness, mLuminosity, mColorHighlights; - - //! Maximum angle between two adjacent triangles - //! that they can be smoothed - in degrees - float mMaximumSmoothAngle; - - //! Vertex color map to be used to color the surface - std::string mVCMap; - uint32_t mVCMapType; - - //! Names of the special shaders to be applied to the surface - ShaderList mShaders; - - //! Textures - the first entry in the list is evaluated first - TextureList mColorTextures, // color textures are added to both diffuse and specular texture stacks - mDiffuseTextures, - mSpecularTextures, - mOpacityTextures, - mBumpTextures, - mGlossinessTextures, - mReflectionTextures; - - //! Index of refraction - float mIOR; - - //! Bump intensity scaling - float mBumpIntensity; - - //! Wireframe flag - bool mWireframe; - - //! Intensity of additive blending - float mAdditiveTransparency; -}; - -// --------------------------------------------------------------------------- -#define AI_LWO_VALIDATE_CHUNK_LENGTH(length, name, size) \ - if (length < size) { \ - throw DeadlyImportError("LWO: " #name " chunk is too small"); \ - } - -// some typedefs ... to make life with loader monsters like this easier -typedef std::vector<aiVector3D> PointList; -typedef std::vector<LWO::Face> FaceList; -typedef std::vector<LWO::Surface> SurfaceList; -typedef std::vector<std::string> TagList; -typedef std::vector<unsigned int> TagMappingTable; -typedef std::vector<unsigned int> ReferrerList; -typedef std::vector<WeightChannel> WeightChannelList; -typedef std::vector<VColorChannel> VColorChannelList; -typedef std::vector<UVChannel> UVChannelList; -typedef std::vector<Clip> ClipList; -typedef std::vector<Envelope> EnvelopeList; -typedef std::vector<unsigned int> SortedRep; - -// --------------------------------------------------------------------------- -/** \brief Represents a layer in the file - */ -struct Layer { - Layer() : - mFaceIDXOfs(0), mPointIDXOfs(0), mParent(0x0), mIndex(0xffff), skip(false) {} - - /** Temporary point list from the file */ - PointList mTempPoints; - - /** Lists for every point the index of another point - that has been copied from *this* point or UINT_MAX if - no copy of the point has been made */ - ReferrerList mPointReferrers; - - /** Weight channel list from the file */ - WeightChannelList mWeightChannels; - - /** Subdivision weight channel list from the file */ - WeightChannelList mSWeightChannels; - - /** Vertex color list from the file */ - VColorChannelList mVColorChannels; - - /** UV channel list from the file */ - UVChannelList mUVChannels; - - /** Normal vector channel from the file */ - NormalChannel mNormals; - - /** Temporary face list from the file*/ - FaceList mFaces; - - /** Current face indexing offset from the beginning of the buffers*/ - unsigned int mFaceIDXOfs; - - /** Current point indexing offset from the beginning of the buffers*/ - unsigned int mPointIDXOfs; - - /** Parent index */ - uint16_t mParent; - - /** Index of the layer */ - uint16_t mIndex; - - /** Name of the layer */ - std::string mName; - - /** Pivot point of the layer */ - aiVector3D mPivot; - - /** Skip this layer? */ - bool skip; -}; - -typedef std::list<LWO::Layer> LayerList; - -} // namespace LWO -} // namespace Assimp - -#endif // !! AI_LWO_FILEDATA_INCLUDED diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.cpp b/src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.cpp deleted file mode 100644 index 7410fb6..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.cpp +++ /dev/null @@ -1,1422 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file LWOLoader.cpp - * @brief Implementation of the LWO importer class - */ - -#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER - -// internal headers -#include "AssetLib/LWO/LWOLoader.h" -#include "PostProcessing/ConvertToLHProcess.h" -#include "PostProcessing/ProcessHelper.h" - -#include <assimp/ByteSwapper.h> -#include <assimp/SGSpatialSort.h> -#include <assimp/StringComparison.h> -#include <assimp/importerdesc.h> -#include <assimp/IOSystem.hpp> - -#include <iomanip> -#include <map> -#include <memory> -#include <sstream> - -using namespace Assimp; - -static const aiImporterDesc desc = { - "LightWave/Modo Object Importer", - "", - "", - "https://www.lightwave3d.com/lightwave_sdk/", - aiImporterFlags_SupportTextFlavour, - 0, - 0, - 0, - 0, - "lwo lxo" -}; - -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -LWOImporter::LWOImporter() : - mIsLWO2(), - mIsLXOB(), - mLayers(), - mCurLayer(), - mTags(), - mMapping(), - mSurfaces(), - mFileBuffer(), - fileSize(), - mScene(nullptr), - configSpeedFlag(), - configLayerIndex(), - hasNamedLayer() { - // empty -} - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -LWOImporter::~LWOImporter() { - // empty -} - -// ------------------------------------------------------------------------------------------------ -// Returns whether the class can handle the format of the given file. -bool LWOImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*checkSig*/) const { - static const uint32_t tokens[] = { - AI_LWO_FOURCC_LWOB, - AI_LWO_FOURCC_LWO2, - AI_LWO_FOURCC_LXOB - }; - return CheckMagicToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens), 8); -} - -// ------------------------------------------------------------------------------------------------ -// Setup configuration properties -void LWOImporter::SetupProperties(const Importer *pImp) { - configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0) ? true : false); - configLayerIndex = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, UINT_MAX); - configLayerName = pImp->GetPropertyString(AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, ""); -} - -// ------------------------------------------------------------------------------------------------ -// Get list of file extensions -const aiImporterDesc *LWOImporter::GetInfo() const { - return &desc; -} - -// ------------------------------------------------------------------------------------------------ -// Imports the given file into the given scene structure. -void LWOImporter::InternReadFile(const std::string &pFile, - aiScene *pScene, - IOSystem *pIOHandler) { - std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb")); - - // Check whether we can read from the file - if (file.get() == nullptr) { - throw DeadlyImportError("Failed to open LWO file ", pFile, "."); - } - - if ((this->fileSize = (unsigned int)file->FileSize()) < 12) { - throw DeadlyImportError("LWO: The file is too small to contain the IFF header"); - } - - // Allocate storage and copy the contents of the file to a memory buffer - std::vector<uint8_t> mBuffer(fileSize); - file->Read(&mBuffer[0], 1, fileSize); - mScene = pScene; - - // Determine the type of the file - uint32_t fileType; - const char *sz = IFF::ReadHeader(&mBuffer[0], fileType); - if (sz) { - throw DeadlyImportError(sz); - } - - mFileBuffer = &mBuffer[0] + 12; - fileSize -= 12; - - // Initialize some members with their default values - hasNamedLayer = false; - - // Create temporary storage on the stack but store pointers to it in the class - // instance. Therefore everything will be destructed properly if an exception - // is thrown and we needn't take care of that. - LayerList _mLayers; - SurfaceList _mSurfaces; - TagList _mTags; - TagMappingTable _mMapping; - - mLayers = &_mLayers; - mTags = &_mTags; - mMapping = &_mMapping; - mSurfaces = &_mSurfaces; - - // Allocate a default layer (layer indices are 1-based from now) - mLayers->push_back(Layer()); - mCurLayer = &mLayers->back(); - mCurLayer->mName = "<LWODefault>"; - mCurLayer->mIndex = (uint16_t) -1; - - // old lightwave file format (prior to v6) - if (AI_LWO_FOURCC_LWOB == fileType) { - ASSIMP_LOG_INFO("LWO file format: LWOB (<= LightWave 5.5)"); - - mIsLWO2 = false; - mIsLXOB = false; - LoadLWOBFile(); - } else if (AI_LWO_FOURCC_LWO2 == fileType) { - // New lightwave format - mIsLXOB = false; - ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)"); - } else if (AI_LWO_FOURCC_LXOB == fileType) { - // MODO file format - mIsLXOB = true; - ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)"); - } - else { - char szBuff[5]; - szBuff[0] = (char)(fileType >> 24u); - szBuff[1] = (char)(fileType >> 16u); - szBuff[2] = (char)(fileType >> 8u); - szBuff[3] = (char)(fileType); - szBuff[4] = '\0'; - throw DeadlyImportError("Unknown LWO sub format: ", szBuff); - } - - if (AI_LWO_FOURCC_LWOB != fileType) { - mIsLWO2 = true; - LoadLWO2File(); - - // The newer lightwave format allows the user to configure the - // loader that just one layer is used. If this is the case - // we need to check now whether the requested layer has been found. - if (UINT_MAX != configLayerIndex) { - unsigned int layerCount = 0; - for (std::list<LWO::Layer>::iterator itLayers = mLayers->begin(); itLayers != mLayers->end(); ++itLayers) - if (!itLayers->skip) - layerCount++; - if (layerCount != 2) - throw DeadlyImportError("LWO2: The requested layer was not found"); - } - - if (configLayerName.length() && !hasNamedLayer) { - throw DeadlyImportError("LWO2: Unable to find the requested layer: ", configLayerName); - } - } - - // now, as we have loaded all data, we can resolve cross-referenced tags and clips - ResolveTags(); - ResolveClips(); - - // now process all layers and build meshes and nodes - std::vector<aiMesh *> apcMeshes; - std::map<uint16_t, aiNode *> apcNodes; - - apcMeshes.reserve(mLayers->size() * std::min(((unsigned int)mSurfaces->size() / 2u), 1u)); - - unsigned int iDefaultSurface = UINT_MAX; // index of the default surface - for (LWO::Layer &layer : *mLayers) { - if (layer.skip) - continue; - - // I don't know whether there could be dummy layers, but it would be possible - const unsigned int meshStart = (unsigned int)apcMeshes.size(); - if (!layer.mFaces.empty() && !layer.mTempPoints.empty()) { - - // now sort all faces by the surfaces assigned to them - std::vector<SortedRep> pSorted(mSurfaces->size() + 1); - - unsigned int i = 0; - for (FaceList::iterator it = layer.mFaces.begin(), end = layer.mFaces.end(); it != end; ++it, ++i) { - // Check whether we support this face's type - if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH && - (*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) { - continue; - } - - unsigned int idx = (*it).surfaceIndex; - if (idx >= mTags->size()) { - ASSIMP_LOG_WARN("LWO: Invalid face surface index"); - idx = UINT_MAX; - } - if (UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) { - if (UINT_MAX == iDefaultSurface) { - iDefaultSurface = (unsigned int)mSurfaces->size(); - mSurfaces->push_back(LWO::Surface()); - LWO::Surface &surf = mSurfaces->back(); - surf.mColor.r = surf.mColor.g = surf.mColor.b = 0.6f; - surf.mName = "LWODefaultSurface"; - } - idx = iDefaultSurface; - } - pSorted[idx].push_back(i); - } - if (UINT_MAX == iDefaultSurface) { - pSorted.erase(pSorted.end() - 1); - } - for (unsigned int p = 0, j = 0; j < mSurfaces->size(); ++j) { - SortedRep &sorted = pSorted[j]; - if (sorted.empty()) - continue; - - // generate the mesh - aiMesh *mesh = new aiMesh(); - apcMeshes.push_back(mesh); - mesh->mNumFaces = (unsigned int)sorted.size(); - - // count the number of vertices - SortedRep::const_iterator it = sorted.begin(), end = sorted.end(); - for (; it != end; ++it) { - mesh->mNumVertices += layer.mFaces[*it].mNumIndices; - } - - aiVector3D *nrm = nullptr, *pv = mesh->mVertices = new aiVector3D[mesh->mNumVertices]; - aiFace *pf = mesh->mFaces = new aiFace[mesh->mNumFaces]; - mesh->mMaterialIndex = j; - - // find out which vertex color channels and which texture coordinate - // channels are really required by the material attached to this mesh - unsigned int vUVChannelIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - unsigned int vVColorIndices[AI_MAX_NUMBER_OF_COLOR_SETS]; - -#ifdef ASSIMP_BUILD_DEBUG - for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++mui) { - vUVChannelIndices[mui] = UINT_MAX; - } - for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS; ++mui) { - vVColorIndices[mui] = UINT_MAX; - } -#endif - - FindUVChannels(_mSurfaces[j], sorted, layer, vUVChannelIndices); - FindVCChannels(_mSurfaces[j], sorted, layer, vVColorIndices); - - // allocate storage for UV and CV channels - aiVector3D *pvUV[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++mui) { - if (UINT_MAX == vUVChannelIndices[mui]) { - break; - } - - pvUV[mui] = mesh->mTextureCoords[mui] = new aiVector3D[mesh->mNumVertices]; - - // LightWave doesn't support more than 2 UV components (?) - mesh->mNumUVComponents[0] = 2; - } - - if (layer.mNormals.name.length()) { - nrm = mesh->mNormals = new aiVector3D[mesh->mNumVertices]; - } - - aiColor4D *pvVC[AI_MAX_NUMBER_OF_COLOR_SETS]; - for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS; ++mui) { - if (UINT_MAX == vVColorIndices[mui]) { - break; - } - pvVC[mui] = mesh->mColors[mui] = new aiColor4D[mesh->mNumVertices]; - } - - // we would not need this extra array, but the code is much cleaner if we use it - std::vector<unsigned int> &smoothingGroups = layer.mPointReferrers; - smoothingGroups.erase(smoothingGroups.begin(), smoothingGroups.end()); - smoothingGroups.resize(mesh->mNumFaces, 0); - - // now convert all faces - unsigned int vert = 0; - std::vector<unsigned int>::iterator outIt = smoothingGroups.begin(); - for (it = sorted.begin(); it != end; ++it, ++outIt) { - const LWO::Face &face = layer.mFaces[*it]; - *outIt = face.smoothGroup; - - // copy all vertices - for (unsigned int q = 0; q < face.mNumIndices; ++q, ++vert) { - unsigned int idx = face.mIndices[q]; - *pv++ = layer.mTempPoints[idx] /*- layer.mPivot*/; - - // process UV coordinates - for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++w) { - if (UINT_MAX == vUVChannelIndices[w]) { - break; - } - aiVector3D *&pp = pvUV[w]; - const aiVector2D &src = ((aiVector2D *)&layer.mUVChannels[vUVChannelIndices[w]].rawData[0])[idx]; - pp->x = src.x; - pp->y = src.y; - pp++; - } - - // process normals (MODO extension) - if (nrm) { - *nrm = ((aiVector3D *)&layer.mNormals.rawData[0])[idx]; - nrm->z *= -1.f; - ++nrm; - } - - // process vertex colors - for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_COLOR_SETS; ++w) { - if (UINT_MAX == vVColorIndices[w]) { - break; - } - *pvVC[w] = ((aiColor4D *)&layer.mVColorChannels[vVColorIndices[w]].rawData[0])[idx]; - - // If a RGB color map is explicitly requested delete the - // alpha channel - it could theoretically be != 1. - if (_mSurfaces[j].mVCMapType == AI_LWO_RGB) - pvVC[w]->a = 1.f; - - pvVC[w]++; - } - -#if 0 - // process vertex weights. We can't properly reconstruct the whole skeleton for now, - // but we can create dummy bones for all weight channels which we have. - for (unsigned int w = 0; w < layer.mWeightChannels.size();++w) - { - } -#endif - - face.mIndices[q] = vert; - } - pf->mIndices = face.mIndices; - pf->mNumIndices = face.mNumIndices; - unsigned int **facePtr = (unsigned int **)&face.mIndices; - *facePtr = nullptr; // HACK: make sure it won't be deleted - pf++; - } - - if (!mesh->mNormals) { - // Compute normal vectors for the mesh - we can't use our GenSmoothNormal- - // Step here since it wouldn't handle smoothing groups correctly for LWO. - // So we use a separate implementation. - ComputeNormals(mesh, smoothingGroups, _mSurfaces[j]); - } else { - ASSIMP_LOG_VERBOSE_DEBUG("LWO2: No need to compute normals, they're already there"); - } - ++p; - } - } - - // Generate nodes to render the mesh. Store the source layer in the mParent member of the nodes - unsigned int num = static_cast<unsigned int>(apcMeshes.size() - meshStart); - if (layer.mName != "<LWODefault>" || num > 0) { - aiNode *pcNode = new aiNode(); - pcNode->mName.Set(layer.mName); - pcNode->mParent = (aiNode *)&layer; - pcNode->mNumMeshes = num; - - if (pcNode->mNumMeshes) { - pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes]; - for (unsigned int p = 0; p < pcNode->mNumMeshes; ++p) - pcNode->mMeshes[p] = p + meshStart; - } - apcNodes[layer.mIndex] = pcNode; - } - } - - if (apcNodes.empty() || apcMeshes.empty()) - throw DeadlyImportError("LWO: No meshes loaded"); - - // The RemoveRedundantMaterials step will clean this up later - pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = (unsigned int)mSurfaces->size()]; - for (unsigned int mat = 0; mat < pScene->mNumMaterials; ++mat) { - aiMaterial *pcMat = new aiMaterial(); - pScene->mMaterials[mat] = pcMat; - ConvertMaterial((*mSurfaces)[mat], pcMat); - } - - // copy the meshes to the output structure - pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = (unsigned int)apcMeshes.size()]; - ::memcpy(pScene->mMeshes, &apcMeshes[0], pScene->mNumMeshes * sizeof(void *)); - - // generate the final node graph - GenerateNodeGraph(apcNodes); -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::ComputeNormals(aiMesh *mesh, const std::vector<unsigned int> &smoothingGroups, - const LWO::Surface &surface) { - // Allocate output storage - mesh->mNormals = new aiVector3D[mesh->mNumVertices]; - - // First generate per-face normals - aiVector3D *out; - std::vector<aiVector3D> faceNormals; - - // ... in some cases that's already enough - if (!surface.mMaximumSmoothAngle) - out = mesh->mNormals; - else { - faceNormals.resize(mesh->mNumVertices); - out = &faceNormals[0]; - } - - aiFace *begin = mesh->mFaces, *const end = mesh->mFaces + mesh->mNumFaces; - for (; begin != end; ++begin) { - aiFace &face = *begin; - - if (face.mNumIndices < 3) { - continue; - } - - // LWO doc: "the normal is defined as the cross product of the first and last edges" - aiVector3D *pV1 = mesh->mVertices + face.mIndices[0]; - aiVector3D *pV2 = mesh->mVertices + face.mIndices[1]; - aiVector3D *pV3 = mesh->mVertices + face.mIndices[face.mNumIndices - 1]; - - aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).Normalize(); - for (unsigned int i = 0; i < face.mNumIndices; ++i) - out[face.mIndices[i]] = vNor; - } - if (!surface.mMaximumSmoothAngle) return; - const float posEpsilon = ComputePositionEpsilon(mesh); - - // Now generate the spatial sort tree - SGSpatialSort sSort; - std::vector<unsigned int>::const_iterator it = smoothingGroups.begin(); - for (begin = mesh->mFaces; begin != end; ++begin, ++it) { - aiFace &face = *begin; - for (unsigned int i = 0; i < face.mNumIndices; ++i) { - unsigned int tt = face.mIndices[i]; - sSort.Add(mesh->mVertices[tt], tt, *it); - } - } - // Sort everything - this takes O(nlogn) time - sSort.Prepare(); - std::vector<unsigned int> poResult; - poResult.reserve(20); - - // Generate vertex normals. We have O(logn) for the binary lookup, which we need - // for n elements, thus the EXPECTED complexity is O(nlogn) - if (surface.mMaximumSmoothAngle < 3.f && !configSpeedFlag) { - const float fLimit = std::cos(surface.mMaximumSmoothAngle); - - for (begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) { - const aiFace &face = *begin; - unsigned int *beginIdx = face.mIndices, *const endIdx = face.mIndices + face.mNumIndices; - for (; beginIdx != endIdx; ++beginIdx) { - unsigned int idx = *beginIdx; - sSort.FindPositions(mesh->mVertices[idx], *it, posEpsilon, poResult, true); - - aiVector3D vNormals; - for (std::vector<unsigned int>::const_iterator a = poResult.begin(); a != poResult.end(); ++a) { - const aiVector3D &v = faceNormals[*a]; - if (v * faceNormals[idx] < fLimit) - continue; - vNormals += v; - } - mesh->mNormals[idx] = vNormals.Normalize(); - } - } - } - // faster code path in case there is no smooth angle - else { - std::vector<bool> vertexDone(mesh->mNumVertices, false); - for (begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) { - const aiFace &face = *begin; - unsigned int *beginIdx = face.mIndices, *const endIdx = face.mIndices + face.mNumIndices; - for (; beginIdx != endIdx; ++beginIdx) { - unsigned int idx = *beginIdx; - if (vertexDone[idx]) - continue; - sSort.FindPositions(mesh->mVertices[idx], *it, posEpsilon, poResult, true); - - aiVector3D vNormals; - for (std::vector<unsigned int>::const_iterator a = poResult.begin(); a != poResult.end(); ++a) { - const aiVector3D &v = faceNormals[*a]; - vNormals += v; - } - vNormals.Normalize(); - for (std::vector<unsigned int>::const_iterator a = poResult.begin(); a != poResult.end(); ++a) { - mesh->mNormals[*a] = vNormals; - vertexDone[*a] = true; - } - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::GenerateNodeGraph(std::map<uint16_t, aiNode *> &apcNodes) { - // now generate the final nodegraph - generate a root node and attach children - aiNode *root = mScene->mRootNode = new aiNode(); - root->mName.Set("<LWORoot>"); - - //Set parent of all children, inserting pivots - std::map<uint16_t, aiNode *> mapPivot; - for (auto itapcNodes = apcNodes.begin(); itapcNodes != apcNodes.end(); ++itapcNodes) { - - //Get the parent index - LWO::Layer *nodeLayer = (LWO::Layer *)(itapcNodes->second->mParent); - uint16_t parentIndex = nodeLayer->mParent; - - //Create pivot node, store it into the pivot map, and set the parent as the pivot - aiNode *pivotNode = new aiNode(); - pivotNode->mName.Set("Pivot-" + std::string(itapcNodes->second->mName.data)); - itapcNodes->second->mParent = pivotNode; - - //Look for the parent node to attach the pivot to - if (apcNodes.find(parentIndex) != apcNodes.end()) { - pivotNode->mParent = apcNodes[parentIndex]; - } else { - //If not, attach to the root node - pivotNode->mParent = root; - } - - //Set the node and the pivot node transformation - itapcNodes->second->mTransformation.a4 = -nodeLayer->mPivot.x; - itapcNodes->second->mTransformation.b4 = -nodeLayer->mPivot.y; - itapcNodes->second->mTransformation.c4 = -nodeLayer->mPivot.z; - pivotNode->mTransformation.a4 = nodeLayer->mPivot.x; - pivotNode->mTransformation.b4 = nodeLayer->mPivot.y; - pivotNode->mTransformation.c4 = nodeLayer->mPivot.z; - mapPivot[-(itapcNodes->first + 2)] = pivotNode; - } - - //Merge pivot map into node map - for (auto itMapPivot = mapPivot.begin(); itMapPivot != mapPivot.end(); ++itMapPivot) { - apcNodes[itMapPivot->first] = itMapPivot->second; - } - - //Set children of all parents - apcNodes[(uint16_t)-1] = root; - for (auto itMapParentNodes = apcNodes.begin(); itMapParentNodes != apcNodes.end(); ++itMapParentNodes) { - for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) { - if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) { - ++(itMapParentNodes->second->mNumChildren); - } - } - if (itMapParentNodes->second->mNumChildren) { - itMapParentNodes->second->mChildren = new aiNode *[itMapParentNodes->second->mNumChildren]; - uint16_t p = 0; - for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) { - if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) { - itMapParentNodes->second->mChildren[p++] = itMapChildNodes->second; - } - } - } - } - - if (!mScene->mRootNode->mNumChildren) - throw DeadlyImportError("LWO: Unable to build a valid node graph"); - - // Remove a single root node with no meshes assigned to it ... - if (1 == mScene->mRootNode->mNumChildren) { - aiNode *pc = mScene->mRootNode->mChildren[0]; - pc->mParent = mScene->mRootNode->mChildren[0] = nullptr; - delete mScene->mRootNode; - mScene->mRootNode = pc; - } - - // convert the whole stuff to RH with CCW winding - MakeLeftHandedProcess maker; - maker.Execute(mScene); - - FlipWindingOrderProcess flipper; - flipper.Execute(mScene); -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::ResolveTags() { - // --- this function is used for both LWO2 and LWOB - mMapping->resize(mTags->size(), UINT_MAX); - for (unsigned int a = 0; a < mTags->size(); ++a) { - - const std::string &c = (*mTags)[a]; - for (unsigned int i = 0; i < mSurfaces->size(); ++i) { - - const std::string &d = (*mSurfaces)[i].mName; - if (!ASSIMP_stricmp(c, d)) { - - (*mMapping)[a] = i; - break; - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::ResolveClips() { - for (unsigned int i = 0; i < mClips.size(); ++i) { - - Clip &clip = mClips[i]; - if (Clip::REF == clip.type) { - - if (clip.clipRef >= mClips.size()) { - ASSIMP_LOG_ERROR("LWO2: Clip referrer index is out of range"); - clip.clipRef = 0; - } - - Clip &dest = mClips[clip.clipRef]; - if (Clip::REF == dest.type) { - ASSIMP_LOG_ERROR("LWO2: Clip references another clip reference"); - clip.type = Clip::UNSUPPORTED; - } - - else { - clip.path = dest.path; - clip.type = dest.type; - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::AdjustTexturePath(std::string &out) { - // --- this function is used for both LWO2 and LWOB - if (!mIsLWO2 && ::strstr(out.c_str(), "(sequence)")) { - - // remove the (sequence) and append 000 - ASSIMP_LOG_INFO("LWOB: Sequence of animated texture found. It will be ignored"); - out = out.substr(0, out.length() - 10) + "000"; - } - - // format: drive:path/file - we just need to insert a slash after the drive - std::string::size_type n = out.find_first_of(':'); - if (std::string::npos != n) { - out.insert(n + 1, "/"); - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOTags(unsigned int size) { - // --- this function is used for both LWO2 and LWOB - - const char *szCur = (const char *)mFileBuffer, *szLast = szCur; - const char *const szEnd = szLast + size; - while (szCur < szEnd) { - if (!(*szCur)) { - const size_t len = (size_t)(szCur - szLast); - // FIX: skip empty-sized tags - if (len) - mTags->push_back(std::string(szLast, len)); - szCur += (len & 0x1 ? 1 : 2); - szLast = szCur; - } - szCur++; - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWOPoints(unsigned int length) { - // --- this function is used for both LWO2 and LWOB but for - // LWO2 we need to allocate 25% more storage - it could be we'll - // need to duplicate some points later. - const size_t vertexLen = 12; - if ((length % vertexLen) != 0) { - throw DeadlyImportError("LWO2: Points chunk length is not multiple of vertexLen (12)"); - } - unsigned int regularSize = (unsigned int)mCurLayer->mTempPoints.size() + length / 12; - if (mIsLWO2) { - mCurLayer->mTempPoints.reserve(regularSize + (regularSize >> 2u)); - mCurLayer->mTempPoints.resize(regularSize); - - // initialize all point referrers with the default values - mCurLayer->mPointReferrers.reserve(regularSize + (regularSize >> 2u)); - mCurLayer->mPointReferrers.resize(regularSize, UINT_MAX); - } else - mCurLayer->mTempPoints.resize(regularSize); - - // perform endianness conversions -#ifndef AI_BUILD_BIG_ENDIAN - for (unsigned int i = 0; i<length >> 2; ++i) - ByteSwap::Swap4(mFileBuffer + (i << 2)); -#endif - ::memcpy(&mCurLayer->mTempPoints[0], mFileBuffer, length); -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2Polygons(unsigned int length) { - LE_NCONST uint16_t *const end = (LE_NCONST uint16_t *)(mFileBuffer + length); - const uint32_t type = GetU4(); - - // Determine the type of the polygons - switch (type) { - // read unsupported stuff too (although we won't process it) - case AI_LWO_MBAL: - ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (METABALL)"); - break; - case AI_LWO_CURV: - ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (SPLINE)"); - ; - break; - - // These are ok with no restrictions - case AI_LWO_PTCH: - case AI_LWO_FACE: - case AI_LWO_BONE: - case AI_LWO_SUBD: - break; - default: - - // hm!? wtf is this? ok ... - ASSIMP_LOG_ERROR("LWO2: Ignoring unknown polygon type."); - break; - } - - // first find out how many faces and vertices we'll finally need - uint16_t *cursor = (uint16_t *)mFileBuffer; - - unsigned int iNumFaces = 0, iNumVertices = 0; - CountVertsAndFacesLWO2(iNumVertices, iNumFaces, cursor, end); - - // allocate the output array and copy face indices - if (iNumFaces) { - cursor = (uint16_t *)mFileBuffer; - - mCurLayer->mFaces.resize(iNumFaces, LWO::Face(type)); - FaceList::iterator it = mCurLayer->mFaces.begin(); - CopyFaceIndicesLWO2(it, cursor, end); - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::CountVertsAndFacesLWO2(unsigned int &verts, unsigned int &faces, - uint16_t *&cursor, const uint16_t *const end, unsigned int max) { - while (cursor < end && max--) { - uint16_t numIndices; - ::memcpy(&numIndices, cursor++, 2); - AI_LSWAP2(numIndices); - numIndices &= 0x03FF; - - verts += numIndices; - ++faces; - - for (uint16_t i = 0; i < numIndices; i++) { - ReadVSizedIntLWO2((uint8_t *&)cursor); - } - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::CopyFaceIndicesLWO2(FaceList::iterator &it, - uint16_t *&cursor, - const uint16_t *const end) { - while (cursor < end) { - LWO::Face &face = *it++; - uint16_t numIndices; - ::memcpy(&numIndices, cursor++, 2); - AI_LSWAP2(numIndices); - face.mNumIndices = numIndices & 0x03FF; - - if (face.mNumIndices) /* byte swapping has already been done */ - { - face.mIndices = new unsigned int[face.mNumIndices]; - for (unsigned int i = 0; i < face.mNumIndices; i++) { - face.mIndices[i] = ReadVSizedIntLWO2((uint8_t *&)cursor) + mCurLayer->mPointIDXOfs; - if (face.mIndices[i] > mCurLayer->mTempPoints.size()) { - ASSIMP_LOG_WARN("LWO2: Failure evaluating face record, index is out of range"); - face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size() - 1; - } - } - } else - throw DeadlyImportError("LWO2: Encountered invalid face record with zero indices"); - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2PolygonTags(unsigned int length) { - LE_NCONST uint8_t *const end = mFileBuffer + length; - - AI_LWO_VALIDATE_CHUNK_LENGTH(length, PTAG, 4); - uint32_t type = GetU4(); - - if (type != AI_LWO_SURF && type != AI_LWO_SMGP) - return; - - while (mFileBuffer < end) { - unsigned int i = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs; - unsigned int j = GetU2(); - - if (i >= mCurLayer->mFaces.size()) { - ASSIMP_LOG_WARN("LWO2: face index in PTAG is out of range"); - continue; - } - - switch (type) { - - case AI_LWO_SURF: - mCurLayer->mFaces[i].surfaceIndex = j; - break; - case AI_LWO_SMGP: /* is that really used? */ - mCurLayer->mFaces[i].smoothGroup = j; - break; - }; - } -} - -// ------------------------------------------------------------------------------------------------ -template <class T> -VMapEntry *FindEntry(std::vector<T> &list, const std::string &name, bool perPoly) { - for (auto &elem : list) { - if (elem.name == name) { - if (!perPoly) { - ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names"); - } - return &elem; - } - } - list.push_back(T()); - VMapEntry *p = &list.back(); - p->name = name; - return p; -} - -// ------------------------------------------------------------------------------------------------ -template <class T> -inline void CreateNewEntry(T &chan, unsigned int srcIdx) { - if (!chan.name.length()) - return; - - chan.abAssigned[srcIdx] = true; - chan.abAssigned.resize(chan.abAssigned.size() + 1, false); - - for (unsigned int a = 0; a < chan.dims; ++a) - chan.rawData.push_back(chan.rawData[srcIdx * chan.dims + a]); -} - -// ------------------------------------------------------------------------------------------------ -template <class T> -inline void CreateNewEntry(std::vector<T> &list, unsigned int srcIdx) { - for (auto &elem : list) { - CreateNewEntry(elem, srcIdx); - } -} - -// ------------------------------------------------------------------------------------------------ -inline void LWOImporter::DoRecursiveVMAPAssignment(VMapEntry *base, unsigned int numRead, - unsigned int idx, float *data) { - ai_assert(nullptr != data); - LWO::ReferrerList &refList = mCurLayer->mPointReferrers; - unsigned int i; - - if (idx >= base->abAssigned.size()) { - throw DeadlyImportError("Bad index"); - } - base->abAssigned[idx] = true; - for (i = 0; i < numRead; ++i) { - base->rawData[idx * base->dims + i] = data[i]; - } - - if (UINT_MAX != (i = refList[idx])) { - DoRecursiveVMAPAssignment(base, numRead, i, data); - } -} - -// ------------------------------------------------------------------------------------------------ -inline void AddToSingleLinkedList(ReferrerList &refList, unsigned int srcIdx, unsigned int destIdx) { - if (UINT_MAX == refList[srcIdx]) { - refList[srcIdx] = destIdx; - return; - } - AddToSingleLinkedList(refList, refList[srcIdx], destIdx); -} - -// ------------------------------------------------------------------------------------------------ -// Load LWO2 vertex map -void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly) { - LE_NCONST uint8_t *const end = mFileBuffer + length; - - AI_LWO_VALIDATE_CHUNK_LENGTH(length, VMAP, 6); - unsigned int type = GetU4(); - unsigned int dims = GetU2(); - - VMapEntry *base; - - // read the name of the vertex map - std::string name; - GetS0(name, length); - - switch (type) { - case AI_LWO_TXUV: - if (dims != 2) { - ASSIMP_LOG_WARN("LWO2: Skipping UV channel \'", name, "\' with !2 components"); - return; - } - base = FindEntry(mCurLayer->mUVChannels, name, perPoly); - break; - case AI_LWO_WGHT: - case AI_LWO_MNVW: - if (dims != 1) { - ASSIMP_LOG_WARN("LWO2: Skipping Weight Channel \'", name, "\' with !1 components"); - return; - } - base = FindEntry((type == AI_LWO_WGHT ? mCurLayer->mWeightChannels : mCurLayer->mSWeightChannels), name, perPoly); - break; - case AI_LWO_RGB: - case AI_LWO_RGBA: - if (dims != 3 && dims != 4) { - ASSIMP_LOG_WARN("LWO2: Skipping Color Map \'", name, "\' with a dimension > 4 or < 3"); - return; - } - base = FindEntry(mCurLayer->mVColorChannels, name, perPoly); - break; - - case AI_LWO_MODO_NORM: - /* This is a non-standard extension chunk used by Luxology's MODO. - * It stores per-vertex normals. This VMAP exists just once, has - * 3 dimensions and is btw extremely beautiful. - */ - if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length()) - return; - - ASSIMP_LOG_INFO("Processing non-standard extension: MODO VMAP.NORM.vert_normals"); - - mCurLayer->mNormals.name = name; - base = &mCurLayer->mNormals; - break; - - case AI_LWO_PICK: /* these VMAPs are just silently dropped */ - case AI_LWO_MORF: - case AI_LWO_SPOT: - return; - - default: - if (name == "APS.Level") { - // XXX handle this (seems to be subdivision-related). - } - ASSIMP_LOG_WARN("LWO2: Skipping unknown VMAP/VMAD channel \'", name, "\'"); - return; - }; - base->Allocate((unsigned int)mCurLayer->mTempPoints.size()); - - // now read all entries in the map - type = std::min(dims, base->dims); - const unsigned int diff = (dims - type) << 2u; - - LWO::FaceList &list = mCurLayer->mFaces; - LWO::PointList &pointList = mCurLayer->mTempPoints; - LWO::ReferrerList &refList = mCurLayer->mPointReferrers; - - const unsigned int numPoints = (unsigned int)pointList.size(); - const unsigned int numFaces = (unsigned int)list.size(); - - while (mFileBuffer < end) { - - unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs; - if (idx >= numPoints) { - ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAP/VMAD entry \'", name, "\', vertex index is out of range"); - mFileBuffer += base->dims << 2u; - continue; - } - if (perPoly) { - unsigned int polyIdx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs; - if (base->abAssigned[idx]) { - // we have already a VMAP entry for this vertex - thus - // we need to duplicate the corresponding polygon. - if (polyIdx >= numFaces) { - ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAD entry \'", name, "\', polygon index is out of range"); - mFileBuffer += base->dims << 2u; - continue; - } - - LWO::Face &src = list[polyIdx]; - - // generate a new unique vertex for the corresponding index - but only - // if we can find the index in the face - bool had = false; - for (unsigned int i = 0; i < src.mNumIndices; ++i) { - - unsigned int srcIdx = src.mIndices[i], tmp = idx; - do { - if (tmp == srcIdx) - break; - } while ((tmp = refList[tmp]) != UINT_MAX); - if (tmp == UINT_MAX) { - continue; - } - - had = true; - refList.resize(refList.size() + 1, UINT_MAX); - - idx = (unsigned int)pointList.size(); - src.mIndices[i] = (unsigned int)pointList.size(); - - // store the index of the new vertex in the old vertex - // so we get a single linked list we can traverse in - // only one direction - AddToSingleLinkedList(refList, srcIdx, src.mIndices[i]); - pointList.push_back(pointList[srcIdx]); - - CreateNewEntry(mCurLayer->mVColorChannels, srcIdx); - CreateNewEntry(mCurLayer->mUVChannels, srcIdx); - CreateNewEntry(mCurLayer->mWeightChannels, srcIdx); - CreateNewEntry(mCurLayer->mSWeightChannels, srcIdx); - CreateNewEntry(mCurLayer->mNormals, srcIdx); - } - if (!had) { - ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAD entry \'", name, "\', vertex index wasn't found in that polygon"); - ai_assert(had); - } - } - } - - std::unique_ptr<float[]> temp(new float[type]); - for (unsigned int l = 0; l < type; ++l) - temp[l] = GetF4(); - - DoRecursiveVMAPAssignment(base, type, idx, temp.get()); - mFileBuffer += diff; - } -} - -// ------------------------------------------------------------------------------------------------ -// Load LWO2 clip -void LWOImporter::LoadLWO2Clip(unsigned int length) { - AI_LWO_VALIDATE_CHUNK_LENGTH(length, CLIP, 10); - - mClips.push_back(LWO::Clip()); - LWO::Clip &clip = mClips.back(); - - // first - get the index of the clip - clip.idx = GetU4(); - - IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - switch (head.type) { - case AI_LWO_STIL: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, STIL, 1); - - // "Normal" texture - GetS0(clip.path, head.length); - clip.type = Clip::STILL; - break; - - case AI_LWO_ISEQ: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ISEQ, 16); - // Image sequence. We'll later take the first. - { - uint8_t digits = GetU1(); - mFileBuffer++; - int16_t offset = GetU2(); - mFileBuffer += 4; - int16_t start = GetU2(); - mFileBuffer += 4; - - std::string s; - std::ostringstream ss; - GetS0(s, head.length); - - head.length -= (uint16_t)s.length() + 1; - ss << s; - ss << std::setw(digits) << offset + start; - GetS0(s, head.length); - ss << s; - clip.path = ss.str(); - clip.type = Clip::SEQ; - } - break; - - case AI_LWO_STCC: - ASSIMP_LOG_WARN("LWO2: Color shifted images are not supported"); - break; - - case AI_LWO_ANIM: - ASSIMP_LOG_WARN("LWO2: Animated textures are not supported"); - break; - - case AI_LWO_XREF: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, XREF, 4); - - // Just a cross-reference to another CLIp - clip.type = Clip::REF; - clip.clipRef = GetU4(); - break; - - case AI_LWO_NEGA: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, NEGA, 2); - clip.negate = (0 != GetU2()); - break; - - default: - ASSIMP_LOG_WARN("LWO2: Encountered unknown CLIP sub-chunk"); - } -} - -// ------------------------------------------------------------------------------------------------ -// Load envelope description -void LWOImporter::LoadLWO2Envelope(unsigned int length) { - LE_NCONST uint8_t *const end = mFileBuffer + length; - AI_LWO_VALIDATE_CHUNK_LENGTH(length, ENVL, 4); - - mEnvelopes.push_back(LWO::Envelope()); - LWO::Envelope &envelope = mEnvelopes.back(); - - // Get the index of the envelope - envelope.index = ReadVSizedIntLWO2(mFileBuffer); - - // It looks like there might be an extra U4 right after the index, - // at least in modo (LXOB) files: we'll ignore it if it's zero, - // otherwise it represents the start of a subchunk, so we backtrack. - if (mIsLXOB) { - uint32_t extra = GetU4(); - if (extra) { - mFileBuffer -= 4; - } - } - - // ... and read all subchunks - while (true) { - if (mFileBuffer + 6 >= end) break; - LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) - throw DeadlyImportError("LWO2: Invalid envelope chunk length"); - - uint8_t *const next = mFileBuffer + head.length; - switch (head.type) { - // Type & representation of the envelope - case AI_LWO_TYPE: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, TYPE, 2); - mFileBuffer++; // skip user format - - // Determine type of envelope - envelope.type = (LWO::EnvelopeType)*mFileBuffer; - ++mFileBuffer; - break; - - // precondition - case AI_LWO_PRE: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, PRE, 2); - envelope.pre = (LWO::PrePostBehaviour)GetU2(); - break; - - // postcondition - case AI_LWO_POST: - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, POST, 2); - envelope.post = (LWO::PrePostBehaviour)GetU2(); - break; - - // keyframe - case AI_LWO_KEY: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, KEY, 8); - - envelope.keys.push_back(LWO::Key()); - LWO::Key &key = envelope.keys.back(); - - key.time = GetF4(); - key.value = GetF4(); - break; - } - - // interval interpolation - case AI_LWO_SPAN: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SPAN, 4); - if (envelope.keys.size() < 2) - ASSIMP_LOG_WARN("LWO2: Unexpected SPAN chunk"); - else { - LWO::Key &key = envelope.keys.back(); - switch (GetU4()) { - case AI_LWO_STEP: - key.inter = LWO::IT_STEP; - break; - case AI_LWO_LINE: - key.inter = LWO::IT_LINE; - break; - case AI_LWO_TCB: - key.inter = LWO::IT_TCB; - break; - case AI_LWO_HERM: - key.inter = LWO::IT_HERM; - break; - case AI_LWO_BEZI: - key.inter = LWO::IT_BEZI; - break; - case AI_LWO_BEZ2: - key.inter = LWO::IT_BEZ2; - break; - default: - ASSIMP_LOG_WARN("LWO2: Unknown interval interpolation mode"); - }; - - // todo ... read params - } - break; - } - - default: - ASSIMP_LOG_WARN("LWO2: Encountered unknown ENVL subchunk"); - break; - } - // regardless how much we did actually read, go to the next chunk - mFileBuffer = next; - } -} - -// ------------------------------------------------------------------------------------------------ -// Load file - master function -void LWOImporter::LoadLWO2File() { - bool skip = false; - - LE_NCONST uint8_t *const end = mFileBuffer + fileSize; - unsigned int iUnnamed = 0; - while (true) { - if (mFileBuffer + sizeof(IFF::ChunkHeader) > end) break; - const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) { - throw DeadlyImportError("LWO2: Chunk length points behind the file"); - break; - } - uint8_t *const next = mFileBuffer + head.length; - - if (!head.length) { - mFileBuffer = next; - continue; - } - - switch (head.type) { - // new layer - case AI_LWO_LAYR: { - // add a new layer to the list .... - mLayers->push_back(LWO::Layer()); - LWO::Layer &layer = mLayers->back(); - mCurLayer = &layer; - - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, LAYR, 16); - - // layer index. - layer.mIndex = GetU2(); - - // Continue loading this layer or ignore it? Check the layer index property - if (UINT_MAX != configLayerIndex && (configLayerIndex - 1) != layer.mIndex) { - skip = true; - } else - skip = false; - - // pivot point - mFileBuffer += 2; /* unknown */ - mCurLayer->mPivot.x = GetF4(); - mCurLayer->mPivot.y = GetF4(); - mCurLayer->mPivot.z = GetF4(); - GetS0(layer.mName, head.length - 16); - - // if the name is empty, generate a default name - if (layer.mName.empty()) { - char buffer[128]; // should be sufficiently large - ::ai_snprintf(buffer, 128, "Layer_%i", iUnnamed++); - layer.mName = buffer; - } - - // load this layer or ignore it? Check the layer name property - if (configLayerName.length() && configLayerName != layer.mName) { - skip = true; - } else - hasNamedLayer = true; - - // optional: parent of this layer - if (mFileBuffer + 2 <= next) - layer.mParent = GetU2(); - else - layer.mParent = (uint16_t) -1; - - // Set layer skip parameter - layer.skip = skip; - - break; - } - - // vertex list - case AI_LWO_PNTS: { - if (skip) - break; - - unsigned int old = (unsigned int)mCurLayer->mTempPoints.size(); - LoadLWOPoints(head.length); - mCurLayer->mPointIDXOfs = old; - break; - } - // vertex tags - case AI_LWO_VMAD: - if (mCurLayer->mFaces.empty()) { - ASSIMP_LOG_WARN("LWO2: Unexpected VMAD chunk"); - break; - } - // --- intentionally no break here - case AI_LWO_VMAP: { - if (skip) - break; - - if (mCurLayer->mTempPoints.empty()) - ASSIMP_LOG_WARN("LWO2: Unexpected VMAP chunk"); - else - LoadLWO2VertexMap(head.length, head.type == AI_LWO_VMAD); - break; - } - // face list - case AI_LWO_POLS: { - if (skip) - break; - - unsigned int old = (unsigned int)mCurLayer->mFaces.size(); - LoadLWO2Polygons(head.length); - mCurLayer->mFaceIDXOfs = old; - break; - } - // polygon tags - case AI_LWO_PTAG: { - if (skip) - break; - - if (mCurLayer->mFaces.empty()) { - ASSIMP_LOG_WARN("LWO2: Unexpected PTAG"); - } else { - LoadLWO2PolygonTags(head.length); - } - break; - } - // list of tags - case AI_LWO_TAGS: { - if (!mTags->empty()) { - ASSIMP_LOG_WARN("LWO2: SRFS chunk encountered twice"); - } else { - LoadLWOTags(head.length); - } - break; - } - - // surface chunk - case AI_LWO_SURF: { - LoadLWO2Surface(head.length); - break; - } - - // clip chunk - case AI_LWO_CLIP: { - LoadLWO2Clip(head.length); - break; - } - - // envelope chunk - case AI_LWO_ENVL: { - LoadLWO2Envelope(head.length); - break; - } - } - mFileBuffer = next; - } -} - -#endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.h b/src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.h deleted file mode 100644 index f3add53..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOLoader.h +++ /dev/null @@ -1,468 +0,0 @@ -/* -Open Asset Import Library (assimp) ----------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the -following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - ----------------------------------------------------------------------- -*/ - -/** @file Declaration of the LWO importer class. */ -#pragma once -#ifndef AI_LWOLOADER_H_INCLUDED -#define AI_LWOLOADER_H_INCLUDED - -#include "LWOFileData.h" -#include <assimp/BaseImporter.h> -#include <assimp/material.h> -#include <assimp/DefaultLogger.hpp> - -#include <map> - -struct aiTexture; -struct aiNode; -struct aiMaterial; - -namespace Assimp { -using namespace LWO; - -// --------------------------------------------------------------------------- -/** Class to load LWO files. - * - * @note Methods named "xxxLWO2[xxx]" are used with the newer LWO2 format. - * Methods named "xxxLWOB[xxx]" are used with the older LWOB format. - * Methods named "xxxLWO[xxx]" are used with both formats. - * Methods named "xxx" are used to preprocess the loaded data - - * they aren't specific to one format version -*/ -// --------------------------------------------------------------------------- -class LWOImporter : public BaseImporter { -public: - LWOImporter(); - ~LWOImporter() override; - - // ------------------------------------------------------------------- - /** Returns whether the class can handle the format of the given file. - * See BaseImporter::CanRead() for details. - */ - bool CanRead(const std::string &pFile, IOSystem *pIOHandler, - bool checkSig) const override; - - // ------------------------------------------------------------------- - /** Called prior to ReadFile(). - * The function is a request to the importer to update its configuration - * basing on the Importer's configuration property list. - */ - void SetupProperties(const Importer *pImp) override; - -protected: - // ------------------------------------------------------------------- - // Get list of supported extensions - const aiImporterDesc *GetInfo() const override; - - // ------------------------------------------------------------------- - /** Imports the given file into the given scene structure. - * See BaseImporter::InternReadFile() for details - */ - void InternReadFile(const std::string &pFile, aiScene *pScene, - IOSystem *pIOHandler) override; - -private: - // ------------------------------------------------------------------- - /** Loads a LWO file in the older LWOB format (LW < 6) - */ - void LoadLWOBFile(); - - // ------------------------------------------------------------------- - /** Loads a LWO file in the newer LWO2 format (LW >= 6) - */ - void LoadLWO2File(); - - // ------------------------------------------------------------------- - /** Parsing functions used for all file format versions - */ - inline void GetS0(std::string &out, unsigned int max); - inline float GetF4(); - inline uint32_t GetU4(); - inline uint16_t GetU2(); - inline uint8_t GetU1(); - - // ------------------------------------------------------------------- - /** Loads a surface chunk from an LWOB file - * @param size Maximum size to be read, in bytes. - */ - void LoadLWOBSurface(unsigned int size); - - // ------------------------------------------------------------------- - /** Loads a surface chunk from an LWO2 file - * @param size Maximum size to be read, in bytes. - */ - void LoadLWO2Surface(unsigned int size); - - // ------------------------------------------------------------------- - /** Loads a texture block from a LWO2 file. - * @param size Maximum size to be read, in bytes. - * @param head Header of the SUF.BLOK header - */ - void LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader *head, - unsigned int size); - - // ------------------------------------------------------------------- - /** Loads a shader block from a LWO2 file. - * @param size Maximum size to be read, in bytes. - * @param head Header of the SUF.BLOK header - */ - void LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader *head, - unsigned int size); - - // ------------------------------------------------------------------- - /** Loads an image map from a LWO2 file - * @param size Maximum size to be read, in bytes. - * @param tex Texture object to be filled - */ - void LoadLWO2ImageMap(unsigned int size, LWO::Texture &tex); - void LoadLWO2Gradient(unsigned int size, LWO::Texture &tex); - void LoadLWO2Procedural(unsigned int size, LWO::Texture &tex); - - // loads the header - used by thethree functions above - void LoadLWO2TextureHeader(unsigned int size, LWO::Texture &tex); - - // ------------------------------------------------------------------- - /** Loads the LWO tag list from the file - * @param size Maximum size to be read, in bytes. - */ - void LoadLWOTags(unsigned int size); - - // ------------------------------------------------------------------- - /** Load polygons from a POLS chunk - * @param length Size of the chunk - */ - void LoadLWO2Polygons(unsigned int length); - void LoadLWOBPolygons(unsigned int length); - - // ------------------------------------------------------------------- - /** Load polygon tags from a PTAG chunk - * @param length Size of the chunk - */ - void LoadLWO2PolygonTags(unsigned int length); - - // ------------------------------------------------------------------- - /** Load a vertex map from a VMAP/VMAD chunk - * @param length Size of the chunk - * @param perPoly Operate on per-polygon base? - */ - void LoadLWO2VertexMap(unsigned int length, bool perPoly); - - // ------------------------------------------------------------------- - /** Load polygons from a PNTS chunk - * @param length Size of the chunk - */ - void LoadLWOPoints(unsigned int length); - - // ------------------------------------------------------------------- - /** Load a clip from a CLIP chunk - * @param length Size of the chunk - */ - void LoadLWO2Clip(unsigned int length); - - // ------------------------------------------------------------------- - /** Load an envelope from an EVL chunk - * @param length Size of the chunk - */ - void LoadLWO2Envelope(unsigned int length); - - // ------------------------------------------------------------------- - /** Count vertices and faces in a LWOB/LWO2 file - */ - void CountVertsAndFacesLWO2(unsigned int &verts, - unsigned int &faces, - uint16_t *&cursor, - const uint16_t *const end, - unsigned int max = UINT_MAX); - - void CountVertsAndFacesLWOB(unsigned int &verts, - unsigned int &faces, - LE_NCONST uint16_t *&cursor, - const uint16_t *const end, - unsigned int max = UINT_MAX); - - // ------------------------------------------------------------------- - /** Read vertices and faces in a LWOB/LWO2 file - */ - void CopyFaceIndicesLWO2(LWO::FaceList::iterator &it, - uint16_t *&cursor, - const uint16_t *const end); - - // ------------------------------------------------------------------- - void CopyFaceIndicesLWOB(LWO::FaceList::iterator &it, - LE_NCONST uint16_t *&cursor, - const uint16_t *const end, - unsigned int max = UINT_MAX); - - // ------------------------------------------------------------------- - /** Resolve the tag and surface lists that have been loaded. - * Generates the mMapping table. - */ - void ResolveTags(); - - // ------------------------------------------------------------------- - /** Resolve the clip list that has been loaded. - * Replaces clip references with real clips. - */ - void ResolveClips(); - - // ------------------------------------------------------------------- - /** Add a texture list to an output material description. - * - * @param pcMat Output material - * @param in Input texture list - * @param type Type identifier of the texture list - */ - bool HandleTextures(aiMaterial *pcMat, const TextureList &in, - aiTextureType type); - - // ------------------------------------------------------------------- - /** Adjust a texture path - */ - void AdjustTexturePath(std::string &out); - - // ------------------------------------------------------------------- - /** Convert a LWO surface description to an ASSIMP material - */ - void ConvertMaterial(const LWO::Surface &surf, aiMaterial *pcMat); - - // ------------------------------------------------------------------- - /** Get a list of all UV/VC channels required by a specific surface. - * - * @param surf Working surface - * @param layer Working layer - * @param out Output list. The members are indices into the - * UV/VC channel lists of the layer - */ - void FindUVChannels(/*const*/ LWO::Surface &surf, - LWO::SortedRep &sorted, - /*const*/ LWO::Layer &layer, - unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS]); - - // ------------------------------------------------------------------- - char FindUVChannels(LWO::TextureList &list, - LWO::Layer &layer, LWO::UVChannel &uv, unsigned int next); - - // ------------------------------------------------------------------- - void FindVCChannels(const LWO::Surface &surf, - LWO::SortedRep &sorted, - const LWO::Layer &layer, - unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS]); - - // ------------------------------------------------------------------- - /** Generate the final node graph - * Unused nodes are deleted. - * @param apcNodes Flat list of nodes - */ - void GenerateNodeGraph(std::map<uint16_t, aiNode *> &apcNodes); - - // ------------------------------------------------------------------- - /** Add children to a node - * @param node Node to become a father - * @param parent Index of the node - * @param apcNodes Flat list of nodes - used nodes are set to nullptr. - */ - void AddChildren(aiNode *node, uint16_t parent, - std::vector<aiNode *> &apcNodes); - - // ------------------------------------------------------------------- - /** Read a variable sized integer - * @param inout Input and output buffer - */ - int ReadVSizedIntLWO2(uint8_t *&inout); - - // ------------------------------------------------------------------- - /** Assign a value from a VMAP to a vertex and all vertices - * attached to it. - * @param base VMAP destination data - * @param numRead Number of float's to be read - * @param idx Absolute index of the first vertex - * @param data Value of the VMAP to be assigned - read numRead - * floats from this array. - */ - void DoRecursiveVMAPAssignment(VMapEntry *base, unsigned int numRead, - unsigned int idx, float *data); - - // ------------------------------------------------------------------- - /** Compute normal vectors for a mesh - * @param mesh Input mesh - * @param smoothingGroups Smoothing-groups-per-face array - * @param surface Surface for the mesh - */ - void ComputeNormals(aiMesh *mesh, const std::vector<unsigned int> &smoothingGroups, - const LWO::Surface &surface); - - // ------------------------------------------------------------------- - /** Setup a new texture after the corresponding chunk was - * encountered in the file. - * @param list Texture list - * @param size Maximum number of bytes to be read - * @return Pointer to new texture - */ - LWO::Texture *SetupNewTextureLWOB(LWO::TextureList &list, - unsigned int size); - -protected: - /** true if the file is a LWO2 file*/ - bool mIsLWO2; - - /** true if the file is a LXOB file*/ - bool mIsLXOB; - - /** Temporary list of layers from the file */ - LayerList *mLayers; - - /** Pointer to the current layer */ - LWO::Layer *mCurLayer; - - /** Temporary tag list from the file */ - TagList *mTags; - - /** Mapping table to convert from tag to surface indices. - UINT_MAX indicates that a no corresponding surface is available */ - TagMappingTable *mMapping; - - /** Temporary surface list from the file */ - SurfaceList *mSurfaces; - - /** Temporary clip list from the file */ - ClipList mClips; - - /** Temporary envelope list from the file */ - EnvelopeList mEnvelopes; - - /** file buffer */ - uint8_t *mFileBuffer; - - /** Size of the file, in bytes */ - unsigned int fileSize; - - /** Output scene */ - aiScene *mScene; - - /** Configuration option: speed flag set? */ - bool configSpeedFlag; - - /** Configuration option: index of layer to be loaded */ - unsigned int configLayerIndex; - - /** Configuration option: name of layer to be loaded */ - std::string configLayerName; - - /** True if we have a named layer */ - bool hasNamedLayer; -}; - -// ------------------------------------------------------------------------------------------------ -inline float LWOImporter::GetF4() { - float f; - ::memcpy(&f, mFileBuffer, 4); - mFileBuffer += 4; - AI_LSWAP4(f); - return f; -} - -// ------------------------------------------------------------------------------------------------ -inline uint32_t LWOImporter::GetU4() { - uint32_t f; - ::memcpy(&f, mFileBuffer, 4); - mFileBuffer += 4; - AI_LSWAP4(f); - return f; -} - -// ------------------------------------------------------------------------------------------------ -inline uint16_t LWOImporter::GetU2() { - uint16_t f; - ::memcpy(&f, mFileBuffer, 2); - mFileBuffer += 2; - AI_LSWAP2(f); - return f; -} - -// ------------------------------------------------------------------------------------------------ -inline uint8_t LWOImporter::GetU1() { - return *mFileBuffer++; -} - -// ------------------------------------------------------------------------------------------------ -inline int LWOImporter::ReadVSizedIntLWO2(uint8_t *&inout) { - int i; - int c = *inout; - inout++; - if (c != 0xFF) { - i = c << 8; - c = *inout; - inout++; - i |= c; - } else { - c = *inout; - inout++; - i = c << 16; - c = *inout; - inout++; - i |= c << 8; - c = *inout; - inout++; - i |= c; - } - return i; -} - -// ------------------------------------------------------------------------------------------------ -inline void LWOImporter::GetS0(std::string &out, unsigned int max) { - unsigned int iCursor = 0; - const char *sz = (const char *)mFileBuffer; - while (*mFileBuffer) { - if (++iCursor > max) { - ASSIMP_LOG_WARN("LWO: Invalid file, string is is too long"); - break; - } - ++mFileBuffer; - } - size_t len = (size_t)((const char *)mFileBuffer - sz); - out = std::string(sz, len); - mFileBuffer += (len & 0x1 ? 1 : 2); -} - -} // end of namespace Assimp - -#endif // AI_LWOIMPORTER_H_INCLUDED diff --git a/src/mesh/assimp-master/code/AssetLib/LWO/LWOMaterial.cpp b/src/mesh/assimp-master/code/AssetLib/LWO/LWOMaterial.cpp deleted file mode 100644 index b6f0bcc..0000000 --- a/src/mesh/assimp-master/code/AssetLib/LWO/LWOMaterial.cpp +++ /dev/null @@ -1,844 +0,0 @@ -/* ---------------------------------------------------------------------------- -Open Asset Import Library (assimp) ---------------------------------------------------------------------------- - -Copyright (c) 2006-2022, assimp team - - - -All rights reserved. - -Redistribution and use of this software in source and binary forms, -with or without modification, are permitted provided that the following -conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of the assimp team, nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission of the assimp team. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ---------------------------------------------------------------------------- -*/ - -/** @file Implementation of the material oart of the LWO importer class */ - -#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER - -// internal headers -#include "LWOLoader.h" -#include <assimp/ByteSwapper.h> - -using namespace Assimp; - -// ------------------------------------------------------------------------------------------------ -template <class T> -T lerp(const T &one, const T &two, float val) { - return one + (two - one) * val; -} - -// ------------------------------------------------------------------------------------------------ -// Convert a lightwave mapping mode to our's -inline aiTextureMapMode GetMapMode(LWO::Texture::Wrap in) { - switch (in) { - case LWO::Texture::REPEAT: - return aiTextureMapMode_Wrap; - - case LWO::Texture::MIRROR: - return aiTextureMapMode_Mirror; - - case LWO::Texture::RESET: - ASSIMP_LOG_WARN("LWO2: Unsupported texture map mode: RESET"); - - // fall though here - case LWO::Texture::EDGE: - return aiTextureMapMode_Clamp; - } - return (aiTextureMapMode)0; -} - -// ------------------------------------------------------------------------------------------------ -bool LWOImporter::HandleTextures(aiMaterial *pcMat, const TextureList &in, aiTextureType type) { - ai_assert(nullptr != pcMat); - - unsigned int cur = 0, temp = 0; - aiString s; - bool ret = false; - - for (const auto &texture : in) { - if (!texture.enabled || !texture.bCanUse) - continue; - ret = true; - - // Convert lightwave's mapping modes to ours. We let them - // as they are, the GenUVcoords step will compute UV - // channels if they're not there. - - aiTextureMapping mapping = aiTextureMapping_OTHER; - switch (texture.mapMode) { - case LWO::Texture::Planar: - mapping = aiTextureMapping_PLANE; - break; - case LWO::Texture::Cylindrical: - mapping = aiTextureMapping_CYLINDER; - break; - case LWO::Texture::Spherical: - mapping = aiTextureMapping_SPHERE; - break; - case LWO::Texture::Cubic: - mapping = aiTextureMapping_BOX; - break; - case LWO::Texture::FrontProjection: - ASSIMP_LOG_ERROR("LWO2: Unsupported texture mapping: FrontProjection"); - mapping = aiTextureMapping_OTHER; - break; - case LWO::Texture::UV: { - if (UINT_MAX == texture.mRealUVIndex) { - // We have no UV index for this texture, so we can't display it - continue; - } - - // add the UV source index - temp = texture.mRealUVIndex; - pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_UVWSRC(type, cur)); - - mapping = aiTextureMapping_UV; - } break; - default: - ai_assert(false); - }; - - if (mapping != aiTextureMapping_UV) { - // Setup the main axis - aiVector3D v; - switch (texture.majorAxis) { - case Texture::AXIS_X: - v = aiVector3D(1.0, 0.0, 0.0); - break; - case Texture::AXIS_Y: - v = aiVector3D(0.0, 1.0, 0.0); - break; - default: // case Texture::AXIS_Z: - v = aiVector3D(0.0, 0.0, 1.0); - break; - } - - pcMat->AddProperty(&v, 1, AI_MATKEY_TEXMAP_AXIS(type, cur)); - - // Setup UV scalings for cylindric and spherical projections - if (mapping == aiTextureMapping_CYLINDER || mapping == aiTextureMapping_SPHERE) { - aiUVTransform trafo; - trafo.mScaling.x = texture.wrapAmountW; - trafo.mScaling.y = texture.wrapAmountH; - - static_assert(sizeof(aiUVTransform) / sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5"); - pcMat->AddProperty(&trafo, 1, AI_MATKEY_UVTRANSFORM(type, cur)); - } - ASSIMP_LOG_VERBOSE_DEBUG("LWO2: Setting up non-UV mapping"); - } - - // The older LWOB format does not use indirect references to clips. - // The file name of a texture is directly specified in the tex chunk. - if (mIsLWO2) { - // find the corresponding clip (take the last one if multiple - // share the same index) - ClipList::iterator end = mClips.end(), candidate = end; - temp = texture.mClipIdx; - for (ClipList::iterator clip = mClips.begin(); clip != end; ++clip) { - if ((*clip).idx == temp) { - candidate = clip; - } - } - if (candidate == end) { - ASSIMP_LOG_ERROR("LWO2: Clip index is out of bounds"); - temp = 0; - - // fixme: apparently some LWO files shipping with Doom3 don't - // have clips at all ... check whether that's true or whether - // it's a bug in the loader. - - s.Set("$texture.png"); - - //continue; - } else { - if (Clip::UNSUPPORTED == (*candidate).type) { - ASSIMP_LOG_ERROR("LWO2: Clip type is not supported"); - continue; - } - AdjustTexturePath((*candidate).path); - s.Set((*candidate).path); - - // Additional image settings - int flags = 0; - if ((*candidate).negate) { - flags |= aiTextureFlags_Invert; - } - pcMat->AddProperty(&flags, 1, AI_MATKEY_TEXFLAGS(type, cur)); - } - } else { - std::string ss = texture.mFileName; - if (!ss.length()) { - ASSIMP_LOG_WARN("LWOB: Empty file name"); - continue; - } - AdjustTexturePath(ss); - s.Set(ss); - } - pcMat->AddProperty(&s, AI_MATKEY_TEXTURE(type, cur)); - - // add the blend factor - pcMat->AddProperty<float>(&texture.mStrength, 1, AI_MATKEY_TEXBLEND(type, cur)); - - // add the blend operation - switch (texture.blendType) { - case LWO::Texture::Normal: - case LWO::Texture::Multiply: - temp = (unsigned int)aiTextureOp_Multiply; - break; - - case LWO::Texture::Subtractive: - case LWO::Texture::Difference: - temp = (unsigned int)aiTextureOp_Subtract; - break; - - case LWO::Texture::Divide: - temp = (unsigned int)aiTextureOp_Divide; - break; - - case LWO::Texture::Additive: - temp = (unsigned int)aiTextureOp_Add; - break; - - default: - temp = (unsigned int)aiTextureOp_Multiply; - ASSIMP_LOG_WARN("LWO2: Unsupported texture blend mode: alpha or displacement"); - } - // Setup texture operation - pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_TEXOP(type, cur)); - - // setup the mapping mode - int mapping_ = static_cast<int>(mapping); - pcMat->AddProperty<int>(&mapping_, 1, AI_MATKEY_MAPPING(type, cur)); - - // add the u-wrapping - temp = (unsigned int)GetMapMode(texture.wrapModeWidth); - pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_MAPPINGMODE_U(type, cur)); - - // add the v-wrapping - temp = (unsigned int)GetMapMode(texture.wrapModeHeight); - pcMat->AddProperty<int>((int *)&temp, 1, AI_MATKEY_MAPPINGMODE_V(type, cur)); - - ++cur; - } - return ret; -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::ConvertMaterial(const LWO::Surface &surf, aiMaterial *pcMat) { - // copy the name of the surface - aiString st; - st.Set(surf.mName); - pcMat->AddProperty(&st, AI_MATKEY_NAME); - - const int i = surf.bDoubleSided ? 1 : 0; - pcMat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED); - - // add the refraction index and the bump intensity - pcMat->AddProperty(&surf.mIOR, 1, AI_MATKEY_REFRACTI); - pcMat->AddProperty(&surf.mBumpIntensity, 1, AI_MATKEY_BUMPSCALING); - - aiShadingMode m; - if (surf.mSpecularValue && surf.mGlossiness) { - float fGloss; - if (mIsLWO2) { - fGloss = std::pow(surf.mGlossiness * ai_real(10.0) + ai_real(2.0), ai_real(2.0)); - } else { - if (16.0 >= surf.mGlossiness) - fGloss = 6.0; - else if (64.0 >= surf.mGlossiness) - fGloss = 20.0; - else if (256.0 >= surf.mGlossiness) - fGloss = 50.0; - else - fGloss = 80.0; - } - - pcMat->AddProperty(&surf.mSpecularValue, 1, AI_MATKEY_SHININESS_STRENGTH); - pcMat->AddProperty(&fGloss, 1, AI_MATKEY_SHININESS); - m = aiShadingMode_Phong; - } else - m = aiShadingMode_Gouraud; - - // specular color - aiColor3D clr = lerp(aiColor3D(1.0, 1.0, 1.0), surf.mColor, surf.mColorHighlights); - pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); - pcMat->AddProperty(&surf.mSpecularValue, 1, AI_MATKEY_SHININESS_STRENGTH); - - // emissive color - // luminosity is not really the same but it affects the surface in a similar way. Some scaling looks good. - clr.g = clr.b = clr.r = surf.mLuminosity * ai_real(0.8); - pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_EMISSIVE); - - // opacity ... either additive or default-blended, please - if (0.0 != surf.mAdditiveTransparency) { - const int add = aiBlendMode_Additive; - pcMat->AddProperty(&surf.mAdditiveTransparency, 1, AI_MATKEY_OPACITY); - pcMat->AddProperty(&add, 1, AI_MATKEY_BLEND_FUNC); - } else if (10e10f != surf.mTransparency) { - const int def = aiBlendMode_Default; - const float f = 1.0f - surf.mTransparency; - pcMat->AddProperty(&f, 1, AI_MATKEY_OPACITY); - pcMat->AddProperty(&def, 1, AI_MATKEY_BLEND_FUNC); - } - - // ADD TEXTURES to the material - // TODO: find out how we can handle COLOR textures correctly... - bool b = HandleTextures(pcMat, surf.mColorTextures, aiTextureType_DIFFUSE); - b = (b || HandleTextures(pcMat, surf.mDiffuseTextures, aiTextureType_DIFFUSE)); - HandleTextures(pcMat, surf.mSpecularTextures, aiTextureType_SPECULAR); - HandleTextures(pcMat, surf.mGlossinessTextures, aiTextureType_SHININESS); - HandleTextures(pcMat, surf.mBumpTextures, aiTextureType_HEIGHT); - HandleTextures(pcMat, surf.mOpacityTextures, aiTextureType_OPACITY); - HandleTextures(pcMat, surf.mReflectionTextures, aiTextureType_REFLECTION); - - // Now we need to know which shader to use .. iterate through the shader list of - // the surface and search for a name which we know ... - for (const auto &shader : surf.mShaders) { - if (shader.functionName == "LW_SuperCelShader" || shader.functionName == "AH_CelShader") { - ASSIMP_LOG_INFO("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon"); - - m = aiShadingMode_Toon; - break; - } else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel") { - ASSIMP_LOG_INFO("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel"); - - m = aiShadingMode_Fresnel; - break; - } else { - ASSIMP_LOG_WARN("LWO2: Unknown surface shader: ", shader.functionName); - } - } - if (surf.mMaximumSmoothAngle <= 0.0) - m = aiShadingMode_Flat; - int m_ = static_cast<int>(m); - pcMat->AddProperty(&m_, 1, AI_MATKEY_SHADING_MODEL); - - // (the diffuse value is just a scaling factor) - // If a diffuse texture is set, we set this value to 1.0 - clr = (b && false ? aiColor3D(1.0, 1.0, 1.0) : surf.mColor); - clr.r *= surf.mDiffuseValue; - clr.g *= surf.mDiffuseValue; - clr.b *= surf.mDiffuseValue; - pcMat->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); -} - -// ------------------------------------------------------------------------------------------------ -char LWOImporter::FindUVChannels(LWO::TextureList &list, - LWO::Layer & /*layer*/, LWO::UVChannel &uv, unsigned int next) { - char ret = 0; - for (auto &texture : list) { - - // Ignore textures with non-UV mappings for the moment. - if (!texture.enabled || !texture.bCanUse || texture.mapMode != LWO::Texture::UV) { - continue; - } - - if (texture.mUVChannelIndex == uv.name) { - ret = 1; - - // got it. - if (texture.mRealUVIndex == UINT_MAX || texture.mRealUVIndex == next) { - texture.mRealUVIndex = next; - } else { - // channel mismatch. need to duplicate the material. - ASSIMP_LOG_WARN("LWO: Channel mismatch, would need to duplicate surface [design bug]"); - - // TODO - } - } - } - return ret; -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::FindUVChannels(LWO::Surface &surf, - LWO::SortedRep &sorted, LWO::Layer &layer, - unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS]) { - unsigned int next = 0, extra = 0, num_extra = 0; - - // Check whether we have an UV entry != 0 for one of the faces in 'sorted' - for (unsigned int i = 0; i < layer.mUVChannels.size(); ++i) { - LWO::UVChannel &uv = layer.mUVChannels[i]; - - for (LWO::SortedRep::const_iterator it = sorted.begin(); it != sorted.end(); ++it) { - - LWO::Face &face = layer.mFaces[*it]; - - for (unsigned int n = 0; n < face.mNumIndices; ++n) { - unsigned int idx = face.mIndices[n]; - - if (uv.abAssigned[idx] && ((aiVector2D *)&uv.rawData[0])[idx] != aiVector2D()) { - - if (extra >= AI_MAX_NUMBER_OF_TEXTURECOORDS) { - - ASSIMP_LOG_ERROR("LWO: Maximum number of UV channels for " - "this mesh reached. Skipping channel \'" + - uv.name + "\'"); - - } else { - // Search through all textures assigned to 'surf' and look for this UV channel - char had = 0; - had |= FindUVChannels(surf.mColorTextures, layer, uv, next); - had |= FindUVChannels(surf.mDiffuseTextures, layer, uv, next); - had |= FindUVChannels(surf.mSpecularTextures, layer, uv, next); - had |= FindUVChannels(surf.mGlossinessTextures, layer, uv, next); - had |= FindUVChannels(surf.mOpacityTextures, layer, uv, next); - had |= FindUVChannels(surf.mBumpTextures, layer, uv, next); - had |= FindUVChannels(surf.mReflectionTextures, layer, uv, next); - - // We have a texture referencing this UV channel so we have to take special care - // and are willing to drop unreferenced channels in favour of it. - if (had != 0) { - if (num_extra) { - - for (unsigned int a = next; a < std::min(extra, AI_MAX_NUMBER_OF_TEXTURECOORDS - 1u); ++a) { - out[a + 1] = out[a]; - } - } - ++extra; - out[next++] = i; - } - // Bah ... seems not to be used at all. Push to end if enough space is available. - else { - out[extra++] = i; - ++num_extra; - } - } - it = sorted.end() - 1; - break; - } - } - } - } - if (extra < AI_MAX_NUMBER_OF_TEXTURECOORDS) { - out[extra] = UINT_MAX; - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::FindVCChannels(const LWO::Surface &surf, LWO::SortedRep &sorted, const LWO::Layer &layer, - unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS]) { - unsigned int next = 0; - - // Check whether we have an vc entry != 0 for one of the faces in 'sorted' - for (unsigned int i = 0; i < layer.mVColorChannels.size(); ++i) { - const LWO::VColorChannel &vc = layer.mVColorChannels[i]; - - if (surf.mVCMap == vc.name) { - // The vertex color map is explicitly requested by the surface so we need to take special care of it - for (unsigned int a = 0; a < std::min(next, AI_MAX_NUMBER_OF_COLOR_SETS - 1u); ++a) { - out[a + 1] = out[a]; - } - out[0] = i; - ++next; - } else { - - for (LWO::SortedRep::iterator it = sorted.begin(); it != sorted.end(); ++it) { - const LWO::Face &face = layer.mFaces[*it]; - - for (unsigned int n = 0; n < face.mNumIndices; ++n) { - unsigned int idx = face.mIndices[n]; - - if (vc.abAssigned[idx] && ((aiColor4D *)&vc.rawData[0])[idx] != aiColor4D(0.0, 0.0, 0.0, 1.0)) { - if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) { - - ASSIMP_LOG_ERROR("LWO: Maximum number of vertex color channels for " - "this mesh reached. Skipping channel \'" + - vc.name + "\'"); - - } else { - out[next++] = i; - } - it = sorted.end() - 1; - break; - } - } - } - } - } - if (next != AI_MAX_NUMBER_OF_COLOR_SETS) { - out[next] = UINT_MAX; - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2ImageMap(unsigned int size, LWO::Texture &tex) { - LE_NCONST uint8_t *const end = mFileBuffer + size; - while (true) { - if (mFileBuffer + 6 >= end) break; - LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) - throw DeadlyImportError("LWO2: Invalid SURF.BLOCK chunk length"); - - uint8_t *const next = mFileBuffer + head.length; - switch (head.type) { - case AI_LWO_PROJ: - tex.mapMode = (Texture::MappingMode)GetU2(); - break; - case AI_LWO_WRAP: - tex.wrapModeWidth = (Texture::Wrap)GetU2(); - tex.wrapModeHeight = (Texture::Wrap)GetU2(); - break; - case AI_LWO_AXIS: - tex.majorAxis = (Texture::Axes)GetU2(); - break; - case AI_LWO_IMAG: - tex.mClipIdx = GetU2(); - break; - case AI_LWO_VMAP: - GetS0(tex.mUVChannelIndex, head.length); - break; - case AI_LWO_WRPH: - tex.wrapAmountH = GetF4(); - break; - case AI_LWO_WRPW: - tex.wrapAmountW = GetF4(); - break; - } - mFileBuffer = next; - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2Procedural(unsigned int /*size*/, LWO::Texture &tex) { - // --- not supported at the moment - ASSIMP_LOG_ERROR("LWO2: Found procedural texture, this is not supported"); - tex.bCanUse = false; -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2Gradient(unsigned int /*size*/, LWO::Texture &tex) { - // --- not supported at the moment - ASSIMP_LOG_ERROR("LWO2: Found gradient texture, this is not supported"); - tex.bCanUse = false; -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2TextureHeader(unsigned int size, LWO::Texture &tex) { - LE_NCONST uint8_t *const end = mFileBuffer + size; - - // get the ordinal string - GetS0(tex.ordinal, size); - - // we could crash later if this is an empty string ... - if (!tex.ordinal.length()) { - ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string"); - tex.ordinal = "\x00"; - } - while (true) { - if (mFileBuffer + 6 >= end) break; - const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) - throw DeadlyImportError("LWO2: Invalid texture header chunk length"); - - uint8_t *const next = mFileBuffer + head.length; - switch (head.type) { - case AI_LWO_CHAN: - tex.type = GetU4(); - break; - case AI_LWO_ENAB: - tex.enabled = GetU2() ? true : false; - break; - case AI_LWO_OPAC: - tex.blendType = (Texture::BlendType)GetU2(); - tex.mStrength = GetF4(); - break; - } - mFileBuffer = next; - } -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader *head, unsigned int size) { - ai_assert(!mSurfaces->empty()); - LWO::Surface &surf = mSurfaces->back(); - LWO::Texture tex; - - // load the texture header - LoadLWO2TextureHeader(head->length, tex); - size -= head->length + 6; - - // now get the exact type of the texture - switch (head->type) { - case AI_LWO_PROC: - LoadLWO2Procedural(size, tex); - break; - case AI_LWO_GRAD: - LoadLWO2Gradient(size, tex); - break; - case AI_LWO_IMAP: - LoadLWO2ImageMap(size, tex); - } - - // get the destination channel - TextureList *listRef = nullptr; - switch (tex.type) { - case AI_LWO_COLR: - listRef = &surf.mColorTextures; - break; - case AI_LWO_DIFF: - listRef = &surf.mDiffuseTextures; - break; - case AI_LWO_SPEC: - listRef = &surf.mSpecularTextures; - break; - case AI_LWO_GLOS: - listRef = &surf.mGlossinessTextures; - break; - case AI_LWO_BUMP: - listRef = &surf.mBumpTextures; - break; - case AI_LWO_TRAN: - listRef = &surf.mOpacityTextures; - break; - case AI_LWO_REFL: - listRef = &surf.mReflectionTextures; - break; - default: - ASSIMP_LOG_WARN("LWO2: Encountered unknown texture type"); - return; - } - - // now attach the texture to the parent surface - sort by ordinal string - for (TextureList::iterator it = listRef->begin(); it != listRef->end(); ++it) { - if (::strcmp(tex.ordinal.c_str(), (*it).ordinal.c_str()) < 0) { - listRef->insert(it, tex); - return; - } - } - listRef->push_back(tex); -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader * /*head*/, unsigned int size) { - LE_NCONST uint8_t *const end = mFileBuffer + size; - - ai_assert(!mSurfaces->empty()); - LWO::Surface &surf = mSurfaces->back(); - LWO::Shader shader; - - // get the ordinal string - GetS0(shader.ordinal, size); - - // we could crash later if this is an empty string ... - if (!shader.ordinal.length()) { - ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string"); - shader.ordinal = "\x00"; - } - - // read the header - while (true) { - if (mFileBuffer + 6 >= end) break; - const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) - throw DeadlyImportError("LWO2: Invalid shader header chunk length"); - - uint8_t *const next = mFileBuffer + head.length; - switch (head.type) { - case AI_LWO_ENAB: - shader.enabled = GetU2() ? true : false; - break; - - case AI_LWO_FUNC: - GetS0(shader.functionName, head.length); - } - mFileBuffer = next; - } - - // now attach the shader to the parent surface - sort by ordinal string - for (ShaderList::iterator it = surf.mShaders.begin(); it != surf.mShaders.end(); ++it) { - if (::strcmp(shader.ordinal.c_str(), (*it).ordinal.c_str()) < 0) { - surf.mShaders.insert(it, shader); - return; - } - } - surf.mShaders.push_back(shader); -} - -// ------------------------------------------------------------------------------------------------ -void LWOImporter::LoadLWO2Surface(unsigned int size) { - LE_NCONST uint8_t *const end = mFileBuffer + size; - - mSurfaces->push_back(LWO::Surface()); - LWO::Surface &surf = mSurfaces->back(); - - GetS0(surf.mName, size); - - // check whether this surface was derived from any other surface - std::string derived; - GetS0(derived, (unsigned int)(end - mFileBuffer)); - if (derived.length()) { - // yes, find this surface - for (SurfaceList::iterator it = mSurfaces->begin(), itEnd = mSurfaces->end() - 1; it != itEnd; ++it) { - if ((*it).mName == derived) { - // we have it ... - surf = *it; - derived.clear(); - break; - } - } - if (derived.size()) { - ASSIMP_LOG_WARN("LWO2: Unable to find source surface: ", derived); - } - } - - while (true) { - if (mFileBuffer + 6 >= end) - break; - const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); - - if (mFileBuffer + head.length > end) - throw DeadlyImportError("LWO2: Invalid surface chunk length"); - - uint8_t *const next = mFileBuffer + head.length; - switch (head.type) { - // diffuse color - case AI_LWO_COLR: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, COLR, 12); - surf.mColor.r = GetF4(); - surf.mColor.g = GetF4(); - surf.mColor.b = GetF4(); - break; - } - // diffuse strength ... hopefully - case AI_LWO_DIFF: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, DIFF, 4); - surf.mDiffuseValue = GetF4(); - break; - } - // specular strength ... hopefully - case AI_LWO_SPEC: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SPEC, 4); - surf.mSpecularValue = GetF4(); - break; - } - // transparency - case AI_LWO_TRAN: { - // transparency explicitly disabled? - if (surf.mTransparency == 10e10f) - break; - - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, TRAN, 4); - surf.mTransparency = GetF4(); - break; - } - // additive transparency - case AI_LWO_ADTR: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ADTR, 4); - surf.mAdditiveTransparency = GetF4(); - break; - } - // wireframe mode - case AI_LWO_LINE: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, LINE, 2); - if (GetU2() & 0x1) - surf.mWireframe = true; - break; - } - // glossiness - case AI_LWO_GLOS: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, GLOS, 4); - surf.mGlossiness = GetF4(); - break; - } - // bump intensity - case AI_LWO_BUMP: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, BUMP, 4); - surf.mBumpIntensity = GetF4(); - break; - } - // color highlights - case AI_LWO_CLRH: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, CLRH, 4); - surf.mColorHighlights = GetF4(); - break; - } - // index of refraction - case AI_LWO_RIND: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, RIND, 4); - surf.mIOR = GetF4(); - break; - } - // polygon sidedness - case AI_LWO_SIDE: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SIDE, 2); - surf.bDoubleSided = (3 == GetU2()); - break; - } - // maximum smoothing angle - case AI_LWO_SMAN: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SMAN, 4); - surf.mMaximumSmoothAngle = std::fabs(GetF4()); - break; - } - // vertex color channel to be applied to the surface - case AI_LWO_VCOL: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, VCOL, 12); - surf.mDiffuseValue *= GetF4(); // strength - ReadVSizedIntLWO2(mFileBuffer); // skip envelope - surf.mVCMapType = GetU4(); // type of the channel - - // name of the channel - GetS0(surf.mVCMap, (unsigned int)(next - mFileBuffer)); - break; - } - // surface bock entry - case AI_LWO_BLOK: { - AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, BLOK, 4); - IFF::SubChunkHeader head2 = IFF::LoadSubChunk(mFileBuffer); - - switch (head2.type) { - case AI_LWO_PROC: - case AI_LWO_GRAD: - case AI_LWO_IMAP: - LoadLWO2TextureBlock(&head2, head.length); - break; - case AI_LWO_SHDR: - LoadLWO2ShaderBlock(&head2, head.length); - break; - - default: - ASSIMP_LOG_WARN("LWO2: Found an unsupported surface BLOK"); - }; - - break; - } - } - mFileBuffer = next; - } -} - -#endif // !! ASSIMP_BUILD_NO_X_IMPORTER |