CWE-ou-minkata/Sources/Plasma/PubUtilLib/plGImage/plBitmap.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==*/
///////////////////////////////////////////////////////////////////////////////
//																			 //
//	plBitmap Class Functions												 //
//	Base bitmap class for all the types of bitmaps (mipmaps, cubic envmaps,  //
//	etc.																	 //
//	Cyan, Inc.																 //
//																			 //
//// Version History //////////////////////////////////////////////////////////
//																			 //
//	6.7.2001 mcn - Created.													 //
//																			 //
///////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "plBitmap.h"

#include "hsResMgr.h"
#include "hsStream.h"
#include "pnKeyedObject/plKey.h"
#include "plPipeline/hsGDeviceRef.h"


//// Static Members ///////////////////////////////////////////////////////////

UInt8	plBitmap::fGlobalNumLevelsToChop = 0;


//// Constructor & Destructor /////////////////////////////////////////////////

plBitmap::plBitmap()
{
	fPixelSize = 0;
	fSpace = kNoSpace;
	fFlags = 0;
	fCompressionType = kUncompressed;
	fUncompressedInfo.fType = UncompressedInfo::kRGB8888;
	fDeviceRef = nil;
	fLowModifiedTime = fHighModifiedTime = 0;
}

plBitmap::~plBitmap()
{
	if( fDeviceRef != nil )
		hsRefCnt_SafeUnRef( fDeviceRef );
}

bool plBitmap::IsSameModifiedTime(UInt32 lowTime, UInt32 highTime)
{
	return (fLowModifiedTime == lowTime && fHighModifiedTime == highTime);
}

void plBitmap::SetModifiedTime(UInt32 lowTime, UInt32 highTime)
{
	fLowModifiedTime = lowTime;
	fHighModifiedTime = highTime;
}

//// Read /////////////////////////////////////////////////////////////////////

static UInt8	sBitmapVersion = 2;

UInt32 	plBitmap::Read( hsStream *s )
{
	UInt8	version = s->ReadByte();
	UInt32	read = 6;


	hsAssert( version == sBitmapVersion, "Invalid bitamp version on Read()" );

	fPixelSize = s->ReadByte();
	fSpace = s->ReadByte();
	fFlags = s->ReadSwap16();
	fCompressionType = s->ReadByte();

	if(( fCompressionType == kUncompressed )||( fCompressionType == kJPEGCompression ))
	{
		fUncompressedInfo.fType = s->ReadByte();
		read++;
	}
	else
	{
		fDirectXInfo.fBlockSize = s->ReadByte();
		fDirectXInfo.fCompressionType = s->ReadByte();
		read += 2;
	}

	fLowModifiedTime = s->ReadSwap32();
	fHighModifiedTime = s->ReadSwap32();

	return read;
}

//// Write ////////////////////////////////////////////////////////////////////

UInt32 	plBitmap::Write( hsStream *s )
{
	UInt32	written = 6;


	s->WriteByte( sBitmapVersion );

	s->WriteByte( fPixelSize );
	s->WriteByte( fSpace );
	s->WriteSwap16( fFlags );
	s->WriteByte( fCompressionType );

	if(( fCompressionType == kUncompressed )||(fCompressionType == kJPEGCompression ))
	{
		s->WriteByte( fUncompressedInfo.fType );
		written++;
	}
	else
	{
		s->WriteByte( fDirectXInfo.fBlockSize );
		s->WriteByte( fDirectXInfo.fCompressionType );
		written += 2;
	}

	s->WriteSwap32(fLowModifiedTime);
	s->WriteSwap32(fHighModifiedTime);

	return written;
}

//// SetDeviceRef /////////////////////////////////////////////////////////////

void	plBitmap::SetDeviceRef( hsGDeviceRef *const devRef )
{
	if( fDeviceRef == devRef )
		return;

	hsRefCnt_SafeAssign( fDeviceRef, devRef );
}

void plBitmap::MakeDirty()
{
	if( fDeviceRef )
		fDeviceRef->SetDirty(true);
}