mirror of
https://github.com/AquariaOSE/Aquaria.git
synced 2024-11-29 12:03:51 +00:00
430 lines
8.4 KiB
C++
430 lines
8.4 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 "Quad.h"
|
|
#include "Core.h"
|
|
#include "RenderBase.h"
|
|
#include "RenderGrid.h"
|
|
#include <assert.h>
|
|
|
|
Quad::Quad(const std::string &tex, const Vector &pos)
|
|
: RenderObject()
|
|
{
|
|
initQuad();
|
|
renderBorderColor = Vector(1,1,1);
|
|
position = pos;
|
|
setTexture(tex);
|
|
}
|
|
|
|
Quad::Quad() : RenderObject()
|
|
{
|
|
initQuad();
|
|
}
|
|
|
|
Quad::~Quad()
|
|
{
|
|
deleteGrid();
|
|
}
|
|
|
|
void Quad::initQuad()
|
|
{
|
|
addType(SCO_QUAD);
|
|
borderAlpha = 0.5;
|
|
repeatToFillScale = Vector(1,1);
|
|
|
|
autoWidth = autoHeight = 0;
|
|
|
|
renderBorder = false;
|
|
renderCenter = true;
|
|
width = 2; height = 2;
|
|
|
|
upperLeftTextureCoordinates = Vector(0,0);
|
|
lowerRightTextureCoordinates = Vector(1,1);
|
|
renderQuad = true;
|
|
grid = NULL;
|
|
}
|
|
|
|
void Quad::deleteGrid()
|
|
{
|
|
delete grid;
|
|
grid = NULL;
|
|
}
|
|
|
|
void Quad::destroy()
|
|
{
|
|
deleteGrid();
|
|
RenderObject::destroy();
|
|
}
|
|
|
|
|
|
|
|
DynamicRenderGrid *Quad::setSegs(int x, int y, float dgox, float dgoy, float dgmx, float dgmy, float dgtm, bool dgo)
|
|
{
|
|
DynamicRenderGrid *g = createGrid(x, y);
|
|
if(g)
|
|
g->setSegs(dgox, dgoy, dgmx, dgmy, dgtm, dgo);
|
|
return g;
|
|
}
|
|
|
|
DynamicRenderGrid *Quad::createGrid(int xd, int yd)
|
|
{
|
|
delete grid;
|
|
grid = NULL;
|
|
if(xd && yd)
|
|
{
|
|
TexCoordBox tc;
|
|
tc.u1 = upperLeftTextureCoordinates.x;
|
|
tc.v1 = upperLeftTextureCoordinates.y;
|
|
tc.u2 = lowerRightTextureCoordinates.x;
|
|
tc.v2 = lowerRightTextureCoordinates.y;
|
|
grid = new DynamicRenderGrid();
|
|
grid->init(xd, yd, tc);
|
|
}
|
|
return grid;
|
|
}
|
|
|
|
void Quad::setDrawGridAlpha(size_t x, size_t y, float alpha)
|
|
{
|
|
if(grid)
|
|
grid->setAlpha(x, y, alpha);
|
|
}
|
|
|
|
void Quad::setStripPoints(bool vert, const Vector *points, size_t n)
|
|
{
|
|
if(grid)
|
|
grid->setStripPoints(vert, points, n);
|
|
}
|
|
|
|
void Quad::resetGrid()
|
|
{
|
|
if(grid)
|
|
grid->reset();
|
|
}
|
|
|
|
void Quad::_renderBorder(const RenderState& rs, Vector color, float borderalpha) const
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
|
|
if (rs.forceRenderCenter || renderCenter)
|
|
{
|
|
glColor4f(color.x, color.y, color.z, borderalpha*alpha.x*alphaMod);
|
|
glPointSize(16);
|
|
glBegin(GL_POINTS);
|
|
glVertex2f(0,0);
|
|
glEnd();
|
|
}
|
|
|
|
glColor4f(color.x, color.y, color.z, alpha.x*alphaMod);
|
|
glLineWidth(2);
|
|
const float _w2 = width*0.5f;
|
|
const float _h2 = height*0.5f;
|
|
glBegin(GL_LINES);
|
|
glVertex2f(-_w2, _h2);
|
|
glVertex2f(_w2, _h2);
|
|
glVertex2f(_w2, -_h2);
|
|
glVertex2f(_w2, _h2);
|
|
glVertex2f(-_w2, -_h2);
|
|
glVertex2f(-_w2, _h2);
|
|
glVertex2f(-_w2, -_h2);
|
|
glVertex2f(_w2, -_h2);
|
|
glEnd();
|
|
RenderObject::lastTextureApplied = 0;
|
|
}
|
|
|
|
|
|
|
|
bool Quad::isCoordinateInside(Vector coord, int minSize) const
|
|
{
|
|
Vector realscale = getRealScale();
|
|
int hw = fabsf((width)*realscale.x)*0.5f;
|
|
int hh = fabsf((height)*realscale.y)*0.5f;
|
|
if (hw < minSize)
|
|
hw = minSize;
|
|
if (hh < minSize)
|
|
hh = minSize;
|
|
|
|
Vector pos = getRealPosition();
|
|
|
|
if (coord.x >= pos.x - hw && coord.x <= pos.x + hw)
|
|
{
|
|
if (coord.y >= pos.y - hh && coord.y <= pos.y + hh)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Quad::isCoordinateInsideWorld(const Vector &coord, int minSize) const
|
|
{
|
|
int hw = fabsf((width)*getRealScale().x)*0.5f;
|
|
int hh = fabsf((height)*getRealScale().y)*0.5f;
|
|
if (hw < minSize)
|
|
hw = minSize;
|
|
if (hh < minSize)
|
|
hh = minSize;
|
|
|
|
Vector pos = getWorldPosition();
|
|
if (coord.x >= pos.x + offset.x - hw && coord.x <= pos.x + offset.x + hw)
|
|
{
|
|
if (coord.y >= pos.y + offset.y - hh && coord.y <= pos.y + offset.y + hh)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Quad::isCoordinateInsideWorldRect(const Vector &coord, int w, int h) const
|
|
{
|
|
int hw = w*0.5f;
|
|
int hh = h*0.5f;
|
|
|
|
Vector pos = getWorldPosition();
|
|
if (coord.x >= pos.x + offset.x - hw && coord.x <= pos.x + offset.x + hw)
|
|
{
|
|
if (coord.y >= pos.y + offset.y - hh && coord.y <= pos.y + offset.y + hh)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void Quad::renderGrid(const RenderState& rs) const
|
|
{
|
|
RenderState rx(rs);
|
|
rx.color = rs.color * this->color;
|
|
rx.alpha = rs.alpha * this->alpha.x * this->alphaMod;
|
|
|
|
glPushMatrix();
|
|
glScalef(width, height, 1);
|
|
|
|
grid->render(rx);
|
|
|
|
// debug points
|
|
if (RenderObject::renderCollisionShape)
|
|
{
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
grid->renderDebugPoints(rs);
|
|
RenderObject::lastTextureApplied = 0;
|
|
}
|
|
|
|
glPopMatrix();
|
|
}
|
|
|
|
|
|
void Quad::repeatTextureToFill(bool on)
|
|
{
|
|
repeatTexture = on;
|
|
refreshRepeatTextureToFill();
|
|
|
|
}
|
|
|
|
void Quad::onRender(const RenderState& rs) const
|
|
{
|
|
if (!renderQuad) return;
|
|
|
|
const float _w2 = width*0.5f;
|
|
const float _h2 = height*0.5f;
|
|
|
|
if (!grid)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
{
|
|
glTexCoord2f(upperLeftTextureCoordinates.x, 1.0f-upperLeftTextureCoordinates.y);
|
|
glVertex2f(-_w2, +_h2);
|
|
|
|
glTexCoord2f(lowerRightTextureCoordinates.x, 1.0f-upperLeftTextureCoordinates.y);
|
|
glVertex2f(+_w2, +_h2);
|
|
|
|
glTexCoord2f(lowerRightTextureCoordinates.x, 1.0f-lowerRightTextureCoordinates.y);
|
|
glVertex2f(+_w2, -_h2);
|
|
|
|
glTexCoord2f(upperLeftTextureCoordinates.x, 1.0f-lowerRightTextureCoordinates.y);
|
|
glVertex2f(-_w2, -_h2);
|
|
}
|
|
glEnd();
|
|
}
|
|
else
|
|
{
|
|
renderGrid(rs);
|
|
}
|
|
|
|
if(renderBorder)
|
|
_renderBorder(rs, renderBorderColor, borderAlpha);
|
|
else if(rs.forceRenderBorder)
|
|
_renderBorder(rs, rs.renderBorderColor, rs.renderBorderAlpha);
|
|
|
|
|
|
}
|
|
|
|
|
|
void Quad::flipHorizontal()
|
|
{
|
|
RenderObject::flipHorizontal();
|
|
}
|
|
|
|
void Quad::flipVertical()
|
|
{
|
|
if (!_fv)
|
|
{
|
|
lowerRightTextureCoordinates.y = 0;
|
|
upperLeftTextureCoordinates.y = 1;
|
|
}
|
|
else
|
|
{
|
|
lowerRightTextureCoordinates.y = 1;
|
|
upperLeftTextureCoordinates.y = 0;
|
|
}
|
|
RenderObject::flipVertical();
|
|
}
|
|
|
|
void Quad::refreshRepeatTextureToFill()
|
|
{
|
|
if (repeatTexture && texture)
|
|
{
|
|
upperLeftTextureCoordinates.x = texOff.x;
|
|
upperLeftTextureCoordinates.y = texOff.y;
|
|
lowerRightTextureCoordinates.x = (width*scale.x*repeatToFillScale.x)/texture->width + texOff.x;
|
|
lowerRightTextureCoordinates.y = (height*scale.y*repeatToFillScale.y)/texture->height + texOff.y;
|
|
}
|
|
else
|
|
{
|
|
if (fabsf(lowerRightTextureCoordinates.x) > 1 || fabsf(lowerRightTextureCoordinates.y)>1)
|
|
lowerRightTextureCoordinates = Vector(1,1);
|
|
}
|
|
}
|
|
|
|
void Quad::reloadDevice()
|
|
{
|
|
RenderObject::reloadDevice();
|
|
}
|
|
|
|
void Quad::onUpdate(float dt)
|
|
{
|
|
RenderObject::onUpdate(dt);
|
|
|
|
if (autoWidth == AUTO_VIRTUALWIDTH)
|
|
width = core->getVirtualWidth();
|
|
else if (autoWidth == AUTO_VIRTUALHEIGHT)
|
|
width = core->getVirtualHeight();
|
|
|
|
if (autoHeight == AUTO_VIRTUALWIDTH)
|
|
height = core->getVirtualWidth();
|
|
else if (autoHeight == AUTO_VIRTUALHEIGHT)
|
|
height = core->getVirtualHeight();
|
|
|
|
if (grid && alpha.x > 0 && alphaMod > 0)
|
|
{
|
|
grid->update(dt);
|
|
}
|
|
}
|
|
|
|
void Quad::setWidthHeight(float w, float h)
|
|
{
|
|
if (h == -1)
|
|
height = w;
|
|
else
|
|
height = h;
|
|
width = w;
|
|
}
|
|
|
|
void Quad::setWidth(float w)
|
|
{
|
|
width = w;
|
|
}
|
|
|
|
void Quad::setHeight(float h)
|
|
{
|
|
height = h;
|
|
}
|
|
|
|
void Quad::onSetTexture()
|
|
{
|
|
if (texture)
|
|
{
|
|
width = this->texture->width;
|
|
height = this->texture->height;
|
|
}
|
|
else
|
|
{
|
|
width = 64;
|
|
height = 64;
|
|
}
|
|
}
|
|
|
|
PauseQuad::PauseQuad() : Quad(), pauseLevel(0), positionSnapTo(0)
|
|
{
|
|
addType(SCO_PAUSEQUAD);
|
|
}
|
|
|
|
PauseQuad::~PauseQuad()
|
|
{
|
|
}
|
|
|
|
void PauseQuad::onUpdate(float dt)
|
|
{
|
|
if (positionSnapTo)
|
|
this->position = *positionSnapTo;
|
|
|
|
if (core->particlesPaused <= pauseLevel)
|
|
{
|
|
Quad::onUpdate(dt);
|
|
}
|
|
}
|
|
|
|
void PauseQuad::setPositionSnapTo(InterpolatedVector *positionSnapTo)
|
|
{
|
|
this->positionSnapTo = positionSnapTo;
|
|
}
|
|
|
|
CollideQuad::CollideQuad()
|
|
: collideRadius(0)
|
|
{
|
|
addType(SCO_COLLIDE_QUAD);
|
|
}
|
|
|
|
CollideQuad::~CollideQuad()
|
|
{
|
|
}
|
|
|
|
void CollideQuad::renderCollision(const RenderState& rs) const
|
|
{
|
|
if (collideRadius > 0)
|
|
{
|
|
glPushMatrix();
|
|
glLoadIdentity();
|
|
core->setupRenderPositionAndScale();
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glTranslatef(position.x+offset.x, position.y+offset.y, 0);
|
|
|
|
glTranslatef(internalOffset.x, internalOffset.y, 0);
|
|
glEnable(GL_BLEND);
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColor4f(1,0,0,0.5);
|
|
drawCircle(collideRadius, 8);
|
|
glDisable(GL_BLEND);
|
|
glTranslatef(offset.x, offset.y,0);
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|