mirror/Aquaria
1
0
Fork 0
mirror of https://github.com/AquariaOSE/Aquaria.git synced 2024-12-01 15:35:47 +00:00
Code Issues Releases Wiki Activity
Aquaria/BBGE/Quad.cpp
fgenesis ce4ca7f794 Temp commit, some WIP things: 
- QuadGrid draft
- Fix minimap_setHealthBarTex accidentally calling MiniMapRender::setAvatarTex
- don't trunkcate to int in entity_rotateTo*() functions
2022-05-06 19:14:47 +02:00

637 lines
12 KiB
C++
Raw Blame History

/*
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 <assert.h>
Vector Quad::renderBorderColor = Vector(1,1,1);
Quad::Quad(const std::string &tex, const Vector &pos)
: RenderObject()
{
initQuad();
position = pos;
setTexture(tex);
}
void Quad::setSegs(int x, int y, float dgox, float dgoy, float dgmx, float dgmy, float dgtm, bool dgo)
{
deleteGrid();
if (x == 0 || y == 0)
{
gridTimer = 0;
xDivs = 0;
yDivs = 0;
doUpdateGrid = false;
}
else
{
this->drawGridOffsetX = dgox;
this->drawGridOffsetY = dgoy;
this->drawGridModX = dgmx;
this->drawGridModY = dgmy;
this->drawGridTimeMultiplier = dgtm;
drawGridOut = dgo;
xDivs = x;
yDivs = y;
createGrid(x, y);
gridTimer = 0;
doUpdateGrid = true;
}
}
void Quad::createStrip(bool vert, int num)
{
strip.resize(num);
stripVert = vert;
resetStrip();
}
void Quad::createGrid(int xd, int yd)
{
deleteGrid();
xDivs = xd;
yDivs = yd;
drawGrid = new Vector * [xDivs];
for (size_t i = 0; i < xDivs; i++)
{
drawGrid[i] = new Vector [yDivs];
for (size_t j = 0; j < yDivs; j++)
{
drawGrid[i][j].z = 1;
}
}
resetGrid();
}
void Quad::setDrawGridAlpha(size_t x, size_t y, float alpha)
{
if (x < xDivs && y < yDivs)
{
drawGrid[x][y].z = alpha;
}
}
void Quad::setGridPoints(bool vert, const std::vector<Vector> &points)
{
if (!drawGrid) return;
resetGrid();
for (size_t i = 0; i < points.size(); i++)
{
if (!vert) // horz
{
for (size_t y = 0; y < yDivs; y++)
{
for (size_t x = 0; x < xDivs; x++)
{
if (x < points.size())
{
drawGrid[x][y] += points[x];
}
}
}
}
else
{
for (size_t x = 0; x < xDivs; x++)
{
for (size_t y = 0; y < yDivs; y++)
{
if (y < points.size())
{
drawGrid[x][y] += points[y];
}
}
}
}
}
}
float Quad::getStripSegmentSize()
{
return (1.0f/(float(strip.size())));
}
void Quad::resetStrip()
{
if (!stripVert)
{
for (size_t i = 0; i < strip.size(); i++)
{
float v = (i/(float(strip.size())));
strip[i].x = v;
strip[i].y = 0;
}
}
else
{
errorLog("VERTICAL STRIP NOT SUPPORTED ^_-");
}
}
void Quad::resetGrid()
{
for (size_t i = 0; i < xDivs; i++)
{
for (size_t j = 0; j < yDivs; j++)
{
drawGrid[i][j].x = i/(float)(xDivs-1)-0.5f;
drawGrid[i][j].y = j/(float)(yDivs-1)-0.5f;
}
}
}
void Quad::initQuad()
{
repeatToFillScale = Vector(1,1);
gridType = GRID_WAVY;
gridTimer = 0;
xDivs = 0;
yDivs = 0;
doUpdateGrid = false;
autoWidth = autoHeight = 0;
repeatingTextureToFill = false;
drawGrid = 0;
renderBorder = false;
renderCenter = true;
width = 2; height = 2;
upperLeftTextureCoordinates = Vector(0,0);
lowerRightTextureCoordinates = Vector(1,1);
renderQuad = true;
}
Quad::Quad() : RenderObject()
{
addType(SCO_QUAD);
borderAlpha = 0.5;
initQuad();
}
void Quad::deleteGrid()
{
if (drawGrid)
{
for (size_t i = 0; i < xDivs; i++)
{
delete[] drawGrid[i];
}
delete[] drawGrid;
drawGrid = 0;
}
}
void Quad::destroy()
{
deleteGrid();
RenderObject::destroy();
}
bool Quad::isCoordinateInside(Vector coord, int minSize)
{
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)
{
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)
{
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::updateGrid(float dt)
{
if (!doUpdateGrid) return;
if (gridType == GRID_WAVY)
{
gridTimer += dt * drawGridTimeMultiplier;
resetGrid();
size_t hx = xDivs/2;
for (size_t x = 0; x < xDivs; x++)
{
float yoffset = x * drawGridOffsetY;
float addY = 0;
if (drawGridModY != 0)
addY = cosf(gridTimer+yoffset)*drawGridModY;
for (size_t y = 0; y < yDivs; y++)
{
float xoffset = y * drawGridOffsetX;
if (drawGridModX != 0)
{
float addX = (sinf(gridTimer+xoffset)*drawGridModX);
if (drawGridOut && x < hx)
drawGrid[x][y].x += addX;
else
drawGrid[x][y].x -= addX;
}
drawGrid[x][y].y += addY;
}
}
}
}
void Quad::renderGrid()
{
if (xDivs < 2 || yDivs < 2)
return;
const float percentX = fabsf(this->lowerRightTextureCoordinates.x - this->upperLeftTextureCoordinates.x);
const float percentY = fabsf(this->upperLeftTextureCoordinates.y - this->lowerRightTextureCoordinates.y);
const float baseX =
(lowerRightTextureCoordinates.x < upperLeftTextureCoordinates.x)
? lowerRightTextureCoordinates.x : upperLeftTextureCoordinates.x;
const float baseY =
(lowerRightTextureCoordinates.y < upperLeftTextureCoordinates.y)
? lowerRightTextureCoordinates.y : upperLeftTextureCoordinates.y;
// NOTE: These are used to avoid repeated expensive divide operations,
// but they may cause rounding error of around 1 part per million,
// which could in theory cause minor graphical glitches with broken
// OpenGL implementations. --achurch
const float incX = percentX / (float)(xDivs-1);
const float incY = percentY / (float)(yDivs-1);
const float w = this->getWidth();
const float h = this->getHeight();
const float red = this->color.x;
const float green = this->color.y;
const float blue = this->color.z;
const float alpha = this->alpha.x * this->alphaMod;
glBegin(GL_QUADS);
float u0 = baseX;
float u1 = u0 + incX;
for (size_t i = 0; i < (xDivs-1); i++, u0 = u1, u1 += incX)
{
float v0 = 1 - percentY + baseY;
float v1 = v0 + incY;
for (size_t j = 0; j < (yDivs-1); j++, v0 = v1, v1 += incY)
{
if (drawGrid[i][j].z != 0 || drawGrid[i][j+1].z != 0 || drawGrid[i+1][j].z != 0 || drawGrid[i+1][j+1].z != 0)
{
glColor4f(red, green, blue, alpha*drawGrid[i][j].z);
glTexCoord2f(u0, v0);
glVertex2f(w*drawGrid[i][j].x, h*drawGrid[i][j].y);
glColor4f(red, green, blue, alpha*drawGrid[i][j+1].z);
glTexCoord2f(u0, v1);
glVertex2f(w*drawGrid[i][j+1].x, h*drawGrid[i][j+1].y);
glColor4f(red, green, blue, alpha*drawGrid[i+1][j+1].z);
glTexCoord2f(u1, v1);
glVertex2f(w*drawGrid[i+1][j+1].x, h*drawGrid[i+1][j+1].y);
glColor4f(red, green, blue, alpha*drawGrid[i+1][j].z);
glTexCoord2f(u1, v0);
glVertex2f(w*drawGrid[i+1][j].x, h*drawGrid[i+1][j].y);
}
}
}
glEnd();
// debug points
if (RenderObject::renderCollisionShape)
{
glBindTexture(GL_TEXTURE_2D, 0);
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
if(xDivs > 0 && yDivs > 0)
for (size_t i = 0; i < (xDivs-1); i++)
{
for (size_t j = 0; j < (yDivs-1); j++)
{
glVertex2f(w*drawGrid[i][j].x, h*drawGrid[i][j].y);
glVertex2f(w*drawGrid[i][j+1].x, h*drawGrid[i][j+1].y);
glVertex2f(w*drawGrid[i+1][j+1].x, h*drawGrid[i+1][j+1].y);
glVertex2f(w*drawGrid[i+1][j].x, h*drawGrid[i+1][j].y);
}
}
glEnd();
if (texture)
glBindTexture(GL_TEXTURE_2D, texture->textures[0]);
}
}
void Quad::repeatTextureToFill(bool on)
{
repeatingTextureToFill = on;
repeatTexture = on;
refreshRepeatTextureToFill();
}
void Quad::onRender()
{
if (!renderQuad) return;
float _w2 = width/2.0f;
float _h2 = height/2.0f;
if (!strip.empty())
{
const float texBits = 1.0f / (strip.size()-1);
glBegin(GL_QUAD_STRIP);
if (!stripVert)
{
for (size_t i = 0; i < strip.size(); i++)
{
glTexCoord2f(texBits*i, 0);
glVertex2f(strip[i].x*width-_w2, strip[i].y*_h2*10 - _h2);
glTexCoord2f(texBits*i, 1);
glVertex2f(strip[i].x*width-_w2, strip[i].y*_h2*10 + _h2);
}
}
glEnd();
glBindTexture( GL_TEXTURE_2D, 0 );
glColor4f(1,0,0,1);
glPointSize(64);
glBegin(GL_POINTS);
for (size_t i = 0; i < strip.size(); i++)
{
glVertex2f((strip[i].x*width)-_w2, strip[i].y*height);
}
glEnd();
}
else
{
if (!drawGrid)
{
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();
}
}
if (renderBorder)
{
glLineWidth(2);
glBindTexture(GL_TEXTURE_2D, 0);
glColor4f(renderBorderColor.x, renderBorderColor.y, renderBorderColor.z, borderAlpha*alpha.x*alphaMod);
if (renderCenter)
{
glPointSize(16);
glBegin(GL_POINTS);
glVertex2f(0,0);
glEnd();
}
glColor4f(renderBorderColor.x, renderBorderColor.y, renderBorderColor.z, 1*alpha.x*alphaMod);
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;
}
}
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 (repeatingTextureToFill && 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();
refreshRepeatTextureToFill();
lowerRightTextureCoordinates.update(dt);
upperLeftTextureCoordinates.update(dt);
if (drawGrid && alpha.x > 0 && alphaMod > 0)
{
updateGrid(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)
{
addType(SCO_PAUSEQUAD);
}
void PauseQuad::onUpdate(float dt)
{
if (core->particlesPaused <= pauseLevel)
{
Quad::onUpdate(dt);
}
}
Reference in a new issue View git blame Copy permalink