CWE-ou-minkata/Sources/Plasma/PubUtilLib/plGImage/plLODMipmap.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==*/

#include "hsTypes.h"
#include "plLODMipmap.h"

#include "hsResMgr.h"
#include "pnKeyedObject/plKey.h"
#include "pnKeyedObject/plUoid.h"
#include "pnMessage/plRefMsg.h"

#include "plPipeline/hsGDeviceRef.h"


plLODMipmap::plLODMipmap() 
:   fBase(nil), 
    fLOD(0)
{
    int i;
    for( i = 0; i < kNumLODs; i++ )
        fDeviceRefs[i] = nil;
}

plLODMipmap::plLODMipmap(plMipmap* mip)
:   fBase(nil),
    fLOD(0)
{
    int i;
    for( i = 0; i < kNumLODs; i++ )
        fDeviceRefs[i] = nil;

    hsgResMgr::ResMgr()->NewKey(mip->GetKey()->GetName(), this, mip->GetKey()->GetUoid().GetLocation());

    // Need some kind of reffing assignment for the mipmap here
    fBase = mip;
    fLevelSizes = TRACKED_NEW UInt32[fBase->GetNumLevels()];

    ISetup();

    hsgResMgr::ResMgr()->AddViaNotify(mip->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefBase), plRefFlags::kActiveRef);

}

plLODMipmap::~plLODMipmap()
{
    // And matching unreffing of the mipmap here.
    fImage = nil;

    int i;
    for( i = 0; i < kNumLODs; i++ )
    {
        hsRefCnt_SafeUnRef(fDeviceRefs[i]);
        fDeviceRefs[i] = nil;
    }
}

hsGDeviceRef* plLODMipmap::GetDeviceRef() const 
{ 
    return fDeviceRefs[GetLOD()]; 
}

void plLODMipmap::SetDeviceRef( hsGDeviceRef *const devRef )
{
    hsRefCnt_SafeAssign(fDeviceRefs[GetLOD()], devRef);
}


void plLODMipmap::SetLOD(int lod)
{
    hsAssert(fBase, "UnInitialized");

    const int kMaxLOD = 5;
    if( lod > kMaxLOD )
        lod = kMaxLOD;
    if( lod >= fBase->GetNumLevels() )
        lod = fBase->GetNumLevels() - 1;

    if( fLOD != lod )
    {
        fLOD = lod;
        ISetup();
    }
}


void plLODMipmap::ISetup()
{
    hsAssert(fBase, "UnInitialized");
    hsAssert(fBase->GetNumLevels() > GetLOD(), "Skipping all mip levels");

    fBase->SetCurrLevel(GetLOD());

    // plBitmap
    fPixelSize = fBase->GetPixelSize(); 
//  fSpace = fBase->fSpace;     
    fFlags = fBase->GetFlags();     

    fCompressionType = fBase->fCompressionType;
    if( !fBase->IsCompressed() )
    {
        fUncompressedInfo = fBase->fUncompressedInfo;
    }
    else
    {
        fDirectXInfo = fBase->fDirectXInfo;
    }

    // plMipmap
    fImage = fBase->GetCurrLevelPtr();
    fWidth = fBase->GetCurrWidth();
    fHeight = fBase->GetCurrHeight();

    fRowBytes = fBase->GetRowBytes();

    if( !fLevelSizes )
        fLevelSizes = TRACKED_NEW UInt32[fBase->GetNumLevels()];
        
    fNumLevels = fBase->GetNumLevels() - GetLOD();
    fNumLevels = 1;

    fTotalSize = 0;
    int i;
    for( i = 0; i < fNumLevels; i++ )
    {
        fLevelSizes[i] = fBase->GetLevelSize(i + GetLOD());
        fTotalSize += fBase->GetLevelSize(i + GetLOD());
    }

    ISetupCurrLevel();

    IMarkDirty();
}

void plLODMipmap::ISetupCurrLevel()
{
    fCurrLevelPtr = fBase->GetCurrLevelPtr();
    fCurrLevel = (UInt8)(fBase->GetCurrLevel());
    fCurrLevelWidth = fBase->GetCurrWidth();
    fCurrLevelHeight = fBase->GetCurrHeight();
    fCurrLevelRowBytes = fBase->GetRowBytes();
}

void plLODMipmap::INilify()
{
    fBase = nil;

    fPixelSize = 0;
    fSpace = kNoSpace;
    fFlags = 0;

    fCompressionType = kUncompressed;
    fUncompressedInfo.fType = UncompressedInfo::kRGB8888;

    // plMipmap
    fImage = nil;
    fWidth = 0;
    fHeight = 0;

    fRowBytes = 0;

    fNumLevels = 0;
    fTotalSize = 0;

    fCurrLevelPtr = nil;
    fCurrLevel = 0;
    fCurrLevelWidth = 0;
    fCurrLevelHeight = 0;
    fCurrLevelRowBytes = 0;

    delete [] fLevelSizes;
    fLevelSizes = nil;

    int i;
    for( i = 0; i < kNumLODs; i++ )
    {
        hsRefCnt_SafeUnRef(fDeviceRefs[i]);
        fDeviceRefs[i] = nil;
    }
}

void plLODMipmap::IMarkDirty()
{
    int i;
    for( i = 0; i < kNumLODs; i++ )
    {
        if( fDeviceRefs[i] )
            fDeviceRefs[i]->SetDirty(true);
    }
}

void plLODMipmap::SetCurrLevel(UInt8 level)
{
    fBase->SetCurrLevel(level + GetLOD());

    ISetupCurrLevel();
}

void plLODMipmap::Reset()
{
    fBase->Reset();
    ISetup();
}

void plLODMipmap::ScaleNicely(UInt32 *destPtr, UInt16 destWidth, UInt16 destHeight,
                            UInt16 destStride, plMipmap::ScaleFilter filter) const
{
    fBase->ScaleNicely(destPtr, destWidth, destHeight, destStride, filter);
}

hsBool plLODMipmap::ResizeNicely(UInt16 newWidth, UInt16 newHeight, plMipmap::ScaleFilter filter)
{
    hsBool retVal = fBase->ResizeNicely(newWidth, newHeight, filter);
    ISetup();
    return retVal;
}

void plLODMipmap::CopyFrom(const plMipmap *source)
{
    fBase->CopyFrom(source);
    ISetup();
}

void plLODMipmap::Composite(plMipmap *source, UInt16 x, UInt16 y, CompositeOptions *options) 
{ 
    fBase->Composite(source, x, y, options); 
    IMarkDirty();
}

hsBool plLODMipmap::MsgReceive(plMessage *msg)
{
    plGenRefMsg* ref = plGenRefMsg::ConvertNoRef(msg);
    if( ref )
    {
        if( ref->fType == kRefBase )
        {
            INilify();
            if( ref->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
            {
                fBase = plMipmap::ConvertNoRef(ref->GetRef());
                ISetup();
            }

            return true;
        }
    }

    return plMipmap::MsgReceive(msg);
}

void plLODMipmap::Read(hsStream *s, hsResMgr *mgr)
{
    INilify();
    hsKeyedObject::Read(s, mgr);
    mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefBase), plRefFlags::kActiveRef); // fBase
}

void plLODMipmap::Write(hsStream *s, hsResMgr *mgr)
{
    hsKeyedObject::Write(s, mgr);
    mgr->WriteKey(s, fBase);
}