mkxp-freebird/src/plane.cpp

261 lines
4.5 KiB
C++
Raw Normal View History

2013-09-01 14:27:21 +00:00
/*
** plane.cpp
**
** This file is part of mkxp.
**
** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
**
** mkxp 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.
**
** mkxp 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 mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "plane.h"
#include "sharedstate.h"
2013-09-01 14:27:21 +00:00
#include "bitmap.h"
#include "etc.h"
#include "util.h"
#include "gl-util.h"
#include "quad.h"
#include "transform.h"
#include "etc-internal.h"
#include "shader.h"
#include "glstate.h"
#include <sigc++/connection.h>
2013-09-01 14:27:21 +00:00
struct PlanePrivate
{
Bitmap *bitmap;
NormValue opacity;
BlendType blendType;
Color *color;
Tone *tone;
int ox, oy;
float zoomX, zoomY;
Scene::Geometry sceneGeo;
bool quadSourceDirty;
Quad quad;
EtcTemps tmp;
sigc::connection prepareCon;
2013-09-01 14:27:21 +00:00
PlanePrivate()
: bitmap(0),
opacity(255),
blendType(BlendNormal),
color(&tmp.color),
tone(&tmp.tone),
ox(0), oy(0),
zoomX(1), zoomY(1),
quadSourceDirty(false)
{
prepareCon = shState->prepareDraw.connect
(sigc::mem_fun(this, &PlanePrivate::prepare));
}
~PlanePrivate()
{
prepareCon.disconnect();
}
2013-09-01 14:27:21 +00:00
void updateQuadSource()
{
FloatRect srcRect;
srcRect.x = (sceneGeo.yOrigin + ox) / zoomX;
srcRect.y = (sceneGeo.xOrigin + oy) / zoomY;
srcRect.w = sceneGeo.rect.w / zoomX;
srcRect.h = sceneGeo.rect.h / zoomY;
quad.setTexRect(srcRect);
}
void prepare()
{
if (quadSourceDirty)
{
updateQuadSource();
quadSourceDirty = false;
}
if (bitmap)
bitmap->flush();
}
2013-09-01 14:27:21 +00:00
};
Plane::Plane(Viewport *viewport)
: ViewportElement(viewport)
{
p = new PlanePrivate();
onGeometryChange(scene->getGeometry());
}
#define DISP_CLASS_NAME "plane"
DEF_ATTR_RD_SIMPLE(Plane, Bitmap, Bitmap*, p->bitmap)
DEF_ATTR_RD_SIMPLE(Plane, OX, int, p->ox)
DEF_ATTR_RD_SIMPLE(Plane, OY, int, p->oy)
DEF_ATTR_RD_SIMPLE(Plane, ZoomX, float, p->zoomX)
DEF_ATTR_RD_SIMPLE(Plane, ZoomY, float, p->zoomY)
DEF_ATTR_RD_SIMPLE(Plane, BlendType, int, p->blendType)
2013-09-01 14:27:21 +00:00
DEF_ATTR_SIMPLE(Plane, Opacity, int, p->opacity)
DEF_ATTR_SIMPLE(Plane, Color, Color*, p->color)
DEF_ATTR_SIMPLE(Plane, Tone, Tone*, p->tone)
Plane::~Plane()
{
dispose();
}
void Plane::setBitmap(Bitmap *value)
{
GUARD_DISPOSED;
p->bitmap = value;
2013-09-28 19:48:02 +00:00
if (!value)
return;
value->ensureNonMega();
}
2013-09-01 14:27:21 +00:00
void Plane::setOX(int value)
{
GUARD_DISPOSED
p->ox = value;
p->quadSourceDirty = true;
}
void Plane::setOY(int value)
{
GUARD_DISPOSED
p->oy = value;
p->quadSourceDirty = true;
}
void Plane::setZoomX(float value)
{
GUARD_DISPOSED
p->zoomX = value;
p->quadSourceDirty = true;
}
void Plane::setZoomY(float value)
{
GUARD_DISPOSED
p->zoomY = value;
p->quadSourceDirty = true;
}
void Plane::setBlendType(int value)
{
GUARD_DISPOSED
switch (value)
{
default :
case BlendNormal :
p->blendType = BlendNormal;
return;
case BlendAddition :
p->blendType = BlendAddition;
return;
case BlendSubstraction :
p->blendType = BlendSubstraction;
return;
}
}
void Plane::draw()
{
if (!p->bitmap)
return;
if (p->bitmap->isDisposed())
return;
if (!p->opacity)
return;
ShaderBase *base;
2013-09-01 14:27:21 +00:00
if (p->color->hasEffect() || p->tone->hasEffect() || p->opacity != 255)
{
PlaneShader &shader = shState->planeShader();
2013-09-01 14:27:21 +00:00
shader.bind();
shader.applyViewportProj();
2013-09-01 14:27:21 +00:00
shader.setTone(p->tone->norm);
shader.setColor(p->color->norm);
shader.setFlash(Vec4());
shader.setOpacity(p->opacity.norm);
base = &shader;
}
else
{
SimpleShader &shader = shState->simpleShader();
shader.bind();
shader.applyViewportProj();
shader.setTranslation(Vec2i());
base = &shader;
2013-09-01 14:27:21 +00:00
}
glState.blendMode.pushSet(p->blendType);
p->bitmap->bindTex(*base);
2013-09-06 10:26:41 +00:00
TEX::setRepeat(true);
2013-09-01 14:27:21 +00:00
p->quad.draw();
2013-09-06 10:26:41 +00:00
TEX::setRepeat(false);
glState.blendMode.pop();
2013-09-01 14:27:21 +00:00
}
void Plane::onGeometryChange(const Scene::Geometry &geo)
{
p->quad.setPosRect(FloatRect(geo.rect));
p->sceneGeo = geo;
p->quadSourceDirty = true;
}
void Plane::aboutToAccess() const
{
GUARD_DISPOSED
}
void Plane::releaseResources()
{
unlink();
delete p;
}