mkxp/src/windowvx.cpp

/*
** window-vx.cpp
**
** This file is part of mkxp.
**
** Copyright (C) 2014 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 "windowvx.h"

#include "bitmap.h"
#include "etc.h"
#include "etc-internal.h"
#include "quad.h"
#include "quadarray.h"
#include "sharedstate.h"
#include "texpool.h"
#include "tilequad.h"
#include "glstate.h"
#include "shader.h"

#include <limits>
#include <algorithm>
#include <sigc++/connection.h>

#define DEF_Z         (rgssVer >= 3 ? 100 :   0)
#define DEF_PADDING   (rgssVer >= 3 ?  12 :  16)
#define DEF_BACK_OPAC (rgssVer >= 3 ? 192 : 255)
#define DEF_SPRITE_Y  (rgssVer >= 3 ? std::numeric_limits<int>::max() : 0) /* See scene.h */

template<typename T>
struct Sides
{
	T l, r, t, b;
};

template<typename T>
struct Corners
{
	T tl, tr, bl, br;
};

/* Offsetting this by one gives a great visual improvement
 * in Majo no Ie */
static const IntRect bgStretchSrc( 1,  1, 62, 62 );
static const IntRect bgTileSrc   ( 0, 64, 64, 64 );

static const Corners<IntRect> cornerSrc =
{
	IntRect(  64,  0, 16, 16 ),
	IntRect( 112,  0, 16, 16 ),
	IntRect(  64, 48, 16, 16 ),
	IntRect( 112, 48, 16, 16 )
};

static const Sides<IntRect> borderSrc =
{
	IntRect(  64, 16, 16, 32 ),
	IntRect( 112, 16, 16, 32 ),
	IntRect(  80,  0, 32, 16 ),
	IntRect(  80, 48, 32, 16 )
};

static const Sides<IntRect> scrollArrowSrc =
{
	IntRect(  80, 24,  8, 16 ),
	IntRect( 104, 24,  8, 16 ),
	IntRect(  88, 16, 16,  8 ),
	IntRect(  88, 40, 16,  8 )
};

static const IntRect pauseSrc[4] =
{
	IntRect(  96, 64, 16, 16 ),
	IntRect( 112, 64, 16, 16 ),
	IntRect(  96, 80, 16, 16 ),
	IntRect( 112, 80, 16, 16 )
};

struct CursorSrc
{
	Corners<IntRect> corners;
	Sides<IntRect> border;
	IntRect bg;
};

static const CursorSrc cursorSrc =
{
	{
		IntRect( 64, 64, 4, 4 ),
		IntRect( 92, 64, 4, 4 ),
		IntRect( 64, 92, 4, 4 ),
		IntRect( 92, 92, 4, 4 )
	},
	{
		IntRect( 64, 68,  4, 24 ),
		IntRect( 92, 68,  4, 24 ),
		IntRect( 68, 64, 24,  4 ),
		IntRect( 68, 92, 24,  4 )
	},
	IntRect( 68, 68, 24, 24 )
};

static const uint8_t cursorAlpha[] =
{
	/* Fade out */
	0xFF, 0xF7, 0xEF, 0xE7, 0xDF, 0xD7, 0xCF, 0xC7, 0xBF, 0xB7,
	0xAF, 0xA7, 0x9F, 0x97, 0x8F, 0x87, 0x7F, 0x77, 0x6F, 0x67,
	/* Fade in */
	0x5F, 0x67, 0x6F, 0x77, 0x7F, 0x87, 0x8F, 0x97, 0x9F, 0xA7,
	0xAF, 0xB7, 0xBF, 0xC7, 0xCF, 0xD7, 0xDF, 0xE7, 0xEF, 0xF7
};

static elementsN(cursorAlpha);

static const uint8_t cursorAlphaResetIdx = 0x10;

/* No cycle */
static const uint8_t pauseAlpha[] =
{
	0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xE0,
	0xFF
};

static elementsN(pauseAlpha);

/* Cycling */
static const uint8_t pauseQuad[] =
{
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
};

static elementsN(pauseQuad);

typedef DisposeWatch<WindowVXPrivate, Bitmap> BitmapWatch;

struct WindowVXPrivate
{
	Bitmap *windowskin;
	BitmapWatch windowskinWatch;

	Bitmap *contents;
	BitmapWatch contentsWatch;

	Rect *cursorRect;
	bool active;
	bool arrowsVisible;
	bool pause;

	/* Externally visible width/height */
	int width, height;

	/* Window geometry (x, Y, width, height)
	 * with non-negative size */
	IntRect geo;

	/* ox / oy */
	Vec2i contentsOff;

	int padding;
	int paddingBottom;

	NormValue opacity;
	NormValue backOpacity;
	NormValue contentsOpacity;

	NormValue openness;
	Tone *tone;

	sigc::connection cursorRectCon;
	sigc::connection toneCon;
	sigc::connection prepareCon;

	EtcTemps tmp;

	struct
	{
		TEXFBO tex;
		ColorQuadArray vert;
		size_t bgTileQuads;
		size_t borderQuads;
		Quad quad;

		bool vertDirty;
		bool texSizeDirty;
		bool texDirty;
	} base;

	ColorQuadArray ctrlVert;
	size_t ctrlQuads;
	Vertex *pauseVert;

	Quad contentsQuad;

	IntRect padRect;
	IntRect clipRect;

	ColorQuadArray cursorVert;

	bool ctrlVertDirty;
	bool ctrlVertArrayDirty;
	bool clipRectDirty;
	bool cursorVertDirty;
	bool cursorVertArrayDirty;

	uint8_t pauseAlphaIdx;
	uint8_t pauseQuadIdx;
	uint8_t cursorAlphaIdx;

	Vec2i sceneOffset;

	WindowVXPrivate(int x, int y, int w, int h)
	    : windowskin(0),
	      windowskinWatch(*this, windowskin),
	      contents(0),
	      contentsWatch(*this, contents),
	      cursorRect(&tmp.rect),
	      active(true),
	      arrowsVisible(true),
	      pause(false),
	      width(w),
	      height(h),
	      geo(x, y, w, h),
	      padding(DEF_PADDING),
	      paddingBottom(padding),
	      opacity(255),
	      backOpacity(DEF_BACK_OPAC),
	      contentsOpacity(255),
	      openness(255),
	      tone(&tmp.tone),
	      pauseAlphaIdx(0),
	      pauseQuadIdx(0),
	      cursorAlphaIdx(0)
	{
		/* 4 scroll arrows + pause */
		ctrlVert.resize(4 + 1);
		pauseVert = &ctrlVert.vertices[4*4];

		base.vertDirty = true;
		base.texSizeDirty = true;
		base.texDirty = true;
		ctrlVertDirty = true;
		clipRectDirty = true;

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

		refreshCursorRectCon();
		updateBaseQuad();
	}

	~WindowVXPrivate()
	{
		shState->texPool().release(base.tex);

		cursorRectCon.disconnect();
		toneCon.disconnect();
		prepareCon.disconnect();
	}

	void invalidateCursorVert()
	{
		cursorVertDirty = true;
	}

	void invalidateBaseTex()
	{
		base.texDirty = true;
	}

	void refreshCursorRectCon()
	{
		cursorRectCon.disconnect();
		cursorRectCon = cursorRect->valueChanged.connect
		        (sigc::mem_fun(this, &WindowVXPrivate::invalidateCursorVert));
	}

	void refreshToneCon()
	{
		toneCon.disconnect();
		toneCon = tone->valueChanged.connect
			(sigc::mem_fun(this, &WindowVXPrivate::invalidateBaseTex));
	}

	void updateBaseTexSize()
	{
		if (base.tex.width >= geo.w && base.tex.height >= geo.h)
			return;

		if (base.tex.tex != TEX::ID(0))
		{
			TEX::bind(base.tex.tex);
			TEX::setSmooth(false); // XXX make pool set this up at alloc time
		}

		shState->texPool().release(base.tex);
		TEXFBO::clear(base.tex);

		if (geo.w == 0 || geo.h == 0)
			return;

		base.tex = shState->texPool().request(geo.w, geo.h);
		TEX::bind(base.tex.tex);
		TEX::setSmooth(true);
	}

	void rebuildBaseVert()
	{
		if (geo.w == 0 || geo.h == 0)
		{
			base.vert.clear();
			base.vert.commit();

			return;
		}

		const IntRect bgPos(2, 2, geo.w-4, geo.h-4);
		size_t count = 0;

		/* Stretched layer (1) */
		count += 1;

		/* Tiled layer (2) */
		base.bgTileQuads = TileQuads::twoDimCount(bgTileSrc.w, bgTileSrc.h, bgPos.w, bgPos.h);
		count += base.bgTileQuads;

		const Vec2 corOff(geo.w - 16, geo.h - 16);

		const Corners<FloatRect> cornerPos =
		{
			FloatRect(        0,        0, 16, 16 ), /* Top left */
			FloatRect( corOff.x,        0, 16, 16 ), /* Top right */
			FloatRect(        0, corOff.y, 16, 16 ), /* Bottom left */
			FloatRect( corOff.x, corOff.y, 16, 16 )  /* Bottom right */
		};

		const Vec2i sideLen(geo.w - 16*2, geo.h - 16*2);

		bool drawSidesLR = sideLen.x > 0;
		bool drawSidesTB = sideLen.y > 0;

		base.borderQuads = 0;
		base.borderQuads += 4; /* 4 corners */

		if (drawSidesLR)
			base.borderQuads += TileQuads::oneDimCount(32, sideLen.y) * 2;

		if (drawSidesTB)
			base.borderQuads += TileQuads::oneDimCount(32, sideLen.x) * 2;

		count += base.borderQuads;

		base.vert.resize(count);

		Vertex *vert = &base.vert.vertices[0];
		size_t i = 0;

		/* Stretched background */
		i += Quad::setTexPosRect(&vert[i*4], bgStretchSrc, bgPos);

		/* Tiled background */
		i += TileQuads::build(bgTileSrc, bgPos, &vert[i*4]);

		/* Corners */
		i += Quad::setTexPosRect(&vert[i*4], cornerSrc.tl, cornerPos.tl);
		i += Quad::setTexPosRect(&vert[i*4], cornerSrc.tr, cornerPos.tr);
		i += Quad::setTexPosRect(&vert[i*4], cornerSrc.bl, cornerPos.bl);
		i += Quad::setTexPosRect(&vert[i*4], cornerSrc.br, cornerPos.br);

		/* Sides */
		if (drawSidesLR)
		{
			i += TileQuads::buildV(borderSrc.l, sideLen.y,        0,       16, &vert[i*4]);
			i += TileQuads::buildV(borderSrc.r, sideLen.y, corOff.x,       16, &vert[i*4]);
		}

		if (drawSidesTB)
		{
			i += TileQuads::buildH(borderSrc.t, sideLen.x,       16,        0, &vert[i*4]);
			i += TileQuads::buildH(borderSrc.b, sideLen.x,       16, corOff.y, &vert[i*4]);
		}

		base.vert.commit();
	}

	void redrawBaseTex()
	{
		if (!windowskin)
			return;

		if (base.tex.tex == TEX::ID(0))
			return;

		FBO::bind(base.tex.fbo);

		/* Clear texture */
		glState.clearColor.pushSet(Vec4());
		FBO::clear();
		glState.clearColor.pop();

		glState.viewport.pushSet(IntRect(0, 0, base.tex.width, base.tex.height));
		glState.blend.pushSet(false);

		ShaderBase *shader;

		if (backOpacity < 255 || tone->hasEffect())
		{
			PlaneShader &planeShader = shState->shaders().plane;
			planeShader.bind();

			planeShader.setColor(Vec4());
			planeShader.setFlash(Vec4());
			planeShader.setTone(tone->norm);
			planeShader.setOpacity(backOpacity.norm);

			shader = &planeShader;
		}
		else
		{
			shader = &shState->shaders().simple;
			shader->bind();
		}

		windowskin->bindTex(*shader);
		TEX::setSmooth(true);

		shader->setTranslation(Vec2i());
		shader->applyViewportProj();

		/* Draw stretched layer */
		base.vert.draw(0, 1);

		glState.blend.set(true);
		glState.blendMode.pushSet(BlendKeepDestAlpha);

		/* Draw tiled layer */
		base.vert.draw(1, base.bgTileQuads);

		glState.blendMode.set(BlendNormal);

		/* If we used plane shader before, switch to simple */
		if (shader != &shState->shaders().simple)
		{
			shader = &shState->shaders().simple;
			shader->bind();
			shader->setTranslation(Vec2i());
			shader->applyViewportProj();
			windowskin->bindTex(*shader);
		}

		base.vert.draw(1+base.bgTileQuads, base.borderQuads);

		TEX::setSmooth(false);

		glState.blendMode.pop();
		glState.blend.pop();
		glState.viewport.pop();
	}

	void updateBaseQuad()
	{
		const FloatRect tex(0, 0, geo.w, geo.h);
		const FloatRect pos(0, (geo.h / 2.0) * (1 - openness.norm),
		                    geo.w, geo.h * openness.norm);

		base.quad.setTexPosRect(tex, pos);
	}

	void updateClipRect()
	{
		SDL_Rect winRect = { 0, 0, geo.w, geo.h };

		padRect.x = padRect.y = padding;
		padRect.w = std::max(0, geo.w - padding*2);
		padRect.h = std::max(0, geo.h - (padding+paddingBottom));

		SDL_Rect tmp = padRect;

		SDL_IntersectRect(&winRect, &tmp, &tmp);
		clipRect = IntRect(tmp.x, tmp.y, tmp.w, tmp.h);

		ctrlVertDirty = true;
	}

	void rebuildCtrlVert()
	{
		const int arrowTBX = (geo.w - 16) / 2;
		const int arrowLRY = (geo.h - 16) / 2;

		const Sides<FloatRect> arrowPos =
		{
			FloatRect(          4,   arrowLRY, 8, 16 ), /* Left */
			FloatRect( geo.w - 12,   arrowLRY, 8, 16 ), /* Right */
			FloatRect(   arrowTBX,          4, 16, 8 ), /* Top */
			FloatRect(   arrowTBX, geo.h - 12, 16, 8 )  /* Bottom */
		};

		size_t i = 0;
		Vertex *vert = &ctrlVert.vertices[0];

		if (contents && arrowsVisible)
		{
			if (contentsOff.x > 0)
				i += Quad::setTexPosRect(&vert[i*4], scrollArrowSrc.l, arrowPos.l);
			if (contentsOff.y > 0)
				i += Quad::setTexPosRect(&vert[i*4], scrollArrowSrc.t, arrowPos.t);

			if (padRect.w < (contents->width() - contentsOff.x))
				i += Quad::setTexPosRect(&vert[i*4], scrollArrowSrc.r, arrowPos.r);

			if (padRect.h < (contents->height() - contentsOff.y))
				i += Quad::setTexPosRect(&vert[i*4], scrollArrowSrc.b, arrowPos.b);
		}

		pauseVert = 0;

		if (pause)
		{
			const FloatRect pausePos(arrowTBX, geo.h - 16, 16, 16);
			pauseVert = &vert[i*4];

			i += Quad::setTexPosRect(&vert[i*4], pauseSrc[0], pausePos);
		}

		ctrlQuads = i;
		ctrlVertArrayDirty = true;
	}

	void rebuildCursorVert()
	{
		const IntRect rect = cursorRect->toIntRect();
		const CursorSrc &src = cursorSrc;

		cursorVertArrayDirty = true;

		if (rect.w <= 0 || rect.h <= 0)
		{
			cursorVert.clear();
			return;
		}

		const Vec2 corOff(rect.w - 4, rect.h - 4);

		const Corners<FloatRect> cornerPos =
		{
			FloatRect(        0,        0, 4, 4 ), /* Top left */
			FloatRect( corOff.x,        0, 4, 4 ), /* Top right */
			FloatRect(        0, corOff.y, 4, 4 ), /* Bottom left */
			FloatRect( corOff.x, corOff.y, 4, 4 )  /* Bottom right */
		};

		const Vec2i sideLen(rect.w - 4*2, rect.h - 4*2);

		const Sides<FloatRect> sidePos =
		{
		    FloatRect(        0,        4,         4, sideLen.y ), /* Left */
		    FloatRect( corOff.x,        4,         4, sideLen.y ), /* Right */
		    FloatRect(        4,        0, sideLen.x,         4 ), /* Top */
		    FloatRect(        4, corOff.y, sideLen.x,         4 )  /* Bottom */
		};

		const FloatRect bgPos(4, 4, sideLen.x, sideLen.y);

		bool drawSidesLR = rect.h > 8;
		bool drawSidesTB = rect.w > 8;
		bool drawBg = drawSidesLR && drawSidesTB;

		size_t quads = 0;
		quads += 4; /* 4 corners */

		if (drawSidesLR)
			quads += 2;

		if (drawSidesTB)
			quads += 2;

		if (drawBg)
			quads += 1;

		cursorVert.resize(quads);
		Vertex *vert = &cursorVert.vertices[0];
		size_t i = 0;

		i += Quad::setTexPosRect(&vert[i*4], src.corners.tl, cornerPos.tl);
		i += Quad::setTexPosRect(&vert[i*4], src.corners.tr, cornerPos.tr);
		i += Quad::setTexPosRect(&vert[i*4], src.corners.bl, cornerPos.bl);
		i += Quad::setTexPosRect(&vert[i*4], src.corners.br, cornerPos.br);

		if (drawSidesLR)
		{
			i += Quad::setTexPosRect(&vert[i*4], src.border.l, sidePos.l);
			i += Quad::setTexPosRect(&vert[i*4], src.border.r, sidePos.r);
		}

		if (drawSidesTB)
		{
			i += Quad::setTexPosRect(&vert[i*4], src.border.t, sidePos.t);
			i += Quad::setTexPosRect(&vert[i*4], src.border.b, sidePos.b);
		}

		if (drawBg)
			Quad::setTexPosRect(&vert[i*4], src.bg, bgPos);
	}

	void updatePauseQuad()
	{
		if (!pauseVert)
			return;

		/* Set quad */
		Quad::setTexRect(pauseVert, pauseSrc[pauseQuad[pauseQuadIdx]]);

		/* Set opacity */
		Quad::setColor(pauseVert, Vec4(1, 1, 1, pauseAlpha[pauseAlphaIdx] / 255.0));

		ctrlVertArrayDirty = true;
	}

	void updateCursorAlpha()
	{
		if (cursorVert.count() == 0)
			return;

		Vec4 color(1, 1, 1, cursorAlpha[cursorAlphaIdx] / 255.0);

		for (size_t i = 0; i < cursorVert.count(); ++i)
			Quad::setColor(&cursorVert.vertices[i*4], color);

		cursorVertArrayDirty = true;
	}

	void stepAnimations()
	{
		if (active)
			if (++cursorAlphaIdx == cursorAlphaN)
				cursorAlphaIdx = 0;

		if (pause)
		{
			if (pauseAlphaIdx < pauseAlphaN-1)
				++pauseAlphaIdx;

			if (++pauseQuadIdx == pauseQuadN)
				pauseQuadIdx = 0;
		}
	}

	void prepare()
	{
		if (base.vertDirty)
		{
			rebuildBaseVert();
			base.vertDirty = false;
			base.texDirty = true;
		}

		if (base.texSizeDirty)
		{
			updateBaseTexSize();
			base.texSizeDirty = false;
			base.texDirty = true;
		}

		if (base.texDirty)
		{
			redrawBaseTex();
			base.texDirty = false;
		}

		if (clipRectDirty)
		{
			updateClipRect();
			clipRectDirty = false;
		}

		if (ctrlVertDirty)
		{
			rebuildCtrlVert();
			updatePauseQuad();
			ctrlVertDirty = false;
		}

		if (ctrlVertArrayDirty)
		{
			ctrlVert.commit();
			ctrlVertArrayDirty = false;
		}

		if (cursorVertDirty)
		{
			rebuildCursorVert();
			updateCursorAlpha();
			cursorVertDirty = false;
		}

		if (cursorVertArrayDirty)
		{
			cursorVert.commit();
			cursorVertArrayDirty = false;
		}
	}

	void draw()
	{
		if (base.tex.tex == TEX::ID(0))
			return;

		Vec2i trans(geo.x + sceneOffset.x,
		            geo.y + sceneOffset.y);

		SimpleAlphaShader &shader = shState->shaders().simpleAlpha;
		shader.bind();
		shader.applyViewportProj();

		if (windowskin)
		{
			shader.setTranslation(trans);
			shader.setTexSize(Vec2i(base.tex.width, base.tex.height));

			TEX::bind(base.tex.tex);
			base.quad.draw();

			if (openness < 255)
				return;

			windowskin->bindTex(shader);

			TEX::setSmooth(true);
			ctrlVert.draw(0, ctrlQuads);
			TEX::setSmooth(false);
		}

		if (openness < 255)
			return;

		bool drawCursor = cursorVert.count() > 0 && windowskin;

		if (drawCursor || contents)
		{
			/* Translate cliprect from local into screen space */
			IntRect clip = clipRect;
			clip.x += trans.x;
			clip.y += trans.y;

			glState.scissorBox.push();
			glState.scissorTest.pushSet(true);

			if (rgssVer >= 3)
				glState.scissorBox.setIntersect(clip);
			else
				glState.scissorBox.setIntersect(IntRect(trans.x, trans.y, geo.w, geo.h));

			IntRect pad = padRect;
			pad.x += trans.x;
			pad.y += trans.y;

			if (drawCursor)
			{
				Vec2i contTrans = pad.pos();
				contTrans.x += cursorRect->x;
				contTrans.y += cursorRect->y;

				if (rgssVer >= 3)
				{
					contTrans.x -= contentsOff.x;
					contTrans.y -= contentsOff.y;
				}

				shader.setTranslation(contTrans);

				TEX::setSmooth(true);
				cursorVert.draw();
				TEX::setSmooth(false);
			}

			if (contents)
			{
				if (rgssVer <= 2)
					glState.scissorBox.setIntersect(clip);

				Vec2i contTrans = pad.pos();
				contTrans.x -= contentsOff.x;
				contTrans.y -= contentsOff.y;
				shader.setTranslation(contTrans);

				TEX::setSmooth(false); // XXX
				contents->bindTex(shader);
				contentsQuad.draw();
			}

			glState.scissorBox.pop();
			glState.scissorTest.pop();
		}

		TEX::setSmooth(false); // XXX FIND out a way to eliminate
	}
};

WindowVX::WindowVX(Viewport *viewport)
    : ViewportElement(viewport, DEF_Z, DEF_SPRITE_Y)
{
	p = new WindowVXPrivate(0, 0, 0, 0);
	onGeometryChange(scene->getGeometry());
}

WindowVX::WindowVX(int x, int y, int width, int height)
    : ViewportElement(0, DEF_Z, DEF_SPRITE_Y)
{
	p = new WindowVXPrivate(x, y, width, height);
	onGeometryChange(scene->getGeometry());
}

WindowVX::~WindowVX()
{
	unlink();

	delete p;
}

void WindowVX::update()
{
	p->stepAnimations();

	p->updatePauseQuad();
	p->updateCursorAlpha();
}

void WindowVX::move(int x, int y, int width, int height)
{
	p->width = width;
	p->height = height;

	const Vec2i size(std::max(0, width), std::max(0, height));

	if (p->geo.w != size.x || p->geo.h != size.y)
		p->base.texSizeDirty = true;

	p->geo = IntRect(x, y, size.x, size.y);
	p->updateBaseQuad();
}

bool WindowVX::isOpen() const
{
	return p->openness == 255;
}

bool WindowVX::isClosed() const
{
	return p->openness == 0;
}

DEF_ATTR_SIMPLE(WindowVX, X,          int,     p->geo.x)
DEF_ATTR_SIMPLE(WindowVX, Y,          int,     p->geo.y)

DEF_ATTR_RD_SIMPLE(WindowVX, Windowskin,      Bitmap*, p->windowskin)
DEF_ATTR_RD_SIMPLE(WindowVX, Contents,        Bitmap*, p->contents)
DEF_ATTR_RD_SIMPLE(WindowVX, CursorRect,      Rect*,   p->cursorRect)
DEF_ATTR_RD_SIMPLE(WindowVX, Active,          bool,    p->active)
DEF_ATTR_RD_SIMPLE(WindowVX, ArrowsVisible,   bool,    p->arrowsVisible)
DEF_ATTR_RD_SIMPLE(WindowVX, Pause,           bool,    p->pause)
DEF_ATTR_RD_SIMPLE(WindowVX, Width,           int,     p->width)
DEF_ATTR_RD_SIMPLE(WindowVX, Height,          int,     p->height)
DEF_ATTR_RD_SIMPLE(WindowVX, OX,              int,     p->contentsOff.x)
DEF_ATTR_RD_SIMPLE(WindowVX, OY,              int,     p->contentsOff.y)
DEF_ATTR_RD_SIMPLE(WindowVX, Padding,         int,     p->padding)
DEF_ATTR_RD_SIMPLE(WindowVX, PaddingBottom,   int,     p->paddingBottom)
DEF_ATTR_RD_SIMPLE(WindowVX, Opacity,         int,     p->opacity)
DEF_ATTR_RD_SIMPLE(WindowVX, BackOpacity,     int,     p->backOpacity)
DEF_ATTR_RD_SIMPLE(WindowVX, ContentsOpacity, int,     p->contentsOpacity)
DEF_ATTR_RD_SIMPLE(WindowVX, Openness,        int,     p->openness)
DEF_ATTR_RD_SIMPLE(WindowVX, Tone,            Tone*,   p->tone)

void WindowVX::setWindowskin(Bitmap *value)
{
	if (p->windowskin == value)
		return;

	p->windowskin = value;
	p->windowskinWatch.update(value);
	p->base.texDirty = true;
}

void WindowVX::setContents(Bitmap *value)
{
	if (p->contents == value)
		return;

	p->contents = value;
	p->contentsWatch.update(value);

	FloatRect rect = p->contents->rect();
	p->contentsQuad.setTexPosRect(rect, rect);
	p->ctrlVertDirty = true;
}

void WindowVX::setCursorRect(Rect *value)
{
	if (p->cursorRect == value)
		return;

	p->cursorRect = value;
	p->cursorVertDirty = true;
	p->refreshCursorRectCon();
}

void WindowVX::setActive(bool value)
{
	if (p->active == value)
		return;

	p->active = value;
	p->cursorAlphaIdx = cursorAlphaResetIdx;
	p->updateCursorAlpha();
}

void WindowVX::setArrowsVisible(bool value)
{
	if (p->arrowsVisible == value)
		return;

	p->arrowsVisible = value;
	p->ctrlVertDirty = true;
}

void WindowVX::setPause(bool value)
{
	if (p->pause == value)
		return;

	p->pause = value;
	p->pauseAlphaIdx = 0;
	p->pauseQuadIdx = 0;
	p->ctrlVertDirty = true;
}

void WindowVX::setWidth(int value)
{
	if (p->width == value)
		return;

	p->width = value;
	p->geo.w = std::max(0, value);
	p->base.vertDirty = true;
	p->base.texSizeDirty = true;
	p->clipRectDirty = true;
	p->ctrlVertDirty = true;
	p->updateBaseQuad();
}

void WindowVX::setHeight(int value)
{
	if (p->height == value)
		return;

	p->height = value;
	p->geo.h = std::max(0, value);
	p->base.vertDirty = true;
	p->base.texSizeDirty = true;
	p->clipRectDirty = true;
	p->ctrlVertDirty = true;
	p->updateBaseQuad();
}

void WindowVX::setOX(int value)
{
	if (p->contentsOff.x == value)
		return;

	p->contentsOff.x = value;
	p->ctrlVertDirty = true;
}

void WindowVX::setOY(int value)
{
	if (p->contentsOff.y == value)
		return;

	p->contentsOff.y = value;
	p->ctrlVertDirty = true;
}

void WindowVX::setPadding(int value)
{
	if (p->padding == value)
		return;

	p->padding = value;
	p->paddingBottom = value;
	p->clipRectDirty = true;
}

void WindowVX::setPaddingBottom(int value)
{
	if (p->paddingBottom == value)
		return;

	p->paddingBottom = value;
	p->clipRectDirty = true;
}

void WindowVX::setOpacity(int value)
{
	if (p->opacity == value)
		return;

	p->opacity = value;
	p->base.quad.setColor(Vec4(1, 1, 1, p->opacity.norm));
}

void WindowVX::setBackOpacity(int value)
{
	if (p->backOpacity == value)
		return;

	p->backOpacity = value;
	p->base.texDirty = true;
}

void WindowVX::setContentsOpacity(int value)
{
	if (p->contentsOpacity == value)
		return;

	p->contentsOpacity = value;
	p->contentsQuad.setColor(Vec4(1, 1, 1, p->contentsOpacity.norm));
}

void WindowVX::setOpenness(int value)
{
	if (p->openness == value)
		return;

	p->openness = value;
	p->updateBaseQuad();
}

void WindowVX::setTone(Tone *value)
{
	if (p->tone == value)
		return;

	p->tone = value;
	p->refreshToneCon();
}

void WindowVX::draw()
{
	p->draw();
}

void WindowVX::onGeometryChange(const Scene::Geometry &geo)
{
	p->sceneOffset.x = geo.rect.x - geo.xOrigin;
	p->sceneOffset.y = geo.rect.y - geo.yOrigin;
}