mkxp/src/sprite.cpp

/*
** sprite.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 "sprite.h"

#include "sharedstate.h"
#include "bitmap.h"
#include "etc.h"
#include "etc-internal.h"
#include "util.h"

#include "gl-util.h"
#include "quad.h"
#include "transform.h"
#include "shader.h"
#include "glstate.h"
#include "quadarray.h"

#include <math.h>

#include <SDL_rect.h>

#include <sigc++/connection.h>

struct SpritePrivate
{
	Bitmap *bitmap;

	Quad quad;
	Transform trans;

	Rect *srcRect;
	sigc::connection srcRectCon;

	bool mirrored;
	int bushDepth;
	float efBushDepth;
	NormValue bushOpacity;
	NormValue opacity;
	BlendType blendType;

	SDL_Rect sceneRect;

	/* Would this sprite be visible on
	 * the screen if drawn? */
	bool isVisible;

	Color *color;
	Tone *tone;

	struct
	{
		int amp;
		int length;
		int speed;
		float phase;

		/* Wave effect is active (amp != 0) */
		bool active;
		/* qArray needs updating */
		bool dirty;
		SimpleQuadArray qArray;
	} wave;

	EtcTemps tmp;

	sigc::connection prepareCon;

	SpritePrivate()
	    : bitmap(0),
	      srcRect(&tmp.rect),
	      mirrored(false),
	      bushDepth(0),
	      efBushDepth(0),
	      bushOpacity(128),
	      opacity(255),
	      blendType(BlendNormal),
	      isVisible(false),
	      color(&tmp.color),
	      tone(&tmp.tone)

	{
		sceneRect.x = sceneRect.y = 0;

		updateSrcRectCon();

		prepareCon = shState->prepareDraw.connect
		        (sigc::mem_fun(this, &SpritePrivate::prepare));

		wave.amp = 0;
		wave.length = 180;
		wave.speed = 360;
		wave.phase = 0.0;
		wave.dirty = false;
	}

	~SpritePrivate()
	{
		srcRectCon.disconnect();
		prepareCon.disconnect();
	}

	void recomputeBushDepth()
	{
		if (!bitmap)
			return;

		/* Calculate effective (normalized) bush depth */
		float texBushDepth = (bushDepth / trans.getScale().y) -
		                     (srcRect->y + srcRect->height) +
		                     bitmap->height();

		efBushDepth = 1.0 - texBushDepth / bitmap->height();
	}

	void onSrcRectChange()
	{
		if (mirrored)
			quad.setTexRect(srcRect->toFloatRect().hFlipped());
		else
			quad.setTexRect(srcRect->toFloatRect());

		quad.setPosRect(IntRect(0, 0, srcRect->width, srcRect->height));
		recomputeBushDepth();

		wave.dirty = true;
	}

	void updateSrcRectCon()
	{
		/* Cut old connection */
		srcRectCon.disconnect();
		/* Create new one */
		srcRectCon = srcRect->valueChanged.connect
				(sigc::mem_fun(this, &SpritePrivate::onSrcRectChange));
	}

	void updateVisibility()
	{
		isVisible = false;

		if (nullOrDisposed(bitmap))
			return;

		if (!opacity)
			return;

		if (wave.active)
		{
			/* Don't do expensive wave bounding box
			 * calculations */
			isVisible = true;
			return;
		}

		/* Compare sprite bounding box against the scene */

		/* If sprite is zoomed/rotated, just opt out for now
		 * for simplicity's sake */
		const Vec2 &scale = trans.getScale();
		if (scale.x != 1 || scale.y != 1 || trans.getRotation() != 0)
		{
			isVisible = true;
			return;
		}

		SDL_Rect self;
		self.x = trans.getPosition().x - trans.getOrigin().x;
		self.y = trans.getPosition().y - trans.getOrigin().y;
		self.w = bitmap->width();
		self.h = bitmap->height();

		isVisible = SDL_HasIntersection(&self, &sceneRect);
	}

	void emitWaveChunk(SVertex *&vert, float phase, int width,
	                   float zoomY, int chunkY, int chunkLength)
	{
		float wavePos = phase + (chunkY / (float) wave.length) * M_PI * 2;
		float chunkX = sin(wavePos) * wave.amp;

		FloatRect tex(0, chunkY / zoomY, width, chunkLength / zoomY);
		FloatRect pos = tex;
		pos.x = chunkX;

		Quad::setTexPosRect(vert, tex, pos);
		vert += 4;
	}

	void updateWave()
	{
		if (nullOrDisposed(bitmap))
			return;

		if (wave.amp == 0)
		{
			wave.active = false;
			return;
		}

		wave.active = true;

		int width = srcRect->width;
		int height = srcRect->height;
		float zoomY = trans.getScale().y;

		if (wave.amp < -(width / 2))
		{
			wave.qArray.resize(0);
			wave.qArray.commit();

			return;
		}

		/* RMVX does this, and I have no fucking clue why */
		if (wave.amp < 0)
		{
			wave.qArray.resize(1);

			int x = -wave.amp;
			int w = width - x * 2;

			FloatRect tex(x, srcRect->y, w, srcRect->height);

			Quad::setTexPosRect(&wave.qArray.vertices[0], tex, tex);
			wave.qArray.commit();

			return;
		}

		/* The length of the sprite as it appears on screen */
		int visibleLength = height * zoomY;

		/* First chunk length (aligned to 8 pixel boundary */
		int firstLength = ((int) trans.getPosition().y) % 8;

		/* Amount of full 8 pixel chunks in the middle */
		int chunks = (visibleLength - firstLength) / 8;

		/* Final chunk length */
		int lastLength = (visibleLength - firstLength) % 8;

		wave.qArray.resize(!!firstLength + chunks + !!lastLength);
		SVertex *vert = &wave.qArray.vertices[0];

		float phase = (wave.phase * M_PI) / 180.f;

		if (firstLength > 0)
			emitWaveChunk(vert, phase, width, zoomY, 0, firstLength);

		for (int i = 0; i < chunks; ++i)
			emitWaveChunk(vert, phase, width, zoomY, firstLength + i * 8, 8);

		if (lastLength > 0)
			emitWaveChunk(vert, phase, width, zoomY, firstLength + chunks * 8, lastLength);

		wave.qArray.commit();
	}

	void prepare()
	{
		if (wave.dirty)
		{
			updateWave();
			wave.dirty = false;
		}

		updateVisibility();
	}
};

Sprite::Sprite(Viewport *viewport)
    : ViewportElement(viewport)
{
	p = new SpritePrivate;
	onGeometryChange(scene->getGeometry());
}

Sprite::~Sprite()
{
	dispose();
}

DEF_ATTR_RD_SIMPLE(Sprite, Bitmap,     Bitmap*, p->bitmap)
DEF_ATTR_RD_SIMPLE(Sprite, X,          int,     p->trans.getPosition().x)
DEF_ATTR_RD_SIMPLE(Sprite, Y,          int,     p->trans.getPosition().y)
DEF_ATTR_RD_SIMPLE(Sprite, OX,         int,     p->trans.getOrigin().x)
DEF_ATTR_RD_SIMPLE(Sprite, OY,         int,     p->trans.getOrigin().y)
DEF_ATTR_RD_SIMPLE(Sprite, ZoomX,      float,   p->trans.getScale().x)
DEF_ATTR_RD_SIMPLE(Sprite, ZoomY,      float,   p->trans.getScale().y)
DEF_ATTR_RD_SIMPLE(Sprite, Angle,      float,   p->trans.getRotation())
DEF_ATTR_RD_SIMPLE(Sprite, Mirror,     bool,    p->mirrored)
DEF_ATTR_RD_SIMPLE(Sprite, BushDepth,  int,     p->bushDepth)
DEF_ATTR_RD_SIMPLE(Sprite, BlendType,  int,     p->blendType)
DEF_ATTR_RD_SIMPLE(Sprite, Width,      int,     p->srcRect->width)
DEF_ATTR_RD_SIMPLE(Sprite, Height,     int,     p->srcRect->height)
DEF_ATTR_RD_SIMPLE(Sprite, WaveAmp,    int,     p->wave.amp)
DEF_ATTR_RD_SIMPLE(Sprite, WaveLength, int,     p->wave.length)
DEF_ATTR_RD_SIMPLE(Sprite, WaveSpeed,  int,     p->wave.speed)
DEF_ATTR_RD_SIMPLE(Sprite, WavePhase,  float,   p->wave.phase)

DEF_ATTR_SIMPLE   (Sprite, BushOpacity, int,    p->bushOpacity)
DEF_ATTR_SIMPLE   (Sprite, Opacity,     int,    p->opacity)

DEF_ATTR_OBJ_VALUE(Sprite, SrcRect,     Rect*,  p->srcRect)
DEF_ATTR_OBJ_VALUE(Sprite, Color,       Color*, p->color)
DEF_ATTR_OBJ_VALUE(Sprite, Tone,        Tone*,  p->tone)

void Sprite::setBitmap(Bitmap *bitmap)
{
	guardDisposed();

	if (p->bitmap == bitmap)
		return;

	p->bitmap = bitmap;

	if (!bitmap)
		return;

	bitmap->ensureNonMega();

	*p->srcRect = bitmap->rect();
	p->onSrcRectChange();
	p->quad.setPosRect(p->srcRect->toFloatRect());

	p->wave.dirty = true;
}

void Sprite::setX(int value)
{
	guardDisposed();

	if (p->trans.getPosition().x == value)
		return;

	p->trans.setPosition(Vec2(value, getY()));
}

void Sprite::setY(int value)
{
	guardDisposed();

	if (p->trans.getPosition().y == value)
		return;

	p->trans.setPosition(Vec2(getX(), value));

	if (rgssVer >= 2)
	{
		p->wave.dirty = true;
		setSpriteY(value);
	}
}

void Sprite::setOX(int value)
{
	guardDisposed();

	if (p->trans.getOrigin().x == value)
		return;

	p->trans.setOrigin(Vec2(value, getOY()));
}

void Sprite::setOY(int value)
{
	guardDisposed();

	if (p->trans.getOrigin().y == value)
		return;

	p->trans.setOrigin(Vec2(getOX(), value));
}

void Sprite::setZoomX(float value)
{
	guardDisposed();

	if (p->trans.getScale().x == value)
		return;

	p->trans.setScale(Vec2(value, getZoomY()));
}

void Sprite::setZoomY(float value)
{
	guardDisposed();

	if (p->trans.getScale().y == value)
		return;

	p->trans.setScale(Vec2(getZoomX(), value));
	p->recomputeBushDepth();

	if (rgssVer >= 2)
		p->wave.dirty = true;
}

void Sprite::setAngle(float value)
{
	guardDisposed();

	if (p->trans.getRotation() == value)
		return;

	p->trans.setRotation(value);
}

void Sprite::setMirror(bool mirrored)
{
	guardDisposed();

	if (p->mirrored == mirrored)
		return;

	p->mirrored = mirrored;
	p->onSrcRectChange();
}

void Sprite::setBushDepth(int value)
{
	guardDisposed();

	if (p->bushDepth == value)
		return;

	p->bushDepth = value;
	p->recomputeBushDepth();
}

void Sprite::setBlendType(int type)
{
	guardDisposed();

	switch (type)
	{
	default :
	case BlendNormal :
		p->blendType = BlendNormal;
		return;
	case BlendAddition :
		p->blendType = BlendAddition;
		return;
	case BlendSubstraction :
		p->blendType = BlendSubstraction;
		return;
	}
}

#define DEF_WAVE_SETTER(Name, name, type) \
	void Sprite::setWave##Name(type value) \
	{ \
		guardDisposed(); \
		if (p->wave.name == value) \
			return; \
		p->wave.name = value; \
		p->wave.dirty = true; \
	}

DEF_WAVE_SETTER(Amp,    amp,    int)
DEF_WAVE_SETTER(Length, length, int)
DEF_WAVE_SETTER(Speed,  speed,  int)
DEF_WAVE_SETTER(Phase,  phase,  float)

#undef DEF_WAVE_SETTER

void Sprite::initDynAttribs()
{
	p->srcRect = new Rect;
	p->color = new Color;
	p->tone = new Tone;

	p->updateSrcRectCon();
}

/* Flashable */
void Sprite::update()
{
	guardDisposed();

	Flashable::update();

	p->wave.phase += p->wave.speed / 180;
	p->wave.dirty = true;
}

/* SceneElement */
void Sprite::draw()
{
	if (!p->isVisible)
		return;

	if (emptyFlashFlag)
		return;

	ShaderBase *base;

	bool renderEffect = p->color->hasEffect() ||
	                    p->tone->hasEffect()  ||
	                    p->opacity != 255     ||
	                    flashing              ||
	                    p->bushDepth != 0;

	if (renderEffect)
	{
		SpriteShader &shader = shState->shaders().sprite;

		shader.bind();
		shader.applyViewportProj();
		shader.setSpriteMat(p->trans.getMatrix());

		shader.setTone(p->tone->norm);
		shader.setOpacity(p->opacity.norm);
		shader.setBushDepth(p->efBushDepth);
		shader.setBushOpacity(p->bushOpacity.norm);

		/* When both flashing and effective color are set,
		 * the one with higher alpha will be blended */
		const Vec4 *blend = (flashing && flashColor.w > p->color->norm.w) ?
			                 &flashColor : &p->color->norm;

		shader.setColor(*blend);

		base = &shader;
	}
	else
	{
		SimpleSpriteShader &shader = shState->shaders().simpleSprite;
		shader.bind();

		shader.setSpriteMat(p->trans.getMatrix());
		shader.applyViewportProj();
		base = &shader;
	}

	glState.blendMode.pushSet(p->blendType);

	p->bitmap->bindTex(*base);

	if (p->wave.active)
		p->wave.qArray.draw();
	else
		p->quad.draw();

	glState.blendMode.pop();
}

void Sprite::onGeometryChange(const Scene::Geometry &geo)
{
	/* Offset at which the sprite will be drawn
	 * relative to screen origin */
	int xOffset = geo.rect.x - geo.xOrigin;
	int yOffset = geo.rect.y - geo.yOrigin;

	p->trans.setGlobalOffset(xOffset, yOffset);

	p->sceneRect.w = geo.rect.w;
	p->sceneRect.h = geo.rect.h;
}

void Sprite::releaseResources()
{
	unlink();

	delete p;
}