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)); }