mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 20:54:46 +00:00
531 lines
13 KiB
C++
531 lines
13 KiB
C++
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
|
|
// Copyright (C) 2015 Faust Logic, Inc.
|
|
//
|
|
// 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 "afx/arcaneFX.h"
|
|
|
|
#include "console/consoleTypes.h"
|
|
#include "core/stream/bitStream.h"
|
|
#include "math/mathIO.h"
|
|
|
|
#include "afx/util/afxPath.h"
|
|
#include "afx/util/afxPath3D.h"
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
|
// afxPathData
|
|
|
|
IMPLEMENT_CO_DATABLOCK_V1(afxPathData);
|
|
|
|
ConsoleDocClass( afxPathData,
|
|
"@brief A datablock for specifiying a 3D path for use with AFX.\n\n"
|
|
|
|
"@ingroup afxUtil\n"
|
|
"@ingroup AFX\n"
|
|
"@ingroup Datablocks\n"
|
|
);
|
|
|
|
StringTableEntry afxPathData::POINTS_FIELD;
|
|
StringTableEntry afxPathData::ROLL_FIELD;
|
|
StringTableEntry afxPathData::TIMES_FIELD;
|
|
|
|
ImplementEnumType( afxPath3DLoopType, "Possible loop types for an afxPath.\n" "@ingroup afxPath\n\n" )
|
|
{ afxPath3D::LOOP_CONSTANT, "constant", "..." },
|
|
{ afxPath3D::LOOP_CYCLE, "cycle", "..." },
|
|
{ afxPath3D::LOOP_OSCILLATE, "oscillate", "..." },
|
|
EndImplementEnumType;
|
|
|
|
afxPathData::afxPathData()
|
|
{
|
|
if (POINTS_FIELD == 0)
|
|
{
|
|
POINTS_FIELD = StringTable->insert("points");
|
|
ROLL_FIELD = StringTable->insert("roll");
|
|
TIMES_FIELD = StringTable->insert("times");
|
|
}
|
|
|
|
loop_string = ST_NULLSTRING;
|
|
delay = 0;
|
|
lifetime = 0;
|
|
loop_type = 0;
|
|
mult = 1.0f;
|
|
time_offset = 0.0f;
|
|
resolved = false;
|
|
reverse = false;
|
|
offset.zero();
|
|
echo = false;
|
|
concentric = false;
|
|
|
|
points_string = ST_NULLSTRING;
|
|
points = 0;
|
|
num_points = 0;
|
|
update_points = true;
|
|
|
|
roll_string = ST_NULLSTRING;
|
|
rolls = 0;
|
|
update_rolls = true;
|
|
|
|
times_string = ST_NULLSTRING;
|
|
times = 0;
|
|
update_times = true;
|
|
}
|
|
|
|
afxPathData::afxPathData(const afxPathData& other, bool temp_clone) : GameBaseData(other, temp_clone)
|
|
{
|
|
points_string = other.points_string;
|
|
roll_string = other.roll_string;
|
|
loop_string = other.loop_string;
|
|
delay = other.delay;
|
|
lifetime = other.lifetime;
|
|
loop_type = other.loop_type; // --
|
|
mult = other.mult;
|
|
time_offset = other.time_offset;
|
|
resolved = other.resolved; // --
|
|
reverse = other.reverse;
|
|
offset = other.offset;
|
|
echo = other.echo;
|
|
concentric = other.concentric;
|
|
times_string = other.times_string;
|
|
|
|
num_points = other.num_points; // --
|
|
if (other.points && num_points > 0)
|
|
{
|
|
points = new Point3F[num_points];
|
|
dMemcpy(points, other.points, sizeof(Point3F)*num_points); // --
|
|
}
|
|
else
|
|
points = 0;
|
|
if (other.rolls && num_points > 0)
|
|
{
|
|
rolls = new F32[num_points];
|
|
dMemcpy(rolls, other.rolls, sizeof(F32)*num_points); // --
|
|
}
|
|
else
|
|
rolls = 0;
|
|
if (other.times && num_points > 0)
|
|
{
|
|
times = new F32[num_points];
|
|
dMemcpy(times, other.times, sizeof(F32)*num_points); // --
|
|
}
|
|
else
|
|
times = 0;
|
|
|
|
update_points = other.update_points; // --
|
|
update_rolls = other.update_rolls; // --
|
|
update_times = other.update_times; // --
|
|
}
|
|
|
|
afxPathData::~afxPathData()
|
|
{
|
|
clear_arrays();
|
|
}
|
|
|
|
void afxPathData::initPersistFields()
|
|
{
|
|
addField("points", TypeString, Offset(points_string, afxPathData),
|
|
"...");
|
|
addField("roll", TypeString, Offset(roll_string, afxPathData),
|
|
"...");
|
|
addField("times", TypeString, Offset(times_string, afxPathData),
|
|
"...");
|
|
addField("loop", TypeString, Offset(loop_string, afxPathData),
|
|
"...");
|
|
addField("mult", TypeF32, Offset(mult, afxPathData),
|
|
"...");
|
|
addField("delay", TypeF32, Offset(delay, afxPathData),
|
|
"...");
|
|
addField("lifetime", TypeF32, Offset(lifetime, afxPathData),
|
|
"...");
|
|
addField("timeOffset", TypeF32, Offset(time_offset, afxPathData),
|
|
"...");
|
|
addField("reverse", TypeBool, Offset(reverse, afxPathData),
|
|
"...");
|
|
addField("offset", TypePoint3F, Offset(offset, afxPathData),
|
|
"...");
|
|
addField("echo", TypeBool, Offset(echo, afxPathData),
|
|
"...");
|
|
addField("concentric", TypeBool, Offset(concentric, afxPathData),
|
|
"...");
|
|
|
|
Parent::initPersistFields();
|
|
}
|
|
|
|
bool afxPathData::onAdd()
|
|
{
|
|
if (Parent::onAdd() == false)
|
|
return false;
|
|
|
|
update_derived_values();
|
|
|
|
return true;
|
|
}
|
|
|
|
void afxPathData::onRemove()
|
|
{
|
|
clear_arrays();
|
|
loop_type = 0;
|
|
|
|
Parent::onRemove();
|
|
}
|
|
|
|
void afxPathData::packData(BitStream* stream)
|
|
{
|
|
Parent::packData(stream);
|
|
|
|
stream->write(num_points);
|
|
if (num_points > 0)
|
|
{
|
|
for (U32 i = 0; i < num_points; i++)
|
|
mathWrite(*stream, points[i]);
|
|
if (stream->writeFlag(rolls != 0))
|
|
{
|
|
for (U32 i = 0; i < num_points; i++)
|
|
stream->write(rolls[i]);
|
|
}
|
|
if (stream->writeFlag(times != 0))
|
|
{
|
|
for (U32 i = 0; i < num_points; i++)
|
|
stream->write(times[i]);
|
|
}
|
|
}
|
|
|
|
stream->writeString(loop_string);
|
|
stream->write(delay);
|
|
stream->write(lifetime);
|
|
stream->write(time_offset);
|
|
stream->write(mult);
|
|
stream->writeFlag(reverse);
|
|
mathWrite(*stream, offset);
|
|
stream->writeFlag(echo);
|
|
stream->writeFlag(concentric);
|
|
}
|
|
|
|
void afxPathData::unpackData(BitStream* stream)
|
|
{
|
|
Parent::unpackData(stream);
|
|
|
|
clear_arrays();
|
|
|
|
// read the points and rolls
|
|
stream->read(&num_points);
|
|
if (num_points > 0)
|
|
{
|
|
points = new Point3F[num_points];
|
|
for (U32 i = 0; i < num_points; i++)
|
|
mathRead(*stream, &points[i]);
|
|
update_points = false;
|
|
if (stream->readFlag())
|
|
{
|
|
rolls = new F32[num_points];
|
|
for (U32 i = 0; i < num_points; i++)
|
|
stream->read(&rolls[i]);
|
|
update_rolls = false;
|
|
}
|
|
if (stream->readFlag())
|
|
{
|
|
times = new F32[num_points];
|
|
for (U32 i = 0; i < num_points; i++)
|
|
stream->read(×[i]);
|
|
update_times = false;
|
|
}
|
|
}
|
|
|
|
loop_string = stream->readSTString();
|
|
stream->read(&delay);
|
|
stream->read(&lifetime);
|
|
stream->read(&time_offset);
|
|
stream->read(&mult);
|
|
reverse = stream->readFlag();
|
|
mathRead(*stream, &offset);
|
|
echo = stream->readFlag();
|
|
concentric = stream->readFlag();
|
|
}
|
|
|
|
void afxPathData::update_derived_values()
|
|
{
|
|
U32 num_rolls = (rolls != 0) ? num_points : 0;
|
|
U32 num_times = (times != 0) ? num_points : 0;
|
|
|
|
if (update_points)
|
|
{
|
|
derive_points_array();
|
|
update_points = false;
|
|
}
|
|
|
|
if (update_rolls || num_rolls != num_points)
|
|
{
|
|
derive_rolls_array();
|
|
update_rolls = false;
|
|
}
|
|
|
|
if (update_times || num_times != num_points)
|
|
{
|
|
derive_times_array();
|
|
update_times = false;
|
|
}
|
|
|
|
// CAUTION: The following block of code is fragile and tricky since it depends
|
|
// on the underlying structures defined by ImplementEnumType/EndImplementEnumType.
|
|
// This done because the enum text is parsed from a longer string.
|
|
if (loop_string != ST_NULLSTRING)
|
|
{
|
|
for (unsigned int i = 0; i < _afxPath3DLoopType::_sEnumTable.getNumValues(); i++)
|
|
{
|
|
if (dStricmp(_afxPath3DLoopType::_sEnumTable[i].mName, loop_string) == 0)
|
|
{
|
|
loop_type = _afxPath3DLoopType::_sEnumTable[i].mInt;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
loop_string = _afxPath3DLoopType::_sEnumTable[0].mName;
|
|
loop_type = _afxPath3DLoopType::_sEnumTable[0].mInt;
|
|
}
|
|
}
|
|
|
|
bool afxPathData::preload(bool server, String &errorStr)
|
|
{
|
|
if (!Parent::preload(server, errorStr))
|
|
return false;
|
|
|
|
update_derived_values();
|
|
|
|
return true;
|
|
}
|
|
|
|
void afxPathData::onStaticModified(const char* slot, const char* newValue)
|
|
{
|
|
Parent::onStaticModified(slot, newValue);
|
|
|
|
if (slot == POINTS_FIELD)
|
|
{
|
|
update_points = true;
|
|
return;
|
|
}
|
|
if (slot == ROLL_FIELD)
|
|
{
|
|
update_rolls = true;
|
|
return;
|
|
}
|
|
if (slot == TIMES_FIELD)
|
|
{
|
|
update_times = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void afxPathData::extract_floats_from_string(Vector<F32>& values, const char* points_str)
|
|
{
|
|
values.clear();
|
|
|
|
if (!points_str)
|
|
return;
|
|
|
|
// make a copy of points_str for tokenizing
|
|
char* tokCopy = dStrdup(points_str);
|
|
|
|
// extract each token, convert to float, add to values[]
|
|
char* currTok = dStrtok(tokCopy, " \t");
|
|
while (currTok != NULL)
|
|
{
|
|
F32 value = dAtof(currTok);
|
|
values.push_back(value);
|
|
currTok = dStrtok(NULL, " \t");
|
|
}
|
|
|
|
dFree(tokCopy);
|
|
}
|
|
|
|
Point3F* afxPathData::build_points_array(Vector<F32>& values, U32& n_points, bool reverse)
|
|
{
|
|
AssertFatal(values.size() > 0, "Values array is empty.");
|
|
AssertFatal(values.size()%3 == 0, "Values array is not a multiple of 3.");
|
|
|
|
n_points = values.size()/3;
|
|
Point3F* points = new Point3F[n_points];
|
|
|
|
if (reverse)
|
|
{
|
|
U32 p_i = 0;
|
|
for (S32 i = values.size()-1; i > 1; i-=3)
|
|
points[p_i++].set(values[i-2], values[i-1], values[i]);
|
|
}
|
|
else
|
|
{
|
|
U32 p_i = 0;
|
|
for (U32 i = 0; i < values.size(); i+=3)
|
|
points[p_i++].set(values[i], values[i+1], values[i+2]);
|
|
}
|
|
|
|
return points;
|
|
}
|
|
|
|
F32* afxPathData::build_floats_array(Vector<F32>& values, U32& n_floats, bool reverse)
|
|
{
|
|
AssertFatal(values.size() > 0, "Values array is empty.");
|
|
|
|
n_floats = values.size();
|
|
F32* floats = new F32[n_floats];
|
|
|
|
if (reverse)
|
|
{
|
|
F32* f = floats;
|
|
for (S32 i = values.size()-1; i >= 0; i--)
|
|
{
|
|
*f = values[i];
|
|
f++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (U32 i = 0; i < values.size(); i++)
|
|
floats[i] = values[i];
|
|
}
|
|
|
|
return floats;
|
|
}
|
|
|
|
void afxPathData::clear_arrays()
|
|
{
|
|
num_points = 0;
|
|
if (points)
|
|
{
|
|
delete [] points;
|
|
points = 0;
|
|
}
|
|
if (rolls)
|
|
{
|
|
delete [] rolls;
|
|
rolls = 0;
|
|
}
|
|
if (times)
|
|
{
|
|
delete [] times;
|
|
times = 0;
|
|
}
|
|
update_points = true;
|
|
update_rolls = true;
|
|
update_times = true;
|
|
}
|
|
|
|
void afxPathData::derive_points_array()
|
|
{
|
|
if (points_string == ST_NULLSTRING)
|
|
return;
|
|
|
|
if (points)
|
|
{
|
|
delete [] points;
|
|
points = 0;
|
|
}
|
|
num_points = 0;
|
|
|
|
Vector<F32> values;
|
|
extract_floats_from_string(values, points_string);
|
|
if (values.size() == 0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "afxPathData(%s) empty points field, datablock is invalid.", getName());
|
|
return;
|
|
}
|
|
if (values.size()%3 != 0)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "afxPathData(%s) total points values is not a multiple of 3, datablock is invalid.", getName());
|
|
return;
|
|
}
|
|
|
|
points = build_points_array(values, num_points, reverse);
|
|
|
|
if (offset.x != 0.0f || offset.y != 0.0f || offset.z != 0.0f)
|
|
{
|
|
// add offset here for efficiency (saves an addition from afxXM_PathConform)
|
|
for (U32 i = 0; i < num_points; i++)
|
|
points[i] += offset;
|
|
}
|
|
}
|
|
|
|
void afxPathData::derive_rolls_array()
|
|
{
|
|
if (roll_string == ST_NULLSTRING)
|
|
return;
|
|
|
|
if (rolls)
|
|
{
|
|
delete [] rolls;
|
|
rolls = 0;
|
|
}
|
|
|
|
Vector<F32> values;
|
|
extract_floats_from_string(values, roll_string);
|
|
if (values.size() == 0)
|
|
return;
|
|
|
|
if (values.size() != num_points)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "afxPathData(%s) total roll values is not equal to total points, rolls ignored.", getName());
|
|
return;
|
|
}
|
|
|
|
U32 num_rolls = 0;
|
|
rolls = build_floats_array(values, num_rolls, reverse);
|
|
|
|
AssertFatal(num_rolls == num_points, "Unexpected error: num_rolls disagrees with num_points.");
|
|
}
|
|
|
|
void afxPathData::derive_times_array()
|
|
{
|
|
if (times_string == ST_NULLSTRING)
|
|
return;
|
|
|
|
if (times)
|
|
{
|
|
delete [] times;
|
|
times = 0;
|
|
}
|
|
|
|
Vector<F32> values;
|
|
extract_floats_from_string(values, times_string);
|
|
if (values.size() == 0)
|
|
return;
|
|
|
|
if (values.size() != num_points)
|
|
{
|
|
Con::warnf(ConsoleLogEntry::General, "afxPathData(%s) total time values is not equal to total points, times ignored", getName());
|
|
return;
|
|
}
|
|
|
|
U32 num_times = 0;
|
|
times = build_floats_array(values, num_times, reverse);
|
|
|
|
AssertFatal(num_times == num_points, "Unexpected error: num_times disagrees with num_points.");
|
|
}
|
|
|
|
void afxPathData::onPerformSubstitutions()
|
|
{
|
|
Parent::onPerformSubstitutions();
|
|
update_derived_values();
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|