/*!
Starts scrolling the widget so that the point \a pos is visible inside the
viewport with margins specified in pixels by \a xmargin and \a ymargin.
If the specified point cannot be reached, the contents are scrolled to the
nearest valid position. The default value for both margins is 50 pixels.
This function performs the actual scrolling by calling scrollTo().
\sa maximumContentPosition()
*/
void QKineticScroller::ensureVisible(const QPointF &pos, int xmargin, int ymargin, int scrollTime)
{
QSizeF visible = viewportSize();
QPointF currentPos = contentPosition();
qKSDebug() << "QKS::ensureVisible(" << pos << " [pix], " << xmargin << " [pix], " << ymargin << " [pix], " << scrollTime << "[ms])";
qKSDebug() << " --> content position:" << contentPosition();
QRectF posRect(pos.x() - xmargin, pos.y() - ymargin, 2 * xmargin, 2 * ymargin);
QRectF visibleRect(currentPos, visible);
if (visibleRect.contains(posRect))
return;
QPointF newPos = currentPos;
if (posRect.top() < visibleRect.top())
newPos.setY(posRect.top());
else if (posRect.bottom() > visibleRect.bottom())
newPos.setY(posRect.bottom() - visible.height());
if (posRect.left() < visibleRect.left())
newPos.setX(posRect.left());
else if (posRect.right() > visibleRect.right())
newPos.setY(posRect.right() - visible.width());
scrollTo(newPos, scrollTime);
}
/*!
Starts scrolling the widget so that the point \a pos is visible inside the
viewport with margins specified in pixels by \a xmargin and \a ymargin.
If the specified point cannot be reached, the contents are scrolled to the
nearest valid position. The default value for both margins is 50 pixels.
This function performs the actual scrolling by calling scrollTo().
\sa maximumScrollPosition()
*/
void QAbstractKineticScroller::ensureVisible(const QPoint &pos, int xmargin, int ymargin)
{
QSize visible = viewportSize();
QPoint currentPos = scrollPosition();
qKSDebug() << "QAbstractKineticScroller::ensureVisible(" << pos << ", " << xmargin << ", " << ymargin << ") - position: " << scrollPosition();
QRect posRect(pos.x() - xmargin, pos.y() - ymargin, 2 * xmargin, 2 * ymargin);
QRect visibleRect(currentPos, visible);
if (visibleRect.contains(posRect))
return;
QPoint newPos = currentPos;
if (posRect.top() < visibleRect.top())
newPos.setY(posRect.top());
else if (posRect.bottom() > visibleRect.bottom())
newPos.setY(posRect.bottom() - visible.height());
if (posRect.left() < visibleRect.left())
newPos.setX(posRect.left());
else if (posRect.right() > visibleRect.right())
newPos.setX(posRect.right() - visible.width());
scrollTo(newPos);
}
void updateFlash()
{
std::vector<CVertex> vertices;
for (int x = 0; x < mapWidth; ++x)
for (int y = 0; y < mapHeight; ++y)
{
Vec4 color;
if (!sampleFlashColor(color, x, y))
continue;
FloatRect posRect(x*32, y*32, 32, 32);
CVertex v[4];
Quad::setPosRect(v, posRect);
Quad::setColor(v, color);
for (size_t i = 0; i < 4; ++i)
vertices.push_back(v[i]);
}
flash.quadCount = vertices.size() / 4;
if (flash.quadCount == 0)
return;
VBO::bind(flash.vbo);
VBO::uploadData(sizeof(CVertex) * vertices.size(), &vertices[0]);
VBO::unbind();
/* Ensure global IBO size */
shState->ensureQuadIBO(flash.quadCount);
}
void handleTile(int x, int y, int z)
{
int tileInd =
tableGetWrapped(mapData, x + viewpPos.x, y + viewpPos.y, z);
/* Check for empty space */
if (tileInd < 48)
return;
int prio = samplePriority(tileInd);
/* Check for faulty data */
if (prio == -1)
return;
SVVector *targetArray;
/* Prio 0 tiles are all part of the same ground layer */
if (prio == 0)
{
targetArray = &groundVert;
}
else
{
int scanInd = y + prio;
targetArray = &scanrowVert[scanInd];
}
/* Check for autotile */
if (tileInd < 48*8)
{
handleAutotile(x, y, tileInd, targetArray);
return;
}
int tsInd = tileInd - 48*8;
int tileX = tsInd % 8;
int tileY = tsInd / 8;
Vec2i texPos = TileAtlas::tileToAtlasCoor(tileX, tileY, atlas.efTilesetH, atlas.size.y);
FloatRect texRect((float) texPos.x+.5, (float) texPos.y+.5, 31, 31);
FloatRect posRect(x*32, y*32, 32, 32);
SVertex v[4];
Quad::setTexPosRect(v, texRect, posRect);
for (size_t i = 0; i < 4; ++i)
targetArray->push_back(v[i]);
}
void DataPanel::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
QColor color=QColor(0,0,0,50);
painter->setPen(color);
QBrush brush=QBrush(color);
painter->setBrush(brush);
painter->drawRect(boundingRect());
painter->setPen(Qt::white);
QRectF fpsRect(5,0,boundingRect().width()/2,20);
QString fpsStr="FPS : "+QString::number(fps);
painter->drawText(fpsRect,fpsStr);
fpsRect=QRectF(boundingRect().width()/2+5,0,boundingRect().width()/2,20);
QString rStr=QObject::tr("Radius : %1").arg(displayRadius);
painter->drawText(fpsRect,rStr);
QRectF posRect(5,20,100,80);
QString posStr=QObject::tr("pos: \nX: %1\nY: %2\nZ: %3").arg(mPosition.x()).arg(mPosition.y()).arg(mPosition.z());
painter->drawText(posRect,posStr);
QRectF eyeRect(105,20,100,80);
QString eyeStr=QObject::tr("pos: \nX: %1\nY: %2\nZ: %3").arg(mEyePosition.x()).arg(mEyePosition.y()).arg(mEyePosition.z());
painter->drawText(eyeRect,eyeStr);
}
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;
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);
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);
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->shaders().blt;
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);
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();
}
void Bitmap::radialBlur(int angle, int divisions)
{
GUARD_DISPOSED;
GUARD_MEGA;
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);
std::vector<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->shaders().simpleMatrix;
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();
}
void Bitmap::drawText(const IntRect &rect, const char *str, int align)
{
guardDisposed();
GUARD_MEGA;
std::string fixed = fixupString(str);
str = fixed.c_str();
if (*str == '\0')
return;
if (str[0] == ' ' && str[1] == '\0')
return;
TTF_Font *font = p->font->getSdlFont();
const Color &fontColor = p->font->getColor();
const Color &outColor = p->font->getOutColor();
SDL_Color c = fontColor.toSDLColor();
c.a = 255;
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_ABGR8888);
int rawTxtSurfH = txtSurf->h;
if (p->font->getShadow())
applyShadow(txtSurf, *p->format, c);
/* outline using TTF_Outline and blending it together with SDL_BlitSurface
* FIXME: outline is forced to have the same opacity as the font color */
if (p->font->getOutline())
{
SDL_Color co = outColor.toSDLColor();
co.a = 255;
SDL_Surface *outline;
/* set the next font render to render the outline */
TTF_SetFontOutline(font, OUTLINE_SIZE);
if (shState->rtData().config.solidFonts)
outline = TTF_RenderUTF8_Solid(font, str, co);
else
outline = TTF_RenderUTF8_Blended(font, str, co);
p->ensureFormat(outline, SDL_PIXELFORMAT_ABGR8888);
SDL_Rect outRect = {OUTLINE_SIZE, OUTLINE_SIZE, txtSurf->w, txtSurf->h};
SDL_SetSurfaceBlendMode(txtSurf, SDL_BLENDMODE_BLEND);
SDL_BlitSurface(txtSurf, NULL, outline, &outRect);
SDL_FreeSurface(txtSurf);
txtSurf = outline;
/* reset outline to 0 */
TTF_SetFontOutline(font, 0);
}
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 - rawTxtSurfH) / 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.0f;
if (fastBlit)
{
if (squeeze == 1.0f && !shState->config().subImageFix)
{
/* 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))
{
bool subImage = false;
int subSrcX = 0, subSrcY = 0;
if (inters.w != txtRect.w || inters.h != txtRect.h)
{
/* Clip the text surface */
subSrcX = inters.x - txtRect.x;
subSrcY = inters.y - txtRect.y;
subImage = true;
posRect.x = inters.x;
posRect.y = inters.y;
posRect.w = inters.w;
posRect.h = inters.h;
}
TEX::bind(p->gl.tex);
if (!subImage)
{
TEX::uploadSubImage(posRect.x, posRect.y,
posRect.w, posRect.h,
txtSurf->pixels, GL_RGBA);
}
else
{
GLMeta::subRectImageUpload(txtSurf->w, subSrcX, subSrcY,
posRect.x, posRect.y,
posRect.w, posRect.h,
txtSurf, GL_RGBA);
GLMeta::subRectImageEnd();
}
}
}
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_RGBA);
GLMeta::blitBegin(p->gl);
GLMeta::blitSource(gpTF);
GLMeta::blitRectangle(IntRect(0, 0, txtSurf->w, txtSurf->h),
posRect, true);
GLMeta::blitEnd();
}
}
else
{
/* Aquire a partial copy of the destination
* buffer we're about to render to */
TEXFBO &gpTex2 = shState->gpTexFBO(posRect.w, posRect.h);
GLMeta::blitBegin(gpTex2);
GLMeta::blitSource(p->gl);
GLMeta::blitRectangle(posRect, Vec2i());
GLMeta::blitEnd();
FloatRect bltRect(0, 0,
(float) (gpTexSize.x * squeeze) / gpTex2.width,
(float) gpTexSize.y / gpTex2.height);
BltShader &shader = shState->shaders().blt;
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_RGBA);
TEX::setSmooth(true);
Quad &quad = shState->gpQuad();
quad.setTexRect(FloatRect(0, 0, txtSurf->w, txtSurf->h));
quad.setPosRect(posRect);
p->bindFBO();
p->pushSetViewport(shader);
p->blitQuad(quad);
p->popViewport();
}
SDL_FreeSurface(txtSurf);
p->addTaintedArea(posRect);
p->onModified();
}