You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

237 lines
8.4 KiB

/*==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==*/
//////////////////////////////////////////////////////////////////////////////
// //
// plPlates - Header file for the plates and plPlateManager //
// //
//////////////////////////////////////////////////////////////////////////////
#ifndef _plPlates_h
#define _plPlates_h
#include "hsTypes.h"
#include "hsStlUtils.h"
#include "hsColorRGBA.h"
#include "hsTemplates.h"
#include "hsUtils.h"
#include "hsMatrix44.h"
//// plPlate Class Definition ////////////////////////////////////////////////
// plPlate is the actual plate object that represents one plate on the
// screen. It has a transform matrix (which includes position, scale and
// rotation), a material, a depth value and a color that is applied to all
// four corners. All plates are parallelograms.
class plPlateManager;
class hsGMaterial;
class plMipmap;
class plBitmap;
class plPlate
{
friend class plPlateManager;
protected:
hsMatrix44 fXformMatrix;
hsGMaterial *fMaterial;
plMipmap *fMipmap;
hsScalar fDepth, fOpacity;
UInt32 fFlags;
char fTitle[ 64 ];
plPlate *fNext;
plPlate **fPrevPtr;
plPlate **fOwningHandle;
static UInt32 fMagicUniqueKeyInt;
plPlate( plPlate** owningHandle );
virtual ~plPlate();
void ILink( plPlate **back );
void IUnlink( void )
{
hsAssert( fPrevPtr, "Plate not in list" );
if( fNext )
fNext->fPrevPtr = fPrevPtr;
*fPrevPtr = fNext;
fNext = nil;
fPrevPtr = nil;
}
void ISetResourceAlphas(UInt32 colorKey);
public:
enum
{
kFlagVisible = 0x00000001,
kFlagLocalMaterial = 0x00000002,
kFlagIsAGraph = 0x00000004
};
/// Basic properties
void SetTransform( hsMatrix44 &matrix, hsBool reSort = true );
void SetMaterial( hsGMaterial *material );
void SetTexture(plBitmap *texture); // Creates a new single layer material to use the texture.
void SetTitle( const char *title ) { if( title != nil ) strncpy( fTitle, title, sizeof( fTitle ) ); else fTitle[ 0 ] = 0; }
hsGMaterial *GetMaterial( void ) { return fMaterial; }
hsMatrix44 &GetTransform( void ) { return fXformMatrix; }
const char *GetTitle( void ) { return fTitle; }
UInt32 GetFlags( void ) { return fFlags; }
const plMipmap *GetMipmap( void ) { return fMipmap; }
void SetVisible( hsBool vis ) { if( vis ) fFlags |= kFlagVisible; else fFlags &= ~kFlagVisible; }
hsBool IsVisible( void );
void SetOpacity( hsScalar opacity = 1.f );
plPlate *GetNext( void ) { return fNext; }
/// Helper functions
void SetDepth( hsScalar depth) { fDepth = depth; }
void SetPosition( hsScalar x, hsScalar y, hsScalar z = -1.0f );
void SetSize( hsScalar width, hsScalar height, bool adjustByAspectRatio = false );
plMipmap *CreateMaterial( UInt32 width, UInt32 height, hsBool withAlpha, plMipmap* texture = NULL );
void CreateFromResource( const char *resName, UInt32 colorKey = 0x00ff00ff );
void ReloadFromResource( const char *resName, UInt32 colorKey = 0x00ff00ff );
void CreateFromJPEGResource( const char *resName, UInt32 colorKey = 0x00ff00ff );
void ReloadFromJPEGResource( const char *resName, UInt32 colorKey = 0x00ff00ff );
};
//// plGraphPlate Class Definition ///////////////////////////////////////////
// A derivation of plPlate that maintains a procedural texture which displays
// a scrolling graph of data.
class plGraphPlate : public plPlate
{
protected:
UInt32 fBGHexColor, fAxesHexColor, fGraphHexColor;
std::vector<UInt32> fDataHexColors;
UInt32 fMin, fMax, fLabelMin, fLabelMax;
std::vector<Int32> fLastValues;
std::vector<std::string> fLabelText;
UInt32 IMakePow2( UInt32 value );
void IDrawNumber( UInt32 number, UInt32 *dataPtr, UInt32 stride, UInt32 color );
void IDrawDigit( char digit, UInt32 *dataPtr, UInt32 stride, UInt32 color );
public:
plGraphPlate( plPlate **owningHandle );
virtual ~plGraphPlate();
void SetDataRange( UInt32 min, UInt32 max, UInt32 width );
void SetDataLabels( UInt32 min, UInt32 max );
void SetLabelText( char *text1, char *text2 = nil, char *text3 = nil, char *text4 = nil );
void SetLabelText( const std::vector<std::string> & text );
void ClearData( void );
void AddData( Int32 value, Int32 value2 = -1, Int32 value3 = -1, Int32 value4 = -1 );
void AddData( std::vector<Int32> values );
void SetColors( UInt32 bgHexColor = 0x80000000, UInt32 axesHexColor = 0xffffffff, UInt32 dataHexColor = 0xff00ff00, UInt32 graphHexColor = 0x80ff0000 );
void SetDataColors( UInt32 hexColor1 = 0xff00ff00, UInt32 hexColor2 = 0xff0000ff, UInt32 hexColor3 = 0xffffff00, UInt32 hexColor4 = 0xffff00ff );
void SetDataColors( const std::vector<UInt32> & hexColors );
const char *GetLabelText( int i ) { return fLabelText[ i ].c_str(); }
const UInt32 GetDataColor( int i ) { return fDataHexColors[ i ]; }
const UInt32 GetNumLabels() { return fLabelText.size(); }
const UInt32 GetNumColors() { return fDataHexColors.size(); }
};
//// plPlateManager Class Definition /////////////////////////////////////////
// This class handles all the plates--it keeps track of all the plates,
// creates and destroys them, and draws them when the pipeline tells it to.
class plPipeline;
class plPlateManager
{
friend class plPlate;
private:
static plPlateManager *fInstance;
protected:
plPlate *fPlates;
plPipeline *fOwner;
hsBool fCreatedSucessfully;
plPlateManager( plPipeline *pipe )
{
fInstance = this;
fPlates = nil;
fOwner = pipe;
fCreatedSucessfully = true;
}
virtual void IDrawToDevice( plPipeline *pipe ) = 0;
void IResortPlate( plPlate *plate, bool fromCurrent );
public:
virtual ~plPlateManager();
static plPlateManager &Instance( void ) { return *fInstance; }
static bool InstanceValid( void ) { return fInstance != nil; }
void CreatePlate( plPlate **handle );
void CreatePlate( plPlate **handle, hsScalar width, hsScalar height );
void CreatePlate( plPlate **handle, hsScalar x, hsScalar y, hsScalar width, hsScalar height );
void CreateGraphPlate( plGraphPlate **handle );
void DestroyPlate( plPlate *plate );
void SetPlateScreenPos( plPlate *plate, UInt32 x, UInt32 y );
void SetPlatePixelSize( plPlate *plate, UInt32 pWidth, UInt32 pHeight );
UInt32 GetPipeWidth( void );
UInt32 GetPipeHeight( void );
void DrawToDevice( plPipeline *pipe );
hsBool IsValid( void ) { return fCreatedSucessfully; }
};
// Sets the hInstance that we load our resources from. A SceneViewer hack.
void SetHInstance(void *instance);
#endif //_plPlates_h