bool OpenGLGraphics::drawImage(Image *image, int srcX, int srcY,
int dstX, int dstY,
int width, int height, bool useColor)
{
if (!image)
return false;
srcX += image->mBounds.x;
srcY += image->mBounds.y;
if (!useColor)
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
bindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
drawQuad(image, srcX, srcY, dstX, dstY, width, height);
if (!useColor)
{
glColor4ub(static_cast<GLubyte>(mColor.r),
static_cast<GLubyte>(mColor.g),
static_cast<GLubyte>(mColor.b),
static_cast<GLubyte>(mColor.a));
}
return true;
}
bool OpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY,
int dstX, int dstY,
int width, int height,
int desiredWidth, int desiredHeight,
bool useColor)
{
if (!image)
return false;
srcX += image->mBounds.x;
srcY += image->mBounds.y;
if (!useColor)
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
glBindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
// Draw a textured quad.
glBegin(GL_QUADS);
drawRescaledQuad(image, srcX, srcY, dstX, dstY, width, height,
desiredWidth, desiredHeight);
glEnd();
if (!useColor)
glColor4ub(mColor.r, mColor.g, mColor.b, mColor.a);
return true;
}
bool OpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY,
int dstX, int dstY,
int width, int height,
int desiredWidth, int desiredHeight,
bool useColor, bool smooth)
{
if (!image)
return false;
// Just draw the image normally when no resizing is necessary,
if (width == desiredWidth && height == desiredHeight)
{
return drawImage(image, srcX, srcY, dstX, dstY,
width, height, useColor);
}
// When the desired image is smaller than the current one,
// disable smooth effect.
if (width > desiredWidth && height > desiredHeight)
smooth = false;
srcX += image->mBounds.x;
srcY += image->mBounds.y;
if (!useColor)
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
bindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
// Draw a textured quad.
drawRescaledQuad(image, srcX, srcY, dstX, dstY, width, height,
desiredWidth, desiredHeight);
if (smooth) // A basic smooth effect...
{
glColor4f(1.0f, 1.0f, 1.0f, 0.2f);
drawRescaledQuad(image, srcX, srcY, dstX - 1, dstY - 1, width, height,
desiredWidth + 1, desiredHeight + 1);
drawRescaledQuad(image, srcX, srcY, dstX + 1, dstY + 1, width, height,
desiredWidth - 1, desiredHeight - 1);
drawRescaledQuad(image, srcX, srcY, dstX + 1, dstY, width, height,
desiredWidth - 1, desiredHeight);
drawRescaledQuad(image, srcX, srcY, dstX, dstY + 1, width, height,
desiredWidth, desiredHeight - 1);
}
if (!useColor)
{
glColor4ub(static_cast<GLubyte>(mColor.r),
static_cast<GLubyte>(mColor.g),
static_cast<GLubyte>(mColor.b),
static_cast<GLubyte>(mColor.a));
}
return true;
}
void OpenGLGraphics::drawPoint(int x, int y)
{
setTexturingAndBlending(false);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
}
void OpenGLGraphics::drawLine(int x1, int y1, int x2, int y2)
{
setTexturingAndBlending(false);
glBegin(GL_LINES);
glVertex2f(x1 + 0.5f, y1 + 0.5f);
glVertex2f(x2 + 0.5f, y2 + 0.5f);
glEnd();
glBegin(GL_POINTS);
glVertex2f(x2 + 0.5f, y2 + 0.5f);
glEnd();
}
void OpenGLGraphics::drawRectangle(const gcn::Rectangle& rect, bool filled)
{
const float offset = filled ? 0 : 0.5f;
setTexturingAndBlending(false);
glBegin(filled ? GL_QUADS : GL_LINE_LOOP);
glVertex2f(rect.x + offset, rect.y + offset);
glVertex2f(rect.x + rect.width - offset, rect.y + offset);
glVertex2f(rect.x + rect.width - offset, rect.y + rect.height - offset);
glVertex2f(rect.x + offset, rect.y + rect.height - offset);
glEnd();
}
void OpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y,
int w, int h,
int scaledWidth, int scaledHeight)
{
if (!image)
return;
const int srcX = image->mBounds.x;
const int srcY = image->mBounds.y;
const int iw = scaledWidth;
const int ih = scaledHeight;
if (iw == 0 || ih == 0)
return;
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
glBindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
// Draw a set of textured rectangles
glBegin(GL_QUADS);
for (int py = 0; py < h; py += ih)
{
const int height = (py + ih >= h) ? h - py : ih;
const int dstY = y + py;
for (int px = 0; px < w; px += iw)
{
int width = (px + iw >= w) ? w - px : iw;
int dstX = x + px;
drawRescaledQuad(image, srcX, srcY, dstX, dstY,
width, height, scaledWidth, scaledHeight);
}
}
glEnd();
glColor4ub(mColor.r, mColor.g, mColor.b, mColor.a);
}
void OpenGLGraphics::drawRectangle(const gcn::Rectangle& rect, bool filled)
{
const float offset = filled ? 0 : 0.5f;
setTexturingAndBlending(false);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
GLfloat vert[] =
{
rect.x + offset, rect.y + offset,
rect.x + rect.width - offset, rect.y + offset,
rect.x + rect.width - offset, rect.y + rect.height - offset,
rect.x + offset, rect.y + rect.height - offset
};
glVertexPointer(2, GL_FLOAT, 0, &vert);
glDrawArrays(filled ? GL_QUADS : GL_LINE_LOOP, 0, 4);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
bool OpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY,
int dstX, int dstY,
int width, int height,
int desiredWidth, int desiredHeight,
bool useColor)
{
if (!image)
return false;
// Just draw the image normally when no resizing is necessary,
if (width == desiredWidth && height == desiredHeight)
{
return drawImage(image, srcX, srcY, dstX, dstY,
width, height, useColor);
}
srcX += image->mBounds.x;
srcY += image->mBounds.y;
if (!useColor)
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
bindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
// Draw a textured quad.
drawRescaledQuad(image, srcX, srcY, dstX, dstY, width, height,
desiredWidth, desiredHeight);
if (!useColor)
{
glColor4ub(static_cast<GLubyte>(mColor.r),
static_cast<GLubyte>(mColor.g),
static_cast<GLubyte>(mColor.b),
static_cast<GLubyte>(mColor.a));
}
return true;
}
void OpenGLGraphics::drawRescaledImagePattern(Image *image,
int x, int y,
int w, int h,
int scaledWidth,
int scaledHeight)
{
if (!image)
return;
if (scaledWidth == 0 || scaledHeight == 0)
return;
const int srcX = image->mBounds.x;
const int srcY = image->mBounds.y;
const int iw = image->getWidth();
const int ih = image->getHeight();
if (iw == 0 || ih == 0)
return;
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
bindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
unsigned int vp = 0;
const unsigned int vLimit = vertexBufSize * 4;
// Draw a set of textured rectangles
if (image->getTextureType() == GL_TEXTURE_2D)
{
const float tw = static_cast<float>(image->getTextureWidth());
const float th = static_cast<float>(image->getTextureHeight());
const float texX1 = static_cast<float>(srcX) / tw;
const float texY1 = static_cast<float>(srcY) / th;
const float tFractionW = iw / tw;
const float tFractionH = ih / th;
for (int py = 0; py < h; py += scaledHeight)
{
const int height = (py + scaledHeight >= h) ? h - py : scaledHeight;
const int dstY = y + py;
for (int px = 0; px < w; px += scaledWidth)
{
int width = (px + scaledWidth >= w) ? w - px : scaledWidth;
int dstX = x + px;
const float visibleFractionW = (float) width / scaledWidth;
const float visibleFractionH = (float) height / scaledHeight;
const float texX2 = texX1 + tFractionW * visibleFractionW;
const float texY2 = texY1 + tFractionH * visibleFractionH;
mFloatTexArray[vp + 0] = texX1;
mFloatTexArray[vp + 1] = texY1;
mFloatTexArray[vp + 2] = texX2;
mFloatTexArray[vp + 3] = texY1;
mFloatTexArray[vp + 4] = texX2;
mFloatTexArray[vp + 5] = texY2;
mFloatTexArray[vp + 6] = texX1;
mFloatTexArray[vp + 7] = texY2;
mIntVertArray[vp + 0] = dstX;
mIntVertArray[vp + 1] = dstY;
mIntVertArray[vp + 2] = dstX + width;
mIntVertArray[vp + 3] = dstY;
mIntVertArray[vp + 4] = dstX + width;
mIntVertArray[vp + 5] = dstY + height;
mIntVertArray[vp + 6] = dstX;
mIntVertArray[vp + 7] = dstY + height;
vp += 8;
if (vp >= vLimit)
{
drawQuadArrayfi(vp);
vp = 0;
}
}
}
if (vp > 0)
drawQuadArrayfi(vp);
}
else
{
const float scaleFactorW = (float) scaledWidth / iw;
const float scaleFactorH = (float) scaledHeight / ih;
for (int py = 0; py < h; py += scaledHeight)
{
const int height = (py + scaledHeight >= h) ? h - py : scaledHeight;
const int dstY = y + py;
for (int px = 0; px < w; px += scaledWidth)
{
int width = (px + scaledWidth >= w) ? w - px : scaledWidth;
int dstX = x + px;
mIntTexArray[vp + 0] = srcX;
mIntTexArray[vp + 1] = srcY;
mIntTexArray[vp + 2] = srcX + width / scaleFactorW;
mIntTexArray[vp + 3] = srcY;
mIntTexArray[vp + 4] = srcX + width / scaleFactorW;
mIntTexArray[vp + 5] = srcY + height / scaleFactorH;
mIntTexArray[vp + 6] = srcX;
mIntTexArray[vp + 7] = srcY + height / scaleFactorH;
mIntVertArray[vp + 0] = dstX;
mIntVertArray[vp + 1] = dstY;
mIntVertArray[vp + 2] = dstX + width;
mIntVertArray[vp + 3] = dstY;
mIntVertArray[vp + 4] = dstX + width;
mIntVertArray[vp + 5] = dstY + height;
mIntVertArray[vp + 6] = dstX;
mIntVertArray[vp + 7] = dstY + height;
vp += 8;
if (vp >= vLimit)
{
drawQuadArrayii(vp);
vp = 0;
}
}
}
if (vp > 0)
drawQuadArrayii(vp);
}
glColor4ub(mColor.r, mColor.g, mColor.b, mColor.a);
}
void OpenGLGraphics::drawImagePattern(Image *image, int x, int y, int w, int h)
{
if (!image)
return;
const int srcX = image->mBounds.x;
const int srcY = image->mBounds.y;
const int iw = image->getWidth();
const int ih = image->getHeight();
if (iw == 0 || ih == 0)
return;
const float tw = static_cast<float>(image->getTextureWidth());
const float th = static_cast<float>(image->getTextureHeight());
glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha);
bindTexture(Image::mTextureType, image->mGLImage);
setTexturingAndBlending(true);
unsigned int vp = 0;
const unsigned int vLimit = vertexBufSize * 4;
// Draw a set of textured rectangles
if (image->getTextureType() == GL_TEXTURE_2D)
{
float texX1 = static_cast<float>(srcX) / tw;
float texY1 = static_cast<float>(srcY) / th;
for (int py = 0; py < h; py += ih)
{
const int height = (py + ih >= h) ? h - py : ih;
const int dstY = y + py;
for (int px = 0; px < w; px += iw)
{
int width = (px + iw >= w) ? w - px : iw;
int dstX = x + px;
float texX2 = static_cast<float>(srcX + width) / tw;
float texY2 = static_cast<float>(srcY + height) / th;
mFloatTexArray[vp + 0] = texX1;
mFloatTexArray[vp + 1] = texY1;
mFloatTexArray[vp + 2] = texX2;
mFloatTexArray[vp + 3] = texY1;
mFloatTexArray[vp + 4] = texX2;
mFloatTexArray[vp + 5] = texY2;
mFloatTexArray[vp + 6] = texX1;
mFloatTexArray[vp + 7] = texY2;
mIntVertArray[vp + 0] = dstX;
mIntVertArray[vp + 1] = dstY;
mIntVertArray[vp + 2] = dstX + width;
mIntVertArray[vp + 3] = dstY;
mIntVertArray[vp + 4] = dstX + width;
mIntVertArray[vp + 5] = dstY + height;
mIntVertArray[vp + 6] = dstX;
mIntVertArray[vp + 7] = dstY + height;
vp += 8;
if (vp >= vLimit)
{
drawQuadArrayfi(vp);
vp = 0;
}
}
}
if (vp > 0)
drawQuadArrayfi(vp);
}
else
{
for (int py = 0; py < h; py += ih)
{
const int height = (py + ih >= h) ? h - py : ih;
const int dstY = y + py;
for (int px = 0; px < w; px += iw)
{
int width = (px + iw >= w) ? w - px : iw;
int dstX = x + px;
mIntTexArray[vp + 0] = srcX;
mIntTexArray[vp + 1] = srcY;
mIntTexArray[vp + 2] = srcX + width;
mIntTexArray[vp + 3] = srcY;
mIntTexArray[vp + 4] = srcX + width;
mIntTexArray[vp + 5] = srcY + height;
mIntTexArray[vp + 6] = srcX;
mIntTexArray[vp + 7] = srcY + height;
mIntVertArray[vp + 0] = dstX;
mIntVertArray[vp + 1] = dstY;
mIntVertArray[vp + 2] = dstX + width;
mIntVertArray[vp + 3] = dstY;
mIntVertArray[vp + 4] = dstX + width;
mIntVertArray[vp + 5] = dstY + height;
mIntVertArray[vp + 6] = dstX;
mIntVertArray[vp + 7] = dstY + height;
vp += 8;
if (vp >= vLimit)
{
drawQuadArrayii(vp);
vp = 0;
}
}
}
if (vp > 0)
drawQuadArrayii(vp);
}
glColor4ub(static_cast<GLubyte>(mColor.r),
static_cast<GLubyte>(mColor.g),
static_cast<GLubyte>(mColor.b),
static_cast<GLubyte>(mColor.a));
}
