|
|
|
|
/*==LICENSE==*
|
|
|
|
|
|
|
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools
|
|
|
|
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
|
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
|
|
|
|
or by snail mail at:
|
|
|
|
|
Cyan Worlds, Inc.
|
|
|
|
|
14617 N Newport Hwy
|
|
|
|
|
Mead, WA 99021
|
|
|
|
|
|
|
|
|
|
*==LICENSE==*/
|
|
|
|
|
#ifndef __HSMATERIALCONVERTER_H
|
|
|
|
|
#define __HSMATERIALCONVERTER_H
|
|
|
|
|
|
|
|
|
|
#include "HeadSpin.h"
|
|
|
|
|
#include "hsTemplates.h"
|
|
|
|
|
|
|
|
|
|
#include "Max.h"
|
|
|
|
|
|
|
|
|
|
class Interface;
|
|
|
|
|
|
|
|
|
|
class hsStream;
|
|
|
|
|
class hsScene;
|
|
|
|
|
class hsGMaterial;
|
|
|
|
|
class plLayer;
|
|
|
|
|
class plLayerInterface;
|
|
|
|
|
class hsGBitmapClass;
|
|
|
|
|
class hsGQTLayer;
|
|
|
|
|
class hsGAVILayer;
|
|
|
|
|
class hsGBinkLayer;
|
|
|
|
|
class hsConverterUtils;
|
|
|
|
|
class hsGAnimLayer;
|
|
|
|
|
class plBitmap;
|
|
|
|
|
class plMipmap;
|
|
|
|
|
class plErrorMsg;
|
|
|
|
|
|
|
|
|
|
class Mtl;
|
|
|
|
|
class Texmap;
|
|
|
|
|
class plMaxNode;
|
|
|
|
|
class StdUVGen;
|
|
|
|
|
class BitmapTex;
|
|
|
|
|
class StdMat;
|
|
|
|
|
class TSTR;
|
|
|
|
|
class Animatable;
|
|
|
|
|
class Bitmap;
|
|
|
|
|
class plLocation;
|
|
|
|
|
|
|
|
|
|
class plLayerTex;
|
|
|
|
|
class plBitmapData;
|
|
|
|
|
class plCubicRenderTarget;
|
|
|
|
|
class plStaticEnvLayer;
|
|
|
|
|
class plDynamicEnvLayer;
|
|
|
|
|
class plDynamicTextLayer;
|
|
|
|
|
class plPassMtlBase;
|
|
|
|
|
class plClothingItem;
|
|
|
|
|
class plClothingMtl;
|
|
|
|
|
class hsBitVector;
|
|
|
|
|
|
|
|
|
|
class plExportMaterialData
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
UInt32 fNumBlendChannels;
|
|
|
|
|
hsGMaterial *fMaterial;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class hsMaterialConverter
|
|
|
|
|
{
|
|
|
|
|
private:
|
|
|
|
|
hsMaterialConverter();
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
~hsMaterialConverter();
|
|
|
|
|
static hsMaterialConverter& Instance();
|
|
|
|
|
|
|
|
|
|
void Init(hsBool save, plErrorMsg *msg);
|
|
|
|
|
|
|
|
|
|
void FreeMaterialCache(const char* path);
|
|
|
|
|
|
|
|
|
|
static void GetUsedMaterials(plMaxNode* node, hsBitVector& used);
|
|
|
|
|
static hsBool IsTwoSided(Mtl* m, int iFace);
|
|
|
|
|
static hsBool PreserveUVOffset(Mtl* m);
|
|
|
|
|
static hsBool IsMultiMat(Mtl *m);
|
|
|
|
|
static hsBool IsMultipassMat(Mtl *m);
|
|
|
|
|
static hsBool IsHsMaxMat(Mtl *m);
|
|
|
|
|
static hsBool IsDecalMat(Mtl *m);
|
|
|
|
|
static hsBool IsCompositeMat(Mtl *m);
|
|
|
|
|
static hsBool IsParticleMat(Mtl *m);
|
|
|
|
|
static hsBool IsHsEnvironMapMat(Mtl *m);
|
|
|
|
|
static hsBool IsClothingMat(Mtl *m);
|
|
|
|
|
// static hsBool IsPortalMat(Mtl *m);
|
|
|
|
|
static hsBool HasAnimatedTextures(Texmap* texMap);
|
|
|
|
|
static hsBool HasAnimatedMaterial(plMaxNode* node);
|
|
|
|
|
static hsBool IsAnimatedMaterial(Mtl* mtl);
|
|
|
|
|
static hsBool HasMaterialDiffuseOrOpacityAnimation(plMaxNode* node, Mtl* mtl=nil);
|
|
|
|
|
static hsBool HasEmissiveLayer(plMaxNode* node, Mtl* mtl=nil);
|
|
|
|
|
static hsBool IsWaterLayer(plMaxNode* node, Texmap* texMap);
|
|
|
|
|
static hsBool IsFireLayer(plMaxNode* node, Texmap* texMap);
|
|
|
|
|
static hsBool IsAVILayer(Texmap* texMap);
|
|
|
|
|
static hsBool IsQTLayer(Texmap* texMap);
|
|
|
|
|
static hsBool IsBinkLayer(Texmap* texMap);
|
|
|
|
|
// static hsBool IsEnvironMapped(plMaxNode *node);
|
|
|
|
|
// static hsBool IsPortal(plMaxNode* node);
|
|
|
|
|
static hsBool ForceNoUvsFlatten(plMaxNode* node);
|
|
|
|
|
// static hsBool IsRenderProc(Mtl* mtl);
|
|
|
|
|
static Mtl* GetBaseMtl(Mtl* mtl);
|
|
|
|
|
static Mtl* GetBaseMtl(plMaxNode* node);
|
|
|
|
|
static int GetCoordMapping(StdUVGen *uvgen);
|
|
|
|
|
static void GetNodesByMaterial(Mtl *mtl, hsTArray<plMaxNode*> &out);
|
|
|
|
|
|
|
|
|
|
static UInt32 VertexChannelsRequestMask(plMaxNode* node, int iSubMtl, Mtl* mtl);
|
|
|
|
|
static UInt32 VertexChannelsRequiredMask(plMaxNode* node, int iSubMtl);
|
|
|
|
|
static int NumVertexOpacityChannelsRequired(plMaxNode* node, int iSubMtl);
|
|
|
|
|
static UInt32 ColorChannelsUseMask(plMaxNode* node, int iSubMtl);
|
|
|
|
|
static int MaxUsedUVWSrc(plMaxNode* node, Mtl* mtl);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static hsBool IsBumpLayer(Texmap* texMap);
|
|
|
|
|
static hsBool IsBumpMtl(Mtl* mtl);
|
|
|
|
|
static hsBool HasBumpLayer(plMaxNode* node, Mtl* mtl);
|
|
|
|
|
static BitmapTex* GetBumpLayer(plMaxNode* node, Mtl* mtl);
|
|
|
|
|
|
|
|
|
|
static hsBool HasVisDists(plMaxNode* node, Mtl* subMtl, hsScalar& minDist, hsScalar& maxDist);
|
|
|
|
|
static hsBool HasVisDists(plMaxNode* node, int iSubMtl, hsScalar& minDist, hsScalar& maxDist);
|
|
|
|
|
|
|
|
|
|
static hsBool IMustBeUniqueMaterial( Mtl *mtl );
|
|
|
|
|
static hsBool IMustBeUniqueLayer( Texmap *layer );
|
|
|
|
|
|
|
|
|
|
static Mtl* FindSubMtlByName(TSTR& name, Animatable* anim);
|
|
|
|
|
Mtl* FindSceneMtlByName(TSTR& name);
|
|
|
|
|
|
|
|
|
|
hsTArray<plExportMaterialData> *CreateMaterialArray(Mtl *maxMaterial, plMaxNode *node, UInt32 multiIndex);
|
|
|
|
|
|
|
|
|
|
// true if last material creation changed MAX time, invalidating current mesh
|
|
|
|
|
hsBool ChangedTimes() { return fChangedTimes; }
|
|
|
|
|
|
|
|
|
|
Texmap *GetUVChannelBase(plMaxNode *node, Mtl* mtl, int which);
|
|
|
|
|
|
|
|
|
|
hsBool ClearDoneMaterials(plMaxNode* node);
|
|
|
|
|
|
|
|
|
|
int GetMaterialArray(Mtl *mtl, plMaxNode* node, hsTArray<hsGMaterial*>& out, UInt32 multiIndex = 0 );
|
|
|
|
|
int GetMaterialArray(Mtl *mtl, hsTArray<hsGMaterial*>& out, UInt32 multiIndex = 0);
|
|
|
|
|
void CollectConvertedMaterials(Mtl *mtl, hsTArray<hsGMaterial *> &out);
|
|
|
|
|
|
|
|
|
|
plClothingItem *GenerateClothingItem(plClothingMtl *mtl, const plLocation &loc);
|
|
|
|
|
hsGMaterial* AlphaHackVersion(plMaxNode* node, Mtl* mtl, int subIndex); // used by DynamicDecals
|
|
|
|
|
hsGMaterial* NonAlphaHackVersion(plMaxNode* node, Mtl* mtl, int subIndex);
|
|
|
|
|
hsGMaterial* AlphaHackPrint(plMaxNode* node, Texmap* baseTex, UInt32 blendFlags);
|
|
|
|
|
hsGMaterial* NonAlphaHackPrint(plMaxNode* node, Texmap* baseTex, UInt32 blendFlags);
|
|
|
|
|
|
|
|
|
|
plMipmap* GetStaticColorTexture(Color c, plLocation &loc); // Creates a 4x4 texture of the specified solid color;
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
kColorRedBlack = 0x1,
|
|
|
|
|
kColorRedGrey = 0x2,
|
|
|
|
|
kColorRedWhite = 0x4,
|
|
|
|
|
kColorRed = kColorRedBlack | kColorRedGrey | kColorRedWhite,
|
|
|
|
|
|
|
|
|
|
kColorGreenBlack = 0x8,
|
|
|
|
|
kColorGreenGrey = 0x10,
|
|
|
|
|
kColorGreenWhite = 0x20,
|
|
|
|
|
kColorGreen = kColorGreenBlack | kColorGreenGrey | kColorGreenWhite,
|
|
|
|
|
|
|
|
|
|
kColorBlueBlack = 0x40,
|
|
|
|
|
kColorBlueGrey = 0x80,
|
|
|
|
|
kColorBlueWhite = 0x100,
|
|
|
|
|
kColorBlue = kColorBlueBlack | kColorBlueGrey | kColorBlueWhite,
|
|
|
|
|
|
|
|
|
|
kColor = kColorRed | kColorGreen | kColorBlue,
|
|
|
|
|
|
|
|
|
|
kIllumRedBlack = 0x200,
|
|
|
|
|
kIllumRedGrey = 0x400,
|
|
|
|
|
kIllumRedWhite = 0x800,
|
|
|
|
|
kIllumRed = kIllumRedBlack | kIllumRedGrey | kIllumRedWhite,
|
|
|
|
|
|
|
|
|
|
kIllumGreenBlack = 0x1000,
|
|
|
|
|
kIllumGreenGrey = 0x2000,
|
|
|
|
|
kIllumGreenWhite = 0x4000,
|
|
|
|
|
kIllumGreen = kIllumGreenBlack | kIllumGreenGrey | kIllumGreenWhite,
|
|
|
|
|
|
|
|
|
|
kIllumBlueBlack = 0x8000,
|
|
|
|
|
kIllumBlueGrey = 0x10000,
|
|
|
|
|
kIllumBlueWhite = 0x20000,
|
|
|
|
|
kIllumBlue = kIllumBlueBlack | kIllumBlueGrey | kIllumBlueWhite,
|
|
|
|
|
|
|
|
|
|
kIllum = kIllumRed | kIllumGreen | kIllumBlue,
|
|
|
|
|
|
|
|
|
|
kAlphaBlack = 0x40000,
|
|
|
|
|
kAlphaGrey = 0x80000,
|
|
|
|
|
kAlphaWhite = 0x100000,
|
|
|
|
|
kAlpha = kAlphaBlack | kAlphaGrey | kAlphaWhite,
|
|
|
|
|
|
|
|
|
|
kAllChannels = kColor | kIllum | kAlpha // Adjust if more channels added.
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// All this to catch duplicate mats with same name. Sigh.
|
|
|
|
|
struct DoneMaterialData
|
|
|
|
|
{
|
|
|
|
|
DoneMaterialData() : fHsMaterial(nil), fMaxMaterial(nil), fNode(nil),
|
|
|
|
|
fSubMultiMat(false), fOwnedCopy(false) { }
|
|
|
|
|
|
|
|
|
|
hsGMaterial *fHsMaterial;
|
|
|
|
|
Mtl *fMaxMaterial;
|
|
|
|
|
plMaxNode *fNode;
|
|
|
|
|
hsBool fSubMultiMat;
|
|
|
|
|
hsBool fOwnedCopy;
|
|
|
|
|
hsBool fRuntimeLit;
|
|
|
|
|
UInt32 fSubMtlFlags;
|
|
|
|
|
int fNumUVChannels;
|
|
|
|
|
hsBool fMakeAlphaLayer;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
enum {
|
|
|
|
|
kWarnedNoMoreDub = 0x1,
|
|
|
|
|
kWarnedNoMoreMult = 0x2,
|
|
|
|
|
kWarnedNoMoreBitmapLoadErr = 0x4,
|
|
|
|
|
kWarnedSubMulti = 0x8,
|
|
|
|
|
kWarnedCompMtlBadBlend = 0x10,
|
|
|
|
|
kWarnedNoLayers = 0x20,
|
|
|
|
|
kWarnedTooManyUVs = 0x40,
|
|
|
|
|
kWarnedAlphaAddCombo = 0x80,
|
|
|
|
|
kWarnedNoBaseTexture = 0x100,
|
|
|
|
|
kWarnedNoUpperTexture = 0x200,
|
|
|
|
|
kWarnedUpperTextureMissing = 0x400,
|
|
|
|
|
kWarnedMissingClothingTexture = 0x800,
|
|
|
|
|
kWarnedBadAnimSDLVarName = 0x1000,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
DoneMaterialData* IFindDoneMaterial(DoneMaterialData& done);
|
|
|
|
|
hsBool IClearDoneMaterial(Mtl* mtl, plMaxNode* node);
|
|
|
|
|
|
|
|
|
|
hsGMaterial *IAddDefaultMaterial(plMaxNode *node);
|
|
|
|
|
plMipmap *IGetUVTransTexture(plMaxNode *node, hsBool useU = true);
|
|
|
|
|
void IInsertSingleBlendLayer(plMipmap *texture, hsGMaterial *mat, plMaxNode *node,
|
|
|
|
|
int layerIdx, int UVChan);
|
|
|
|
|
|
|
|
|
|
hsGMaterial *ICreateMaterial(Mtl *mtl, plMaxNode *node, const char *name, int subIndex, int numUVChannels, hsBool makeAlphaLayer);
|
|
|
|
|
hsGMaterial *IProcessMaterial(Mtl *mtl, plMaxNode *node, const char *name, int UVChan, int subMtlFlags = 0);
|
|
|
|
|
|
|
|
|
|
// ... calls one of:
|
|
|
|
|
hsGMaterial *IProcessMultipassMtl(Mtl *mtl, plMaxNode *node, const char *name, int UVChan);
|
|
|
|
|
hsGMaterial *IProcessCompositeMtl(Mtl *mtl, plMaxNode *node, const char *name, int UVChan, int subMtlFlags);
|
|
|
|
|
hsGMaterial *IProcessParticleMtl(Mtl *mtl, plMaxNode *node, const char *name);
|
|
|
|
|
hsBool IProcessPlasmaMaterial(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, const char* namePrefix);
|
|
|
|
|
|
|
|
|
|
hsGMaterial* IInsertDoneMaterial(Mtl *mtl, hsGMaterial *hMat, plMaxNode *node, hsBool isMultiMat,
|
|
|
|
|
hsBool forceCopy, hsBool runtimeLit, UInt32 subMtlFlags, int numUVChannels, hsBool makeAlphaLayer);
|
|
|
|
|
|
|
|
|
|
void IInsertBumpLayers(plMaxNode* node, hsGMaterial* mat, int bumpLayerIdx);
|
|
|
|
|
void IInsertBumpLayers(plMaxNode* node, hsGMaterial* mat);
|
|
|
|
|
plLayer* IMakeBumpLayer(plMaxNode* node, const char* nameBase, hsGMaterial* mat, UInt32 miscFlag);
|
|
|
|
|
plMipmap* IGetBumpLutTexture(plMaxNode* node);
|
|
|
|
|
|
|
|
|
|
hsBool IHasSubMtl(Mtl* base, Mtl* sub);
|
|
|
|
|
int IFindSubIndex(plMaxNode* node, Mtl* mtl);
|
|
|
|
|
|
|
|
|
|
// NOTE: each insert function potentially modifies the layers,
|
|
|
|
|
// so make sure you own the material copy before calling these
|
|
|
|
|
void IInsertAlphaBlendingLayers(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, int UVChan,
|
|
|
|
|
hsBool makeAlphaLayer);
|
|
|
|
|
void IInsertMultipassBlendingLayers(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, int UVChan,
|
|
|
|
|
hsBool makeAlphaLayer);
|
|
|
|
|
void IInsertCompBlendingLayers(Mtl *mtl, plMaxNode *node, hsGMaterial *mat, int subMtlFlags,
|
|
|
|
|
int UVChan, hsBool makeAlphaLayer);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void IAddLayerToMaterial(hsGMaterial *mat, plLayerInterface *layer);
|
|
|
|
|
#if 0 // Out for now...
|
|
|
|
|
void IInitAttrSurface(hsGLayer *hLay, StdMat *stdMtl, plMaxNode *node);
|
|
|
|
|
void IInitAttrTexture(plMaxNode *node, Mtl *mtl, hsGLayer* hLay, Texmap *texMap, char *nodeName);
|
|
|
|
|
void IInitAttrLayer(hsGLayer* hLay, Mtl *mtl, Texmap* layer, plMaxNode* node);
|
|
|
|
|
#endif
|
|
|
|
|
// ... and so forth
|
|
|
|
|
hsBool IUVGenHasDynamicScale(plMaxNode* node, StdUVGen *uvGen);
|
|
|
|
|
void IScaleLayerOpacity(plLayer* hLay, hsScalar scale);
|
|
|
|
|
|
|
|
|
|
hsGMaterial *ICheckForProjectedTexture(plMaxNode *node);
|
|
|
|
|
hsGMaterial *IWrapTextureInMaterial(Texmap *texMap, plMaxNode *node);
|
|
|
|
|
|
|
|
|
|
BMM_Color_64 ICubeSample(Bitmap *bitmap[6], double phi, double theta);
|
|
|
|
|
void IBuildSphereMap(Bitmap *bitmap[6], Bitmap *bm);
|
|
|
|
|
#if 0 // DEFER_ANIM_MAT
|
|
|
|
|
void IProcessAnimMaterial(BitmapTex *bitmapTex, hsGAnimLayer* at, UInt32 texFlags, UInt32 procFlags);
|
|
|
|
|
#endif // DEFER_ANIM_MAT
|
|
|
|
|
static hsBool ITextureTransformIsAnimated(Texmap *texmap);
|
|
|
|
|
static hsBool IHasAnimatedControllers(Animatable* anim);
|
|
|
|
|
static hsBool IIsAnimatedTexmap(Texmap* texmap);
|
|
|
|
|
|
|
|
|
|
static UInt32 ICheckPoints(const Point3& p0, const Point3& p1, const Point3& p2, const Point3& p3,
|
|
|
|
|
int chan,
|
|
|
|
|
UInt32 mBlack, UInt32 mGrey, UInt32 mWhite);
|
|
|
|
|
static UInt32 ICheckPoints(const Point3& p0, const Point3& p1, const Point3& p2,
|
|
|
|
|
int chan,
|
|
|
|
|
UInt32 mBlack, UInt32 mGrey, UInt32 mWhite);
|
|
|
|
|
|
|
|
|
|
void IAppendWetLayer(plMaxNode* node, hsGMaterial* mat);
|
|
|
|
|
static plBitmap* IGetFunkyRamp(plMaxNode* node, UInt32 funkyType);
|
|
|
|
|
static void IAppendFunkyLayer(plMaxNode* node, Texmap* texMap, hsGMaterial* mat);
|
|
|
|
|
static hsBool IHasFunkyOpacity(plMaxNode* node, Texmap* texMap);
|
|
|
|
|
static UInt32 IGetFunkyType(Texmap* texMap);
|
|
|
|
|
static UInt32 IGetOpacityRanges(plMaxNode* node, Texmap* texMap, hsScalar& tr0, hsScalar& op0, hsScalar& op1, hsScalar& tr1);
|
|
|
|
|
|
|
|
|
|
Interface *fInterface;
|
|
|
|
|
hsConverterUtils& fConverterUtils;
|
|
|
|
|
hsBool fSave;
|
|
|
|
|
plErrorMsg *fErrorMsg;
|
|
|
|
|
|
|
|
|
|
Int32 fSubIndex;
|
|
|
|
|
hsBool fChangedTimes;
|
|
|
|
|
|
|
|
|
|
char *fNodeName;
|
|
|
|
|
UInt32 fWarned;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DoneMaterialData fLastMaterial;
|
|
|
|
|
hsTArray<DoneMaterialData> fDoneMaterials;
|
|
|
|
|
|
|
|
|
|
hsBool IsMatchingDoneMaterial(DoneMaterialData *dmd,
|
|
|
|
|
Mtl *mtl, hsBool isMultiMat, UInt32 subMtlFlags, hsBool forceCopy, hsBool runtimeLit,
|
|
|
|
|
plMaxNode *node, int numUVChannels, hsBool makeAlphaLayer);
|
|
|
|
|
|
|
|
|
|
void ISortDoneMaterials(hsTArray<DoneMaterialData*>& doneMats);
|
|
|
|
|
hsBool IEquivalent(DoneMaterialData* one, DoneMaterialData* two);
|
|
|
|
|
void IPrintDoneMat(hsStream* stream, const char* prefix, DoneMaterialData* doneMat);
|
|
|
|
|
void IPrintDoneMaterials(const char* path, hsTArray<DoneMaterialData*>& doneMats);
|
|
|
|
|
void IGenMaterialReport(const char* path);
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
// Apologies all around, but I need this list for dumping some export warnings. mf
|
|
|
|
|
const hsTArray<struct DoneMaterialData>& DoneMaterials() { return fDoneMaterials; }
|
|
|
|
|
|
|
|
|
|
//hsBool CheckValidityOfSDLVarAnim(plPassMtlBase *mtl, char *varName, plMaxNode *node);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern hsMaterialConverter gMaterialConverter;
|
|
|
|
|
|
|
|
|
|
#endif
|
