mirror of
https://forgejo.xatacraft.ru/Sunshine/mkxp-sunshine.git
synced 2026-08-19 21:39:57 +00:00
ef2430e0c3
The general rule I'm aiming for is to <> include system wide / installed paths / generally everything that's outside the git managed source tree (this means mruby paths too!), and "" include everything else, ie. local mkxp headers. The only current exception are the mri headers, which all have './' at their front as to not clash with system wide ruby headers. I'm leaving them be for now until I can come up with a better general solution.
1010 lines
20 KiB
C++
1010 lines
20 KiB
C++
/*
|
|
** bitmap.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 "bitmap.h"
|
|
|
|
#include <SDL.h>
|
|
#include <SDL_image.h>
|
|
#include <SDL_ttf.h>
|
|
#include <SDL_rect.h>
|
|
|
|
#include <pixman.h>
|
|
|
|
#include <QString>
|
|
#include <QChar>
|
|
|
|
#include "gl-util.h"
|
|
#include "quad.h"
|
|
#include "quadarray.h"
|
|
#include "transform.h"
|
|
#include "exception.h"
|
|
|
|
#include "sharedstate.h"
|
|
#include "glstate.h"
|
|
#include "texpool.h"
|
|
#include "shader.h"
|
|
#include "filesystem.h"
|
|
#include "font.h"
|
|
#include "eventthread.h"
|
|
|
|
#define DISP_CLASS_NAME "bitmap"
|
|
|
|
#define GUARD_MEGA \
|
|
{ \
|
|
if (p->megaSurface) \
|
|
throw Exception(Exception::MKXPError, \
|
|
"Operation not supported for mega surfaces"); \
|
|
}
|
|
|
|
struct BitmapPrivate
|
|
{
|
|
TEXFBO gl;
|
|
|
|
/* 'setPixel()' calls are cached and executed
|
|
* in batches on 'flush()' */
|
|
PointArray pointArray;
|
|
|
|
Font *font;
|
|
|
|
/* "Mega surfaces" are a hack to allow Tilesets to be used
|
|
* whose Bitmaps don't fit into a regular texture. They're
|
|
* kept in RAM and will throw an error if they're used in
|
|
* any context other than as Tilesets */
|
|
SDL_Surface *megaSurface;
|
|
|
|
/* The 'tainted' area describes which parts of the
|
|
* bitmap are not cleared, ie. don't have 0 opacity.
|
|
* If we're blitting / drawing text to a cleared part
|
|
* with full opacity, we can disregard any old contents
|
|
* in the texture and blit to it directly, saving
|
|
* ourselves the expensive blending calculation */
|
|
pixman_region16_t tainted;
|
|
|
|
BitmapPrivate()
|
|
: megaSurface(0)
|
|
{
|
|
font = &shState->defaultFont();
|
|
pixman_region_init(&tainted);
|
|
}
|
|
|
|
~BitmapPrivate()
|
|
{
|
|
pixman_region_fini(&tainted);
|
|
}
|
|
|
|
void clearTaintedArea()
|
|
{
|
|
pixman_region_clear(&tainted);
|
|
}
|
|
|
|
void addTaintedArea(const IntRect &rect)
|
|
{
|
|
pixman_region_union_rect
|
|
(&tainted, &tainted, rect.x, rect.y, rect.w, rect.h);
|
|
}
|
|
|
|
void substractTaintedArea(const IntRect &rect)
|
|
{
|
|
if (!touchesTaintedArea(rect))
|
|
return;
|
|
|
|
pixman_region16_t m_reg;
|
|
pixman_region_init_rect(&m_reg, rect.x, rect.y, rect.w, rect.h);
|
|
|
|
pixman_region_subtract(&tainted, &m_reg, &tainted);
|
|
|
|
pixman_region_fini(&m_reg);
|
|
}
|
|
|
|
bool touchesTaintedArea(const IntRect &rect)
|
|
{
|
|
pixman_box16_t box;
|
|
box.x1 = rect.x;
|
|
box.y1 = rect.y;
|
|
box.x2 = rect.x + rect.w;
|
|
box.y2 = rect.y + rect.h;
|
|
|
|
pixman_region_overlap_t result =
|
|
pixman_region_contains_rectangle(&tainted, &box);
|
|
|
|
return result != PIXMAN_REGION_OUT;
|
|
}
|
|
|
|
void bindTexture(ShaderBase &shader)
|
|
{
|
|
TEX::bind(gl.tex);
|
|
shader.setTexSize(Vec2i(gl.width, gl.height));
|
|
}
|
|
|
|
void bindFBO()
|
|
{
|
|
FBO::bind(gl.fbo, FBO::Draw);
|
|
}
|
|
|
|
void pushSetViewport(ShaderBase &shader) const
|
|
{
|
|
glState.viewport.pushSet(IntRect(0, 0, gl.width, gl.height));
|
|
shader.applyViewportProj();
|
|
}
|
|
|
|
void popViewport() const
|
|
{
|
|
glState.viewport.pop();
|
|
}
|
|
|
|
void blitQuad(Quad &quad)
|
|
{
|
|
glState.blendMode.pushSet(BlendNone);
|
|
quad.draw();
|
|
glState.blendMode.pop();
|
|
}
|
|
|
|
void flushPoints()
|
|
{
|
|
if (pointArray.count() == 0)
|
|
return;
|
|
|
|
SimpleColorShader &shader = shState->simpleColorShader();
|
|
shader.bind();
|
|
shader.setTranslation(Vec2i());
|
|
|
|
bindFBO();
|
|
pushSetViewport(shader);
|
|
glState.blendMode.pushSet(BlendNone);
|
|
|
|
pointArray.commit();
|
|
pointArray.draw();
|
|
pointArray.reset();
|
|
|
|
glState.blendMode.pop();
|
|
popViewport();
|
|
}
|
|
|
|
void fillRect(const IntRect &rect,
|
|
const Vec4 &color)
|
|
{
|
|
flushPoints();
|
|
|
|
bindFBO();
|
|
|
|
glState.scissorTest.pushSet(true);
|
|
glState.scissorBox.pushSet(rect);
|
|
glState.clearColor.pushSet(color);
|
|
|
|
FBO::clear();
|
|
|
|
glState.clearColor.pop();
|
|
glState.scissorBox.pop();
|
|
glState.scissorTest.pop();
|
|
}
|
|
|
|
static void ensureFormat(SDL_Surface *&surf, Uint32 format)
|
|
{
|
|
if (surf->format->format == format)
|
|
return;
|
|
|
|
SDL_Surface *surfConv = SDL_ConvertSurfaceFormat(surf, format, 0);
|
|
SDL_FreeSurface(surf);
|
|
surf = surfConv;
|
|
}
|
|
};
|
|
|
|
Bitmap::Bitmap(const char *filename)
|
|
{
|
|
SDL_RWops ops;
|
|
const char *extension;
|
|
shState->fileSystem().openRead(ops, filename, FileSystem::Image, false, &extension);
|
|
SDL_Surface *imgSurf = IMG_LoadTyped_RW(&ops, 1, extension);
|
|
|
|
if (!imgSurf)
|
|
throw Exception(Exception::SDLError, "SDL: %s", SDL_GetError());
|
|
|
|
p->ensureFormat(imgSurf, SDL_PIXELFORMAT_ABGR8888);
|
|
|
|
if (imgSurf->w > glState.caps.maxTexSize || imgSurf->h > glState.caps.maxTexSize)
|
|
{
|
|
/* Mega surface */
|
|
p = new BitmapPrivate;
|
|
p->megaSurface = imgSurf;
|
|
}
|
|
else
|
|
{
|
|
/* Regular surface */
|
|
TEXFBO tex;
|
|
|
|
try
|
|
{
|
|
tex = shState->texPool().request(imgSurf->w, imgSurf->h);
|
|
}
|
|
catch (const Exception &e)
|
|
{
|
|
SDL_FreeSurface(imgSurf);
|
|
throw e;
|
|
}
|
|
|
|
p = new BitmapPrivate;
|
|
p->gl = tex;
|
|
|
|
TEX::bind(p->gl.tex);
|
|
TEX::uploadImage(p->gl.width, p->gl.height, imgSurf->pixels, GL_RGBA);
|
|
|
|
SDL_FreeSurface(imgSurf);
|
|
}
|
|
|
|
p->addTaintedArea(rect());
|
|
}
|
|
|
|
Bitmap::Bitmap(int width, int height)
|
|
{
|
|
if (width <= 0 || height <= 0)
|
|
throw Exception(Exception::RGSSError, "failed to create bitmap");
|
|
|
|
TEXFBO tex = shState->texPool().request(width, height);
|
|
|
|
p = new BitmapPrivate;
|
|
p->gl = tex;
|
|
|
|
clear();
|
|
}
|
|
|
|
Bitmap::Bitmap(const Bitmap &other)
|
|
{
|
|
other.ensureNonMega();
|
|
|
|
p = new BitmapPrivate;
|
|
|
|
p->gl = shState->texPool().request(other.width(), other.height());
|
|
|
|
other.flush();
|
|
blt(0, 0, other, rect());
|
|
}
|
|
|
|
Bitmap::~Bitmap()
|
|
{
|
|
dispose();
|
|
}
|
|
|
|
int Bitmap::width() const
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
if (p->megaSurface)
|
|
return p->megaSurface->w;
|
|
|
|
return p->gl.width;
|
|
}
|
|
|
|
int Bitmap::height() const
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
if (p->megaSurface)
|
|
return p->megaSurface->h;
|
|
|
|
return p->gl.height;
|
|
}
|
|
|
|
IntRect Bitmap::rect() const
|
|
{
|
|
return IntRect(0, 0, width(), height());
|
|
}
|
|
|
|
void Bitmap::blt(int x, int y,
|
|
const Bitmap &source, const IntRect &rect,
|
|
int opacity)
|
|
{
|
|
stretchBlt(IntRect(x, y, rect.w, rect.h),
|
|
source, rect, opacity);
|
|
}
|
|
|
|
void Bitmap::stretchBlt(const IntRect &destRect,
|
|
const Bitmap &source, const IntRect &sourceRect,
|
|
int opacity)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
opacity = clamp(opacity, 0, 255);
|
|
|
|
if (opacity == 0)
|
|
return;
|
|
|
|
if (source.megaSurface())
|
|
{
|
|
/* Don't do transparent blits for now */
|
|
if (opacity < 255)
|
|
source.ensureNonMega();
|
|
|
|
SDL_Surface *srcSurf = source.megaSurface();
|
|
|
|
int bpp;
|
|
Uint32 rMask, gMask, bMask, aMask;
|
|
SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_ABGR8888,
|
|
&bpp, &rMask, &gMask, &bMask, &aMask);
|
|
SDL_Surface *blitTemp =
|
|
SDL_CreateRGBSurface(0, destRect.w, destRect.h, bpp, rMask, gMask, bMask, aMask);
|
|
|
|
SDL_Rect srcRect;
|
|
srcRect.x = sourceRect.x;
|
|
srcRect.y = sourceRect.y;
|
|
srcRect.w = sourceRect.w;
|
|
srcRect.h = sourceRect.h;
|
|
|
|
SDL_Rect dstRect;
|
|
dstRect.x = dstRect.y = 0;
|
|
dstRect.w = blitTemp->w;
|
|
dstRect.h = blitTemp->h;
|
|
|
|
// FXIME: This is supposed to be a scaled blit, put SDL2 for some reason
|
|
// makes the source surface unusable after BlitScaled() is called. Investigate!
|
|
SDL_BlitSurface(srcSurf, &srcRect, blitTemp, &dstRect);
|
|
|
|
TEX::bind(p->gl.tex);
|
|
TEX::uploadSubImage(destRect.x, destRect.y, destRect.w, destRect.h, blitTemp->pixels, GL_RGBA);
|
|
|
|
SDL_FreeSurface(blitTemp);
|
|
|
|
modified();
|
|
return;
|
|
}
|
|
|
|
if (opacity == 255 && !p->touchesTaintedArea(destRect))
|
|
{
|
|
/* Fast blit */
|
|
flush();
|
|
|
|
FBO::bind(source.p->gl.fbo, FBO::Read);
|
|
FBO::bind(p->gl.fbo, FBO::Draw);
|
|
|
|
FBO::blit(sourceRect.x, sourceRect.y, sourceRect.w, sourceRect.h,
|
|
destRect.x, destRect.y, destRect.w, destRect.h);
|
|
}
|
|
else
|
|
{
|
|
/* Fragment pipeline */
|
|
flush();
|
|
|
|
float normOpacity = (float) opacity / 255.0f;
|
|
|
|
TEXFBO &gpTex = shState->gpTexFBO(destRect.w, destRect.h);
|
|
|
|
FBO::bind(gpTex.fbo, FBO::Draw);
|
|
FBO::bind(p->gl.fbo, FBO::Read);
|
|
FBO::blit(destRect.x, destRect.y, 0, 0, destRect.w, destRect.h);
|
|
|
|
FloatRect bltSubRect((float) sourceRect.x / source.width(),
|
|
(float) sourceRect.y / source.height(),
|
|
((float) source.width() / sourceRect.w) * ((float) destRect.w / gpTex.width),
|
|
((float) source.height() / sourceRect.h) * ((float) destRect.h / gpTex.height));
|
|
|
|
BltShader &shader = shState->bltShader();
|
|
shader.bind();
|
|
shader.setDestination(gpTex.tex);
|
|
shader.setSubRect(bltSubRect);
|
|
shader.setOpacity(normOpacity);
|
|
|
|
Quad &quad = shState->gpQuad();
|
|
quad.setTexPosRect(sourceRect, destRect);
|
|
quad.setColor(Vec4(1, 1, 1, normOpacity));
|
|
|
|
source.p->bindTexture(shader);
|
|
p->bindFBO();
|
|
p->pushSetViewport(shader);
|
|
|
|
p->blitQuad(quad);
|
|
|
|
p->popViewport();
|
|
}
|
|
|
|
p->addTaintedArea(destRect);
|
|
|
|
modified();
|
|
}
|
|
|
|
void Bitmap::fillRect(int x, int y,
|
|
int width, int height,
|
|
const Vec4 &color)
|
|
{
|
|
fillRect(IntRect(x, y, width, height), color);
|
|
}
|
|
|
|
void Bitmap::fillRect(const IntRect &rect, const Vec4 &color)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
p->fillRect(rect, color);
|
|
|
|
if (color.w == 0)
|
|
/* Clear op */
|
|
p->substractTaintedArea(rect);
|
|
else
|
|
/* Fill op */
|
|
p->addTaintedArea(rect);
|
|
|
|
modified();
|
|
}
|
|
|
|
#ifdef RGSS2
|
|
|
|
void Bitmap::gradientFillRect(int x, int y,
|
|
int width, int height,
|
|
const Vec4 &color1, const Vec4 &color2,
|
|
bool vertical)
|
|
{
|
|
gradientFillRect(IntRect(x, y, width, height), color1, color2, vertical);
|
|
}
|
|
|
|
void Bitmap::gradientFillRect(const IntRect &rect,
|
|
const Vec4 &color1, const Vec4 &color2,
|
|
bool vertical)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
flush();
|
|
|
|
SimpleColorShader &shader = shState->simpleColorShader();
|
|
shader.bind();
|
|
shader.setTranslation(Vec2i());
|
|
|
|
Quad &quad = shState->gpQuad();
|
|
|
|
if (vertical)
|
|
{
|
|
quad.vert[0].color = color2;
|
|
quad.vert[1].color = color2;
|
|
quad.vert[2].color = color1;
|
|
quad.vert[3].color = color1;
|
|
}
|
|
else
|
|
{
|
|
quad.vert[0].color = color1;
|
|
quad.vert[3].color = color1;
|
|
quad.vert[1].color = color2;
|
|
quad.vert[2].color = color2;
|
|
}
|
|
|
|
quad.setPosRect(rect);
|
|
|
|
p->bindFBO();
|
|
p->pushSetViewport(shader);
|
|
|
|
p->blitQuad(quad);
|
|
|
|
p->popViewport();
|
|
|
|
p->addTaintedArea(rect);
|
|
|
|
modified();
|
|
}
|
|
|
|
void Bitmap::clearRect(int x, int y, int width, int height)
|
|
{
|
|
clearRect(IntRect(x, y, width, height));
|
|
}
|
|
|
|
void Bitmap::clearRect(const IntRect &rect)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
p->fillRect(rect, Vec4());
|
|
|
|
modified();
|
|
}
|
|
|
|
void Bitmap::blur()
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
flush();
|
|
|
|
Quad &quad = shState->gpQuad();
|
|
FloatRect rect(0, 0, width(), height());
|
|
quad.setTexPosRect(rect, rect);
|
|
|
|
TEXFBO auxTex = shState->texPool().request(width(), height());
|
|
|
|
BlurShader &shader = shState->blurShader();
|
|
BlurShader::HPass &pass1 = shader.pass1;
|
|
BlurShader::VPass &pass2 = shader.pass2;
|
|
|
|
glState.blendMode.pushSet(BlendNone);
|
|
glState.viewport.pushSet(IntRect(0, 0, width(), height()));
|
|
|
|
TEX::bind(p->gl.tex);
|
|
FBO::bind(auxTex.fbo, FBO::Draw);
|
|
|
|
pass1.bind();
|
|
pass1.setTexSize(Vec2i(width(), height()));
|
|
pass1.applyViewportProj();
|
|
|
|
quad.draw();
|
|
|
|
TEX::bind(auxTex.tex);
|
|
FBO::bind(p->gl.fbo, FBO::Draw);
|
|
|
|
pass2.bind();
|
|
pass2.setTexSize(Vec2i(width(), height()));
|
|
pass2.applyViewportProj();
|
|
|
|
quad.draw();
|
|
|
|
glState.viewport.pop();
|
|
glState.blendMode.pop();
|
|
|
|
shState->texPool().release(auxTex);
|
|
|
|
modified();
|
|
}
|
|
|
|
void Bitmap::radialBlur(int angle, int divisions)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
flush();
|
|
|
|
angle = clamp<int>(angle, 0, 359);
|
|
divisions = clamp<int>(divisions, 2, 100);
|
|
|
|
const int _width = width();
|
|
const int _height = height();
|
|
|
|
float angleStep = (float) angle / (divisions-1);
|
|
float opacity = 1.0f / divisions;
|
|
float baseAngle = -((float) angle / 2);
|
|
|
|
ColorQuadArray qArray;
|
|
qArray.resize(5);
|
|
|
|
QVector<Vertex> &vert = qArray.vertices;
|
|
|
|
int i = 0;
|
|
|
|
/* Center */
|
|
FloatRect texRect(0, 0, _width, _height);
|
|
FloatRect posRect(0, 0, _width, _height);
|
|
|
|
i += Quad::setTexPosRect(&vert[i*4], texRect, posRect);
|
|
|
|
/* Upper */
|
|
posRect = FloatRect(0, 0, _width, -_height);
|
|
|
|
i += Quad::setTexPosRect(&vert[i*4], texRect, posRect);
|
|
|
|
/* Lower */
|
|
posRect = FloatRect(0, _height*2, _width, -_height);
|
|
|
|
i += Quad::setTexPosRect(&vert[i*4], texRect, posRect);
|
|
|
|
/* Left */
|
|
posRect = FloatRect(0, 0, -_width, _height);
|
|
|
|
i += Quad::setTexPosRect(&vert[i*4], texRect, posRect);
|
|
|
|
/* Right */
|
|
posRect = FloatRect(_width*2, 0, -_width, _height);
|
|
|
|
i += Quad::setTexPosRect(&vert[i*4], texRect, posRect);
|
|
|
|
for (int i = 0; i < 4*5; ++i)
|
|
vert[i].color = Vec4(1, 1, 1, opacity);
|
|
|
|
qArray.commit();
|
|
|
|
TEXFBO newTex = shState->texPool().request(_width, _height);
|
|
|
|
FBO::bind(newTex.fbo, FBO::Draw);
|
|
|
|
glState.clearColor.pushSet(Vec4());
|
|
FBO::clear();
|
|
|
|
Transform trans;
|
|
trans.setOrigin(Vec2(_width / 2.0f, _height / 2.0f));
|
|
trans.setPosition(Vec2(_width / 2.0f, _height / 2.0f));
|
|
|
|
glState.blendMode.pushSet(BlendAddition);
|
|
|
|
SimpleMatrixShader &shader = shState->simpleMatrixShader();
|
|
shader.bind();
|
|
|
|
p->bindTexture(shader);
|
|
TEX::setSmooth(true);
|
|
|
|
p->pushSetViewport(shader);
|
|
|
|
for (int i = 0; i < divisions; ++i)
|
|
{
|
|
trans.setRotation(baseAngle + i*angleStep);
|
|
shader.setMatrix(trans.getMatrix());
|
|
qArray.draw();
|
|
}
|
|
|
|
p->popViewport();
|
|
|
|
TEX::setSmooth(false);
|
|
|
|
glState.blendMode.pop();
|
|
glState.clearColor.pop();
|
|
|
|
shState->texPool().release(p->gl);
|
|
p->gl = newTex;
|
|
|
|
modified();
|
|
}
|
|
|
|
#endif
|
|
|
|
void Bitmap::clear()
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
/* Any queued points won't be visible after this anyway */
|
|
p->pointArray.reset();
|
|
|
|
p->bindFBO();
|
|
|
|
glState.clearColor.pushSet(Vec4());
|
|
|
|
FBO::clear();
|
|
|
|
glState.clearColor.pop();
|
|
|
|
p->clearTaintedArea();
|
|
|
|
modified();
|
|
}
|
|
|
|
Vec4 Bitmap::getPixel(int x, int y) const
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
if (x < 0 || y < 0 || x >= width() || y >= height())
|
|
return Vec4();
|
|
|
|
flush();
|
|
|
|
p->bindFBO();
|
|
|
|
glState.viewport.pushSet(IntRect(0, 0, width(), height()));
|
|
Vec4 pixel = FBO::getPixel(x, y);
|
|
glState.viewport.pop();
|
|
|
|
return pixel;
|
|
}
|
|
|
|
void Bitmap::setPixel(int x, int y, const Vec4 &color)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
p->pointArray.append(Vec2(x+.5, y+.5), color);
|
|
|
|
p->addTaintedArea(IntRect(x, y, 1, 1));
|
|
|
|
modified();
|
|
}
|
|
|
|
void Bitmap::hueChange(int hue)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
if ((hue % 360) == 0)
|
|
return;
|
|
|
|
flush();
|
|
|
|
TEXFBO newTex = shState->texPool().request(width(), height());
|
|
|
|
FloatRect texRect(rect());
|
|
|
|
Quad &quad = shState->gpQuad();
|
|
quad.setTexPosRect(texRect, texRect);
|
|
quad.setColor(Vec4(1, 1, 1, 1));
|
|
|
|
/* Calculate hue parameter */
|
|
hue = wrapRange(hue, 0, 359);
|
|
float hueAdj = -((M_PI * 2) / 360) * hue;
|
|
|
|
HueShader &shader = shState->hueShader();
|
|
shader.bind();
|
|
shader.setHueAdjust(hueAdj);
|
|
|
|
FBO::bind(newTex.fbo, FBO::Draw);
|
|
p->pushSetViewport(shader);
|
|
p->bindTexture(shader);
|
|
|
|
p->blitQuad(quad);
|
|
|
|
shader.unbind();
|
|
|
|
p->popViewport();
|
|
|
|
TEX::unbind();
|
|
|
|
shState->texPool().release(p->gl);
|
|
p->gl = newTex;
|
|
|
|
modified();
|
|
}
|
|
|
|
void Bitmap::drawText(int x, int y,
|
|
int width, int height,
|
|
const char *str, int align)
|
|
{
|
|
drawText(IntRect(x, y, width, height), str, align);
|
|
}
|
|
|
|
void Bitmap::drawText(const IntRect &rect, const char *str, int align)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
if (*str == '\0')
|
|
return;
|
|
|
|
if (str[0] == ' ' && str[1] == '\0')
|
|
return;
|
|
|
|
flush();
|
|
|
|
TTF_Font *font = p->font->getSdlFont();
|
|
Color *fontColor = p->font->getColor();
|
|
|
|
SDL_Color c;
|
|
fontColor->toSDLColor(c);
|
|
|
|
float txtAlpha = fontColor->norm.w;
|
|
|
|
SDL_Surface *txtSurf;
|
|
|
|
if (shState->rtData().config.solidFonts)
|
|
txtSurf = TTF_RenderUTF8_Solid(font, str, c);
|
|
else
|
|
txtSurf = TTF_RenderUTF8_Blended(font, str, c);
|
|
|
|
p->ensureFormat(txtSurf, SDL_PIXELFORMAT_ARGB8888);
|
|
|
|
int alignX = rect.x;
|
|
|
|
switch (align)
|
|
{
|
|
default:
|
|
case Left :
|
|
break;
|
|
|
|
case Center :
|
|
alignX += (rect.w - txtSurf->w) / 2;
|
|
break;
|
|
|
|
case Right :
|
|
alignX += rect.w - txtSurf->w;
|
|
break;
|
|
}
|
|
|
|
if (alignX < rect.x)
|
|
alignX = rect.x;
|
|
|
|
int alignY = rect.y + (rect.h - txtSurf->h) / 2;
|
|
|
|
float squeeze = (float) rect.w / txtSurf->w;
|
|
|
|
if (squeeze > 1)
|
|
squeeze = 1;
|
|
|
|
FloatRect posRect(alignX, alignY, txtSurf->w * squeeze, txtSurf->h);
|
|
|
|
Vec2i gpTexSize;
|
|
shState->ensureTexSize(txtSurf->w, txtSurf->h, gpTexSize);
|
|
|
|
bool fastBlit = !p->touchesTaintedArea(posRect) && txtAlpha == 1.0;
|
|
|
|
if (fastBlit)
|
|
{
|
|
if (squeeze == 1.0)
|
|
{
|
|
/* Even faster: upload directly to bitmap texture.
|
|
* We have to make sure the posRect lies within the texture
|
|
* boundaries or texSubImage will generate errors.
|
|
* If it partly lies outside bounds we have to upload
|
|
* the clipped visible part of it. */
|
|
SDL_Rect btmRect;
|
|
btmRect.x = btmRect.y = 0;
|
|
btmRect.w = width();
|
|
btmRect.h = height();
|
|
|
|
SDL_Rect txtRect;
|
|
txtRect.x = posRect.x;
|
|
txtRect.y = posRect.y;
|
|
txtRect.w = posRect.w;
|
|
txtRect.h = posRect.h;
|
|
|
|
SDL_Rect inters;
|
|
|
|
/* If we have no intersection at all,
|
|
* there's nothing to upload to begin with */
|
|
if (SDL_IntersectRect(&btmRect, &txtRect, &inters))
|
|
{
|
|
if (inters.w != txtRect.w || inters.h != txtRect.h)
|
|
{
|
|
/* Clip the text surface */
|
|
SDL_Rect clipSrc = inters;
|
|
clipSrc.x -= txtRect.x;
|
|
clipSrc.y -= txtRect.y;
|
|
|
|
posRect.x = inters.x;
|
|
posRect.y = inters.y;
|
|
posRect.w = inters.w;
|
|
posRect.h = inters.h;
|
|
|
|
PixelStore::setupSubImage(txtSurf->w, clipSrc.x, clipSrc.y);
|
|
}
|
|
|
|
TEX::bind(p->gl.tex);
|
|
TEX::uploadSubImage(posRect.x, posRect.y, posRect.w, posRect.h, txtSurf->pixels, GL_BGRA_EXT);
|
|
|
|
PixelStore::reset();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Squeezing involved: need to use intermediary TexFBO */
|
|
TEXFBO &gpTF = shState->gpTexFBO(txtSurf->w, txtSurf->h);
|
|
|
|
TEX::bind(gpTF.tex);
|
|
TEX::uploadSubImage(0, 0, txtSurf->w, txtSurf->h, txtSurf->pixels, GL_BGRA_EXT);
|
|
|
|
FBO::bind(gpTF.fbo, FBO::Read);
|
|
p->bindFBO();
|
|
|
|
FBO::blit(0, 0, txtSurf->w, txtSurf->h,
|
|
posRect.x, posRect.y, posRect.w, posRect.h,
|
|
FBO::Linear);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Aquire a partial copy of the destination
|
|
* buffer we're about to render to */
|
|
TEXFBO &gpTex2 = shState->gpTexFBO(posRect.w, posRect.h);
|
|
|
|
FBO::bind(gpTex2.fbo, FBO::Draw);
|
|
FBO::bind(p->gl.fbo, FBO::Read);
|
|
FBO::blit(posRect.x, posRect.y, 0, 0, posRect.w, posRect.h);
|
|
|
|
FloatRect bltRect(0, 0,
|
|
(float) gpTexSize.x / gpTex2.width,
|
|
(float) gpTexSize.y / gpTex2.height);
|
|
|
|
BltShader &shader = shState->bltShader();
|
|
shader.bind();
|
|
shader.setTexSize(gpTexSize);
|
|
shader.setSource();
|
|
shader.setDestination(gpTex2.tex);
|
|
shader.setSubRect(bltRect);
|
|
shader.setOpacity(txtAlpha);
|
|
|
|
shState->bindTex();
|
|
TEX::uploadSubImage(0, 0, txtSurf->w, txtSurf->h, txtSurf->pixels, GL_BGRA_EXT);
|
|
TEX::setSmooth(true);
|
|
|
|
Quad &quad = shState->gpQuad();
|
|
quad.setTexRect(FloatRect(0, 0, txtSurf->w, txtSurf->h));
|
|
quad.setPosRect(posRect);
|
|
|
|
p->bindFBO();
|
|
p->pushSetViewport(shader);
|
|
|
|
glState.blendMode.pushSet(BlendNone);
|
|
|
|
quad.draw();
|
|
|
|
glState.blendMode.pop();
|
|
p->popViewport();
|
|
}
|
|
|
|
SDL_FreeSurface(txtSurf);
|
|
p->addTaintedArea(posRect);
|
|
|
|
modified();
|
|
}
|
|
|
|
IntRect Bitmap::textSize(const char *str)
|
|
{
|
|
GUARD_DISPOSED;
|
|
|
|
GUARD_MEGA;
|
|
|
|
TTF_Font *font = p->font->getSdlFont();
|
|
|
|
int w, h;
|
|
TTF_SizeUTF8(font, str, &w, &h);
|
|
|
|
QString qstr = QString::fromUtf8(str);
|
|
|
|
if (p->font->getItalic() && qstr.length() == 1)
|
|
TTF_GlyphMetrics(font, qstr.at(0).unicode(), 0, 0, 0, 0, &w);
|
|
|
|
return IntRect(0, 0, w, h);
|
|
}
|
|
|
|
DEF_ATTR_SIMPLE(Bitmap, Font, Font*, p->font)
|
|
|
|
void Bitmap::flush() const
|
|
{
|
|
if (isDisposed())
|
|
return;
|
|
|
|
if (p->megaSurface)
|
|
return;
|
|
|
|
p->flushPoints();
|
|
}
|
|
|
|
TEXFBO &Bitmap::getGLTypes()
|
|
{
|
|
return p->gl;
|
|
}
|
|
|
|
SDL_Surface *Bitmap::megaSurface() const
|
|
{
|
|
return p->megaSurface;
|
|
}
|
|
|
|
void Bitmap::ensureNonMega() const
|
|
{
|
|
if (isDisposed())
|
|
return;
|
|
|
|
GUARD_MEGA;
|
|
}
|
|
|
|
void Bitmap::bindTex(ShaderBase &shader)
|
|
{
|
|
p->bindTexture(shader);
|
|
}
|
|
|
|
void Bitmap::releaseResources()
|
|
{
|
|
if (p->megaSurface)
|
|
SDL_FreeSurface(p->megaSurface);
|
|
else
|
|
shState->texPool().release(p->gl);
|
|
|
|
delete p;
|
|
}
|