TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-01-20 12:44:46 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
Torque3D/Engine/source/gui/editor/guiParticleGraphCtrl.cpp
bank f3fc84738b Use fixed buffer size var when allocating return buffer from console. 
Conflicts:
	Engine/source/T3D/missionArea.cpp
	Engine/source/gui/editor/guiDebugger.cpp
2014-06-11 13:09:55 +04:00

1465 lines
41 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#include "gfx/gfxInit.h"
#include "gfx/primBuilder.h"
#include "gfx/gfxDrawUtil.h"
#include "console/console.h"
#include "console/consoleTypes.h"
#include "gui/core/guiCanvas.h"
#include "gui/editor/guiParticleGraphCtrl.h"
IMPLEMENT_CONOBJECT(GuiParticleGraphCtrl);
ConsoleDocClass( GuiParticleGraphCtrl,
"@brief Legacy remnant from old Torque particle editor\n\n"
"Editor use only.\n\n"
"@internal"
);
GuiParticleGraphCtrl::GuiParticleGraphCtrl()
{
for(S32 i = 0; i < MaxPlots; i++)
{
mPlots[i].mGraphColor = ColorF(1.0, 1.0, 1.0);
VECTOR_SET_ASSOCIATION(mPlots[i].mGraphData);
mPlots[i].mGraphMax.x = 1;
mPlots[i].mGraphMax.y = 50;
mPlots[i].mGraphMin.x = 0;
mPlots[i].mGraphMin.y = 0;
mPlots[i].mGraphType = Polyline;
mPlots[i].mGraphName = StringTable->insert("");
mPlots[i].mHidden = false;
mPlots[i].mGraphScale = 0.05f;
}
mPlots[0].mGraphColor = ColorF(1.0f, 0.2f, 0.2f);
mPlots[1].mGraphColor = ColorF(1.0f, 0.5f, 0.5f);
mPlots[2].mGraphColor = ColorF(0.0f, 1.0f, 0.0f);
mPlots[3].mGraphColor = ColorF(0.0f, 0.0f, 1.0f);
mPlots[4].mGraphColor = ColorF(0.0f, 1.0f, 1.0f);
mPlots[5].mGraphColor = ColorF(0.0f, 0.0f, 0.0f);
mPlots[6].mGraphColor = ColorF(0.5f, 0.5f, 0.5f);
mPlots[7].mGraphColor = ColorF(0.5f, 0.0f, 0.0f);
mPlots[8].mGraphColor = ColorF(0.0f, 0.5f, 0.0f);
mPlots[9].mGraphColor = ColorF(0.0f, 0.0f, 0.5f);
mPlots[10].mGraphColor = ColorF(0.0f, 0.5f, 0.5f);
mPlots[11].mGraphColor = ColorF(0.25f, 0.25f, 0.25f);
mPlots[12].mGraphColor = ColorF(0.5f, 0.5f, 0.5f);
mPlots[13].mGraphColor = ColorF(0.5f, 0.0f, 0.0f);
mPlots[14].mGraphColor = ColorF(0.0f, 0.5f, 0.0f);
mPlots[15].mGraphColor = ColorF(0.0f, 0.0f, 0.5f);
mPlots[16].mGraphColor = ColorF(0.0f, 0.5f, 0.5f);
mPlots[17].mGraphColor = ColorF(0.25f, 0.25f, 0.25f);
mPlots[18].mGraphColor = ColorF(1.0f, 0.2f, 0.2f);
mPlots[19].mGraphColor = ColorF(1.0f, 0.5f, 0.5f);
mPlots[20].mGraphColor = ColorF(0.0f, 1.0f, 0.0f);
mPlots[21].mGraphColor = ColorF(0.0f, 0.0f, 1.0f);
mPlots[22].mGraphColor = ColorF(0.0f, 1.0f, 1.0f);
mPlots[23].mGraphColor = ColorF(0.0f, 0.0f, 0.0f);
mPlots[24].mGraphColor = ColorF(0.5f, 0.5f, 0.5f);
mPlots[25].mGraphColor = ColorF(0.5f, 0.0f, 0.0f);
mPlots[26].mGraphColor = ColorF(0.0f, 0.5f, 0.0f);
mPlots[27].mGraphColor = ColorF(0.0f, 0.0f, 0.5f);
mPlots[28].mGraphColor = ColorF(1.0f, 0.0f, 0.0f);
mPlots[29].mGraphColor = ColorF(0.0f, 1.0f, 0.0f);
mPlots[30].mGraphColor = ColorF(0.0f, 0.0f, 1.0f);
mPlots[31].mGraphColor = ColorF(0.5f, 0.0f, 0.0f);
mVertexClickSize = 6;
mSelectedPlot = 0;
mSelectedPoint = -1;
mOriginalSelectedPoint = -1;
mLastSelectedPoint = -1;
mAddedPointIndex = -1;
mAutoMax = false;
mAutoRemove = false;
mRenderAllPoints = false;
mRenderGraphTooltip = true;
mPointWasAdded = false;
mPointXMovementClamped = false;
mOutlineColor = ColorI(1, 1, 1);
mCursorPos = Point2I(0, 0);
}
ImplementEnumType( GuiParticleGraphType,
"\n\n"
"@ingroup GuiCore"
"@internal")
{ GuiParticleGraphCtrl::Bar, "bar" },
{ GuiParticleGraphCtrl::Filled, "filled" },
{ GuiParticleGraphCtrl::Point, "point" },
{ GuiParticleGraphCtrl::Polyline , "polyline" },
EndImplementEnumType;
bool GuiParticleGraphCtrl::onWake()
{
if (! Parent::onWake())
return false;
setActive(true);
return true;
}
void GuiParticleGraphCtrl::onRender(Point2I offset, const RectI &updateRect)
{
// Fetch Draw Utility.
GFXDrawUtil* pDrawUtil = GFX->getDrawUtil();
if (mProfile->mBorder)
{
const RectI bounds = getBounds();
RectI rect(offset.x, offset.y, bounds.extent.x, bounds.extent.y);
pDrawUtil->drawRect(rect, mProfile->mBorderColor);
}
GuiControlProfile* profile = dynamic_cast<GuiControlProfile*>(Sim::findObject("GuiDefaultProfile"));
Resource<GFont> font = profile->mFont;
GFXVideoMode videoMode = GFXInit::getDesktopResolution();
ColorF color(1.0f, 1.0f, 1.0f, 0.5f);
pDrawUtil->drawRectFill(updateRect, color);
for (S32 k = 0; k < MaxPlots; k++)
{
// Nothing to graph
if ((mPlots[k].mGraphData.size() == 0) || (mPlots[k].mHidden == true))
continue;
Point2F graphExtent = getGraphExtent(k);
// Adjust scale to max value + 5% so we can see high value
F32 ScaleX = (F32(getExtent().x) / (graphExtent.x*(1.00 + (mPlots[k].mGraphScale))));
F32 ScaleY = (F32(getExtent().y) / (graphExtent.y*(1.00 + (mPlots[k].mGraphScale))));
if((mPlots[k].mGraphType == Point) || (mPlots[k].mGraphType == Polyline))
{
S32 posX;
S32 posY;
S32 lastPosX = 0;
S32 lastPosY = 0;
Point2F plotPoint;
S32 size = 32;
for (S32 sample = 0; sample < mPlots[k].mGraphData.size(); sample++)
{
S32 temp;
temp = (S32)(((F32)getExtent().x / (F32)mPlots[k].mGraphData.size()) * (F32)sample);
// calculate the point positions
plotPoint = getPlotPoint(k, sample);
posX = (S32)((plotPoint.x - mPlots[k].mGraphMin.x) * (ScaleX /(1.00 + mPlots[k].mGraphScale)));
posY = (getExtent().y) - (S32)((plotPoint.y - mPlots[k].mGraphMin.y) * ScaleY);
posX += getExtent().x * (mPlots[k].mGraphScale);
posY /= (1.00 + (mPlots[k].mGraphScale));
posX = localToGlobalCoord(Point2I(posX, posY)).x;
posY = localToGlobalCoord(Point2I(posX, posY)).y;
// check if this isn't our first loop through, if it is we won't have starting points
if(sample > 0)
{
pDrawUtil->drawLine( lastPosX, lastPosY , posX, posY , mPlots[k].mGraphColor );
} else
{
mPlots[k].mNutList.clear();
}
mPlots[k].mNutList.push_back( Point2F(posX, posY) );
// store the last positions to be the starting points drawn into a line next loop
lastPosX = posX;
lastPosY = posY;
//Con::printf("red %f green %f blue %f", mPlots[k].mGraphColor.red, mPlots[k].mGraphColor.green, mPlots[k].mGraphColor.blue);
if(mSelectedPoint != -1)
{
mLastSelectedPoint = mSelectedPoint;
}
ColorI nutColor (mPlots[k].mGraphColor);
if(k == mSelectedPlot && sample == mLastSelectedPoint)
{
// grab the colors for the nut
F32 red = mPlots[k].mGraphColor.red;
F32 green = mPlots[k].mGraphColor.green;
F32 blue = mPlots[k].mGraphColor.blue;
// invert the colors for the nut since this is a selected nut
red = 1.0 - red;
green = 1.0 - green;
blue = 1.0 - blue;
// nut color
nutColor = ColorI(ColorF(red, green, blue));
}
// draw the seleciton nut
drawNut( Point2I(posX, posY), 3, mOutlineColor, nutColor );
if((mLastSelectedPoint != -1) || (mRenderAllPoints == true))
{
if((k == mSelectedPlot && sample == mLastSelectedPoint) || (mRenderAllPoints == true))
{
char number[32];
Point2I comparePos = localToGlobalCoord(Point2I(getPosition().x, getPosition().y));
dSprintf(number, 32, "%4.3f %4.3f", plotPoint.x, plotPoint.y);
S32 textWidth = (S32)font->getStrWidth((const UTF8*)number);;
textWidth /= 2;
if((((S32)posX - (textWidth/2)) < comparePos.x) || (((S32)posX - textWidth) <= 0))
{
posX += (textWidth/1.5);
} else if((posX + (textWidth * 1.8)) > (comparePos.x + getExtent().x) || ((posX + textWidth) >= videoMode.resolution.x))
{
posX -= (textWidth * 1.5);
}
if((((S32)posY) < comparePos.y) || (((S32)posY - textWidth) <= 0))
{
posY += 40;
}
pDrawUtil->setBitmapModulation( profile->mFontColor );
pDrawUtil->drawText( font, Point2I(posX, posY + 5) - Point2I(size >> 1, size), number );
pDrawUtil->clearBitmapModulation();
}
}
}
}
}
if(mRenderNextGraphTooltip == true && mRenderGraphTooltip == true)
{
char argBuffer[1][32];
dSprintf(argBuffer[0], 32, "%s", getGraphName(mTooltipSelectedPlot));
renderGraphTooltip(mCursorPos, argBuffer[0]);
}
}
S32 GuiParticleGraphCtrl::addPlotPoint(S32 plotID, Point2F v, bool setAdded)
{
S32 mPlotIndex = 0;
bool plotChanged = false;
bool plotAdded = false;
if(mAutoMax == false)
{
if(v.x < mPlots[plotID].mGraphMin.x)
{
v.x = mPlots[plotID].mGraphMin.x;
}
if(v.x > mPlots[plotID].mGraphMax.x)
{
v.x = mPlots[plotID].mGraphMax.x;
}
if(v.y < mPlots[plotID].mGraphMin.y)
{
v.y = mPlots[plotID].mGraphMin.y;
}
if(v.y > mPlots[plotID].mGraphMax.y)
{
v.y = mPlots[plotID].mGraphMax.y;
}
}
for(S32 i = 0; i < mPlots[plotID].mGraphData.size(); i++)
{
if(mFabs(v.x - mPlots[plotID].mGraphData[i].x) < 0.001)
{
if(mAutoRemove == true)
{
changePlotPoint(plotID, i, v);
plotChanged = true;
mPlotIndex = i;
} else
{
mPlotIndex = -1;
}
plotAdded = true;
break;
} else if(v.x < mPlots[plotID].mGraphData[i].x)
{
insertPlotPoint(plotID, i, v);
plotAdded = true;
mPlotIndex = i;
break;
}
}
if(plotAdded == false)
{
mPlots[plotID].mGraphData.push_back( v );
mPlotIndex = mPlots[plotID].mGraphData.size() - 1;
}
if(mAutoMax == true)
{
// Keep record of maximum data value for scaling purposes.
if(v.y > mPlots[plotID].mGraphMax.y)
mPlots[plotID].mGraphMax.y = v.y;
if(v.x > mPlots[plotID].mGraphMax.x)
mPlots[plotID].mGraphMax.x = v.x;
}
if(plotChanged == true)
{
mPointWasAdded = false;
} else if(mPlotIndex != -1 && setAdded)
{
mPointWasAdded = true;
mAddedPoint = v;
mAddedPointIndex = mPlotIndex;
}
return mPlotIndex;
}
void GuiParticleGraphCtrl::insertPlotPoint(S32 plotID, S32 i, Point2F v)
{
//AssertFatal(plotID > -1 && plotID < MaxPlots, "Invalid plot specified!");
// Add the data and trim the vector...
mPlots[plotID].mGraphData.insert( i );
mPlots[plotID].mGraphData[ i ] = v;
if(mAutoMax == true)
{
// Keep record of maximum data value for scaling purposes.
if(v.y > mPlots[plotID].mGraphMax.y)
mPlots[plotID].mGraphMax.y = v.y;
if(v.x > mPlots[plotID].mGraphMax.x)
mPlots[plotID].mGraphMax.x = v.x;
}
// Argument Buffer.
char argBuffer[2][32];
dSprintf(argBuffer[0], 32, "%d", plotID);
dSprintf(argBuffer[1], 32, "%f %f", v.x, v.y);
// Call Scripts.
Con::executef(this, "onPlotPointInserted", argBuffer[0], argBuffer[1]);
}
S32 GuiParticleGraphCtrl::changePlotPoint(S32 plotID, S32 i, Point2F v)
{
//AssertFatal(plotID > -1 && plotID < MaxPlots, "Invalid plot specified!");
// Add the data and trim the vector...
S32 point = removePlotPoint(plotID, i);
// Argument Buffer.
char argBuffer[3][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%d", point);
dSprintf(argBuffer[2], 32, "%f %f", v.x, v.y);
// Call Scripts.
Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
// call the insert function
S32 index = addPlotPoint(plotID, v);
return index;
}
S32 GuiParticleGraphCtrl::removePlotPoint(S32 plotID, S32 i)
{
if((plotID < MaxPlots && plotID >= 0) && (i < mPlots[plotID].mGraphData.size()))
{
Point2F v = mPlots[plotID].mGraphData[i];
mPlots[plotID].mGraphData.erase(i);
if(i == mPlots[plotID].mGraphData.size() && mSelectedPlot == plotID && mLastSelectedPoint == i)
{
setSelectedPoint(i-1);
} else if(i < mLastSelectedPoint)
{
setSelectedPoint(mLastSelectedPoint-1);
}
}
return i;
}
S32 GuiParticleGraphCtrl::getSelectedPlot()
{
return mSelectedPlot;
}
S32 GuiParticleGraphCtrl::getSelectedPoint()
{
return mLastSelectedPoint;
}
bool GuiParticleGraphCtrl::isExistingPoint(S32 plotID, S32 sample)
{
if (((plotID < 0) || (plotID > MaxPlots)) || ((sample < 0) || (sample > MaxDataPoints)) || (sample >= mPlots[plotID].mGraphData.size()))
{
return false;
} else
{
return true;
}
}
Point2F GuiParticleGraphCtrl::getPlotPoint(S32 plotID, S32 sample)
{
Point2F val;
val.x = -1;
val.y = -1;
if (((plotID < 0) || (plotID > MaxPlots)) || ((sample < 0) || (sample > MaxDataPoints)))
{
return val;
}
return mPlots[plotID].mGraphData[sample];
}
S32 GuiParticleGraphCtrl::getPlotIndex(S32 plotID, F32 x, F32 y)
{
if ((plotID < 0) || (plotID > MaxPlots))
{
return -1;
}
F32 compareX = 0.0;
F32 compareY = 0.0;
for(S32 i = 0; i < mPlots[plotID].mGraphData.size(); i++)
{
compareX = mPlots[plotID].mGraphData[i].x;
compareY = mPlots[plotID].mGraphData[i].y;
//
//if((x == compareX) && (y == compareY))
if((mFabs(x - compareX) < 0.001) && (mFabs(y - compareY) < 0.001))
return i;
}
return -1;
}
void GuiParticleGraphCtrl::setGraphType(S32 plotID, const char *graphType)
{
AssertFatal(plotID > -1 && plotID < MaxPlots, "Invalid plot specified!");
if(!dStricmp(graphType,"Bar"))
mPlots[plotID].mGraphType = Bar;
else if(!dStricmp(graphType,"Filled"))
mPlots[plotID].mGraphType = Filled;
else if(!dStricmp(graphType,"Point"))
mPlots[plotID].mGraphType = Point;
else if(!dStricmp(graphType,"Polyline"))
mPlots[plotID].mGraphType = Polyline;
else AssertWarn(true, "Invalid graph type!");
}
void GuiParticleGraphCtrl::setSelectedPlot(S32 plotID)
{
mSelectedPlot = plotID;
// Argument Buffer.
char argBuffer[32];
dSprintf(argBuffer, 32, "%d", plotID);
// Call Scripts.
Con::executef(this, "onSetSelected", argBuffer);
}
void GuiParticleGraphCtrl::setSelectedPoint(S32 point)
{
if(point != mSelectedPoint && point < mPlots[mSelectedPlot].mGraphData.size() && point >= 0)
{
mSelectedPoint = point;
mLastSelectedPoint = point;
char argBuffer[32];
dSprintf(argBuffer, 32, "%d", point);
// Call Scripts.
Con::executef(this, "onPlotPointSelected", argBuffer);
}
}
void GuiParticleGraphCtrl::resetSelectedPoint()
{
mSelectedPoint = -1;
}
void GuiParticleGraphCtrl::setAutoGraphMax(bool autoMax)
{
mAutoMax = autoMax;
}
void GuiParticleGraphCtrl::setAutoRemove(bool autoRemove)
{
mAutoRemove = autoRemove;
}
void GuiParticleGraphCtrl::setGraphHidden(S32 plotID, bool isHidden)
{
mPlots[plotID].mHidden = isHidden;
}
void GuiParticleGraphCtrl::setRenderAll(bool renderAll)
{
mRenderAllPoints = renderAll;
}
void GuiParticleGraphCtrl::setPointXMovementClamped(bool clamped)
{
mPointXMovementClamped = clamped;
}
void GuiParticleGraphCtrl::setRenderGraphTooltip(bool renderGraphTooltip)
{
mRenderGraphTooltip = renderGraphTooltip;
}
void GuiParticleGraphCtrl::drawNut(const Point2I &nut, S32 size, ColorI &outlineColor, ColorI &nutColor)
{
// Fetch Draw Utility.
GFXDrawUtil* pDrawUtil = GFX->getDrawUtil();
//Con::printf("r %d g %d b %d", nutColor.red, nutColor.green, nutColor.blue);
S32 NUT_SIZE = size;
RectI r(nut.x - NUT_SIZE, nut.y - NUT_SIZE, 2 * NUT_SIZE + 1, 2 * NUT_SIZE + 1);
r.inset(1, 1);
pDrawUtil->drawRectFill(r, nutColor);
r.inset(-1, -1);
pDrawUtil->drawRect(r, outlineColor);
}
bool GuiParticleGraphCtrl::inNut(const Point2I &pt, S32 x, S32 y)
{
S32 dx = pt.x - x;
S32 dy = pt.y - y;
return dx <= mVertexClickSize && dx >= -mVertexClickSize && dy <= mVertexClickSize && dy >= -mVertexClickSize;
}
Point2I GuiParticleGraphCtrl::findHitNut( Point2I hitPoint )
{
for(S32 i = 0; i < MaxPlots; i++)
{
if ( (mPlots[i].mGraphData.size() == 0) || (mPlots[i].mHidden == true))
continue;
for (S32 j = 0 ; j < mPlots[i].mNutList.size(); j++ )
{
if( inNut (Point2I( mPlots[i].mNutList[j].x, mPlots[i].mNutList[j].y), hitPoint.x, hitPoint.y) )
{
mTooltipSelectedPlot = i;
return Point2I(i,j);
}
}
}
return Point2I(-1,-1);
}
Point2F GuiParticleGraphCtrl::convertToGraphCoord(S32 plotID, Point2I v)
{
Point2F resultV;
v = globalToLocalCoord( v );
v.y = getExtent().y - v.y;
resultV = Point2F(v.x, v.y);
resultV.x /= getExtent().x;
resultV.y /= getExtent().y;
resultV.x *= getGraphExtent(plotID).x;
resultV.y *= getGraphExtent(plotID).y;
resultV.x *= 1.00 + (mPlots[plotID].mGraphScale*2);
resultV.y *= 1.00 + (mPlots[plotID].mGraphScale*2);
resultV.x -= getGraphExtent(plotID).x * ((mPlots[plotID].mGraphScale));
resultV.y -= getGraphExtent(plotID).y * ((mPlots[plotID].mGraphScale));
resultV.x += mPlots[plotID].mGraphMin.x;
resultV.y += mPlots[plotID].mGraphMin.y;
if(mAutoMax == false)
{
if(resultV.x < mPlots[plotID].mGraphMin.x)
{
resultV.x = mPlots[plotID].mGraphMin.x;
}
if(resultV.x > mPlots[plotID].mGraphMax.x)
{
resultV.x = mPlots[plotID].mGraphMax.x;
}
if(resultV.y < mPlots[plotID].mGraphMin.y)
{
resultV.y = mPlots[plotID].mGraphMin.y;
}
if(resultV.y > mPlots[plotID].mGraphMax.y)
{
resultV.y = mPlots[plotID].mGraphMax.y;
}
}
return resultV;
}
Point2F GuiParticleGraphCtrl::getGraphExtent(S32 plotID)
{
Point2F resultV;
resultV.x = mPlots[plotID].mGraphMax.x - mPlots[plotID].mGraphMin.x;
resultV.y = mPlots[plotID].mGraphMax.y - mPlots[plotID].mGraphMin.y;
return resultV;
}
ColorF GuiParticleGraphCtrl::getGraphColor(S32 plotID)
{
return mPlots[plotID].mGraphColor;
}
Point2F GuiParticleGraphCtrl::getGraphMax(S32 plotID)
{
return mPlots[plotID].mGraphMax;
}
Point2F GuiParticleGraphCtrl::getGraphMin(S32 plotID)
{
return mPlots[plotID].mGraphMin;
}
void GuiParticleGraphCtrl::setGraphMin(S32 plotID, Point2F graphMin)
{
mPlots[plotID].mGraphMin = graphMin;
}
void GuiParticleGraphCtrl::setGraphMax(S32 plotID, Point2F graphMax)
{
mPlots[plotID].mGraphMax = graphMax;
}
void GuiParticleGraphCtrl::setGraphMinX(S32 plotID, F32 graphMinX)
{
mPlots[plotID].mGraphMin.x = graphMinX;
}
void GuiParticleGraphCtrl::setGraphMinY(S32 plotID, F32 graphMinY)
{
mPlots[plotID].mGraphMin.y = graphMinY;
}
void GuiParticleGraphCtrl::setGraphMaxX(S32 plotID, F32 graphMaxX)
{
mPlots[plotID].mGraphMax.x = graphMaxX;
}
void GuiParticleGraphCtrl::setGraphMaxY(S32 plotID, F32 graphMaxY)
{
mPlots[plotID].mGraphMax.y = graphMaxY;
}
void GuiParticleGraphCtrl::setGraphName(S32 plotID, StringTableEntry graphName)
{
mPlots[plotID].mGraphName = StringTable->insert(graphName);
}
StringTableEntry GuiParticleGraphCtrl::getGraphName(S32 plotID)
{
return mPlots[plotID].mGraphName;
}
void GuiParticleGraphCtrl::onMouseMove(const GuiEvent &event)
{
mCursorPos = event.mousePoint;
Point2I hitNut = findHitNut(event.mousePoint);
if( hitNut != Point2I(-1,-1) )
{
mRenderNextGraphTooltip = true;
} else
{
mRenderNextGraphTooltip = false;
}
// Argument Buffer.
char argBuffer[32];
dSprintf(argBuffer, 32, "%f %f", convertToGraphCoord(mSelectedPlot, event.mousePoint).x, convertToGraphCoord(mSelectedPlot, event.mousePoint).y);
// Call Scripts.
Con::executef(this, "onMouseMove", argBuffer);
}
void GuiParticleGraphCtrl::onMouseDown(const GuiEvent &event)
{
Point2I hitNut = findHitNut(event.mousePoint);
if( hitNut != Point2I(-1,-1) )
{
if(event.mouseClickCount == 2)
{
Point2F plotPoint = getPlotPoint(hitNut.x, hitNut.y);
Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);
S32 point = removePlotPoint(hitNut.x, hitNut.y);
// Argument Buffer.
char argBuffer[3][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%d", point);
dSprintf(argBuffer[2], 32, "%f %f", plotPoint.x, plotPoint.y);
// Call Scripts.
Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
} else
{
setSelectedPlot(hitNut.x);
setSelectedPoint(hitNut.y);
mOriginalSelectedPoint = hitNut.y;
char argBuffer[32];
dSprintf(argBuffer, 32, "%d", hitNut.y);
// Call Scripts.
Con::executef(this, "onPlotPointSelectedMouseDown", argBuffer);
}
} else if( mSelectedPlot != -1 )
{
Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);
mLastSelectedPoint = addPlotPoint(mSelectedPlot, mousePos);
// Argument Buffer.
char argBuffer[32];
dSprintf(argBuffer, 32, "%f %f", convertToGraphCoord(mSelectedPlot, event.mousePoint).x, convertToGraphCoord(mSelectedPlot, event.mousePoint).y);
// Call Scripts.
Con::executef(this, "onMouseDragged", argBuffer);
return;
}
}
void GuiParticleGraphCtrl::onMouseUp(const GuiEvent &event)
{
if(mSelectedPoint != -1)
mLastSelectedPoint = mSelectedPoint;
if(mPointWasAdded == true)
{
if(mSelectedPoint == -1)
{
// Argument Buffer.
char argBuffer[3][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%f %f", mAddedPoint.x, mAddedPoint.y);
dSprintf(argBuffer[2], 32, "%d", mAddedPointIndex);
// Call Scripts.
Con::executef(this, "onPlotPointAdded", argBuffer[0], argBuffer[1], argBuffer[2]);
} else
{
// Argument Buffer.
char argBuffer[4][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%f %f", mAddedPoint.x, mAddedPoint.y);
dSprintf(argBuffer[2], 32, "%d", mOriginalSelectedPoint);
dSprintf(argBuffer[3], 32, "%d", mAddedPointIndex);
// Call Scripts.
Con::executef(this, "onPlotPointChangedUp", argBuffer[0], argBuffer[1], argBuffer[2], argBuffer[3]);
}
}
mPointWasAdded = false;
mSelectedPoint = -1;
}
void GuiParticleGraphCtrl::onMouseDragged(const GuiEvent &event)
{
mRenderNextGraphTooltip = false;
if(mSelectedPoint != -1)
{
Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);
if(mPointXMovementClamped == true)
{
F32 prevXPos = getPlotPoint(mSelectedPlot, mSelectedPoint).x;
if(mousePos.x != prevXPos)
{
mousePos.x = prevXPos;
}
}
removePlotPoint(mSelectedPlot, mSelectedPoint);
S32 point = addPlotPoint(mSelectedPlot, mousePos);
if(point != -1)
{
setSelectedPoint(point);
mLastMousePos = mousePos;
// Argument Buffer.
char argBuffer[3][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%f %f", mAddedPoint.x, mAddedPoint.y);
dSprintf(argBuffer[2], 32, "%d", point);
// Call Scripts.
Con::executef(this, "onPlotPointChangedMove", argBuffer[0], argBuffer[1], argBuffer[2]);
} else
{
point = addPlotPoint(mSelectedPlot, mLastMousePos);
}
}
// Argument Buffer.
char argBuffer[32];
dSprintf(argBuffer, 32, "%f %f", convertToGraphCoord(mSelectedPlot, event.mousePoint).x, convertToGraphCoord(mSelectedPlot, event.mousePoint).y);
// Call Scripts.
Con::executef(this, "onMouseDragged", argBuffer);
}
void GuiParticleGraphCtrl::onRightMouseDown(const GuiEvent &event)
{
Point2I hitNut = findHitNut(event.mousePoint);
if( hitNut != Point2I(-1,-1) )
{
Point2F plotPoint = getPlotPoint(hitNut.x, hitNut.y);
Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);
S32 point = removePlotPoint(hitNut.x, hitNut.y);
// Argument Buffer.
char argBuffer[3][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%d", point);
dSprintf(argBuffer[2], 32, "%f %f", plotPoint.x, plotPoint.y);
// Call Scripts.
Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
}
}
void GuiParticleGraphCtrl::onRightMouseUp(const GuiEvent &event)
{
}
void GuiParticleGraphCtrl::onRightMouseDragged(const GuiEvent &event)
{
Point2I hitNut = findHitNut(event.mousePoint);
if( hitNut != Point2I(-1,-1) )
{
Point2F plotPoint = getPlotPoint(hitNut.x, hitNut.y);
Point2F mousePos = convertToGraphCoord(mSelectedPlot, event.mousePoint);
S32 point = removePlotPoint(hitNut.x, hitNut.y);
// Argument Buffer.
char argBuffer[3][32];
dSprintf(argBuffer[0], 32, "%d", mSelectedPlot);
dSprintf(argBuffer[1], 32, "%d", point);
dSprintf(argBuffer[2], 32, "%f %f", plotPoint.x, plotPoint.y);
// Call Scripts.
Con::executef(this, "onPlotPointRemoved", argBuffer[0], argBuffer[1], argBuffer[2]);
}
}
void GuiParticleGraphCtrl::clearAllGraphs()
{
for(S32 i = 0;i < MaxPlots;i++)
{
clearGraph(i);
}
}
void GuiParticleGraphCtrl::clearGraph(S32 plotID)
{
mPlots[plotID].mGraphData.clear();
mPlots[plotID].mNutList.clear();
}
bool GuiParticleGraphCtrl::renderGraphTooltip(Point2I cursorPos, StringTableEntry tooltip)
{
// Short Circuit.
if (!mAwake)
return false;
if ( dStrlen( tooltip ) == 0 )
return false;
// Need to have root.
GuiCanvas *root = getRoot();
if ( !root )
return false;
if (!mTooltipProfile)
setTooltipProfile( mProfile );
GFont *font = mTooltipProfile->mFont;
// Fetch Canvas.
GuiCanvas *pCanvas = getRoot();
//Vars used:
//Screensize (for position check)
//Offset to get position of cursor
//textBounds for text extent.
Point2I screensize = pCanvas->getWindowSize();
Point2I offset = cursorPos;
Point2I textBounds;
S32 textWidth = font->getStrWidth(tooltip);
//Offset below cursor image
offset.y -= root->getCursorExtent().y;
//Create text bounds.
textBounds.x = textWidth+8;
textBounds.y = font->getHeight() + 4;
// Check position/width to make sure all of the tooltip will be rendered
// 5 is given as a buffer against the edge
if (screensize.x < offset.x + textBounds.x + 5)
offset.x = screensize.x - textBounds.x - 5;
// And ditto for the height
if(screensize.y < offset.y + textBounds.y + 5)
offset.y = cursorPos.y - textBounds.y - 5;
// Set rectangle for the box, and set the clip rectangle.
RectI rect(offset, textBounds);
GFX->setClipRect(rect);
// Fetch Draw Utility.
GFXDrawUtil* pDrawUtil = GFX->getDrawUtil();
// Draw Filler bit, then border on top of that
pDrawUtil->drawRectFill(rect, ColorI(mTooltipProfile->mFillColor.red, mTooltipProfile->mFillColor.green, mTooltipProfile->mFillColor.blue, 200) );
pDrawUtil->drawRect( rect, mTooltipProfile->mBorderColor );
// Draw the text centered in the tool tip box
pDrawUtil->setBitmapModulation( mTooltipProfile->mFontColor );
Point2I start;
start.set( ( textBounds.x - textWidth) / 2, ( textBounds.y - font->getHeight() ) / 2 );
pDrawUtil->drawText( font, start + offset, tooltip, mProfile->mFontColors );
pDrawUtil->clearBitmapModulation();
return true;
}
ConsoleMethod(GuiParticleGraphCtrl, setSelectedPoint, void, 3, 3, "(int point)"
"Set the selected point on the graph.\n"
"@return No return value")
{
S32 point = dAtoi(argv[2]);
if(point >= object->mPlots[object->mSelectedPlot].mGraphData.size() || point < 0)
{
Con::errorf("Invalid point to select.");
return;
}
object->setSelectedPoint( point );
}
ConsoleMethod(GuiParticleGraphCtrl, setSelectedPlot, void, 3, 3, "(int plotID)"
"Set the selected plot (a.k.a. graph)."
"@return No return value" )
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setSelectedPlot( plotID );
}
ConsoleMethod(GuiParticleGraphCtrl, clearGraph, void, 3, 3, "(int plotID)"
"Clear the graph of the given plot."
"@return No return value")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->clearGraph( plotID );
}
ConsoleMethod(GuiParticleGraphCtrl, clearAllGraphs, void, 2, 2, "()"
"Clear all of the graphs."
"@return No return value")
{
object->clearAllGraphs();
}
ConsoleMethod(GuiParticleGraphCtrl, addPlotPoint, const char*, 5, 6, "(int plotID, float x, float y, bool setAdded = true;)"
"Add a data point to the given plot."
"@return")
{
S32 plotID = dAtoi(argv[2]);
S32 pointAdded = 0;
static const U32 bufSize = 32;
char *retBuffer = Con::getReturnBuffer(bufSize);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
dSprintf(retBuffer, bufSize, "%d", -2);
return retBuffer;
}
if(argc == 5)
{
pointAdded = object->addPlotPoint( plotID, Point2F(dAtof(argv[3]), dAtof(argv[4])));
} else if(argc == 6)
{
pointAdded = object->addPlotPoint( plotID, Point2F(dAtof(argv[3]), dAtof(argv[4])), dAtob(argv[5]));
}
dSprintf(retBuffer, bufSize, "%d", pointAdded);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, insertPlotPoint, void, 6, 6, "(int plotID, int i, float x, float y)\n"
"Insert a data point to the given plot and plot position.\n"
"@param plotID The plot you want to access\n"
"@param i The data point.\n"
"@param x,y The plot position.\n"
"@return No return value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->insertPlotPoint( plotID, dAtoi(argv[3]), Point2F(dAtof(argv[4]), dAtof(argv[5])));
}
ConsoleMethod(GuiParticleGraphCtrl, changePlotPoint, const char*, 6, 6, "(int plotID, int i, float x, float y)"
"Change a data point to the given plot and plot position.\n"
"@param plotID The plot you want to access\n"
"@param i The data point.\n"
"@param x,y The plot position.\n"
"@return No return value.")
{
S32 plotID = dAtoi(argv[2]);
static const U32 bufSize = 64;
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
char *retBuffer = Con::getReturnBuffer(bufSize);
const S32 index = -1;
dSprintf(retBuffer, bufSize, "%d", index);
return retBuffer;
}
char *retBuffer = Con::getReturnBuffer(bufSize);
const S32 index = object->changePlotPoint( plotID, dAtoi(argv[3]), Point2F(dAtof(argv[4]), dAtof(argv[5])));
dSprintf(retBuffer, bufSize, "%d", index);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getSelectedPlot, const char*, 2, 2, "() "
"Gets the selected Plot (a.k.a. graph).\n"
"@return The plot's ID.")
{
static const U32 bufSize = 32;
char *retBuffer = Con::getReturnBuffer(bufSize);
const S32 plot = object->getSelectedPlot();
dSprintf(retBuffer, bufSize, "%d", plot);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getSelectedPoint, const char*, 2, 2, "()"
"Gets the selected Point on the Plot (a.k.a. graph)."
"@return The last selected point ID")
{
static const U32 bufSize = 32;
char *retBuffer = Con::getReturnBuffer(bufSize);
const S32 point = object->getSelectedPoint();
dSprintf(retBuffer, bufSize, "%d", point);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, isExistingPoint, const char*, 4, 4, "(int plotID, int samples)"
"@return Returns true or false whether or not the point in the plot passed is an existing point.")
{
S32 plotID = dAtoi(argv[2]);
S32 samples = dAtoi(argv[3]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
if(samples > object->MaxDataPoints)
{
Con::errorf("Invalid sample.");
}
static const U32 bufSize = 32;
char *retBuffer = Con::getReturnBuffer(bufSize);
const bool isPoint = object->isExistingPoint(plotID, samples);
dSprintf(retBuffer, bufSize, "%d", isPoint);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getPlotPoint, const char*, 4, 4, "(int plotID, int samples)"
"Get a data point from the plot specified, samples from the start of the graph."
"@return The data point ID")
{
S32 plotID = dAtoi(argv[2]);
S32 samples = dAtoi(argv[3]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
if(samples > object->MaxDataPoints)
{
Con::errorf("Invalid sample.");
}
static const U32 bufSize = 64;
char *retBuffer = Con::getReturnBuffer(bufSize);
const Point2F &pos = object->getPlotPoint(plotID, samples);
dSprintf(retBuffer, bufSize, "%f %f", pos.x, pos.y);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getPlotIndex, const char*, 5, 5, "(int plotID, float x, float y)\n"
"Gets the index of the point passed on the plotID passed (graph ID).\n"
"@param plotID The plot you wish to check.\n"
"@param x,y The coordinates of the point to get.\n"
"@return Returns the index of the point.\n")
{
S32 plotID = dAtoi(argv[2]);
F32 x = dAtof(argv[3]);
F32 y = dAtof(argv[4]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
static const U32 bufSize = 32;
char *retBuffer = Con::getReturnBuffer(bufSize);
const S32 &index = object->getPlotIndex(plotID, x, y);
dSprintf(retBuffer, bufSize, "%d", index);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getGraphColor, const char*, 3, 3, "(int plotID)"
"Get the color of the graph passed."
"@return Returns the color of the graph as a string of RGB values formatted as \"R G B\"")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
static const U32 bufSize = 64;
char *retBuffer = Con::getReturnBuffer(bufSize);
const ColorF &color = object->getGraphColor(plotID);
dSprintf(retBuffer, bufSize, "%f %f %f", color.red, color.green, color.blue);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getGraphMin, const char*, 3, 3, "(int plotID) "
"Get the minimum values of the graph ranges.\n"
"@return Returns the minimum of the range formatted as \"x-min y-min\"")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
static const U32 bufSize = 64;
char *retBuffer = Con::getReturnBuffer(bufSize);
const Point2F graphMin = object->getGraphMin(plotID);
dSprintf(retBuffer, bufSize, "%f %f", graphMin.x, graphMin.y);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getGraphMax, const char*, 3, 3, "(int plotID) "
"Get the maximum values of the graph ranges.\n"
"@return Returns the maximum of the range formatted as \"x-max y-max\"")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
static const U32 bufSize = 64;
char *retBuffer = Con::getReturnBuffer(bufSize);
const Point2F graphMax = object->getGraphMax(plotID);
dSprintf(retBuffer, bufSize, "%f %f", graphMax.x, graphMax.y);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, getGraphName, const char*, 3, 3, "(int plotID) "
"Get the name of the graph passed.\n"
"@return Returns the name of the plot")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
}
static const U32 bufSize = 64;
char *retBuffer = Con::getReturnBuffer(bufSize);
const StringTableEntry graphName = object->getGraphName(plotID);
dSprintf(retBuffer, bufSize, "%s", graphName);
return retBuffer;
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphMin, void, 5, 5, "(int plotID, float minX, float minY) "
"Set the min values of the graph of plotID.\n"
"@param plotID The plot to modify\n"
"@param minX,minY The minimum bound of the value range.\n"
"@return No return value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphMin(dAtoi(argv[2]), Point2F(dAtof(argv[3]), dAtof(argv[4])));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphMinX, void, 4, 4, "(int plotID, float minX) "
"Set the min X value of the graph of plotID.\n"
"@param plotID The plot to modify.\n"
"@param minX The minimum x value.\n"
"@return No return Value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphMinX(dAtoi(argv[2]), dAtof(argv[3]));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphMinY, void, 4, 4, "(int plotID, float minY) "
"Set the min Y value of the graph of plotID."
"@param plotID The plot to modify.\n"
"@param minY The minimum y value.\n"
"@return No return Value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphMinY(dAtoi(argv[2]), dAtof(argv[3]));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphMax, void, 5, 5, "(int plotID, float maxX, float maxY) "
"Set the max values of the graph of plotID."
"@param plotID The plot to modify\n"
"@param maxX,maxY The maximum bound of the value range.\n"
"@return No return value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphMax(dAtoi(argv[2]), Point2F(dAtof(argv[3]), dAtof(argv[4])));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphMaxX, void, 4, 4, "(int plotID, float maxX)"
"Set the max X value of the graph of plotID."
"@param plotID The plot to modify.\n"
"@param maxX The maximum x value.\n"
"@return No return Value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphMaxX(dAtoi(argv[2]), dAtof(argv[3]));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphMaxY, void, 4, 4, "(int plotID, float maxY)"
"Set the max Y value of the graph of plotID."
"@param plotID The plot to modify.\n"
"@param maxY The maximum y value.\n"
"@return No return Value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphMaxY(dAtoi(argv[2]), dAtof(argv[3]));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphHidden, void, 4, 4, "(int plotID, bool isHidden)"
"Set whether the graph number passed is hidden or not."
"@return No return value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphHidden(dAtoi(argv[2]), dAtob(argv[3]));
}
ConsoleMethod(GuiParticleGraphCtrl, setAutoGraphMax, void, 3, 3, "(bool autoMax) "
"Set whether the max will automatically be set when adding points "
"(ie if you add a value over the current max, the max is increased to that value).\n"
"@return No return value.")
{
object->setAutoGraphMax(dAtob(argv[2]));
}
ConsoleMethod(GuiParticleGraphCtrl, setAutoRemove, void, 3, 3, "(bool autoRemove) "
"Set whether or not a point should be deleted when you drag another one over it."
"@return No return value.")
{
object->setAutoRemove(dAtob(argv[2]));
}
ConsoleMethod(GuiParticleGraphCtrl, setRenderAll, void, 3, 3, "(bool renderAll)"
"Set whether or not a position should be rendered on every point or just the last selected."
"@return No return value.")
{
object->setRenderAll(dAtob(argv[2]));
}
ConsoleMethod(GuiParticleGraphCtrl, setPointXMovementClamped, void, 3, 3, "(bool clamped)"
"Set whether the x position of the selected graph point should be clamped"
"@return No return value.")
{
object->setPointXMovementClamped(dAtob(argv[2]));
}
ConsoleMethod(GuiParticleGraphCtrl, setRenderGraphTooltip, void, 3, 3, "(bool renderGraphTooltip)"
"Set whether or not to render the graph tooltip."
"@return No return value.")
{
object->setRenderGraphTooltip(dAtob(argv[2]));
}
ConsoleMethod(GuiParticleGraphCtrl, setGraphName, void, 4, 4, "(int plotID, string graphName) "
"Set the name of the given plot.\n"
"@param plotID The plot to modify.\n"
"@param graphName The name to set on the plot.\n"
"@return No return value.")
{
S32 plotID = dAtoi(argv[2]);
if(plotID > object->MaxPlots)
{
Con::errorf("Invalid plotID.");
return;
}
object->setGraphName(dAtoi(argv[2]), argv[3]);
}
ConsoleMethod(GuiParticleGraphCtrl, resetSelectedPoint, void, 2, 2, "()"
"This will reset the currently selected point to nothing."
"@return No return value.")
{
object->resetSelectedPoint();
}
Reference in a new issue View git blame Copy permalink