CWE-ou-minkata/Sources/Tools/MaxConvert/plLayerConverter.cpp

/*==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==*/
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  plLayerConverter - Utility class that converts plPlasmaMAXLayers into    //
//                     other stuff.                                          //
//  Cyan, Inc.                                                               //
//                                                                           //
//// Version History //////////////////////////////////////////////////////////
//                                                                           //
//  1.13.2002 mcn - Created.                                                 //
//                                                                           //
//// Notes ////////////////////////////////////////////////////////////////////
//                                                                           //
//  If you add a new PlasmaMAXLayer type, you need to add the appropriate    //
//  test in ConvertTexmap() as well as your own function to do the           //
//  conversion. Messy, but thanks to the dependencies of the convert process,//
//  we can't do it the nice, pretty, OOP way.                                //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "hsWindows.h"
#include "Max.h"
#include "stdmat.h"
#include "istdplug.h"
#include "iparamb2.h"
#include "iparamm2.h"

#include "hsUtils.h"
#include "hsExceptionStack.h"

#include "plLayerConverter.h"

#include "MaxConvert/hsMaxLayerBase.h"
#include "MaxConvert/hsConverterUtils.h"
#include "MaxConvert/hsControlConverter.h"
#include "MaxConvert/hsMaterialConverter.h"
#include "MaxConvert/plBitmapCreator.h"
#include "hsResMgr.h"
#include "MaxExport/plErrorMsg.h"
#include "MaxMain/plMaxNode.h"

#include "pnKeyedObject/plUoid.h"
#include "pnKeyedObject/plKey.h"
#include "pnSceneObject/plSceneObject.h"
#include "plSurface/plLayerInterface.h"
#include "plSurface/plLayer.h"
#include "pnMessage/plRefMsg.h"
#include "pnMessage/plObjRefMsg.h"
#include "plMessage/plLayRefMsg.h"
#include "plDrawable/plGeometrySpan.h"

#include "plGImage/plMipmap.h"
#include "plGImage/plDynamicTextMap.h"
#include "plGImage/plCubicEnvironmap.h"
#include "plPipeline/plCubicRenderTarget.h"
#include "plPipeline/plCubicRenderTargetModifier.h"
#include "plPipeline/plDynamicEnvMap.h"

#include "pfSurface/plLayerAVI.h"
#include "pfSurface/plLayerBink.h"

#include "MaxPlasmaMtls/Layers/plPlasmaMAXLayer.h"
#include "MaxPlasmaMtls/Layers/plLayerTex.h"
#include "MaxPlasmaMtls/Layers/plLayerTexBasicPB.h"
#include "MaxPlasmaMtls/Layers/plLayerTexBitmapPB.h"
#include "MaxPlasmaMtls/Layers/plStaticEnvLayer.h"
#include "MaxPlasmaMtls/Layers/plDynamicEnvLayer.h"
#include "MaxPlasmaMtls/Layers/plDynamicTextLayer.h"
#include "MaxPlasmaMtls/Layers/plAngleAttenLayer.h"
#include "MaxPlasmaMtls/Layers/plMAXCameraLayer.h"

#include "MaxComponent/plComponent.h"
#include "MaxComponent/plWaterComponent.h"
#include "pfCamera/plCameraModifier.h"

//// Local Static Stuff ///////////////////////////////////////////////////////

namespace
{
    enum {
        kWarnedTooManyUVs           = 0x01,
        kWarnedNoBaseTexture        = 0x02,
        kWarnedUpperTextureMissing  = 0x04,
        kWarnedNoUpperTexture       = 0x08,
    };

    const char  sWarnBaseTextureMissing[] = "The object \"%s\"'s material has a base layer that is assigned texture \"%s\", but the texture file is missing. "
                                        "This can cause unwanted effects during runtime."; 
    const char  sWarnUpperTextureMissing[] = "The object \"%s\"'s material has an upper layer that is assigned texture \"%s\", but the texture file is missing. "
                                        "This is not supported in the engine, so the upper layer will be ignored."; 
    const char  sWarnNoUpperTexture[] = "The object \"%s\"'s material has an uppper layer that is not assigned a texture. "
                                        "This is not supported in the engine, so the upper layer will be disabled."; 
}


//// Constructor/Destructor ///////////////////////////////////////////////////

plLayerConverter::plLayerConverter() :
    fInterface( nil ),
    fConverterUtils( hsConverterUtils::Instance() )
{
    fErrorMsg = nil;
    fWarned = 0;
    fSaving = false;
}

plLayerConverter::~plLayerConverter()
{
}

plLayerConverter    &plLayerConverter::Instance( void )
{
    hsGuardBegin( "plLayerConverter::Instance" );

    static plLayerConverter     instance;

    return instance;

    hsGuardEnd;
}

void    plLayerConverter::Init( hsBool save, plErrorMsg *msg )
{
    fSaving = save;
    fErrorMsg = msg;
    fWarned = 0;
    fInterface = GetCOREInterface();
}

void    plLayerConverter::DeInit( void )
{
    int i;
    for( i = 0; i < fConvertedLayers.GetCount(); i++ )
    {
        if( fConvertedLayers[ i ] != nil )
            fConvertedLayers[ i ]->IClearConversionTargets();
    }
    fConvertedLayers.Reset();
}

//// Mute/Unmute Warnings /////////////////////////////////////////////////////

void    plLayerConverter::MuteWarnings( void )
{
    fSavedWarned = fWarned; 
    fWarned |= kWarnedNoBaseTexture | kWarnedUpperTextureMissing; 
}

void    plLayerConverter::UnmuteWarnings( void )
{
    fWarned = fSavedWarned; 
}

///////////////////////////////////////////////////////////////////////////////
//// Main Switcheroo //////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//// ConvertTexmap ////////////////////////////////////////////////////////////
        
plLayerInterface    *plLayerConverter::ConvertTexmap( Texmap *texmap,
                                                        plMaxNode *maxNode,
                                                        UInt32 blendFlags, hsBool preserveUVOffset,
                                                        hsBool upperLayer )
{
    hsGuardBegin( "plLayerConverter::ConvertTexmap" );
    
    fDbgNodeName = maxNode->GetName();

    // We only convert plPlasmaMAXLayers
    plPlasmaMAXLayer    *layer = plPlasmaMAXLayer::GetPlasmaMAXLayer( texmap );
    if( layer == nil )
    {
        fErrorMsg->Set( true, "Plasma Layer Error", "Cannot convert layer '%s'--unrecognized MAX layer type", texmap->GetName() );
        fErrorMsg->Show();
        fErrorMsg->Set();
        return nil;
    }

    // KLUDGE - Some things don't set the name for their layers (ie projected
    // runtime lights).  So that we don't end up with an empty keyname, set the
    // name to the nodes name if there isn't one. -Colin
    const char* layerName = layer->GetName();
    if (!layerName || layerName[0] == '\0')
        layer->SetName(maxNode->GetName());

    // Switch on the class ID
    plLayerInterface    *plasmaLayer = nil;

    if( layer->ClassID() == LAYER_TEX_CLASS_ID )
        plasmaLayer = IConvertLayerTex( layer, maxNode, blendFlags, preserveUVOffset, upperLayer );

    else if( layer->ClassID() == STATIC_ENV_LAYER_CLASS_ID )
        plasmaLayer = IConvertStaticEnvLayer( layer, maxNode, blendFlags, preserveUVOffset, upperLayer );

    else if( layer->ClassID() == DYNAMIC_ENV_LAYER_CLASS_ID )
        plasmaLayer = IConvertDynamicEnvLayer( layer, maxNode, blendFlags, preserveUVOffset, upperLayer );

    else if( layer->ClassID() == DYN_TEXT_LAYER_CLASS_ID )
        plasmaLayer = IConvertDynamicTextLayer( layer, maxNode, blendFlags, preserveUVOffset, upperLayer );

    else if( layer->ClassID() == ANGLE_ATTEN_LAYER_CLASS_ID )
        plasmaLayer = IConvertAngleAttenLayer( layer, maxNode, blendFlags, preserveUVOffset, upperLayer );

    else if( layer->ClassID() == MAX_CAMERA_LAYER_CLASS_ID )
        plasmaLayer = IConvertCameraLayer( layer, maxNode, blendFlags, preserveUVOffset, upperLayer );


    IRegisterConversion( layer, plasmaLayer );

    return plasmaLayer;

    hsGuardEnd;
}

//// IRegisterConversion //////////////////////////////////////////////////////

void    plLayerConverter::IRegisterConversion( plPlasmaMAXLayer *origLayer, plLayerInterface *convertedLayer )
{
    if( convertedLayer == nil )
        return;

    // Add this to our list of converted layers (so we can clean them up later)
    if( fConvertedLayers.Find( origLayer ) == fConvertedLayers.kMissingIndex )
        fConvertedLayers.Append( origLayer );

    // Now add the converted layer to that layer's list of conversion targets.
    // (easier than us keeping a huge lookup table, since this is *acting* 
    //  as that lookup table more or less)
    origLayer->IAddConversionTarget( convertedLayer );
}

///////////////////////////////////////////////////////////////////////////////
//// Main Processing Functions ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

//// IConvertLayerTex /////////////////////////////////////////////////////////
                            
plLayerInterface    *plLayerConverter::IConvertLayerTex( plPlasmaMAXLayer *layer, 
                                                                plMaxNode *maxNode, UInt32 blendFlags, 
                                                                hsBool preserveUVOffset, hsBool upperLayer )
{
    hsGuardBegin( "plLayerConverter::IConvertLayerTex" );

    IParamBlock2        *bitmapPB;
    plLocation          loc;


    loc = maxNode->GetLocation();
    bitmapPB = layer->GetParamBlockByID( plLayerTex::kBlkBitmap );
    
    if( !bitmapPB )
    {
        fErrorMsg->Set( !bitmapPB, "Plasma Layer Error", "Bitmap paramblock for Plasma Layer not found" ).Show();
        fErrorMsg->Set();
        return nil;
    }

    // Get a new layer to play with
    plLayer *plasmaLayer = ICreateLayer( layer->GetName(), upperLayer, loc );

    // We're using a texture, try and get its info
    PBBitmap    *pbbm = nil;
    BitmapInfo  *bi = nil;

    if( bitmapPB->GetInt( kBmpUseBitmap ) )
    {
        if( bitmapPB )
            pbbm = bitmapPB->GetBitmap( kBmpBitmap );
        if( pbbm )
            bi = &pbbm->bi;
    }

    // If the texture had bad info, assert and return the empty layer
    if( !bi || !bi->Name() || !strcmp(bi->Name(), "") )
    {
        if( upperLayer )
        {
            if( fErrorMsg->Set( !( fWarned & kWarnedNoUpperTexture ), "Plasma Export Error", sWarnNoUpperTexture, maxNode->GetName() ).CheckAskOrCancel() )
                fWarned |= kWarnedNoUpperTexture; 
            fErrorMsg->Set( false );

            delete plasmaLayer;
            return nil;
        }
        else
        {
            return (plLayerInterface *)plasmaLayer;
        }
    }

    // Setup the texture creation parameters
    plBitmapData bd;
    bd.fileName = bi->Name();

    // Create texture and add it to list if unique
    Int32 texFlags = 0;//hsGTexture::kMipMap;

    // Texture Alpha/Color
    if( bitmapPB->GetInt( kBmpInvertColor ) )
        plasmaLayer->SetBlendFlags( plasmaLayer->GetBlendFlags() | hsGMatState::kBlendInvertColor );
    if( bitmapPB->GetInt( kBmpDiscardColor ) )
        plasmaLayer->SetBlendFlags( plasmaLayer->GetBlendFlags() | hsGMatState::kBlendNoTexColor );
    if( bitmapPB->GetInt( kBmpDiscardAlpha ) )
        plasmaLayer->SetBlendFlags( plasmaLayer->GetBlendFlags() | hsGMatState::kBlendNoTexAlpha );
    if( bitmapPB->GetInt( kBmpInvertAlpha ) )
        bd.invertAlpha = true;

    // Texture quality
    if( bitmapPB->GetInt( kBmpNonCompressed ) )
        texFlags |= plBitmap::kForceNonCompressed;

    if( bitmapPB->GetInt( kBmpNoDiscard ) )
        texFlags |= plBitmap::kDontThrowAwayImage;

    switch( bitmapPB->GetInt( kBmpScaling ) )
    {
        case kScalingHalf: texFlags |= plBitmap::kHalfSize;  break;
        case kScalingNone: texFlags |= plBitmap::kNoMaxSize; break;
    }

    // Mip map filtering.
    if( bitmapPB->GetInt( kBmpNoFilter ) )
        texFlags |= plBitmap::kForceOneMipLevel;
    if( bitmapPB->GetInt( kBmpMipBias ) )
    {
        plasmaLayer->SetZFlags( plasmaLayer->GetZFlags() | hsGMatState::kZLODBias );
        plasmaLayer->SetLODBias( bitmapPB->GetFloat( kBmpMipBiasAmt, fConverterUtils.GetTime( fInterface ) ) );
    }
    float sig = bitmapPB->GetFloat( kBmpMipBlur );

    bd.texFlags = texFlags;
    bd.sig = sig;

    // Get detail parameters
    if( bitmapPB->GetInt( kBmpUseDetail ) )
    {                                           // TODO: be smarter
        if( blendFlags & hsGMatState::kBlendAdd )
            bd.createFlags |= plMipmap::kCreateDetailAdd;
        else if( blendFlags & hsGMatState::kBlendMult )
            bd.createFlags |= plMipmap::kCreateDetailMult;
        else
            bd.createFlags |= plMipmap::kCreateDetailAlpha;
        bd.detailDropoffStart = float(bitmapPB->GetInt(kBmpDetailStartSize)) / 100.f;
        bd.detailDropoffStop = float(bitmapPB->GetInt(kBmpDetailStopSize)) / 100.f;
        bd.detailMax = float(bitmapPB->GetInt(kBmpDetailStartOpac)) / 100.f;
        bd.detailMin = float(bitmapPB->GetInt(kBmpDetailStopOpac)) / 100.f;
    }

    // Get max export dimension (since the function we eventually call
    // expects the max of the two dimensions, we figure that out here and
    // pass it on)
    bd.maxDimension = bitmapPB->GetInt( kBmpExportWidth );
    int expHt = bitmapPB->GetInt( kBmpExportHeight );
    if( bd.maxDimension < expHt )
        bd.maxDimension = expHt;
    int clipID = 0, w;
    for( clipID = 0, w = bi->Width(); w > bd.maxDimension; w >>= 1, clipID++ );

    // Do the UV gen (before we do texture, since it could modify the bitmapData struct)
    IProcessUVGen( layer, plasmaLayer, &bd, preserveUVOffset );

    // Create the texture.  If it works, assign it to the layer
    if( ( plasmaLayer = IAssignTexture( &bd, maxNode, plasmaLayer, upperLayer, clipID ) ) == nil )
        return nil;

    // All done!
    return (plLayerInterface *)plasmaLayer;

    hsGuardEnd;
}

//// IConvertStaticEnvLayer ///////////////////////////////////////////////////
                            
plLayerInterface    *plLayerConverter::IConvertStaticEnvLayer( plPlasmaMAXLayer *layer, 
                                                                plMaxNode *maxNode, UInt32 blendFlags, 
                                                                hsBool preserveUVOffset, hsBool upperLayer )
{
    hsGuardBegin( "plLayerConverter::IConvertStaticEnvLayer" );

    IParamBlock2        *bitmapPB;
    plLocation          loc;

    loc = maxNode->GetLocation();
    bitmapPB = layer->GetParamBlockByID( plStaticEnvLayer::kBlkBitmap );
    
    if( !bitmapPB )
    {
        fErrorMsg->Set( !bitmapPB, "Plasma Layer Error", "Bitmap paramblock for Plasma Layer not found" ).Show();
        fErrorMsg->Set();
        return nil;
    }

    // Get a new layer to play with
    plLayer *plasmaLayer = ICreateLayer( layer->GetName(), upperLayer, loc );

    // Get the texture info
    PBBitmap *pbbm = bitmapPB->GetBitmap( plStaticEnvLayer::kBmpFrontBitmap + 0 );
    BitmapInfo *bi = nil;
    if( pbbm )
        bi = &pbbm->bi;

    // If the texture had bad info, assert and return the empty layer
    if (!bi || !bi->Name() || !strcmp(bi->Name(), ""))
    {
        // Or don't assert since it can get annoying when you are using someone
        // elses file and don't have all the textures.
        return (plLayerInterface *)plasmaLayer;
    }

    // Setup the texture creation parameters
    plBitmapData bd;
    bd.fileName = bi->Name();

    // Create texture and add it to list if unique
    Int32 texFlags = 0;

    // Texture Alpha/Color
    if( bitmapPB->GetInt( plStaticEnvLayer::kBmpInvertColor ) )
        plasmaLayer->SetBlendFlags( plasmaLayer->GetBlendFlags() | hsGMatState::kBlendInvertColor );
    if( bitmapPB->GetInt( plStaticEnvLayer::kBmpDiscardColor ) )
        plasmaLayer->SetBlendFlags( plasmaLayer->GetBlendFlags() | hsGMatState::kBlendNoTexColor );
    if( bitmapPB->GetInt( kBmpDiscardAlpha ) )
        plasmaLayer->SetBlendFlags( plasmaLayer->GetBlendFlags() | hsGMatState::kBlendNoTexAlpha );
    if( bitmapPB->GetInt( plStaticEnvLayer::kBmpInvertAlpha ) )
        bd.invertAlpha = true;

    // Texture quality
    if( bitmapPB->GetInt( plStaticEnvLayer::kBmpNonCompressed ) )
        texFlags |= plBitmap::kForceNonCompressed;

    switch( bitmapPB->GetInt( plStaticEnvLayer::kBmpScaling ) )
    {
        case plStaticEnvLayer::kScalingHalf: texFlags |= plBitmap::kHalfSize;  break;
        case plStaticEnvLayer::kScalingNone: texFlags |= plBitmap::kNoMaxSize; break;
    }

    bd.texFlags = texFlags;
    bd.isStaticCubicEnvMap = true;
    for( int i = 0; i < 6; i++ )
    {
        PBBitmap *face = bitmapPB->GetBitmap( plStaticEnvLayer::kBmpFrontBitmap + i );
        if( !face )
            return (plLayerInterface *)plasmaLayer;
        bd.faceNames[ i ] = face->bi.Name();
    }

    // Get detail parameters
    if( bitmapPB->GetInt( plStaticEnvLayer::kBmpUseDetail ) )
    {                                           // TODO: be smarter
        if( blendFlags & hsGMatState::kBlendAdd )
            bd.createFlags = plMipmap::kCreateDetailAdd;
        else if( blendFlags & hsGMatState::kBlendMult )
            bd.createFlags = plMipmap::kCreateDetailMult;
        else
            bd.createFlags = plMipmap::kCreateDetailAlpha;

        bd.detailDropoffStart = float( bitmapPB->GetInt( plStaticEnvLayer::kBmpDetailStartSize ) ) / 100.f;
        bd.detailDropoffStop = float( bitmapPB->GetInt( plStaticEnvLayer::kBmpDetailStopSize ) ) / 100.f;
        bd.detailMax = float( bitmapPB->GetInt( plStaticEnvLayer::kBmpDetailStartOpac ) ) / 100.f;
        bd.detailMin = float( bitmapPB->GetInt( plStaticEnvLayer::kBmpDetailStopOpac ) ) / 100.f;
    }

    /// Since we're a cubic environMap, we don't care about the UV transform nor the uvwSrc
    plasmaLayer->SetUVWSrc( 0 );
    plasmaLayer->SetUVWSrc( plasmaLayer->GetUVWSrc() | plLayerInterface::kUVWReflect );

    // Create the texture.  If it works, assign it to the layer
    if( ( plasmaLayer = IAssignTexture( &bd, maxNode, plasmaLayer, upperLayer ) ) == nil )
        return nil;

    // Tag this layer as reflective cubic environmentmapping
    if( bitmapPB->GetInt(plStaticEnvLayer::kBmpRefract) )
        plasmaLayer->SetMiscFlags( plasmaLayer->GetMiscFlags() | hsGMatState::kMiscUseRefractionXform );
    else
        plasmaLayer->SetMiscFlags( plasmaLayer->GetMiscFlags() | hsGMatState::kMiscUseReflectionXform );

    return (plLayerInterface *)plasmaLayer;

    hsGuardEnd;
}

//// IConvertDynamicEnvLayer //////////////////////////////////////////////////
                            
plLayerInterface    *plLayerConverter::IConvertDynamicEnvLayer( plPlasmaMAXLayer *layer, 
                                                                plMaxNode *maxNode, UInt32 blendFlags, 
                                                                hsBool preserveUVOffset, hsBool upperLayer )
{
    hsGuardBegin( "plLayerConverter::IConvertDynamicEnvLayer" );

    IParamBlock2        *bitmapPB;
    plLocation          loc;

    loc = maxNode->GetLocation();
    bitmapPB = layer->GetParamBlockByID( plDynamicEnvLayer::kBlkBitmap );
    
    if( !bitmapPB )
    {
        fErrorMsg->Set( !bitmapPB, "Plasma Layer Error", "Bitmap paramblock for Plasma Layer not found" ).Show();
        fErrorMsg->Set();
        return nil;
    }

    // Get a new layer to play with
    plLayer *plasmaLayer = ICreateLayer( layer->GetName(), upperLayer, loc );

    // Get the anchor node
    plMaxNode   *anchor = (plMaxNode *)bitmapPB->GetINode( plDynamicEnvLayer::kBmpAnchorNode );
    if( anchor == nil )
        // Default to self as the anchor--just make sure we make unique versions of this material!
        anchor = maxNode;
    
    if( !anchor->CanConvert() || !( anchor->GetForceLocal() || anchor->GetDrawable() ) )
    {
        fErrorMsg->Set( true, "Plasma Layer Error", "The dynamic envMap material %s has an invalid anchor specified. Please specify a valid Plasma scene object as an anchor.", plasmaLayer->GetKeyName() ).Show();
        fErrorMsg->Set();
        return (plLayerInterface *)plasmaLayer;
    }

    // Create texture and add it to list if unique
    Int32 texFlags = 0;

    /// Since we're a cubic environMap, we don't care about the UV transform nor the uvwSrc
    plasmaLayer->SetUVWSrc( 0 );
    plasmaLayer->SetUVWSrc( plasmaLayer->GetUVWSrc() | plLayerInterface::kUVWReflect );

    // Create the texture.  If it works, assign it to the layer
    char    texName[ 256 ];
    if( anchor == maxNode )
    {
        // Self-anchoring material, make sure the name is unique via the nodeName
        sprintf( texName, "%s_cubicRT@%s", plasmaLayer->GetKeyName(), maxNode->GetName() );
    }
    else
        sprintf( texName, "%s_cubicRT", plasmaLayer->GetKeyName() );

    plBitmap *texture = (plBitmap *)IMakeCubicRenderTarget( texName, maxNode, anchor );
    if( texture )
        hsgResMgr::ResMgr()->AddViaNotify( texture->GetKey(), TRACKED_NEW plLayRefMsg( plasmaLayer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture ), plRefFlags::kActiveRef );

    // Tag this layer as reflective cubic environmentmapping
    if( bitmapPB->GetInt(plDynamicEnvLayer::kBmpRefract) )
        plasmaLayer->SetMiscFlags( plasmaLayer->GetMiscFlags() | hsGMatState::kMiscUseRefractionXform );
    else
        plasmaLayer->SetMiscFlags( plasmaLayer->GetMiscFlags() | hsGMatState::kMiscUseReflectionXform );

    return (plLayerInterface *)plasmaLayer;

    hsGuardEnd;
}

plLayerInterface    *plLayerConverter::IConvertCameraLayer(plPlasmaMAXLayer *layer, 
                                                           plMaxNode *maxNode, UInt32 blendFlags, 
                                                           hsBool preserveUVOffset, hsBool upperLayer)
{
    hsGuardBegin( "plLayerConverter::IConvertCameraLayer" );

    IParamBlock2        *pb;
    plLocation          loc;

    loc = maxNode->GetLocation();
    pb = layer->GetParamBlockByID(plMAXCameraLayer::kBlkMain);

    if (!pb)
    {
        fErrorMsg->Set(!pb, "Plasma Layer Error", "Paramblock for Plasma Camera Layer not found" ).Show();
        fErrorMsg->Set();
        return nil;
    }

    plLayer *plasmaLayer = ICreateLayer (layer->GetName(), upperLayer, loc);

    plMaxNode *rootNode = (plMaxNode*)pb->GetINode(ParamID(plMAXCameraLayer::kRootNode));
    plDynamicCamMap *map = plEnvMapComponent::GetCamMap(rootNode ? rootNode : maxNode);
    if (map)
    {
        Int32 texFlags = 0;
        if (!pb->GetInt(ParamID(plMAXCameraLayer::kExplicitCam)))
        {
            plasmaLayer->SetUVWSrc(plLayerInterface::kUVWPosition);
            plasmaLayer->SetMiscFlags(hsGMatState::kMiscCam2Screen | hsGMatState::kMiscPerspProjection);
            hsgResMgr::ResMgr()->AddViaNotify(rootNode->GetSceneObject()->GetKey(), TRACKED_NEW plGenRefMsg(map->GetKey(), plRefMsg::kOnCreate, -1, plDynamicCamMap::kRefRootNode), plRefFlags::kActiveRef);
            hsgResMgr::ResMgr()->AddViaNotify(plasmaLayer->GetKey(), TRACKED_NEW plGenRefMsg(map->GetKey(), plRefMsg::kOnCreate, -1, plDynamicCamMap::kRefMatLayer), plRefFlags::kActiveRef);
            if (!pb->GetInt(ParamID(plMAXCameraLayer::kForce)))
            {
                plBitmap *disableTexture = hsMaterialConverter::Instance().GetStaticColorTexture(pb->GetColor(ParamID(plMAXCameraLayer::kDisableColor)), loc);
                hsgResMgr::ResMgr()->AddViaNotify(disableTexture->GetKey(), TRACKED_NEW plGenRefMsg(map->GetKey(), plRefMsg::kOnCreate, -1, plDynamicCamMap::kRefDisableTexture), plRefFlags::kActiveRef);
            }
        }
        else
        {
            plMaxNode *camNode = (plMaxNode*)pb->GetINode(ParamID(plMAXCameraLayer::kCamera));
            if (camNode)
            {
                const plCameraModifier1 *mod = plCameraModifier1::ConvertNoRef(camNode->GetSceneObject()->GetModifierByType(plCameraModifier1::Index()));
                if (mod)
                    hsgResMgr::ResMgr()->AddViaNotify(mod->GetKey(), TRACKED_NEW plGenRefMsg(map->GetKey(), plRefMsg::kOnCreate, -1, plDynamicCamMap::kRefCamera), plRefFlags::kActiveRef);
            }

            plasmaLayer->SetUVWSrc(pb->GetInt(ParamID(plMAXCameraLayer::kUVSource)));
        }

        hsTArray<plMaxNode*> nodeList;
        hsMaterialConverter::GetNodesByMaterial(maxNode->GetMtl(), nodeList);
        int i;
        for (i = 0; i < nodeList.GetCount(); i++)
        {
            hsgResMgr::ResMgr()->AddViaNotify(nodeList[i]->GetSceneObject()->GetKey(), TRACKED_NEW plGenRefMsg(map->GetKey(), plRefMsg::kOnCreate, -1, plDynamicCamMap::kRefTargetNode), plRefFlags::kActiveRef);
        }
        hsgResMgr::ResMgr()->AddViaNotify(map->GetKey(), TRACKED_NEW plLayRefMsg(plasmaLayer->GetKey(), plRefMsg::kOnCreate, -1, plLayRefMsg::kTexture), plRefFlags::kActiveRef);

    }

    return plasmaLayer;

    hsGuardEnd;
}

//// IConvertDynamicTextLayer /////////////////////////////////////////////////
                            
plLayerInterface    *plLayerConverter::IConvertDynamicTextLayer( plPlasmaMAXLayer *layer, 
                                                                plMaxNode *maxNode, UInt32 blendFlags, 
                                                                hsBool preserveUVOffset, hsBool upperLayer )
{
    hsGuardBegin( "plLayerConverter::IConvertDynamicTextLayer" );

    plDynamicTextLayer  *maxLayer;
    IParamBlock2        *bitmapPB;
    plLocation          loc;

    maxLayer = (plDynamicTextLayer *)layer;
    loc = maxNode->GetLocation();
    bitmapPB = maxLayer->GetParamBlockByID( plDynamicTextLayer::kBlkBitmap );
    
    if( !bitmapPB )
    {
        fErrorMsg->Set( !bitmapPB, "Plasma Layer Error", "Bitmap paramblock for Plasma Layer not found" ).Show();
        fErrorMsg->Set();
        return nil;
    }

    // Get a new layer to play with
    plLayer *plasmaLayer = ICreateLayer( maxLayer->GetName(), upperLayer, loc );


    /// UV Gen
    IProcessUVGen( maxLayer, plasmaLayer, nil, preserveUVOffset );

    // Create the "texture"
    plDynamicTextMap *texture = ICreateDynTextMap( plasmaLayer->GetKeyName(), 
                                                    bitmapPB->GetInt( plDynamicTextLayer::kBmpExportWidth ), 
                                                    bitmapPB->GetInt( plDynamicTextLayer::kBmpExportHeight ),
                                                    bitmapPB->GetInt( plDynamicTextLayer::kBmpIncludeAlphaChannel ),
                                                    maxNode );

    // Set the initial bitmap if necessary
    UInt32 *initBuffer = IGetInitBitmapBuffer( maxLayer );
    if( initBuffer != nil )
    {
        texture->SetInitBuffer( initBuffer );
        delete [] initBuffer;
    }

    // Add the texture in
    hsgResMgr::ResMgr()->AddViaNotify( texture->GetKey(), TRACKED_NEW plLayRefMsg( plasmaLayer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture ), plRefFlags::kActiveRef );

    // All done!
    return (plLayerInterface *)plasmaLayer;

    hsGuardEnd;
}

//// IGetInitBitmapBuffer /////////////////////////////////////////////////////
//  Called to get a 32-bit uncompressed ARGB version of the init bitmap of
//  a dynamic text layer

UInt32  *plLayerConverter::IGetInitBitmapBuffer( plDynamicTextLayer *layer ) const
{
    UInt32          *buffer;
    hsRGBAColor32   *buffPtr;
    UInt16          width, height;


    IParamBlock2 *bitmapPB = layer->GetParamBlockByID( plDynamicTextLayer::kBlkBitmap );
    Bitmap      *initBitmap = layer->GetBitmap( TimeValue( 0 ) );

    if( bitmapPB->GetInt( (ParamID)plDynamicTextLayer::kBmpUseInitImage ) == 0 || initBitmap == nil )
        return nil;

    width = bitmapPB->GetInt( (ParamID)plDynamicTextLayer::kBmpExportWidth );
    height = bitmapPB->GetInt( (ParamID)plDynamicTextLayer::kBmpExportHeight );

    buffer = TRACKED_NEW UInt32[ width * height ];
    if( buffer == nil )
        return nil;

    // Fill buffer from the MAX bitmap
    PixelBuf        l64( width );
    BMM_Color_64    *p64 = l64.Ptr();

    buffPtr = (hsRGBAColor32 *)buffer;
    for( int y = 0; y < height; y++ )
    {
        hsRGBAColor32   color;

        if( !initBitmap->GetLinearPixels( 0, y, width, p64 ) )
        {
            delete [] buffer;
            return nil;
        }

        for( int x = 0; x < width; x++ )
        {
            color.SetARGB(  p64[ x ].a * 255.f / 65535.f,
                            p64[ x ].r * 255.f / 65535.f,
                            p64[ x ].g * 255.f / 65535.f,
                            p64[ x ].b * 255.f / 65535.f );
            buffPtr[ x ] = color;
        }

        buffPtr += width;
    }

    return buffer;
}

static UInt32 MakeUInt32Color(float r, float g, float b, float a)
{
    return (UInt32(a * 255.9f) << 24)
            |(UInt32(r * 255.9f) << 16)
            |(UInt32(g * 255.9f) << 8)
            |(UInt32(b * 255.9f) << 0);
}

plBitmap* plLayerConverter::IGetAttenRamp(plMaxNode *node, BOOL isAdd, int loClamp, int hiClamp)
{
    char funkName[512];
    sprintf(funkName, "%s_%d_%d", 
        isAdd ? "AttenRampAdd" : "AttenRampMult",
        loClamp,
        hiClamp);

    float range = float(hiClamp - loClamp) * 1.e-2f;
    float lowest = float(loClamp) * 1.e-2f;
    const int kLUTWidth = 16;
    const int kLUTHeight = 16;

    // NOTE: CreateBlankMipmap might return an old mipmap if it was already created, so in those
    // cases we wouldn't really need to re-write the texture. However, there's no harm in doing so,
    // and since we're close to Alpha, I don't want to shake up the code any more than absolutely 
    // necessary. -mcn
    plMipmap *texture = plBitmapCreator::Instance().CreateBlankMipmap( kLUTWidth, kLUTHeight, plMipmap::kARGB32Config, 1, funkName, node->GetLocation() );

    UInt32* pix = (UInt32*)texture->GetImage();

    if( isAdd )
    {
        int i;
        for( i = 0; i < kLUTHeight; i++ )
        {
            int j;
            for( j = 0; j < kLUTWidth; j++ )
            {
                float x = float(j) / (kLUTWidth-1);
                float y = float(i) / (kLUTHeight-1);
                if( x < y )
                    x = y;
                x *= range;
                x += lowest;
                *pix++ = MakeUInt32Color(1.f, 1.f, 1.f, x);
            }
        }
    }
    else
    {
        int i;
        for( i = 0; i < kLUTHeight; i++ )
        {
            int j;
            for( j = 0; j < kLUTWidth; j++ )
            {
                float x = float(j) / (kLUTWidth-1);
                float y = float(i) / (kLUTHeight-1);
                float val = x * y;
                val *= range;
                val += lowest;
                *pix++ = MakeUInt32Color(1.f, 1.f, 1.f, val);
            }
        }
    }

    return texture;
}


plLayer* plLayerConverter::ICreateAttenuationLayer(const char* name, plMaxNode *node, int uvwSrc,
                                                            float tr0, float op0, float tr1, float op1,
                                                            int loClamp, int hiClamp)
{
    hsMatrix44 uvwXfm;
    uvwXfm.Reset();
    uvwXfm.fMap[0][0] = uvwXfm.fMap[1][1] = uvwXfm.fMap[2][2] = 0;
    uvwXfm.NotIdentity();

    if( op0 != tr0 )
    {
        uvwXfm.fMap[0][2] = -1.f / (tr0 - op0);
        uvwXfm.fMap[0][3] = uvwXfm.fMap[0][2] * -tr0;
    }
    else
    {
        uvwXfm.fMap[0][3] = 1.f;
    }

    if( op1 != tr1 )
    {
        uvwXfm.fMap[1][2] = -1.f / (tr1 - op1);
        uvwXfm.fMap[1][3] = uvwXfm.fMap[1][2] * -tr1;
    }
    else
    {
        uvwXfm.fMap[1][3] = 1.f;
    }

    BOOL chanAdd = false;
    if( op0 < tr0 )
    {
        if( (op0 < op1) && (tr1 < op1) )
            chanAdd = true;
    }
    else if( op0 > tr0 )
    {
        if( (op0 > op1) && (tr1 > op1) )
            chanAdd = true;
    }
    plBitmap* funkRamp = IGetAttenRamp(node, chanAdd, loClamp, hiClamp);

    plLayer* layer = TRACKED_NEW plLayer;
    layer->InitToDefault();
    hsgResMgr::ResMgr()->NewKey(name, layer, node->GetLocation());
    hsgResMgr::ResMgr()->AddViaNotify(funkRamp->GetKey(), TRACKED_NEW plLayRefMsg(layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture), plRefFlags::kActiveRef);

    layer->SetAmbientColor(hsColorRGBA().Set(1.f, 1.f, 1.f, 1.f));
    layer->SetPreshadeColor(hsColorRGBA().Set(0, 0, 0, 1.f));
    layer->SetRuntimeColor(hsColorRGBA().Set(0, 0, 0, 1.f));

    layer->SetZFlags(hsGMatState::kZNoZWrite);
    UInt32 blendFlags = hsGMatState::kBlendAlpha | hsGMatState::kBlendNoTexColor | hsGMatState::kBlendAlphaMult;
    layer->SetBlendFlags(blendFlags);
    layer->SetClampFlags(hsGMatState::kClampTexture);

    layer->SetTransform(uvwXfm);

    layer->SetUVWSrc(uvwSrc);

    return layer;
}

plLayerInterface* plLayerConverter::IConvertAngleAttenLayer(plPlasmaMAXLayer *layer, 
                                                                plMaxNode *maxNode, UInt32 blendFlags, 
                                                                hsBool preserveUVOffset, hsBool upperLayer)
{
    hsGuardBegin( "plPlasmaMAXLayer::IConvertAngleAttenLayer" );
    if( !upperLayer )
    {
        fErrorMsg->Set(true, maxNode->GetName(), "Angle Attenuation layers can only be used as a top layer").Show();
        fErrorMsg->Set();
        return nil;
    }
    plAngleAttenLayer* aaLay = (plAngleAttenLayer*)layer;
    Box3 fade = aaLay->GetFade();
    float tr0 = cosf(DegToRad(180.f - fade.Min().x));
    float op0 = cosf(DegToRad(180.f - fade.Min().y));
    float tr1 = cosf(DegToRad(180.f - fade.Max().x));
    float op1 = cosf(DegToRad(180.f - fade.Max().y));

    int loClamp = aaLay->GetLoClamp();
    int hiClamp = aaLay->GetHiClamp();

    int uvwSrc = aaLay->Reflect() ? plLayerInterface::kUVWReflect : plLayerInterface::kUVWNormal;

    plLayer* lut = ICreateAttenuationLayer(layer->GetName(), maxNode, uvwSrc, tr0, op0, tr1, op1, loClamp, hiClamp);

    return lut;

    hsGuardEnd;
}
//// ICreateLayer /////////////////////////////////////////////////////////////

plLayer     *plLayerConverter::ICreateLayer( const char *name, hsBool upperLayer, plLocation &loc )
{
    hsGuardBegin( "plPlasmaMAXLayer::ICreateLayer" );

    plLayer *layer = TRACKED_NEW plLayer;
    layer->InitToDefault();

    hsgResMgr::ResMgr()->NewKey( name, layer, loc );

    return layer;

    hsGuardEnd;
}

//// IProcessUVGen ////////////////////////////////////////////////////////////

void    plLayerConverter::IProcessUVGen( plPlasmaMAXLayer *srcLayer, plLayer *destLayer, 
                                        plBitmapData *bitmapData, hsBool preserveUVOffset )
{
    hsGuardBegin( "plPlasmaMAXLayer::IProcessUVGen" );

    StdUVGen *uvGen = (StdUVGen *)srcLayer->GetTheUVGen();

    int tiling = uvGen->GetTextureTiling();

    // If set this indicates the texture map is tiled in U
    if (!(tiling & U_WRAP))
    {
        destLayer->SetClampFlags( destLayer->GetClampFlags() | hsGMatState::kClampTextureU );
        if( bitmapData != nil )
            bitmapData->clampFlags |= plBitmapData::kClampU;
    }

    // If set this indicates the texture map is tiled in V
    if (!(tiling & V_WRAP))
    {
        destLayer->SetClampFlags( destLayer->GetClampFlags() | hsGMatState::kClampTextureV );
        if( bitmapData != nil )
            bitmapData->clampFlags |= plBitmapData::kClampV;
    }

    // UVW Src
    Int32 uvwSrc = srcLayer->GetMapChannel() - 1;

    if( fErrorMsg->Set( !( fWarned & kWarnedTooManyUVs ) && 
                        ( ( uvwSrc < 0 ) || ( uvwSrc >= plGeometrySpan::kMaxNumUVChannels ) ), 
                        destLayer->GetKeyName(), "Only %d UVW channels (1-%d) currently supported", 
        plGeometrySpan::kMaxNumUVChannels, plGeometrySpan::kMaxNumUVChannels).CheckAskOrCancel() )
        fWarned |= kWarnedTooManyUVs; 
    fErrorMsg->Set( false );

    destLayer->SetUVWSrc( uvwSrc );

    // Get the actual texture transform
    hsMatrix44 hsTopX;
    if (uvGen && (hsControlConverter::Instance().StdUVGenToHsMatrix44(&hsTopX, uvGen, preserveUVOffset == true)))
        destLayer->SetTransform( hsTopX );

    // All done!
    hsGuardEnd;
}

//// ICreateDynTextMap ////////////////////////////////////////////////////////

plDynamicTextMap    *plLayerConverter::ICreateDynTextMap( const char *layerName, UInt32 width, UInt32 height,
                                                        hsBool includeAlphaChannel, plMaxNode *node )
{
    hsGuardBegin( "plPlasmaMAXLayer::ICreateDynTextMap" );

    char                texName[ 256 ];
    plKey               key;
    plDynamicTextMap    *map = nil;

    
    // Need a unique key name for every layer that uses one. We could also key
    // off of width and height, but layerName should be more than plenty
    sprintf( texName, "%s_dynText", layerName );

    // Does it already exist?
    key = node->FindPageKey( plDynamicTextMap::Index(), texName );
    if( key != nil )
    {
        map = plDynamicTextMap::ConvertNoRef( key->GetObjectPtr() );
        if( map != nil )
            return map;
    }

    // Create
    map = TRACKED_NEW plDynamicTextMap();
    map->SetNoCreate( width, height, includeAlphaChannel );

    /// Add a key for it
    key = hsgResMgr::ResMgr()->NewKey( texName, map, node->GetLocation() );

    // All done!
    return map;

    hsGuardEnd;
}

///////////////////////////////////////////////////////////////////////////////
//// Texture/Bitmap Management ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

plBitmap *plLayerConverter::CreateSimpleTexture(const char *fileName, const plLocation &loc, 
                                                UInt32 clipID /* = 0 */, UInt32 texFlags /* = 0 */, bool useJPEG /* = false */)
{
    plBitmapData bd;
    bd.fileName = fileName;
    bd.texFlags = texFlags;
    bd.createFlags = 0;
    bd.detailDropoffStart = 0;
    bd.detailDropoffStop = 0;
    bd.detailMax = 0;
    bd.detailMin = 0;
    bd.sig = 0;
    bd.isStaticCubicEnvMap = false;
    bd.invertAlpha = false;
    bd.clampFlags = 0;
    bd.useJPEG = useJPEG;

    return plBitmapCreator::Instance().CreateTexture(&bd, loc, clipID);
}

//// IAssignTexture ///////////////////////////////////////////////////////////
//  Create a texture and assign it to the layer given. Returns the layer again,
//  or nil if there was an error and it got deleted.

plLayer *plLayerConverter::IAssignTexture( plBitmapData *bd, plMaxNode *maxNode, plLayer *destLayer, hsBool upperLayer, int clipID )
{
    plBitmap *texture = plBitmapCreator::Instance().CreateTexture( bd, maxNode->GetLocation(), clipID );
    if( texture == nil )
    {
        if( upperLayer )
        {
            if( fErrorMsg->Set( !( fWarned & kWarnedUpperTextureMissing ), "Plasma Export Error", sWarnUpperTextureMissing, maxNode->GetName(), bd->fileName ).CheckAskOrCancel() )
                fWarned |= kWarnedUpperTextureMissing; 
            fErrorMsg->Set( false );

            delete destLayer;
            return nil;
        }
        else
        {
            if( fErrorMsg->Set( !( fWarned & kWarnedNoBaseTexture ), "Plasma Export Error", sWarnBaseTextureMissing, maxNode->GetName(), bd->fileName ).CheckAskOrCancel() )
                fWarned |= kWarnedNoBaseTexture; 
            fErrorMsg->Set( false );

            return destLayer;
        }
    }
    else
        hsgResMgr::ResMgr()->AddViaNotify( texture->GetKey(), TRACKED_NEW plLayRefMsg( destLayer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture ), plRefFlags::kActiveRef );

    return destLayer;
}

//// IMakeCubicRenderTarget ///////////////////////////////////////////////////
//  Makes a plCubicRenderTarget as a texture. Also constructs the associated
//  modifier and attaches it to the necessary object (hacked for now)

plCubicRenderTarget *plLayerConverter::IMakeCubicRenderTarget( const char *name, plMaxNode *node, plMaxNode *anchor )
{
    plDynamicEnvMap* env = plEnvMapComponent::GetEnvMap(anchor);
    if( env )
        return env;

    char                modName[ 256 ];
    plCubicRenderTarget *cubic = nil;


    plKey   key;

    key = node->FindPageKey( plCubicRenderTarget::Index(), name );
    if( key != nil )
    {
        plCubicRenderTarget *cubic = plCubicRenderTarget::ConvertNoRef( key->GetObjectPtr() );
        if( cubic != nil )
            return cubic;
    }

    /// Get the key from the anchor
    if( anchor == nil || anchor->GetSceneObject() == nil )
        return nil;

    plKey   sObjKey = anchor->GetSceneObject()->GetKey();
    if( sObjKey == nil )
        return nil;

    /// Create
    cubic = TRACKED_NEW plCubicRenderTarget( plRenderTarget::kIsTexture, 256, 256, 32 );
    hsAssert( cubic != nil, "Cannot create cubic render target!" );

    /// Add a key
    key = hsgResMgr::ResMgr()->NewKey( name, cubic, node->GetLocation() );

    /// Now make a modifier
    plCubicRenderTargetModifier *mod = TRACKED_NEW plCubicRenderTargetModifier();
    sprintf( modName, "%s_mod", name );

    hsgResMgr::ResMgr()->NewKey( modName, mod, node->GetLocation() );
    hsgResMgr::ResMgr()->AddViaNotify( cubic->GetKey(), TRACKED_NEW plGenRefMsg( mod->GetKey(), plRefMsg::kOnCreate, 0, 0 ), plRefFlags::kPassiveRef );
    hsgResMgr::ResMgr()->AddViaNotify( mod->GetKey(), TRACKED_NEW plObjRefMsg( sObjKey, plRefMsg::kOnCreate, 0, plObjRefMsg::kModifier ), plRefFlags::kActiveRef );

    return cubic;
}