mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-13 03:33:48 +00:00
Add all new AFX files
This commit is contained in:
Marc Chapman
parent
3d7c1bbbf7
commit
d7a8510756
218 changed files with 54970 additions and 0 deletions
530
Engine/source/afx/util/afxPath.cpp
Normal file
530
Engine/source/afx/util/afxPath.cpp
Normal file
|
|
@ -0,0 +1,530 @@
|
|||
|
||||
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
||||
// 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();
|
||||
}
|
||||
|
||||
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
|
||||
Loading…
Add table
Add a link
Reference in a new issue