mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-12-25 06:05:45 +00:00
4320b8296b
This commit introduces pointer checks to various functions; so that entity_* will no longer crash or produce weird results if passed a Node pointer, etc. The checks are disabled by default, but can be enabled in ScriptInterface.cpp. Fixed possible crashes in a few more functions due to missing NULL-checks. There was a "feature" in the single Lua state that it would keep globals intact until the game was quit. That made any globals from mods "leak" into the game or other mods. Now it resets the Lua state when a mod is loaded or closed.
275 lines
6 KiB
C++
275 lines
6 KiB
C++
/*
|
|
Copyright (C) 2007, 2010 - Bit-Blot
|
|
|
|
This file is part of Aquaria.
|
|
|
|
Aquaria 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 2
|
|
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, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
#pragma once
|
|
#include "Quad.h"
|
|
#include "SimpleIStringStream.h"
|
|
// for 2d system only
|
|
|
|
enum AnimationCommand
|
|
{
|
|
AC_PRT_LOAD =0,
|
|
AC_PRT_START ,
|
|
AC_PRT_STOP ,
|
|
AC_SEGS_START ,
|
|
AC_FRM_SHOW ,
|
|
AC_SND_PLAY ,
|
|
AC_SEGS_STOP
|
|
};
|
|
|
|
class ParticleEffect;
|
|
class SkeletalSprite;
|
|
|
|
class Bone : public ScriptObject, public Quad
|
|
{
|
|
public:
|
|
Bone();
|
|
void setAnimated(int a);
|
|
|
|
enum {
|
|
ANIM_NONE = 0,
|
|
ANIM_POS = 1,
|
|
ANIM_ROT = 2,
|
|
ANIM_ALL = 10
|
|
};
|
|
void createStrip(bool vert, int num);
|
|
Quad* addFrame(const std::string &gfx);
|
|
void showFrame(int i);
|
|
void destroy();
|
|
std::string gfx;
|
|
std::string name;
|
|
int boneIdx, pidx, rbp;
|
|
std::map<int, ParticleEffect*> emitters;
|
|
std::string prt;
|
|
std::vector<Vector> changeStrip;
|
|
|
|
bool generateCollisionMask;
|
|
int animated;
|
|
Vector originalScale;
|
|
|
|
void addSegment(Bone *b);
|
|
|
|
int segmentChain;
|
|
|
|
void updateSegments();
|
|
void updateSegment(Bone *b, const Vector &diff);
|
|
|
|
SkeletalSprite *skeleton;
|
|
|
|
|
|
void setSegmentProps(int minDist, int maxDist, bool reverse);
|
|
Vector segmentOffset;
|
|
|
|
bool fileRenderQuad;
|
|
|
|
|
|
protected:
|
|
int minDist, maxDist, reverse;
|
|
std::vector<Bone*> segments;
|
|
};
|
|
|
|
class BoneCommand
|
|
{
|
|
public:
|
|
void parse(Bone *b, SimpleIStringStream &is);
|
|
void run();
|
|
AnimationCommand command;
|
|
Bone *b;
|
|
|
|
int slot;
|
|
std::string file;
|
|
};
|
|
|
|
class BoneKeyframe
|
|
{
|
|
public:
|
|
BoneKeyframe() : idx(0), x(0), y(0), rot(0), doScale(0), sx(1), sy(1) {}
|
|
int idx, x, y, rot;
|
|
float sx, sy;
|
|
bool doScale;
|
|
std::vector<Vector> strip;
|
|
};
|
|
|
|
class SkeletalKeyframe
|
|
{
|
|
public:
|
|
SkeletalKeyframe()
|
|
{
|
|
lerpType = 0;
|
|
t = 0;
|
|
}
|
|
int lerpType;
|
|
float t;
|
|
std::string sound;
|
|
std::vector<BoneKeyframe> keyframes;
|
|
BoneKeyframe *getBoneKeyframe(int idx);
|
|
std::string cmd;
|
|
std::vector<BoneCommand> commands;
|
|
|
|
void copyAllButTime(SkeletalKeyframe *copy);
|
|
};
|
|
|
|
class Animation
|
|
{
|
|
public:
|
|
std::string name;
|
|
typedef std::vector <SkeletalKeyframe> Keyframes;
|
|
Keyframes keyframes;
|
|
SkeletalKeyframe *getKeyframe(int key);
|
|
SkeletalKeyframe *getLastKeyframe();
|
|
SkeletalKeyframe *getFirstKeyframe();
|
|
SkeletalKeyframe *getPrevKeyframe(float t);
|
|
SkeletalKeyframe *getNextKeyframe(float t);
|
|
void cloneKey(int key, float toffset);
|
|
void deleteKey(int key);
|
|
void reorderKeyframes();
|
|
float getAnimationLength();
|
|
int getSkeletalKeyframeIndex(SkeletalKeyframe *skey);
|
|
int getNumKeyframes();
|
|
void reverse();
|
|
};
|
|
|
|
class SkeletalSprite;
|
|
|
|
class AnimationLayer
|
|
{
|
|
public:
|
|
|
|
//----
|
|
AnimationLayer();
|
|
void setSkeletalSprite(SkeletalSprite *s);
|
|
Animation *getCurrentAnimation();
|
|
void animate(const std::string &animation, int loop);
|
|
void update(float dt);
|
|
void updateBones();
|
|
void stopAnimation();
|
|
float getAnimationLength();
|
|
bool createTransitionAnimation(std::string anim, float time);
|
|
void playAnimation(int idx, int loop);
|
|
void playCurrentAnimation(int loop);
|
|
void enqueueAnimation(std::string anim, int loop);
|
|
float transitionAnimate(std::string anim, float time, int loop);
|
|
void setTimeMultiplier(float t);
|
|
bool isAnimating();
|
|
//float lerp(float v1, float v2, float dt, int lerpType);
|
|
|
|
//----
|
|
float fallThru;
|
|
float fallThruSpeed;
|
|
std::string name;
|
|
std::vector<int> ignoreBones;
|
|
std::vector<int> includeBones;
|
|
SkeletalSprite *s;
|
|
|
|
SkeletalKeyframe *lastNewKey;
|
|
//int index;
|
|
float timer;
|
|
int loop;
|
|
Animation blendAnimation;
|
|
std::string enqueuedAnimation;
|
|
int enqueuedAnimationLoop;
|
|
//float timeMultiplier;
|
|
//HACK: should be a lerped float
|
|
InterpolatedVector timeMultiplier;
|
|
float animationLength;
|
|
int currentAnimation;
|
|
bool animating;
|
|
|
|
|
|
};
|
|
|
|
class SkeletalSprite : public RenderObject
|
|
{
|
|
public:
|
|
|
|
SkeletalSprite();
|
|
void loadSkeletal(const std::string &fn);
|
|
void saveSkeletal(const std::string &fn);
|
|
void loadSkin(const std::string &fn);
|
|
|
|
Bone *getBoneByIdx(int idx);
|
|
Bone *getBoneByName(const std::string &name);
|
|
void animate(const std::string &animation, int loop = 0, int layer=0);
|
|
|
|
|
|
|
|
void setTime(float time, int layer=0);
|
|
|
|
void updateBones();
|
|
void playCurrentAnimation(int loop=0, int layer=0);
|
|
void stopAnimation(int layer=0);
|
|
void stopAllAnimations();
|
|
|
|
float transitionAnimate(std::string anim, float time, int loop=0, int layer=0);
|
|
|
|
bool isAnimating(int layer=0);
|
|
|
|
void setTimeMultiplier(float t, int layer=0);
|
|
|
|
Bone* getSelectedBone(int ignoreBone=-1, bool mouseBased = true);
|
|
Animation *getCurrentAnimation(int layer=0);
|
|
|
|
|
|
void nextAnimation();
|
|
void prevAnimation();
|
|
void lastAnimation();
|
|
void firstAnimation();
|
|
void updateSelectedBoneColor();
|
|
|
|
|
|
void setFreeze(bool f);
|
|
|
|
|
|
|
|
Animation *getAnimation(std::string anim);
|
|
|
|
std::vector<Animation> animations;
|
|
std::vector<Bone*> bones;
|
|
|
|
inline int getSelectedBoneIdx(void) { return selectedBone; }
|
|
void setSelectedBone(int b);
|
|
void selectPrevBone();
|
|
void selectNextBone();
|
|
|
|
bool isLoaded();
|
|
|
|
AnimationLayer* getAnimationLayer(int l);
|
|
int getBoneIdx(Bone *b);
|
|
void toggleBone(int idx, int v);
|
|
|
|
void setAnimationKeyNotify(RenderObject *r);
|
|
|
|
std::string filenameLoaded;
|
|
|
|
static std::string animationPath, skinPath, secondaryAnimationPath;
|
|
|
|
protected:
|
|
bool frozen;
|
|
RenderObject *animKeyNotify;
|
|
bool loaded;
|
|
int selectedBone;
|
|
friend class AnimationLayer;
|
|
std::vector<AnimationLayer> animLayers;
|
|
Bone* initBone(int idx, std::string gfx, int pidx, int rbp=0, std::string name="", int cr=0, bool fh=false, bool fv=false, const Vector &cp=Vector(0,0,0));
|
|
void deleteBones();
|
|
void onUpdate(float dt);
|
|
};
|
|
|
|
|