OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
363 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 3ead2ccda5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3ead2ccda5'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plPipeline/plPlates.cpp

792 lines
23 KiB
Raw Blame History

/*==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/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
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.cpp - Implementation of plates and plate manager //
// //
//////////////////////////////////////////////////////////////////////////////
#include "hsWindows.h"
#include "hsTypes.h"
#include "plPipeline.h"
#include "plPlates.h"
#include "plJPEG/plJPEG.h"
#include "plGImage/plPNG.h"
#include "plGImage/plMipmap.h"
#include "plSurface/plLayer.h"
#include "plSurface/hsGMaterial.h"
#include "plMessage/plLayRefMsg.h"
#include "pnMessage/plRefMsg.h"
#include "hsGDeviceRef.h"
#include "hsResMgr.h"
#include "plPipeDebugFlags.h"
#include "plClientResMgr/plClientResMgr.h"
// A bit of a hack so that we will have the correct instance in the SceneViewer
static HINSTANCE gHInstance = GetModuleHandle(nil);
void SetHInstance(void *instance)
{
gHInstance = (HINSTANCE)instance;
}
//////////////////////////////////////////////////////////////////////////////
//// plPlate Functions ///////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
UInt32 plPlate::fMagicUniqueKeyInt = 0;
plPlate::plPlate( plPlate **owningHandle )
{
fXformMatrix.Reset();
fDepth = 1.0f;
fMaterial = nil;
fFlags = 0;
fOpacity = 1.f;
fNext = nil;
fPrevPtr = nil;
fOwningHandle = owningHandle;
fMipmap = nil;
memset( fTitle, 0, sizeof( fTitle ) );
}
plPlate::~plPlate()
{
if( fFlags & kFlagLocalMaterial )
fMaterial->GetKey()->UnRefObject();
else
{
hsRefCnt_SafeUnRef( fMaterial );
}
fMaterial = nil;
*fOwningHandle = nil;
}
//// SetPosition /////////////////////////////////////////////////////////////
void plPlate::SetPosition( hsScalar x, hsScalar y, hsScalar z )
{
hsVector3 triple;
if( z != -1.0f )
{
/// Gotta resort--let the manager do it
plPlateManager::Instance().IResortPlate( this, ( z + 1.0f <= fDepth ) ? true : false );
fDepth = z + 1.0f;
}
x *= fDepth / 1.0f;
y *= fDepth / 1.0f;
triple.fX = x;
triple.fY = y;
triple.fZ = fDepth;
fXformMatrix.SetTranslate( &triple );
}
//// SetSize /////////////////////////////////////////////////////////////////
void plPlate::SetSize( hsScalar width, hsScalar height, bool adjustByAspectRation )
{
hsVector3 size;
width *= fDepth / 1.0f;
height *= fDepth / 1.0f;
size.fX = adjustByAspectRation ? (width * ((hsScalar)plPlateManager::Instance().GetPipeHeight() / (hsScalar)plPlateManager::Instance().GetPipeWidth())) : width;
size.fY = height;
size.fZ = 1.0f;
fXformMatrix.SetScale( &size );
}
//// SetTransform ////////////////////////////////////////////////////////////
void plPlate::SetTransform( hsMatrix44 &matrix, hsBool reSort )
{
fXformMatrix = matrix;
if( reSort )
plPlateManager::Instance().IResortPlate( this, false );
}
//// SetMaterial /////////////////////////////////////////////////////////////
void plPlate::SetMaterial( hsGMaterial *material )
{
hsRefCnt_SafeAssign( fMaterial, material );
}
void plPlate::SetTexture(plBitmap *texture)
{
plLayer *layer;
hsGMaterial *material;
char keyName[ 128 ];
material = TRACKED_NEW hsGMaterial();
sprintf( keyName, "PlateBlank#%d", fMagicUniqueKeyInt++ );
hsgResMgr::ResMgr()->NewKey( keyName, material, plLocation::kGlobalFixedLoc );
layer = material->MakeBaseLayer();
layer->SetShadeFlags( layer->GetShadeFlags() | hsGMatState::kShadeNoShade | hsGMatState::kShadeWhite | hsGMatState::kShadeReallyNoFog );
layer->SetZFlags( layer->GetZFlags() | hsGMatState::kZNoZRead );
layer->SetBlendFlags( layer->GetBlendFlags() | hsGMatState::kBlendAlpha );
layer->SetOpacity( fOpacity );
layer->SetUVWSrc(plLayerInterface::kUVWPassThru);
hsgResMgr::ResMgr()->AddViaNotify(texture->GetKey(), TRACKED_NEW plGenRefMsg(layer->GetKey(), plRefMsg::kOnCreate, -1, plLayRefMsg::kTexture), plRefFlags::kActiveRef);
SetMaterial(material);
}
//// SetOpacity //////////////////////////////////////////////////////////////
void plPlate::SetOpacity( hsScalar opacity )
{
if( fMaterial != nil && fMaterial->GetLayer( 0 ) != nil )
{
plLayer *layer = (plLayer *)fMaterial->GetLayer( 0 );
layer->SetOpacity( opacity );
}
fOpacity = opacity;
}
//// CreateMaterial /////////////////////////////////////////////////////
// Creates a new material for this plate with either a specified texture
// or an empty, white-filled bitmap.
plMipmap *plPlate::CreateMaterial( UInt32 width, UInt32 height, hsBool withAlpha, plMipmap* texture )
{
plLayer *layer;
hsGMaterial *material;
char keyName[ 128 ];
if (texture)
{
fMipmap = texture;
}
else
{
/// Create a new bitmap
fMipmap = TRACKED_NEW plMipmap( width, height, withAlpha ? plMipmap::kARGB32Config : plMipmap::kRGB32Config, 1 );
memset( fMipmap->GetImage(), 0xff, height * fMipmap->GetRowBytes() );
sprintf( keyName, "PlateBitmap#%d", fMagicUniqueKeyInt++ );
hsgResMgr::ResMgr()->NewKey( keyName, fMipmap, plLocation::kGlobalFixedLoc );
fMipmap->SetFlags( fMipmap->GetFlags() | plMipmap::kDontThrowAwayImage );
}
/// NOW create a layer wrapper and a material for that layer
material = TRACKED_NEW hsGMaterial();
sprintf( keyName, "PlateBlank#%d", fMagicUniqueKeyInt++ );
hsgResMgr::ResMgr()->NewKey( keyName, material, plLocation::kGlobalFixedLoc );
layer = material->MakeBaseLayer();
layer->SetShadeFlags( layer->GetShadeFlags() | hsGMatState::kShadeNoShade | hsGMatState::kShadeWhite | hsGMatState::kShadeReallyNoFog );
layer->SetZFlags( layer->GetZFlags() | hsGMatState::kZNoZRead );
layer->SetBlendFlags( layer->GetBlendFlags() | hsGMatState::kBlendAlpha );
layer->SetOpacity( fOpacity );
hsgResMgr::ResMgr()->AddViaNotify( fMipmap->GetKey(), TRACKED_NEW plLayRefMsg( layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture ), plRefFlags::kActiveRef );
// Set up a ref to these. Since we don't have a key, we use the
// generic RefObject() (and matching UnRefObject() when we're done).
// If we had a key, we would use myKey->AddViaNotify(otherKey) and myKey->Release(otherKey).
material->GetKey()->RefObject();
/// Set this as our new material and return the bitmap
fFlags |= kFlagLocalMaterial;
fMaterial = material;
return fMipmap;
}
//// CreateFromResource //////////////////////////////////////////////////////
// Creates a plate's material from a resource of the given name.
void plPlate::CreateFromResource(const char *resName)
{
if (resName)
{
plMipmap* resTexture = TRACKED_NEW plMipmap;
resTexture->CopyFrom(plClientResMgr::Instance().getResource(resName));
char keyName[128];
sprintf( keyName, "PlateResource#%d", fMagicUniqueKeyInt++ );
hsgResMgr::ResMgr()->NewKey(keyName, resTexture, plLocation::kGlobalFixedLoc);
CreateMaterial(resTexture->GetWidth(), resTexture->GetHeight(), true, resTexture);
}
else
{
// Null resource request - Create a blank Material instead
CreateMaterial(32, 32, true);
}
}
void plPlate::ReloadFromResource(const char *resName)
{
if (resName)
{
fMipmap->CopyFrom(plClientResMgr::Instance().getResource(resName));
}
}
//// ILink ///////////////////////////////////////////////////////////////////
// Links a plate into a plate list, but also sorts by decreasing depth,
// so the plate won't actually necessarily be added after the pointer
// given.
void plPlate::ILink( plPlate **back )
{
hsAssert( fNext == nil && fPrevPtr == nil, "Trying to link a plate that's already linked" );
/// Advance back as far as we need to go
while( *back != nil && (*back)->fDepth > fDepth )
back = &( (*back)->fNext );
/// Link!
fNext = *back;
if( *back )
(*back)->fPrevPtr = &fNext;
fPrevPtr = back;
*back = this;
}
hsBool plPlate::IsVisible()
{
// return not-visible if our material is not valid
if (fMaterial->GetNumLayers() == 0)
return false;
plLayerInterface* layer = fMaterial->GetLayer(0);
if (layer->GetTexture() == nil)
return false;
// cursory check of material indicates it's valid, return our visible flag status
return ( fFlags & kFlagVisible ) ? true : false;
}
//////////////////////////////////////////////////////////////////////////////
//// plGraphPlate Functions //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//// Constructor & Destructor ////////////////////////////////////////////////
plGraphPlate::plGraphPlate( plPlate **owningHandle ) : plPlate( owningHandle )
{
fFlags |= kFlagIsAGraph;
SetLabelText( nil );
}
plGraphPlate::~plGraphPlate()
{
}
//// IMakePow2 ///////////////////////////////////////////////////////////////
UInt32 plGraphPlate::IMakePow2( UInt32 value )
{
int i;
for( i = 0; value != 0; i++, value >>= 1 );
return 1 << i;
}
//// SetDataRange ////////////////////////////////////////////////////////////
void plGraphPlate::SetDataRange( UInt32 min, UInt32 max, UInt32 width )
{
UInt32 height;
width = IMakePow2( width + 4 );
height = IMakePow2( max - min + 1 + 4 );
CreateMaterial( width, height, true );
fMin = min;
fMax = max;
SetDataLabels( fMin, fMax );
SetColors();
SetDataColors();
ClearData();
}
//// SetDataLabels ///////////////////////////////////////////////////////////
void plGraphPlate::SetDataLabels( UInt32 min, UInt32 max )
{
fLabelMin = min;
fLabelMax = max;
}
//// ClearData ///////////////////////////////////////////////////////////////
void plGraphPlate::ClearData( void )
{
UInt32 *bits = (UInt32 *)fMipmap->GetImage(), *ptr;
int i;
// Background color
for( i = 0; i < fMipmap->GetWidth() * fMipmap->GetHeight(); bits[ i ] = fBGHexColor, i++ );
// Axes
ptr = bits + fMipmap->GetWidth();
*ptr = fAxesHexColor;
for( ptr++, i = 0; i < fMipmap->GetHeight() - 4; i++, ptr += fMipmap->GetWidth() )
*ptr = fAxesHexColor;
for( i = 0; i < fMipmap->GetWidth() - 4; ptr[ i ] = fAxesHexColor, i++ );
ptr += fMipmap->GetWidth() - 1;
ptr[ 0 ] = fAxesHexColor;
ptr[ fMipmap->GetWidth() - 5 + 1 ] = fAxesHexColor;
if( fMaterial->GetLayer( 0 ) != nil && fMaterial->GetLayer( 0 )->GetTexture() )
{
hsGDeviceRef *ref = fMaterial->GetLayer( 0 )->GetTexture()->GetDeviceRef();
if( ref != nil )
ref->SetDirty( true );
}
}
//// AddData /////////////////////////////////////////////////////////////////
// Scroll graph data left by one, then add the new value
void plGraphPlate::AddData( Int32 value, Int32 value2, Int32 value3, Int32 value4 )
{
std::vector<Int32> values;
if (value != -1)
values.push_back(value);
if (value2 != -1)
values.push_back(value2);
if (value3 != -1)
values.push_back(value3);
if (value4 != -1)
values.push_back(value4);
AddData(values);
}
void plGraphPlate::AddData( std::vector<Int32> values )
{
hsAssert( fMipmap != nil, "Trying to add data to an uninitialized plGraphPlate" );
fMipmap->SetCurrLevel( 0 );
UInt32 *bits = (UInt32 *)fMipmap->GetImage(), *ptr;
UInt32 *minDPos = fMipmap->GetAddr32( 3, fMipmap->GetHeight() - 3 - 10 );
UInt32 *maxDPos = fMipmap->GetAddr32( 3, 2 );
int i, j;
std::vector<int> lows, his;
float lineCtr, lineInc;
int lastLineInt, lineInt, bumpCtr;
// make sure we have enough colors
if (values.size() > fDataHexColors.size())
{
for (i=fDataHexColors.size(); i<values.size(); i++)
fDataHexColors.push_back(0xff00ff00); // make it a nice green color
}
// make sure we have enough "last values"
if (values.size() > fLastValues.size())
{
for (i=fLastValues.size(); i<values.size(); i++)
fLastValues.push_back(0);
}
// Scale values
for (i=0; i<values.size(); i++)
{
lows.push_back(0);
his.push_back(0);
if( values[ i ] > fLabelMax )
values[ i ] = fLabelMax;
else if( values[ i ] < fLabelMin )
values[ i ] = fLabelMin;
values[ i ] = (UInt32)( (float)values[ i ] * ( fMipmap->GetHeight() - 4 ) / ( fLabelMax - fLabelMin + 1 ) );
if( values[ i ] < fLastValues[ i ] )
{
lows[ i ] = values[ i ] - 1;
his[ i ] = fLastValues[ i ];
}
else
{
lows[ i ] = fLastValues[ i ] - 1;
his[ i ] = values[ i ];
}
}
lineCtr = 0;
lastLineInt = 0;
bumpCtr = 0;
lineInc = 8.0f / ( fMipmap->GetHeight() - 4 );
IDrawNumber( fLabelMin, minDPos, fMipmap->GetWidth(), fBGHexColor );
IDrawNumber( fLabelMax, maxDPos, fMipmap->GetWidth(), fBGHexColor );
for( i = 0, ptr = bits + fMipmap->GetWidth() + 2, j = fMipmap->GetHeight() - 4; i < fMipmap->GetHeight() - 4; i++, j-- )
{
lineInt = (int)lineCtr;
if( lineInt != lastLineInt )
bumpCtr = 2;
memmove( ptr, ptr + 1, ( fMipmap->GetWidth() - 5 ) * sizeof( UInt32 ) );
int dataIndex;
bool dataPlotted = false;
for (dataIndex = 0; dataIndex < values.size(); dataIndex++)
{
if( j >= lows[ dataIndex ] && j <= his[ dataIndex ] )
{
ptr[ fMipmap->GetWidth() - 5 ] = fDataHexColors[ dataIndex ];
dataPlotted = true;
break;
}
}
if (!dataPlotted)
{
if( bumpCtr > 0 )
{
if( lineInt == 4 )
ptr[ fMipmap->GetWidth() - 5 ] = fGraphHexColor | 0xff000000;
else
ptr[ fMipmap->GetWidth() - 5 ] = fGraphHexColor;
bumpCtr--;
}
else
ptr[ fMipmap->GetWidth() - 5 ] = fBGHexColor;
}
ptr += fMipmap->GetWidth();
lastLineInt = lineInt;
lineCtr += lineInc;
}
IDrawNumber( fLabelMin, minDPos, fMipmap->GetWidth(), fAxesHexColor );
IDrawNumber( fLabelMax, maxDPos, fMipmap->GetWidth(), fAxesHexColor );
fLastValues = values;
if( fMaterial->GetLayer( 0 ) != nil && fMaterial->GetLayer( 0 )->GetTexture() != nil )
{
hsGDeviceRef *ref = fMaterial->GetLayer( 0 )->GetTexture()->GetDeviceRef();
if( ref != nil )
ref->SetDirty( true );
}
}
//// SetColors ///////////////////////////////////////////////////////////////
void plGraphPlate::SetColors( UInt32 bgHexColor, UInt32 axesHexColor, UInt32 dataHexColor, UInt32 graphHexColor )
{
fBGHexColor = bgHexColor;
fAxesHexColor = axesHexColor;
if (fDataHexColors.size() == 0)
fDataHexColors.push_back(dataHexColor);
else
fDataHexColors[ 0 ] = dataHexColor;
fGraphHexColor = graphHexColor;
ClearData();
}
//// SetDataColors ///////////////////////////////////////////////////////////
void plGraphPlate::SetDataColors( UInt32 hexColor1, UInt32 hexColor2, UInt32 hexColor3, UInt32 hexColor4 )
{
std::vector<UInt32> colors;
colors.push_back(hexColor1);
colors.push_back(hexColor2);
colors.push_back(hexColor3);
colors.push_back(hexColor4);
SetDataColors(colors);
}
void plGraphPlate::SetDataColors( const std::vector<UInt32> & hexColors )
{
fDataHexColors = hexColors;
}
//// SetLabelText ////////////////////////////////////////////////////////////
void plGraphPlate::SetLabelText( char *text1, char *text2, char *text3, char *text4 )
{
std::vector<std::string> strings;
if( text1 != nil )
strings.push_back(text1);
else
strings.push_back("");
if( text2 != nil )
strings.push_back(text2);
else
strings.push_back("");
if( text3 != nil )
strings.push_back(text3);
else
strings.push_back("");
if( text4 != nil )
strings.push_back(text4);
else
strings.push_back("");
SetLabelText(strings);
}
void plGraphPlate::SetLabelText( const std::vector<std::string> & text )
{
fLabelText = text;
}
//// IDrawNumber /////////////////////////////////////////////////////////////
void plGraphPlate::IDrawNumber( UInt32 number, UInt32 *dataPtr, UInt32 stride, UInt32 color )
{
char str[ 16 ];
int i;
sprintf( str, "%d", number );
for( i = 0; str[ i ] != 0; i++ )
{
IDrawDigit( str[ i ] - '0', dataPtr, stride, color );
dataPtr += 7;
}
}
//// IDrawDigit //////////////////////////////////////////////////////////////
void plGraphPlate::IDrawDigit( char digit, UInt32 *dataPtr, UInt32 stride, UInt32 color )
{
/// Yes, I know this is ugly. Move it into another file if you like.
char digits[ 10 ][ 5 * 3 ] =
{ { 1,1,1,
1,0,1,
1,0,1,
1,0,1,
1,1,1 },
{ 0,1,0,
1,1,0,
0,1,0,
0,1,0,
1,1,1 },
{ 2,2,2,
0,0,2,
0,2,0,
2,0,0,
2,2,2 },
{ 3,3,3,
0,0,3,
3,3,3,
0,0,3,
3,3,3 },
{ 4,0,4,
4,0,4,
4,4,4,
0,0,4,
0,0,4 },
{ 5,5,5,
5,0,0,
5,5,5,
0,0,5,
5,5,5 },
{ 6,6,6,
6,0,0,
6,6,6,
6,0,6,
6,6,6 },
{ 7,7,7,
0,0,7,
0,0,7,
0,0,7,
0,0,7 },
{ 8,8,8,
8,0,8,
8,8,8,
8,0,8,
8,8,8 },
{ 9,9,9,
9,0,9,
9,9,9,
0,0,9,
0,0,9 } };
char *digData = digits[ digit ];
int i, j;
for( i = 0; i < 5; i++ )
{
for( j = 0; j < 6; j += 2 )
{
if( *digData )
{
dataPtr[ j ] = color;
dataPtr[ j + 1 ] = color;
dataPtr[ j + stride ] = color;
dataPtr[ j + stride + 1 ] = color;
}
digData++;
}
dataPtr += stride + stride;
}
}
//////////////////////////////////////////////////////////////////////////////
//// plPlateManager Functions ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
plPlateManager *plPlateManager::fInstance = nil;
//// Destructor /////////////////////////////////////////////////////////////
plPlateManager::~plPlateManager()
{
while( fPlates != nil )
DestroyPlate( fPlates );
fInstance = nil;
}
//// CreatePlate /////////////////////////////////////////////////////////////
void plPlateManager::CreatePlate( plPlate **handle )
{
plPlate *plate = TRACKED_NEW plPlate( handle );
plate->ILink( &fPlates );
*handle = plate;
}
void plPlateManager::CreatePlate( plPlate **handle, hsScalar width, hsScalar height )
{
CreatePlate( handle );
(*handle)->SetSize( width, height );
}
void plPlateManager::CreatePlate( plPlate **handle, hsScalar x, hsScalar y, hsScalar width, hsScalar height )
{
CreatePlate( handle );
(*handle)->SetPosition( x, y );
(*handle)->SetSize( width, height );
}
void plPlateManager::CreateGraphPlate( plGraphPlate **handle )
{
plGraphPlate *plate = TRACKED_NEW plGraphPlate( (plPlate **)handle );
plate->ILink( &fPlates );
*handle = plate;
}
//// DestroyPlate ////////////////////////////////////////////////////////////
void plPlateManager::DestroyPlate( plPlate *plate )
{
if( plate != nil )
{
plate->IUnlink();
delete plate;
}
}
//// GetPipeWidth/Height /////////////////////////////////////////////////////
UInt32 plPlateManager::GetPipeWidth( void )
{
return fOwner->Width();
}
UInt32 plPlateManager::GetPipeHeight( void )
{
return fOwner->Height();
}
//// DrawToDevice ////////////////////////////////////////////////////////////
void plPlateManager::DrawToDevice( plPipeline *pipe )
{
if( !pipe->IsDebugFlagSet(plPipeDbg::kFlagNoPlates) )
IDrawToDevice( pipe );
}
//// IResortPlate ////////////////////////////////////////////////////////////
void plPlateManager::IResortPlate( plPlate *plate, bool fromCurrent )
{
plPlate **start = &fPlates;
if( fromCurrent )
start = plate->fPrevPtr;
plate->IUnlink();
plate->ILink( start );
}
//// SetPlateScreenPos ///////////////////////////////////////////////////////
void plPlateManager::SetPlateScreenPos( plPlate *plate, UInt32 x, UInt32 y )
{
float cX = ( (float)x / fOwner->Width() ) * 2.0f - 1.0f;
float cY = ( (float)y / fOwner->Height() ) * 2.0f - 1.0f;
plate->SetPosition( cX, cY );
}
void plPlateManager::SetPlatePixelSize( plPlate *plate, UInt32 pWidth, UInt32 pHeight )
{
float width = (float)pWidth / fOwner->Width() * 2.0f;
float height = (float)pHeight / fOwner->Height() * 2.0f;
plate->SetSize(width, height);
}