bool RenderObject::isPieceFlippedHorizontal()
{
RenderObject *p = getTopParent();
if (p)
return p->isfh();
return isfh();
}
void RenderObject::render()
{
if (isHidden()) return;
/// new (breaks anything?)
if (alpha.x == 0 || alphaMod == 0) return;
if (core->currentLayerPass != RENDER_ALL && renderPass != RENDER_ALL)
{
RenderObject *top = getTopParent();
if (top == NULL && this->overrideRenderPass != OVERRIDE_NONE)
{
// FIXME: overrideRenderPass is not applied to the
// node itself in the original check (below); is
// that intentional? Doing the same thing here
// for the time being. --achurch
if (core->currentLayerPass != this->renderPass
&& core->currentLayerPass != this->overrideRenderPass)
return;
}
else if (top != NULL && top->overrideRenderPass != OVERRIDE_NONE)
{
if (core->currentLayerPass != top->overrideRenderPass)
return;
}
else
{
if (!hasRenderPass(core->currentLayerPass))
return;
}
}
if (motionBlur || motionBlurTransition)
{
Vector oldPos = position;
float oldAlpha = alpha.x;
float oldRotZ = rotation.z;
for (int i = 0; i < motionBlurPositions.size(); i++)
{
position = motionBlurPositions[i].position;
rotation.z = motionBlurPositions[i].rotz;
alpha = 1.0f-(float(i)/float(motionBlurPositions.size()));
alpha *= 0.5f;
if (motionBlurTransition)
{
alpha *= motionBlurTransitionTimer;
}
renderCall();
}
position = oldPos;
alpha.x = oldAlpha;
rotation.z = oldRotZ;
renderCall();
}
else
renderCall();
}
const Tile* Item::getTile() const
{
const Cylinder* cylinder = getTopParent();
//get root cylinder
if (cylinder->getParent()) {
cylinder = cylinder->getParent();
}
return dynamic_cast<const Tile*>(cylinder);
}
Tile* Thing::getTile()
{
Cylinder* cylinder = getTopParent();
#ifdef __DEBUG__MOVESYS__
if(!cylinder){
std::cout << "Failure: [Thing::getTile()], NULL tile" << std::endl;
DEBUG_REPORT
return &(Tile::null_tile);
}
ReturnValue Container::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags, Creature* actor/* = NULL*/) const
{
bool childIsOwner = hasBitSet(FLAG_CHILDISOWNER, flags);
if(childIsOwner)
{
//a child container is querying, since we are the top container (not carried by a player)
//just return with no error.
return RET_NOERROR;
}
const Item* item = thing->getItem();
if(item == NULL)
return RET_NOTPOSSIBLE;
if(!item->isPickupable())
return RET_CANNOTPICKUP;
if(item == this)
return RET_THISISIMPOSSIBLE;
const Cylinder* cylinder = getParent();
if(!hasBitSet(FLAG_NOLIMIT, flags))
{
while(cylinder)
{
if(cylinder == thing)
return RET_THISISIMPOSSIBLE;
if(dynamic_cast<const Inbox*>(cylinder))
return RET_CONTAINERNOTENOUGHROOM;
cylinder = cylinder->getParent();
}
if(index == INDEX_WHEREEVER && size() >= capacity())
return RET_CONTAINERNOTENOUGHROOM;
}
else
{
while(cylinder)
{
if(cylinder == thing)
return RET_THISISIMPOSSIBLE;
cylinder = cylinder->getParent();
}
}
const Cylinder* topParent = getTopParent();
if(topParent != this)
return topParent->__queryAdd(INDEX_WHEREEVER, item, count, flags | FLAG_CHILDISOWNER, actor);
else
return RET_NOERROR;
}
void Container::postRemoveNotification(Thing* thing, const Cylinder* newParent, int32_t index, cylinderlink_t)
{
Cylinder* topParent = getTopParent();
if (topParent->getCreature()) {
topParent->postRemoveNotification(thing, newParent, index, LINK_TOPPARENT);
} else if (topParent == this) {
//let the tile class notify surrounding players
if (topParent->getParent()) {
topParent->getParent()->postRemoveNotification(thing, newParent, index, LINK_NEAR);
}
} else {
topParent->postRemoveNotification(thing, newParent, index, LINK_PARENT);
}
}
const Tile* Thing::getTile() const
{
const Cylinder* cylinder = getTopParent();
#ifdef __DEBUG_MOVESYS__
if(!cylinder)
{
std::clog << "[Failure - Thing::getTile] NULL tile" << std::endl;
return &(Tile::nullTile);
}
#endif
if(cylinder->getParent())
cylinder = cylinder->getParent();
return dynamic_cast<const Tile*>(cylinder);
}
ReturnValue Container::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags) const
{
bool childIsOwner = ((flags & FLAG_CHILDISOWNER) == FLAG_CHILDISOWNER);
if(childIsOwner){
//a child container is querying, since we are the top container (not carried by a player)
//just return with no error.
return RET_NOERROR;
}
const Item* item = thing->getItem();
if(item == NULL){
return RET_NOTPOSSIBLE;
}
if(!item->isPickupable()){
return RET_CANNOTPICKUP;
}
if(item == this){
return RET_THISISIMPOSSIBLE;
}
const Cylinder* cylinder = getParent();
while(cylinder){
if(cylinder == thing){
return RET_THISISIMPOSSIBLE;
}
cylinder = cylinder->getParent();
}
bool skipLimit = ((flags & FLAG_NOLIMIT) == FLAG_NOLIMIT);
if(index == INDEX_WHEREEVER && !skipLimit){
if(size() >= capacity())
return RET_CONTAINERNOTENOUGHROOM;
}
const Cylinder* topParent = getTopParent();
if(topParent != this){
return topParent->__queryAdd(INDEX_WHEREEVER, item, count, flags | FLAG_CHILDISOWNER);
}
else
return RET_NOERROR;
}
void Container::postRemoveNotification(Creature* actor, Thing* thing, const Cylinder* newParent,
int32_t index, bool isCompleteRemoval, CylinderLink_t/* link = LINK_OWNER*/)
{
Cylinder* topParent = getTopParent();
if(!topParent->getCreature())
{
if(topParent == this)
{
//let the tile class notify surrounding players
if(topParent->getParent())
topParent->getParent()->postRemoveNotification(actor, thing, newParent, index, isCompleteRemoval, LINK_NEAR);
}
else
topParent->postRemoveNotification(actor, thing, newParent, index, isCompleteRemoval, LINK_PARENT);
}
else
topParent->postRemoveNotification(actor, thing, newParent, index, isCompleteRemoval, LINK_TOPPARENT);
}
ReturnValue Container::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags, Creature* actor/* = NULL*/) const
{
bool childIsOwner = hasBitSet(FLAG_CHILDISOWNER, flags);
if(childIsOwner)
{
//a child container is querying, since we are the top container (not carried by a player)
//just return with no error.
return RET_NOERROR;
}
const Item* item = thing->getItem();
if(!item)
return RET_NOTPOSSIBLE;
if(!item->isPickupable())
return RET_CANNOTPICKUP;
if(item == this)
return RET_THISISIMPOSSIBLE;
if(const Container* container = item->getContainer())
{
for(const Cylinder* cylinder = getParent(); cylinder; cylinder = cylinder->getParent())
{
if(cylinder == container)
return RET_THISISIMPOSSIBLE;
}
}
if((flags & FLAG_NOLIMIT) != FLAG_NOLIMIT)
{
if((index == INDEX_WHEREEVER && full()))
return RET_CONTAINERNOTENOUGHROOM;
}
const Cylinder* topParent = getTopParent();
if(topParent != this)
return topParent->__queryAdd(INDEX_WHEREEVER, item, count, flags | FLAG_CHILDISOWNER, actor);
return RET_NOERROR;
}
void RoundButton::onUpdate(float dt)
{
if (noNested && core->isNested()) return;
RenderObject::onUpdate(dt);
RenderObject *top = getTopParent();
if (alpha.x == 1 && top->alpha.x == 1)
{
Vector p = core->mouse.position;
Vector c = getWorldPosition();
int w2 = width/2;
int h2 = height/2;
if ((p.x > (c.x - w2)) && (p.x < (c.x + w2)) && (p.y > (c.y - h2)) && (p.y < (c.y + h2)))
{
if (core->mouse.buttons.left && !mbd)
{
mbd = true;
}
else if (!core->mouse.buttons.left && mbd)
{
mbd = false;
event.call();
}
}
else
{
mbd = false;
}
if (!core->mouse.buttons.left && mbd)
{
mbd = false;
}
}
else
{
mbd = false;
}
}
void RenderObject::renderCall()
{
//RenderObjectLayer *rlayer = core->getRenderObjectLayer(getTopLayer());
if (positionSnapTo)
this->position = *positionSnapTo;
position += offset;
#ifdef BBGE_BUILD_DIRECTX
if (!RENDEROBJECT_FASTTRANSFORM)
core->getD3DMatrixStack()->Push();
#endif
#ifdef BBGE_BUILD_OPENGL
if (!RENDEROBJECT_FASTTRANSFORM)
glPushMatrix();
if (!RENDEROBJECT_SHAREATTRIBUTES)
{
glPushAttrib(GL_ALL_ATTRIB_BITS);
}
#endif
if (!RENDEROBJECT_FASTTRANSFORM)
{
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)
{
#ifdef BBGE_BUILD_OPENGL
glLoadIdentity();
glScalef(core->globalResolutionScale.x, core->globalResolutionScale.y,0);
glTranslatef(position.x, position.y, position.z);
if (isfh())
{
glDisable(GL_CULL_FACE);
glRotatef(180, 0, 1, 0);
}
if (core->mode == Core::MODE_3D)
{
glRotatef(rotation.x+rotationOffset.x, 1, 0, 0);
glRotatef(rotation.y+rotationOffset.y, 0, 1, 0);
}
glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
#endif
#ifdef BBGE_BUILD_DIRECTX
core->getD3DMatrixStack()->LoadIdentity();
core->scaleMatrixStack(core->globalResolutionScale.x, core->globalResolutionScale.y,0);
core->translateMatrixStack(position.x, position.y, 0);
if (isfh())
{
//HACK: disable cull ->
core->getD3DMatrixStack()->RotateAxisLocal(&D3DXVECTOR3(0, 1, 0), D3DXToRadian(180));
}
core->rotateMatrixStack(rotation.z + rotationOffset.z);
#endif
}
else
{
Vector pos = getFollowCameraPosition();
#ifdef BBGE_BUILD_OPENGL
glTranslatef(pos.x, pos.y, pos.z);
if (isfh())
{
glDisable(GL_CULL_FACE);
glRotatef(180, 0, 1, 0);
}
if (core->mode == Core::MODE_3D)
{
glRotatef(rotation.x+rotationOffset.x, 1, 0, 0);
glRotatef(rotation.y+rotationOffset.y, 0, 1, 0);
}
glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
#endif
#ifdef BBGE_BUILD_DIRECTX
core->translateMatrixStack(pos.x, pos.y, 0);
if (isfh())
{
//HACK: disable cull ->
core->getD3DMatrixStack()->RotateAxisLocal(&D3DXVECTOR3(0, 1, 0), D3DXToRadian(180));
}
core->rotateMatrixStack(rotation.z + rotationOffset.z);
#endif
}
}
else
{
#ifdef BBGE_BUILD_OPENGL
glTranslatef(position.x, position.y, position.z);
#endif
#ifdef BBGE_BUILD_DIRECTX
core->translateMatrixStack(position.x, position.y, 0);
#endif
#ifdef BBGE_BUILD_OPENGL
if (RenderObject::renderPaths && position.data && position.data->path.getNumPathNodes() > 0)
{
glLineWidth(4);
glEnable(GL_BLEND);
int 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();
}
#endif
#ifdef BBGE_BUILD_OPENGL
if (core->mode == Core::MODE_3D)
{
glRotatef(rotation.x+rotationOffset.x, 1, 0, 0);
glRotatef(rotation.y+rotationOffset.y, 0, 1, 0);
}
glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
if (isfh())
{
glDisable(GL_CULL_FACE);
glRotatef(180, 0, 1, 0);
}
#endif
#ifdef BBGE_BUILD_DIRECTX
//core->getD3DMatrixStack()->RotateAxisLocal(&D3DXVECTOR3(0, 0, 1), rotation.z+rotationOffset.z);
core->rotateMatrixStack(rotation.z + rotationOffset.z);
if (isfh())
{
//HACK: disable cull
core->getD3DDevice()->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
//core->getD3DMatrixStack()->Scale(-1, 1, 1);
//core->applyMatrixStackToWorld();
core->getD3DMatrixStack()->RotateAxisLocal(&D3DXVECTOR3(0, 1, 0), D3DXToRadian(180));
//core->applyMatrixStackToWorld();
}
#endif
}
#ifdef BBGE_BUILD_OPENGL
glTranslatef(beforeScaleOffset.x, beforeScaleOffset.y, beforeScaleOffset.z);
if (core->mode == Core::MODE_3D)
glScalef(scale.x, scale.y, scale.z);
else
glScalef(scale.x, scale.y, 1);
glTranslatef(internalOffset.x, internalOffset.y, internalOffset.z);
#endif
#ifdef BBGE_BUILD_DIRECTX
core->translateMatrixStack(beforeScaleOffset.x, beforeScaleOffset.y, 0);
core->scaleMatrixStack(scale.x, scale.y, 1);
core->translateMatrixStack(internalOffset.x, internalOffset.y, 0);
core->applyMatrixStackToWorld();
#endif
//glDisable(GL_CULL_FACE);
/* Never set anywhere. --achurch
if (renderOrigin)
{
#ifdef BBGE_BUILD_OPENGL
glBegin(GL_TRIANGLES);
glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
glVertex3f(0.0f, 5.0f, 0.0f);
glVertex3f(50.0f, 0.0f, 0.0f);
glVertex3f(0.0f, -5.0f, 0.0f);
glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
glVertex3f(0.0f, 0.0f, 5.0f);
glVertex3f(0.0f, 50.0f, 0.0f);
glVertex3f(0.0f, 0.0f, -5.0f);
glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
glVertex3f(5.0f, 0.0f, 0.0f);
glVertex3f(0.0f, 0.0f, 50.0f);
glVertex3f(-5.0f, 0.0f, 0.0f);
glEnd();
#endif
}
*/
}
for (Children::iterator i = children.begin(); i != children.end(); i++)
{
if (!(*i)->isDead() && (*i)->renderBeforeParent)
(*i)->render();
}
//if (useColor)
{
#ifdef BBGE_BUILD_OPENGL
if (rlayer)
glColor4f(color.x * rlayer->color.x, color.y * rlayer->color.y, color.z * rlayer->color.z, alpha.x*alphaMod);
else
glColor4f(color.x, color.y, color.z, alpha.x*alphaMod);
#elif defined(BBGE_BUILD_DIRECTX)
core->setColor(color.x, color.y, color.z, alpha.x*alphaMod);
#endif
}
if (texture)
{
#ifdef BBGE_BUILD_OPENGL
if (texture->textures[0] != lastTextureApplied || repeatTexture != lastTextureRepeat)
{
texture->apply(repeatTexture);
lastTextureRepeat = repeatTexture;
lastTextureApplied = texture->textures[0];
}
#endif
#ifdef BBGE_BUILD_DIRECTX
texture->apply(repeatTexture);
#endif
}
else
{
if (lastTextureApplied != 0 || repeatTexture != lastTextureRepeat)
{
#ifdef BBGE_BUILD_OPENGL
glBindTexture(GL_TEXTURE_2D, 0);
#endif
#ifdef BBGE_BUILD_DIRECTX
core->bindTexture(0, 0);
#endif
lastTextureApplied = 0;
lastTextureRepeat = repeatTexture;
}
}
applyBlendType();
bool doRender = true;
int pass = renderPass;
if (core->currentLayerPass != RENDER_ALL && renderPass != RENDER_ALL)
{
RenderObject *top = getTopParent();
if (top)
{
if (top->overrideRenderPass != OVERRIDE_NONE)
pass = top->overrideRenderPass;
}
doRender = (core->currentLayerPass == pass);
}
if (renderCollisionShape)
renderCollision();
if (doRender)
onRender();
//collisionShape.render();
if (!RENDEROBJECT_SHAREATTRIBUTES)
{
glPopAttrib();
}
for (Children::iterator i = children.begin(); i != children.end(); i++)
{
if (!(*i)->isDead() && !(*i)->renderBeforeParent)
(*i)->render();
}
if (!RENDEROBJECT_FASTTRANSFORM)
{
#ifdef BBGE_BUILD_OPENGL
glPopMatrix();
#endif
#ifdef BBGE_BUILD_DIRECTX
core->getD3DMatrixStack()->Pop();
core->applyMatrixStackToWorld();
#endif
}
position -= offset;
if (integerizePositionForRender)
{
position = savePosition;
}
}
ReturnValue Container::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags) const
{
bool childIsOwner = ((flags & FLAG_CHILDISOWNER) == FLAG_CHILDISOWNER);
if(childIsOwner){
//a child container is querying, since we are the top container (not carried by a player)
//just return with no error.
return RET_NOERROR;
}
const Item* item = thing->getItem();
if(item == NULL){
return RET_NOTPOSSIBLE;
}
if(!item->isPickupable()){
return RET_CANNOTPICKUP;
}
if(item == this){
return RET_THISISIMPOSSIBLE;
}
const Cylinder* cylinder = getParent();
while(cylinder){
if(cylinder == thing){
return RET_THISISIMPOSSIBLE;
}
cylinder = cylinder->getParent();
}
bool skipLimit = ((flags & FLAG_NOLIMIT) == FLAG_NOLIMIT);
if(index == INDEX_WHEREEVER && !skipLimit){
if(size() >= capacity())
return RET_CONTAINERNOTENOUGHROOM;
}
const Cylinder* topParent = getTopParent();
if(topParent != this){
ReturnValue ret = topParent->__queryAdd(INDEX_WHEREEVER, item, count, flags | FLAG_CHILDISOWNER);
if (ret != RET_NOERROR){
return ret;
}
}
int32_t maxDeepness = g_config.getNumber(ConfigManager::MAX_DEEPNESS_OF_CHAIN_OF_CONTAINERS);
if (maxDeepness > 0){
if (item->getContainer() && getParentContainer()){ //only containers inside of other containers have a deepness updated
if (getDeepness() + 1 > maxDeepness){
return RET_CONTAINERHASTOMANYCONTAINERS;
}
}
}
/* the return value of RET_CONTAINERHASTOMANYITEMS and RET_CONTAINERHASTOMANYCONTAINERS
should be sent ONLY if there weren't any other error */
const Container* c = this;
int32_t max_amount_inside = g_config.getNumber(ConfigManager::MAX_AMOUNT_ITEMS_INSIDE_CONTAINERS);
if (max_amount_inside > 0){
do {
if ((c->getTotalAmountOfItemsInside() + thing->getTotalAmountOfItemsInside()) > (uint32_t) max_amount_inside + 1)
return RET_CONTAINERHASTOMANYITEMS;
c = c->getParentContainer();
}
while(c);
}
return RET_NOERROR;
}