| /* |
| --------------------------------------------------------------------------- |
| Open Asset Import Library (assimp) |
| --------------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, 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 "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: |
| DefaultLogger::get()->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(NULL != 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; |
| 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: |
| DefaultLogger::get()->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)); |
| } |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->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) { |
| DefaultLogger::get()->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()) { |
| DefaultLogger::get()->error("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; |
| DefaultLogger::get()->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 |
| pcMat->AddProperty<int>((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") { |
| DefaultLogger::get()->info("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon"); |
| |
| m = aiShadingMode_Toon; |
| break; |
| } |
| else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel") { |
| DefaultLogger::get()->info("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel"); |
| |
| m = aiShadingMode_Fresnel; |
| break; |
| } |
| else |
| { |
| DefaultLogger::get()->warn("LWO2: Unknown surface shader: " + shader.functionName); |
| } |
| } |
| if (surf.mMaximumSmoothAngle <= 0.0) |
| m = aiShadingMode_Flat; |
| pcMat->AddProperty((int*)&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. |
| DefaultLogger::get()->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) { |
| |
| DefaultLogger::get()->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) { |
| |
| DefaultLogger::get()->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 |
| DefaultLogger::get()->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 |
| DefaultLogger::get()->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()) |
| { |
| DefaultLogger::get()->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 = NULL; |
| 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: |
| DefaultLogger::get()->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()) |
| { |
| DefaultLogger::get()->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(), end = mSurfaces->end()-1; it != end; ++it) { |
| if ((*it).mName == derived) { |
| // we have it ... |
| surf = *it; |
| derived.clear();break; |
| } |
| } |
| if (derived.size()) |
| DefaultLogger::get()->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: |
| DefaultLogger::get()->warn("LWO2: Found an unsupported surface BLOK"); |
| }; |
| |
| break; |
| } |
| } |
| mFileBuffer = next; |
| } |
| } |
| |
| #endif // !! ASSIMP_BUILD_NO_X_IMPORTER |
