325 lines
9.8 KiB
C++
325 lines
9.8 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "alcachofa/alcachofa.h"
|
|
#include "alcachofa/graphics.h"
|
|
#include "alcachofa/detection.h"
|
|
#include "alcachofa/graphics-opengl-base.h"
|
|
|
|
#include "common/system.h"
|
|
#include "common/config-manager.h"
|
|
#include "engines/util.h"
|
|
#include "graphics/tinygl/tinygl.h"
|
|
|
|
using namespace Common;
|
|
using namespace Math;
|
|
using namespace Graphics;
|
|
|
|
namespace Alcachofa {
|
|
|
|
class TinyGLTexture : public ITexture {
|
|
public:
|
|
TinyGLTexture(int32 w, int32 h, bool withMipmaps)
|
|
: ITexture({ (int16)w, (int16)h })
|
|
, _withMipmaps(withMipmaps) {
|
|
tglEnable(TGL_TEXTURE_2D);
|
|
tglGenTextures(1, &_handle);
|
|
tglBindTexture(TGL_TEXTURE_2D, _handle);
|
|
tglTexParameteri(TGL_TEXTURE_2D, TGL_TEXTURE_MIN_FILTER, TGL_LINEAR_MIPMAP_LINEAR);
|
|
tglTexParameteri(TGL_TEXTURE_2D, TGL_TEXTURE_MAG_FILTER, TGL_LINEAR);
|
|
tglTexParameteri(TGL_TEXTURE_2D, TGL_TEXTURE_WRAP_S, TGL_MIRRORED_REPEAT);
|
|
tglTexParameteri(TGL_TEXTURE_2D, TGL_TEXTURE_WRAP_T, TGL_MIRRORED_REPEAT);
|
|
}
|
|
|
|
~TinyGLTexture() override {
|
|
if (_handle != 0)
|
|
tglDeleteTextures(1, &_handle);
|
|
}
|
|
|
|
inline TGLuint handle() const { return _handle; }
|
|
|
|
void update(const Surface &surface) override {
|
|
assert(surface.format == g_engine->renderer().getPixelFormat());
|
|
assert(surface.w == size().x && surface.h == size().y);
|
|
|
|
const void *pixels = surface.getPixels();
|
|
|
|
tglEnable(TGL_TEXTURE_2D);
|
|
tglBindTexture(TGL_TEXTURE_2D, _handle);
|
|
tglTexImage2D(TGL_TEXTURE_2D, 0, TGL_RGBA, size().x, size().y, 0, TGL_RGBA, TGL_UNSIGNED_BYTE, pixels);
|
|
if (_withMipmaps && false)
|
|
warning("NO TINYGL MIPMAPS IMPLEMENTED YET");
|
|
else
|
|
tglTexParameteri(TGL_TEXTURE_2D, TGL_TEXTURE_MAX_LEVEL, 0);
|
|
}
|
|
|
|
protected:
|
|
bool _withMipmaps;
|
|
TGLuint _handle;
|
|
};
|
|
|
|
class TinyGLRenderer : public OpenGLRendererBase {
|
|
public:
|
|
TinyGLRenderer(Point resolution) : OpenGLRendererBase(resolution) {
|
|
if (g_engine->config().bits32())
|
|
initGraphics(resolution.x, resolution.y, nullptr);
|
|
else {
|
|
// we try to take some 16-bit format and fallback
|
|
auto formats = g_system->getSupportedFormats();
|
|
for (auto it = formats.begin(); it != formats.end();) {
|
|
if (it->bytesPerPixel == 2)
|
|
++it;
|
|
else
|
|
it = formats.erase(it);
|
|
}
|
|
if (formats.empty())
|
|
initGraphics(resolution.x, resolution.y, nullptr);
|
|
else
|
|
initGraphics(resolution.x, resolution.y, formats);
|
|
}
|
|
|
|
debug("Using framebuffer format: %s", g_system->getScreenFormat().toString().c_str());
|
|
if (g_system->getScreenFormat().bytesPerPixel < 2)
|
|
error("Alcachofa needs at least 16bit colors");
|
|
_context = TinyGL::createContext(
|
|
resolution.x, resolution.y,
|
|
g_system->getScreenFormat(),
|
|
1024, // some background images are even larger than this
|
|
false, false);
|
|
TinyGL::setContext(_context);
|
|
|
|
tglDisable(TGL_DEPTH_TEST);
|
|
tglDisable(TGL_SCISSOR_TEST);
|
|
tglDisable(TGL_STENCIL_TEST);
|
|
tglDisable(TGL_CULL_FACE);
|
|
tglEnable(TGL_BLEND);
|
|
tglDepthMask(TGL_FALSE);
|
|
}
|
|
|
|
~TinyGLRenderer() override {
|
|
if (_context != nullptr)
|
|
TinyGL::destroyContext(_context);
|
|
}
|
|
|
|
ScopedPtr<ITexture> createTexture(int32 w, int32 h, bool withMipmaps) override {
|
|
assert(w >= 0 && h >= 0);
|
|
return ScopedPtr<ITexture>(new TinyGLTexture(w, h, withMipmaps));
|
|
}
|
|
|
|
PixelFormat getPixelFormat() const override {
|
|
return PixelFormat::createFormatRGBA32();
|
|
}
|
|
|
|
bool requiresPoTTextures() const override {
|
|
return false;
|
|
}
|
|
|
|
void begin() override {
|
|
resetState();
|
|
_currentTexture = nullptr;
|
|
}
|
|
|
|
void setTexture(ITexture *texture) override {
|
|
if (texture == _currentTexture)
|
|
return;
|
|
else if (texture == nullptr) {
|
|
tglDisable(TGL_TEXTURE_2D);
|
|
_currentTexture = nullptr;
|
|
} else {
|
|
if (_currentTexture == nullptr) {
|
|
tglEnable(TGL_TEXTURE_2D);
|
|
}
|
|
auto glTexture = dynamic_cast<TinyGLTexture *>(texture);
|
|
assert(glTexture != nullptr);
|
|
tglBindTexture(TGL_TEXTURE_2D, glTexture->handle()); //-V522
|
|
_currentTexture = glTexture;
|
|
}
|
|
}
|
|
|
|
void setBlendMode(BlendMode blendMode) override {
|
|
if (blendMode == _currentBlendMode)
|
|
return;
|
|
switch (blendMode) {
|
|
case BlendMode::AdditiveAlpha:
|
|
case BlendMode::Tinted:
|
|
tglBlendFunc(TGL_ONE, TGL_ONE_MINUS_SRC_ALPHA);
|
|
break;
|
|
case BlendMode::Additive:
|
|
tglBlendFunc(TGL_ONE, TGL_ONE);
|
|
break;
|
|
case BlendMode::Multiply:
|
|
tglBlendFunc(TGL_DST_COLOR, TGL_ONE);
|
|
break;
|
|
case BlendMode::Alpha:
|
|
tglBlendFunc(TGL_SRC_ALPHA, TGL_ONE_MINUS_SRC_ALPHA);
|
|
break;
|
|
default: assert(false && "Invalid blend mode"); break;
|
|
}
|
|
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_TEXTURE_ENV_MODE, TGL_COMBINE);
|
|
switch (blendMode) {
|
|
case BlendMode::AdditiveAlpha:
|
|
case BlendMode::Additive:
|
|
case BlendMode::Multiply:
|
|
// TintAlpha * TexColor, TexAlpha
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_RGB, TGL_MODULATE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_ALPHA, TGL_REPLACE);
|
|
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_RGB, TGL_TEXTURE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_RGB, TGL_SRC_COLOR);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_ALPHA, TGL_TEXTURE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_ALPHA, TGL_SRC_ALPHA);
|
|
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE1_RGB, TGL_PRIMARY_COLOR);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND1_RGB, TGL_SRC_ALPHA); // alpha replaces color
|
|
break;
|
|
case BlendMode::Alpha:
|
|
// TexColor, TintAlpha
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_RGB, TGL_REPLACE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_ALPHA, TGL_REPLACE);
|
|
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_RGB, TGL_TEXTURE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_RGB, TGL_SRC_COLOR);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_ALPHA, TGL_PRIMARY_COLOR);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_ALPHA, TGL_SRC_ALPHA);
|
|
break;
|
|
case BlendMode::Tinted:
|
|
// (TintColor * TintAlpha) * TexColor, TexAlpha
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_RGB, TGL_MODULATE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_COMBINE_ALPHA, TGL_REPLACE);
|
|
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_RGB, TGL_TEXTURE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_RGB, TGL_SRC_COLOR);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE0_ALPHA, TGL_TEXTURE);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND0_ALPHA, TGL_SRC_ALPHA);
|
|
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_SOURCE1_RGB, TGL_PRIMARY_COLOR);
|
|
tglTexEnvi(TGL_TEXTURE_ENV, TGL_OPERAND1_RGB, TGL_SRC_COLOR); // we have to pre-multiply
|
|
break;
|
|
default:
|
|
assert(false && "Invalid blend mode");
|
|
break;
|
|
}
|
|
_currentBlendMode = blendMode;
|
|
}
|
|
|
|
void setLodBias(float lodBias) override {
|
|
_currentLodBias = lodBias;
|
|
// TinyGL does not support lod bias
|
|
}
|
|
|
|
void setOutput(Surface &output) override {
|
|
assert(_isFirstDrawCommand);
|
|
setViewportToRect(output.w, output.h);
|
|
_currentOutput = &output;
|
|
|
|
if (output.w > _resolution.x || output.h > _resolution.y)
|
|
debugC(0, kDebugGraphics, "Output is larger than screen, output will be cropped (%d, %d) > (%d, %d)",
|
|
output.w, output.h, _resolution.x, _resolution.y);
|
|
|
|
// no need to check format for TinyGL, we need to be prepared for conversion anyways
|
|
}
|
|
|
|
void end() override {
|
|
tglFlush();
|
|
TinyGL::presentBuffer();
|
|
|
|
Surface framebuffer;
|
|
TinyGL::getSurfaceRef(framebuffer);
|
|
if (_currentOutput == nullptr) {
|
|
g_system->copyRectToScreen(framebuffer.getPixels(), framebuffer.pitch, 0, 0, framebuffer.w, framebuffer.h);
|
|
g_system->updateScreen();
|
|
} else {
|
|
framebuffer = framebuffer.getSubArea(Rect(0, 0, _currentOutput->w, _currentOutput->h));
|
|
crossBlit(
|
|
(byte *)_currentOutput->getPixels(),
|
|
(const byte *)framebuffer.getPixels(),
|
|
_currentOutput->pitch,
|
|
framebuffer.pitch,
|
|
framebuffer.w,
|
|
framebuffer.h,
|
|
_currentOutput->format,
|
|
framebuffer.format);
|
|
}
|
|
}
|
|
|
|
void quad(
|
|
Vector2d topLeft,
|
|
Vector2d size,
|
|
Color color,
|
|
Angle rotation,
|
|
Vector2d texMin,
|
|
Vector2d texMax) override {
|
|
Vector2d positions[4], texCoords[4];
|
|
getQuadPositions(topLeft, size, rotation, positions);
|
|
getQuadTexCoords(texMin, texMax, texCoords);
|
|
|
|
float colors[] = { color.r / 255.0f, color.g / 255.0f, color.b / 255.0f, color.a / 255.0f };
|
|
if (_currentBlendMode == BlendMode::Tinted) {
|
|
colors[0] *= colors[3];
|
|
colors[1] *= colors[3];
|
|
colors[2] *= colors[3];
|
|
}
|
|
|
|
if (_isFirstDrawCommand) {
|
|
_isFirstDrawCommand = false;
|
|
tglClearColor(0, 0, 0, 0);
|
|
tglClear(TGL_COLOR_BUFFER_BIT);
|
|
}
|
|
|
|
tglColor4fv(colors);
|
|
tglBegin(TGL_QUADS);
|
|
for (int i = 0; i < 4; i++) {
|
|
tglTexCoord2f(texCoords[i].getX(), texCoords[i].getY());
|
|
tglVertex2f(positions[i].getX(), positions[i].getY());
|
|
}
|
|
tglEnd();
|
|
TinyGL::presentBuffer();
|
|
}
|
|
|
|
protected:
|
|
void setViewportInner(int x, int y, int width, int height) override {
|
|
tglViewport(x, y, width, height);
|
|
}
|
|
|
|
void setMatrices(bool flipped) override {
|
|
float bottom = flipped ? _resolution.y : 0.0f;
|
|
float top = flipped ? 0.0f : _resolution.y;
|
|
|
|
tglMatrixMode(TGL_PROJECTION);
|
|
tglLoadIdentity();
|
|
tglOrtho(0.0f, _resolution.x, bottom, top, -1.0f, 1.0f);
|
|
tglMatrixMode(TGL_MODELVIEW);
|
|
tglLoadIdentity();
|
|
}
|
|
|
|
private:
|
|
TinyGL::ContextHandle *_context = nullptr;
|
|
TinyGLTexture *_currentTexture = nullptr;
|
|
};
|
|
|
|
IRenderer *IRenderer::createTinyGLRenderer(Point resolution) {
|
|
debug("Use TinyGL renderer");
|
|
return new TinyGLRenderer(resolution);
|
|
}
|
|
|
|
}
|