mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-11-25 17:53:47 +00:00
9e2c640b51
This problem might have been introduced in 06270eaac0 but not sure.
The crash could happen due to a use-after-free memory access:
When deleting an entity with skel in postInit(), deletion would be
delayed by 1 frame because that is how entity_delete() works.
During deletion, RenderObject::children were removed and deleted
but SkeletalSprite::bones still had those pointers.
Additionally an object would delete its children in onUpdate() after
safeKill(), and still proceed to run scripts, which would then possibly
access freed memory too.
This fix causes children to not be deleted until we're out of the update()
cycle, and instead delete children together with the root object.
989 lines
19 KiB
C++
989 lines
19 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.
|
|
*/
|
|
#include "RenderObject.h"
|
|
#include "Core.h"
|
|
#include "MathFunctions.h"
|
|
#include "RenderBase.h"
|
|
|
|
#include <assert.h>
|
|
#include <algorithm>
|
|
|
|
#ifdef BBGE_USE_GLM
|
|
#include "glm/glm.hpp"
|
|
#include "glm/gtx/transform.hpp"
|
|
#endif
|
|
|
|
bool RenderObject::renderCollisionShape = false;
|
|
size_t RenderObject::lastTextureApplied = 0;
|
|
bool RenderObject::lastTextureRepeat = false;
|
|
bool RenderObject::renderPaths = false;
|
|
|
|
void RenderObject::toggleAlpha(float t)
|
|
{
|
|
if (alpha.x < 0.5f)
|
|
alpha.interpolateTo(1,t);
|
|
else
|
|
alpha.interpolateTo(0,t);
|
|
}
|
|
|
|
int RenderObject::getTopLayer() const
|
|
{
|
|
if (parent)
|
|
{
|
|
return parent->getTopLayer();
|
|
}
|
|
return layer;
|
|
}
|
|
|
|
RenderObject::RenderObject()
|
|
{
|
|
addType(SCO_RENDEROBJECT);
|
|
useOldDT = false;
|
|
|
|
ignoreUpdate = false;
|
|
renderPass = 0;
|
|
overrideCullRadiusSqr = 0;
|
|
repeatTexture = false;
|
|
alphaMod = 1;
|
|
motionBlur = 0;
|
|
idx = -1;
|
|
_fv = false;
|
|
_fh = false;
|
|
_markedForDelete = false;
|
|
updateCull = -1;
|
|
|
|
layer = LR_NONE;
|
|
cull = true;
|
|
|
|
pm = PM_NONE;
|
|
|
|
texture = 0;
|
|
width = 0;
|
|
height = 0;
|
|
scale = Vector(1,1,1);
|
|
color = Vector(1,1,1);
|
|
alpha.x = 1;
|
|
|
|
life = maxLife = 1;
|
|
decayRate = 0;
|
|
_dead = false;
|
|
_hidden = false;
|
|
fadeAlphaWithLife = false;
|
|
_blendType = BLEND_DEFAULT;
|
|
|
|
followCamera = 0;
|
|
stateData = 0;
|
|
parent = 0;
|
|
|
|
renderBeforeParent = false;
|
|
|
|
shareAlphaWithChildren = false;
|
|
shareColorWithChildren = false;
|
|
}
|
|
|
|
RenderObject::~RenderObject()
|
|
{
|
|
freeMotionBlur();
|
|
assert(children.empty()); // if this fires some objects were not deleted and will leak
|
|
}
|
|
|
|
Vector RenderObject::getWorldPosition() const
|
|
{
|
|
return getWorldCollidePosition();
|
|
}
|
|
|
|
RenderObject* RenderObject::getTopParent() const
|
|
{
|
|
RenderObject *p = parent;
|
|
RenderObject *lastp=0;
|
|
while (p)
|
|
{
|
|
lastp = p;
|
|
p = p->parent;
|
|
}
|
|
return lastp;
|
|
}
|
|
|
|
#ifdef BBGE_USE_GLM
|
|
static glm::mat4 getInvRotation(const RenderObject *p)
|
|
{
|
|
glm::mat4 m = glm::rotate(-(p->rotation.z + p->rotationOffset.z), glm::vec3(0.0f, 0.0f, 1.0f));
|
|
if(p->isfh())
|
|
m *= glm::rotate(180.0f, glm::vec3(0.0f, 1.0f, 0.0f));
|
|
return m;
|
|
}
|
|
#endif
|
|
|
|
Vector RenderObject::getInvRotPosition(const Vector &vec) const
|
|
{
|
|
#ifdef BBGE_USE_GLM
|
|
glm::mat4 m = getInvRotation(this);
|
|
for(RenderObject *p = parent; p; p = p->parent)
|
|
m *= getInvRotation(p);
|
|
m *= glm::translate(vec.x, vec.y, 0.0f);
|
|
float x = m[3][0];
|
|
float y = m[3][1];
|
|
float z = m[3][2];
|
|
|
|
#else
|
|
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
std::vector<const RenderObject*>chain;
|
|
const RenderObject *p = this;
|
|
while(p)
|
|
{
|
|
chain.push_back(p);
|
|
p = p->parent;
|
|
}
|
|
|
|
for (int i = chain.size()-1; i >= 0; i--)
|
|
{
|
|
glRotatef(-(chain[i]->rotation.z+chain[i]->rotationOffset.z), 0, 0, 1);
|
|
|
|
if (chain[i]->isfh())
|
|
{
|
|
|
|
glRotatef(180, 0, 1, 0);
|
|
}
|
|
}
|
|
|
|
if (vec.x != 0 || vec.y != 0)
|
|
{
|
|
|
|
glTranslatef(vec.x, vec.y, 0);
|
|
}
|
|
|
|
float m[16];
|
|
glGetFloatv(GL_MODELVIEW_MATRIX, m);
|
|
float x = m[12];
|
|
float y = m[13];
|
|
float z = m[14];
|
|
|
|
glPopMatrix();
|
|
#endif
|
|
|
|
return Vector(x,y,z);
|
|
}
|
|
|
|
#ifdef BBGE_USE_GLM
|
|
static glm::mat4 matrixChain(const RenderObject *ro)
|
|
{
|
|
glm::mat4 tranformMatrix = glm::scale(
|
|
glm::translate(
|
|
glm::rotate(
|
|
glm::translate(
|
|
ro->getParent() ? matrixChain(ro->getParent()) : glm::mat4(1.0f),
|
|
glm::vec3(ro->position.x+ro->offset.x, ro->position.y+ro->offset.y, 0)
|
|
),
|
|
ro->rotation.z + ro->rotationOffset.z,
|
|
glm::vec3(0.0f, 0.0f, 1.0f)
|
|
),
|
|
glm::vec3(ro->beforeScaleOffset.x, ro->beforeScaleOffset.y, 0.0f)
|
|
),
|
|
glm::vec3(ro->scale.x, ro->scale.y, 0.0f)
|
|
);
|
|
|
|
if (ro->isfh())
|
|
tranformMatrix *= glm::rotate(180.0f, glm::vec3(0.0f, 1.0f, 0.0f));
|
|
|
|
tranformMatrix *= glm::translate(glm::vec3(ro->internalOffset.x, ro->internalOffset.y, 0.0f));
|
|
return tranformMatrix;
|
|
}
|
|
#else
|
|
static void matrixChain(RenderObject *ro)
|
|
{
|
|
if (RenderObject *parent = ro->getParent())
|
|
matrixChain(parent);
|
|
|
|
glTranslatef(ro->position.x+ro->offset.x, ro->position.y+ro->offset.y, 0);
|
|
glRotatef(ro->rotation.z+ro->rotationOffset.z, 0, 0, 1);
|
|
glTranslatef(ro->beforeScaleOffset.x, ro->beforeScaleOffset.y, 0);
|
|
glScalef(ro->scale.x, ro->scale.y, 0);
|
|
if (ro->isfh())
|
|
{
|
|
|
|
glRotatef(180, 0, 1, 0);
|
|
}
|
|
glTranslatef(ro->internalOffset.x, ro->internalOffset.y, 0);
|
|
}
|
|
#endif
|
|
|
|
float RenderObject::getWorldRotation() const
|
|
{
|
|
Vector up = getWorldCollidePosition(Vector(0,1));
|
|
Vector orig = getWorldPosition();
|
|
float rot = 0;
|
|
MathFunctions::calculateAngleBetweenVectorsInDegrees(orig, up, rot);
|
|
return rot;
|
|
}
|
|
|
|
Vector RenderObject::getWorldPositionAndRotation() const
|
|
{
|
|
Vector up = getWorldCollidePosition(Vector(0,1));
|
|
Vector orig = getWorldPosition();
|
|
MathFunctions::calculateAngleBetweenVectorsInDegrees(orig, up, orig.z);
|
|
return orig;
|
|
}
|
|
|
|
Vector RenderObject::getWorldCollidePosition(const Vector &vec) const
|
|
{
|
|
#ifdef BBGE_USE_GLM
|
|
glm::mat4 transformMatrix = glm::translate(
|
|
matrixChain(this),
|
|
glm::vec3(vec.x, vec.y, 0.0f)
|
|
);
|
|
|
|
return Vector(transformMatrix[3][0], transformMatrix[3][1], 0);
|
|
#else
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
|
|
matrixChain(this);
|
|
glTranslatef(vec.x, vec.y, 0);
|
|
|
|
float m[16];
|
|
glGetFloatv(GL_MODELVIEW_MATRIX, m);
|
|
float x = m[12];
|
|
float y = m[13];
|
|
|
|
glPopMatrix();
|
|
return Vector(x,y,0);
|
|
#endif
|
|
}
|
|
|
|
void RenderObject::fhTo(bool fh)
|
|
{
|
|
if ((fh && !_fh) || (!fh && _fh))
|
|
{
|
|
flipHorizontal();
|
|
}
|
|
}
|
|
|
|
void RenderObject::flipHorizontal()
|
|
{
|
|
bool wasFlippedHorizontal = _fh;
|
|
|
|
_fh = !_fh;
|
|
|
|
if (wasFlippedHorizontal != _fh)
|
|
{
|
|
onFH();
|
|
}
|
|
|
|
}
|
|
|
|
void RenderObject::flipVertical()
|
|
{
|
|
|
|
_fv = !_fv;
|
|
|
|
}
|
|
|
|
void RenderObject::destroy()
|
|
{
|
|
for (Children::iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
// must do this first
|
|
// otherwise child will try to remove THIS
|
|
(*i)->parent = 0;
|
|
(*i)->destroy();
|
|
if((*i)->pm == PM_POINTER)
|
|
delete (*i);
|
|
}
|
|
children.clear();
|
|
|
|
if (parent)
|
|
{
|
|
parent->removeChild(this);
|
|
parent = 0;
|
|
}
|
|
|
|
texture = NULL;
|
|
}
|
|
|
|
Vector RenderObject::getRealPosition() const
|
|
{
|
|
if (parent)
|
|
{
|
|
return position + offset + parent->getRealPosition();
|
|
}
|
|
return position + offset;
|
|
}
|
|
|
|
Vector RenderObject::getRealScale() const
|
|
{
|
|
if (parent)
|
|
{
|
|
return scale * parent->getRealScale();
|
|
}
|
|
return scale;
|
|
}
|
|
|
|
void RenderObject::setStateDataObject(StateData *state)
|
|
{
|
|
stateData = state;
|
|
}
|
|
|
|
|
|
void RenderObject::toggleCull(bool value)
|
|
{
|
|
cull = value;
|
|
}
|
|
|
|
void RenderObject::moveToFront()
|
|
{
|
|
if(RenderObject *p = parent)
|
|
{
|
|
if(p->children.size() && p->children[p->children.size()-1] != this)
|
|
{
|
|
p->removeChild(this);
|
|
p->addChild(this, (ParentManaged)this->pm, RBP_NONE, CHILD_BACK); // To back of list -> rendered on top
|
|
}
|
|
}
|
|
else if (layer != -1)
|
|
core->renderObjectLayers[this->layer].moveToFront(this);
|
|
}
|
|
|
|
void RenderObject::moveToBack()
|
|
{
|
|
if(RenderObject *p = parent)
|
|
{
|
|
if(p->children.size() && p->children[0] != this)
|
|
{
|
|
p->removeChild(this);
|
|
p->addChild(this, (ParentManaged)this->pm, RBP_NONE, CHILD_FRONT); // To front of list -> rendered first, below everything else
|
|
}
|
|
}
|
|
else if (layer != -1)
|
|
core->renderObjectLayers[this->layer].moveToBack(this);
|
|
}
|
|
|
|
void RenderObject::enableMotionBlur(int sz, int off)
|
|
{
|
|
MotionBlurData *mb = ensureMotionBlur();
|
|
mb->transition = false;
|
|
mb->positions.resize(sz);
|
|
mb->frameOffsetCounter = 0;
|
|
mb->frameOffset = off;
|
|
for (size_t i = 0; i < mb->positions.size(); i++)
|
|
{
|
|
mb->positions[i].position = position;
|
|
mb->positions[i].rotz = rotation.z;
|
|
}
|
|
}
|
|
|
|
void RenderObject::disableMotionBlur()
|
|
{
|
|
if(MotionBlurData *mb = this->motionBlur)
|
|
{
|
|
mb->transition = true;
|
|
mb->transitionTimer = 1.0;
|
|
}
|
|
}
|
|
|
|
bool RenderObject::isfhr() const
|
|
{
|
|
const RenderObject *p = this;
|
|
bool fh = false;
|
|
do
|
|
if (p->isfh())
|
|
fh = !fh;
|
|
while ((p = p->parent));
|
|
return fh;
|
|
|
|
}
|
|
|
|
bool RenderObject::isfvr() const
|
|
{
|
|
const RenderObject *p = this;
|
|
bool fv = false;
|
|
do
|
|
if (p->isfv())
|
|
fv = !fv;
|
|
while ((p = p->parent));
|
|
return fv;
|
|
|
|
}
|
|
|
|
bool RenderObject::hasRenderPass(const int pass) const
|
|
{
|
|
if (pass == renderPass)
|
|
return true;
|
|
for (Children::const_iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
if (!(*i)->isDead() && (*i)->hasRenderPass(pass))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool RenderObject::shouldTryToRender() const
|
|
{
|
|
return !parent
|
|
&& alpha.x > 0
|
|
&& (!cull || isOnScreen());
|
|
}
|
|
|
|
bool RenderObject::isVisibleInPass(int pass) const
|
|
{
|
|
assert(!parent); // This check should be done for root objects only
|
|
assert(pass != RENDER_ALL); // why call this when we already know we don't do passes
|
|
|
|
return hasRenderPass(pass);
|
|
}
|
|
|
|
void RenderObject::render(const RenderState& rs) const
|
|
{
|
|
if (isHidden()) return;
|
|
|
|
/// new (breaks anything?)
|
|
if (alpha.x == 0 || alphaMod == 0) return;
|
|
|
|
if (MotionBlurData *mb = this->motionBlur)
|
|
{
|
|
RenderState rx(rs);
|
|
const Vector oldPos = position;
|
|
const float oldRotZ = rotation.z;
|
|
const size_t sz = mb->positions.size();
|
|
const float m = 1.0f / float(sz);
|
|
const float m2 = alpha.x * 0.5f * (mb->transition ? mb->transitionTimer : 1.0f);
|
|
for (size_t i = 0; i < sz; i++)
|
|
{
|
|
position = mb->positions[i].position;
|
|
rotation.z = mb->positions[i].rotz;
|
|
rx.alpha = (1.0f-(float(i) * m)) * m2;
|
|
renderCall(rx);
|
|
}
|
|
position = oldPos;
|
|
rotation.z = oldRotZ;
|
|
}
|
|
|
|
renderCall(rs);
|
|
}
|
|
|
|
void RenderObject::renderCall(const RenderState& rs) const
|
|
{
|
|
position += offset;
|
|
|
|
glPushMatrix();
|
|
|
|
|
|
if (layer != LR_NONE)
|
|
{
|
|
RenderObjectLayer *l = &core->renderObjectLayers[layer];
|
|
if (l->followCamera != NO_FOLLOW_CAMERA)
|
|
{
|
|
followCamera = l->followCamera;
|
|
}
|
|
}
|
|
if (followCamera!=0 && !parent)
|
|
{
|
|
if (followCamera == 1)
|
|
{
|
|
glLoadIdentity();
|
|
glScalef(core->globalResolutionScale.x, core->globalResolutionScale.y,0);
|
|
glTranslatef(position.x, position.y, position.z);
|
|
if (isfh())
|
|
{
|
|
|
|
glRotatef(180, 0, 1, 0);
|
|
}
|
|
|
|
glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
|
|
}
|
|
else
|
|
{
|
|
Vector pos = getFollowCameraPosition();
|
|
|
|
glTranslatef(pos.x, pos.y, pos.z);
|
|
if (isfh())
|
|
{
|
|
|
|
glRotatef(180, 0, 1, 0);
|
|
}
|
|
glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
glTranslatef(position.x, position.y, position.z);
|
|
|
|
if (RenderObject::renderPaths && position.data && position.data->path.getNumPathNodes() > 0)
|
|
{
|
|
glLineWidth(4);
|
|
glEnable(GL_BLEND);
|
|
|
|
size_t i = 0;
|
|
glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
glBegin(GL_LINES);
|
|
for (i = 0; i < position.data->path.getNumPathNodes()-1; i++)
|
|
{
|
|
glVertex2f(position.data->path.getPathNode(i)->value.x-position.x, position.data->path.getPathNode(i)->value.y-position.y);
|
|
glVertex2f(position.data->path.getPathNode(i+1)->value.x-position.x, position.data->path.getPathNode(i+1)->value.y-position.y);
|
|
}
|
|
glEnd();
|
|
|
|
glPointSize(20);
|
|
glBegin(GL_POINTS);
|
|
glColor4f(0.5,0.5,1,1);
|
|
for (i = 0; i < position.data->path.getNumPathNodes(); i++)
|
|
{
|
|
glVertex2f(position.data->path.getPathNode(i)->value.x-position.x, position.data->path.getPathNode(i)->value.y-position.y);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
|
|
if (isfh())
|
|
{
|
|
|
|
glRotatef(180, 0, 1, 0);
|
|
}
|
|
}
|
|
|
|
glTranslatef(beforeScaleOffset.x, beforeScaleOffset.y, beforeScaleOffset.z);
|
|
glScalef(scale.x, scale.y, 1);
|
|
glTranslatef(internalOffset.x, internalOffset.y, internalOffset.z);
|
|
|
|
for (Children::const_iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
if (!(*i)->isDead() && (*i)->renderBeforeParent)
|
|
(*i)->render(rs);
|
|
}
|
|
|
|
|
|
if (rs.pass == RENDER_ALL || renderPass == RENDER_ALL || rs.pass == renderPass)
|
|
{
|
|
if (texture)
|
|
{
|
|
if (texture->textures[0] != lastTextureApplied || repeatTexture != lastTextureRepeat)
|
|
{
|
|
texture->apply(repeatTexture);
|
|
lastTextureRepeat = repeatTexture;
|
|
lastTextureApplied = texture->textures[0];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (lastTextureApplied != 0 || repeatTexture != lastTextureRepeat)
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
lastTextureApplied = 0;
|
|
lastTextureRepeat = repeatTexture;
|
|
}
|
|
}
|
|
|
|
rs.gpu.setBlend(getBlendType());
|
|
|
|
// RenderState color applies to everything in the scene graph,
|
|
// so that needs to be multiplied in unconditionally
|
|
{
|
|
Vector col = this->color * rs.color;
|
|
glColor4f(col.x, col.y, col.z, rs.alpha*alpha.x*alphaMod);
|
|
}
|
|
|
|
onRender(rs);
|
|
|
|
if (renderCollisionShape)
|
|
renderCollision(rs);
|
|
}
|
|
|
|
|
|
for (Children::const_iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
if (!(*i)->isDead() && !(*i)->renderBeforeParent)
|
|
(*i)->render(rs);
|
|
}
|
|
|
|
|
|
glPopMatrix();
|
|
|
|
|
|
position -= offset;
|
|
}
|
|
|
|
void RenderObject::renderCollision(const RenderState& rs) const
|
|
{
|
|
}
|
|
|
|
void RenderObject::addDeathNotify(RenderObject *r)
|
|
{
|
|
deathNotifications.remove(r);
|
|
deathNotifications.push_back(r);
|
|
}
|
|
|
|
void RenderObject::deathNotify(RenderObject *r)
|
|
{
|
|
deathNotifications.remove(r);
|
|
}
|
|
|
|
void RenderObject::lookAt(const Vector &pos, float t, float minAngle, float maxAngle, float offset)
|
|
{
|
|
Vector myPos = this->getWorldPosition();
|
|
float angle = 0;
|
|
|
|
if (myPos.x == pos.x && myPos.y == pos.y)
|
|
{
|
|
return;
|
|
}
|
|
MathFunctions::calculateAngleBetweenVectorsInDegrees(myPos, pos, angle);
|
|
|
|
RenderObject *p = parent;
|
|
while (p)
|
|
{
|
|
angle -= p->rotation.z;
|
|
p = p->parent;
|
|
}
|
|
|
|
const bool ishfh = this->isfhr();
|
|
|
|
if (ishfh)
|
|
{
|
|
angle = 180-angle;
|
|
|
|
|
|
|
|
offset = -offset;
|
|
}
|
|
angle += offset;
|
|
if (angle < minAngle)
|
|
angle = minAngle;
|
|
if (angle > maxAngle)
|
|
angle = maxAngle;
|
|
|
|
int amt = 10;
|
|
if (ishfh)
|
|
{
|
|
if (pos.x < myPos.x-amt)
|
|
{
|
|
angle = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pos.x > myPos.x+amt)
|
|
{
|
|
angle = 0;
|
|
}
|
|
}
|
|
|
|
rotation.interpolateTo(Vector(0,0,angle), t);
|
|
}
|
|
|
|
void RenderObject::update(float dt)
|
|
{
|
|
if (ignoreUpdate)
|
|
{
|
|
return;
|
|
}
|
|
if (useOldDT)
|
|
{
|
|
dt = core->get_old_dt();
|
|
}
|
|
if (!isDead())
|
|
{
|
|
onUpdate(dt);
|
|
}
|
|
}
|
|
|
|
void RenderObject::removeChild(RenderObject *r)
|
|
{
|
|
r->parent = 0;
|
|
Children::iterator oldend = children.end();
|
|
Children::iterator newend = std::remove(children.begin(), oldend, r);
|
|
if(oldend != newend)
|
|
{
|
|
children.resize(std::distance(children.begin(), newend));
|
|
return;
|
|
}
|
|
|
|
for (Children::iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
(*i)->removeChild(r);
|
|
}
|
|
}
|
|
|
|
void RenderObject::safeKill()
|
|
{
|
|
alpha = 0;
|
|
life = 0;
|
|
onEndOfLife();
|
|
|
|
for (RenderObjectList::iterator i = deathNotifications.begin(); i != deathNotifications.end(); i++)
|
|
{
|
|
(*i)->deathNotify(this);
|
|
}
|
|
|
|
if (this->parent)
|
|
{
|
|
_markedForDelete = true;
|
|
}
|
|
else
|
|
{
|
|
if (stateData)
|
|
stateData->removeRenderObject(this);
|
|
else
|
|
core->enqueueRenderObjectDeletion(this);
|
|
}
|
|
}
|
|
|
|
Vector RenderObject::getNormal() const
|
|
{
|
|
float a = MathFunctions::toRadians(getAbsoluteRotation().z);
|
|
return Vector(sinf(a),cosf(a));
|
|
}
|
|
|
|
// HACK: this is probably a slow implementation
|
|
Vector RenderObject::getForward() const
|
|
{
|
|
Vector v = getWorldCollidePosition(Vector(0,-1, 0));
|
|
Vector r = v - getWorldCollidePosition();
|
|
r.normalize2D();
|
|
|
|
|
|
return r;
|
|
}
|
|
|
|
Vector RenderObject::getAbsoluteRotation() const
|
|
{
|
|
Vector r = rotation;
|
|
if (parent)
|
|
{
|
|
return parent->getAbsoluteRotation() + r;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void RenderObject::onUpdate(float dt)
|
|
{
|
|
if (isDead()) return;
|
|
|
|
if(!updateLife(dt))
|
|
return;
|
|
|
|
// FIXME: We might not need to do lifetime checks either; I just
|
|
// left that above for safety since I'm not certain. --achurch
|
|
if (isHidden()) return;
|
|
|
|
position += velocity * dt;
|
|
velocity += gravity * dt;
|
|
position.update(dt);
|
|
velocity.update(dt);
|
|
gravity.update(dt);
|
|
scale.update(dt);
|
|
rotation.update(dt);
|
|
color.update(dt);
|
|
alpha.update(dt);
|
|
offset.update(dt);
|
|
internalOffset.update(dt);
|
|
beforeScaleOffset.update(dt);
|
|
rotationOffset.update(dt);
|
|
|
|
bool hasChildrenToDelete = false;
|
|
for (Children::iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
if (shareAlphaWithChildren)
|
|
(*i)->alpha.x = this->alpha.x;
|
|
if (shareColorWithChildren)
|
|
(*i)->color = this->color;
|
|
|
|
if ((*i)->pm != PM_NONE)
|
|
{
|
|
(*i)->update(dt);
|
|
}
|
|
hasChildrenToDelete |= (*i)->_markedForDelete;
|
|
|
|
}
|
|
|
|
if (hasChildrenToDelete)
|
|
{
|
|
size_t w = 0;
|
|
const size_t N = children.size();
|
|
for (size_t i = 0; i < N; ++i)
|
|
{
|
|
RenderObject *ro = children[i];
|
|
if(ro->_markedForDelete)
|
|
{
|
|
ro->parent = NULL;
|
|
ro->destroy();
|
|
if(ro->pm == PM_POINTER)
|
|
delete ro;
|
|
}
|
|
else
|
|
children[w++] = ro;
|
|
}
|
|
children.resize(w);
|
|
}
|
|
|
|
if (MotionBlurData *mb = this->motionBlur)
|
|
{
|
|
if(!mb->transition)
|
|
{
|
|
if (mb->frameOffsetCounter >= mb->frameOffset)
|
|
{
|
|
mb->frameOffsetCounter = 0;
|
|
mb->positions[0].position = position;
|
|
mb->positions[0].rotz = rotation.z;
|
|
for (int i = mb->positions.size()-1; i > 0; i--)
|
|
{
|
|
mb->positions[i] = mb->positions[i-1];
|
|
}
|
|
}
|
|
else
|
|
mb->frameOffsetCounter ++;
|
|
}
|
|
else
|
|
{
|
|
mb->transitionTimer -= dt*2;
|
|
if (mb->transitionTimer <= 0)
|
|
freeMotionBlur();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool RenderObject::updateLife(float dt)
|
|
{
|
|
if (decayRate > 0)
|
|
{
|
|
life -= decayRate*dt;
|
|
if (life<=0)
|
|
{
|
|
safeKill();
|
|
return false;
|
|
}
|
|
}
|
|
if (fadeAlphaWithLife && !alpha.isInterpolating())
|
|
{
|
|
|
|
alpha = life/maxLife;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RenderObject::unloadDevice()
|
|
{
|
|
for (Children::iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
(*i)->unloadDevice();
|
|
}
|
|
}
|
|
|
|
void RenderObject::reloadDevice()
|
|
{
|
|
for (Children::iterator i = children.begin(); i != children.end(); i++)
|
|
{
|
|
(*i)->reloadDevice();
|
|
}
|
|
}
|
|
|
|
MotionBlurData* RenderObject::ensureMotionBlur()
|
|
{
|
|
MotionBlurData *mb = this->motionBlur;
|
|
if(!mb)
|
|
{
|
|
mb = new MotionBlurData;
|
|
this->motionBlur = mb;
|
|
}
|
|
return mb;
|
|
}
|
|
|
|
void RenderObject::freeMotionBlur()
|
|
{
|
|
if(motionBlur)
|
|
{
|
|
delete motionBlur;
|
|
motionBlur = NULL;
|
|
}
|
|
}
|
|
|
|
bool RenderObject::setTexture(const std::string &n)
|
|
{
|
|
std::string name = n;
|
|
stringToLowerUserData(name);
|
|
|
|
if (name.empty())
|
|
{
|
|
setTexturePointer(NULL);
|
|
return false;
|
|
}
|
|
|
|
if(texture && texture->getLoadResult() == TEX_SUCCESS && name == texture->name)
|
|
return true; // no texture change
|
|
|
|
CountedPtr<Texture> tex = core->addTexture(name);
|
|
setTexturePointer(tex);
|
|
return tex && tex->getLoadResult() == TEX_SUCCESS;
|
|
}
|
|
|
|
void RenderObject::addChild(RenderObject *r, ParentManaged pm, RenderBeforeParent rbp, ChildOrder order)
|
|
{
|
|
if (r->parent)
|
|
{
|
|
errorLog("Engine does not support multiple parents");
|
|
return;
|
|
}
|
|
|
|
if (order == CHILD_BACK)
|
|
children.push_back(r);
|
|
else
|
|
children.insert(children.begin(), r);
|
|
|
|
r->pm = pm;
|
|
|
|
if (rbp == RBP_OFF)
|
|
r->renderBeforeParent = 0;
|
|
else if (rbp == RBP_ON)
|
|
r->renderBeforeParent = 1;
|
|
|
|
r->parent = this;
|
|
}
|
|
|
|
StateData *RenderObject::getStateData() const
|
|
{
|
|
if (parent)
|
|
{
|
|
return parent->getStateData();
|
|
}
|
|
else
|
|
return stateData;
|
|
}
|
|
|
|
void RenderObject::setOverrideCullRadius(float ovr)
|
|
{
|
|
overrideCullRadiusSqr = ovr * ovr;
|
|
}
|
|
|
|
bool RenderObject::isCoordinateInRadius(const Vector &pos, float r) const
|
|
{
|
|
Vector d = pos-getRealPosition();
|
|
|
|
return (d.getSquaredLength2D() < r*r);
|
|
}
|
|
|
|
MotionBlurData::MotionBlurData()
|
|
: transition(false), frameOffsetCounter(0), frameOffset(0), transitionTimer(0)
|
|
{
|
|
}
|