Initial commit

graphics/tinygl/zbuffer.h

@@ -0,0 +1,870 @@
+/* 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/>.
+ *
+ */
+
+/*
+ * This file is based on, or a modified version of code from TinyGL (C) 1997-2022 Fabrice Bellard,
+ * which is licensed under the MIT license (see LICENSE).
+ * It also has modifications by the ResidualVM-team, which are covered under the GPLv2 (or later).
+ */
+
+#ifndef GRAPHICS_TINYGL_ZBUFFER_H_
+#define GRAPHICS_TINYGL_ZBUFFER_H_
+
+#include "graphics/surface.h"
+#include "graphics/tinygl/texelbuffer.h"
+#include "graphics/tinygl/gl.h"
+
+#include "common/rect.h"
+#include "common/textconsole.h"
+
+namespace TinyGL {
+
+// Z buffer
+
+#define ZB_Z_BITS 16
+
+#define ZB_FOG_BITS               16
+#define ZB_FOG_MAX                ( (1 << ZB_FOG_BITS) - 1 )
+
+#define ZB_POINT_Z_FRAC_BITS 14
+
+#define ZB_POINT_ST_FRAC_BITS 14
+#define ZB_POINT_ST_FRAC_SHIFT     (ZB_POINT_ST_FRAC_BITS - 1)
+#define ZB_POINT_ST_MAX            ( (_textureSize << ZB_POINT_ST_FRAC_BITS) - 1 )
+
+#define ZB_POINT_RED_BITS         16
+#define ZB_POINT_RED_FRAC_BITS    8
+#define ZB_POINT_RED_FRAC_SHIFT   (ZB_POINT_RED_FRAC_BITS - 1)
+#define ZB_POINT_RED_MAX          ( (1 << ZB_POINT_RED_BITS) - 1 )
+
+#define ZB_POINT_GREEN_BITS       16
+#define ZB_POINT_GREEN_FRAC_BITS  8
+#define ZB_POINT_GREEN_FRAC_SHIFT (ZB_POINT_GREEN_FRAC_BITS - 1)
+#define ZB_POINT_GREEN_MAX        ( (1 << ZB_POINT_GREEN_BITS) - 1 )
+
+#define ZB_POINT_BLUE_BITS        16
+#define ZB_POINT_BLUE_FRAC_BITS   8
+#define ZB_POINT_BLUE_FRAC_SHIFT  (ZB_POINT_BLUE_FRAC_BITS - 1)
+#define ZB_POINT_BLUE_MAX         ( (1 << ZB_POINT_BLUE_BITS) - 1 )
+
+#define ZB_POINT_ALPHA_BITS       16
+#define ZB_POINT_ALPHA_FRAC_BITS  8
+#define ZB_POINT_ALPHA_FRAC_SHIFT (ZB_POINT_ALPHA_FRAC_BITS - 1)
+#define ZB_POINT_ALPHA_MAX        ( (1 << ZB_POINT_ALPHA_BITS) - 1 )
+
+#define RGB_TO_PIXEL(r, g, b)     _pbufFormat.ARGBToColor(255, r, g, b) // Default to 255 alpha aka solid colour.
+
+static const int DRAW_DEPTH_ONLY = 0;
+static const int DRAW_FLAT = 1;
+static const int DRAW_SMOOTH = 2;
+
+struct GLTextureEnv; // defined in zdirtyrect.h
+
+struct Buffer {
+	byte *pbuf;
+	uint *zbuf;
+	bool used;
+};
+
+struct ZBufferPoint {
+	int x, y, z;      // integer coordinates in the zbuffer
+	int s, t;         // coordinates for the mapping
+	int r, g, b, a;   // color indexes
+	float sz, tz;     // temporary coordinates for mapping
+	int f;            // fog factor
+
+	bool operator==(const ZBufferPoint &other) const {
+		return
+			x == other.x &&
+			y == other.y &&
+			z == other.z &&
+			s == other.s &&
+			t == other.t &&
+			r == other.r &&
+			g == other.g &&
+			b == other.b &&
+			a == other.a;
+	}
+};
+
+struct FrameBuffer {
+	FrameBuffer(int width, int height, const Graphics::PixelFormat &format, bool enableStencilBuffer);
+	~FrameBuffer();
+
+	Graphics::PixelFormat getPixelFormat() {
+		return _pbufFormat;
+	}
+
+	byte *getPixelBuffer() {
+		return _pbuf;
+	}
+
+	int getPixelBufferWidth() {
+		return _pbufWidth;
+	}
+
+	int getPixelBufferHeight() {
+		return _pbufHeight;
+	}
+
+	int getPixelBufferPitch() {
+		return _pbufPitch;
+	}
+
+	int getPixelBufferBpp() {
+		return _pbufBpp;
+	}
+
+	const uint *getZBuffer() {
+		return _zbuf;
+	}
+
+	Graphics::Surface *copyFromFrameBuffer(const Graphics::PixelFormat &dstFormat) {
+		Graphics::Surface tmp;
+		tmp.init(_pbufWidth, _pbufHeight, _pbufPitch, _pbuf, _pbufFormat);
+		return tmp.convertTo(dstFormat);
+	}
+
+	void getSurfaceRef(Graphics::Surface &surface) {
+		surface.init(_pbufWidth, _pbufHeight, _pbufPitch, _pbuf, _pbufFormat);
+	}
+
+private:
+
+	FORCEINLINE void setPixelAt(int pixel, uint32 value) {
+		switch (_pbufBpp) {
+		case 2:
+			((uint16 *) _pbuf)[pixel] = value;
+			return;
+		case 3:
+			pixel *= 3;
+#if defined(SCUMM_BIG_ENDIAN)
+			_pbuf[pixel + 0] = (value >> 16) & 0xFF;
+			_pbuf[pixel + 1] = (value >> 8) & 0xFF;
+			_pbuf[pixel + 2] = value & 0xFF;
+#elif defined(SCUMM_LITTLE_ENDIAN)
+			_pbuf[pixel + 0] = value & 0xFF;
+			_pbuf[pixel + 1] = (value >> 8) & 0xFF;
+			_pbuf[pixel + 2] = (value >> 16) & 0xFF;
+#endif
+			return;
+		case 4:
+			((uint32 *) _pbuf)[pixel] = value;
+			return;
+		}
+		error("setPixelAt: Unhandled bytesPerPixel %d", int(_pbufBpp));
+	}
+
+	FORCEINLINE uint32 getPixelAt(int i) const {
+		switch (_pbufBpp) {
+		case 2:
+			return ((uint16 *) _pbuf)[i];
+		case 3:
+			i *= 3;
+#if defined(SCUMM_BIG_ENDIAN)
+			return (_pbuf[i + 0] << 16) | (_pbuf[i + 1] << 8) | _pbuf[i + 2];
+#elif defined(SCUMM_LITTLE_ENDIAN)
+			return _pbuf[i + 0] | (_pbuf[i + 1] << 8) | (_pbuf[i + 2] << 16);
+#endif
+		case 4:
+			return ((uint32 *) _pbuf)[i];
+		}
+		error("getPixelAt: Unhandled bytesPerPixel %d", int(_pbufBpp));
+	}
+
+	FORCEINLINE bool compareDepth(uint &zSrc, uint &zDst) {
+		if (!_depthTestEnabled)
+			return true;
+
+		switch (_depthFunc) {
+		case TGL_NEVER:
+			break;
+		case TGL_LESS:
+			if (zDst < zSrc)
+				return true;
+			break;
+		case TGL_EQUAL:
+			if (zDst == zSrc)
+				return true;
+			break;
+		case TGL_LEQUAL:
+			if (zDst <= zSrc)
+				return true;
+			break;
+		case TGL_GREATER:
+			if (zDst > zSrc)
+				return true;
+			break;
+		case TGL_NOTEQUAL:
+			if (zDst != zSrc)
+				return true;
+			break;
+		case TGL_GEQUAL:
+			if (zDst >= zSrc)
+				return true;
+			break;
+		case TGL_ALWAYS:
+			return true;
+		}
+		return false;
+	}
+
+	FORCEINLINE bool checkAlphaTest(byte aSrc) {
+		if (!_alphaTestEnabled)
+			return true;
+
+		switch (_alphaTestFunc) {
+		case TGL_NEVER:
+			break;
+		case TGL_LESS:
+			if (aSrc < _alphaTestRefVal)
+				return true;
+			break;
+		case TGL_EQUAL:
+			if (aSrc == _alphaTestRefVal)
+				return true;
+			break;
+		case TGL_LEQUAL:
+			if (aSrc <= _alphaTestRefVal)
+				return true;
+			break;
+		case TGL_GREATER:
+			if (aSrc > _alphaTestRefVal)
+				return true;
+			break;
+		case TGL_NOTEQUAL:
+			if (aSrc != _alphaTestRefVal)
+				return true;
+			break;
+		case TGL_GEQUAL:
+			if (aSrc >= _alphaTestRefVal)
+				return true;
+			break;
+		case TGL_ALWAYS:
+			return true;
+		}
+		return false;
+	}
+
+	FORCEINLINE bool stencilTest(byte sSrc) {
+		switch (_stencilTestFunc) {
+		case TGL_NEVER:
+			break;
+		case TGL_LESS:
+			if ((_stencilRefVal & _stencilMask) < (sSrc & _stencilMask))
+				return true;
+			break;
+		case TGL_LEQUAL:
+			if ((_stencilRefVal & _stencilMask) <= (sSrc & _stencilMask))
+				return true;
+			break;
+		case TGL_GREATER:
+			if ((_stencilRefVal & _stencilMask) > (sSrc & _stencilMask))
+				return true;
+			break;
+		case TGL_GEQUAL:
+			if ((_stencilRefVal & _stencilMask) >= (sSrc & _stencilMask))
+				return true;
+			break;
+		case TGL_EQUAL:
+			if ((_stencilRefVal & _stencilMask) == (sSrc & _stencilMask))
+				return true;
+			break;
+		case TGL_NOTEQUAL:
+			if ((_stencilRefVal & _stencilMask) != (sSrc & _stencilMask))
+				return true;
+			break;
+		case TGL_ALWAYS:
+			return true;
+		}
+		return false;
+	}
+
+	FORCEINLINE void stencilOp(bool stencilTestResult, bool depthTestResult, byte *sDst) {
+		int op = !stencilTestResult ? _stencilSfail : !depthTestResult ? _stencilDpfail : _stencilDppass;
+		byte oldValue = *sDst;
+		byte newValue = oldValue;
+		switch (op) {
+		case TGL_KEEP:
+			return;
+		case TGL_ZERO:
+			newValue = 0;
+			break;
+		case TGL_REPLACE:
+			newValue = _stencilRefVal;
+			break;
+		case TGL_INCR:
+			if (newValue < 255)
+				newValue++;
+			break;
+		case TGL_INCR_WRAP:
+			newValue++;
+			break;
+		case TGL_DECR:
+			if (newValue > 0)
+				newValue--;
+			break;
+		case TGL_DECR_WRAP:
+			newValue--;
+			break;
+		case TGL_INVERT:
+			newValue = ~newValue;
+		}
+		*sDst = (newValue & _stencilWriteMask) | (oldValue & ~_stencilWriteMask);
+	}
+
+	template <bool kEnableAlphaTest, bool kBlendingEnabled>
+	FORCEINLINE void writePixel(int pixel, int value) {
+		writePixel<kEnableAlphaTest, kBlendingEnabled, false>(pixel, value, 0);
+	}
+
+	template <bool kEnableAlphaTest, bool kBlendingEnabled, bool kDepthWrite>
+	FORCEINLINE void writePixel(int pixel, int value, uint z) {
+		if (kBlendingEnabled == false) {
+			setPixelAt(pixel, value);
+			if (kDepthWrite) {
+				_zbuf[pixel] = z;
+			}
+		} else {
+			byte rSrc, gSrc, bSrc, aSrc;
+			_pbufFormat.colorToARGB(value, aSrc, rSrc, gSrc, bSrc);
+
+			writePixel<kEnableAlphaTest, kBlendingEnabled, kDepthWrite>(pixel, aSrc, rSrc, gSrc, bSrc, z);
+		}
+	}
+
+	FORCEINLINE void writePixel(int pixel, int value) {
+		if (_alphaTestEnabled) {
+			writePixel<true>(pixel, value);
+		} else {
+			writePixel<false>(pixel, value);
+		}
+	}
+
+	template <bool kDepthWrite, bool kSmoothMode, bool kFogMode, bool kEnableAlphaTest, bool kEnableScissor, bool kEnableBlending, bool kStencilEnabled, bool kStippleEnabled, bool kDepthTestEnabled>
+	void putPixelNoTexture(int fbOffset, uint *pz, byte *ps, int _a,
+	                       int x, int y, uint &z, uint &r, uint &g, uint &b, uint &a,
+	                       int &dzdx, int &drdx, int &dgdx, int &dbdx, uint dadx,
+	                       uint &fog, int fog_r, int fog_g, int fog_b, int &dfdx);
+
+	enum class ColorMode {
+		NoInterpolation,
+		Default, // GL_TEXTURE_ENV_MODE == GL_MODULATE
+		CustomTexEnv
+	};
+
+	template <bool kDepthWrite, ColorMode kColorMode, bool kSmoothMode, bool kFogMode, bool kEnableAlphaTest, bool kEnableScissor, bool kEnableBlending, bool kStencilEnabled, bool kDepthTestEnabled>
+	void putPixelTexture(int fbOffset, const TexelBuffer *texture,
+	                     uint wrap_s, uint wrap_t, uint *pz, byte *ps, int _a,
+	                     int x, int y, uint &z, int &t, int &s,
+	                     uint &r, uint &g, uint &b, uint &a,
+	                     int &dzdx, int &dsdx, int &dtdx, int &drdx, int &dgdx, int &dbdx, uint dadx,
+	                     uint &fog, int fog_r, int fog_g, int fog_b, int &dfdx);
+
+	template <bool kDepthWrite, bool kEnableScissor, bool kStencilEnabled, bool kStippleEnabled, bool kDepthTestEnabled>
+	void putPixelDepth(uint *pz, byte *ps, int _a, int x, int y, uint &z, int &dzdx);
+
+
+	template <bool kEnableAlphaTest>
+	FORCEINLINE void writePixel(int pixel, int value) {
+		if (_blendingEnabled) {
+			writePixel<kEnableAlphaTest, true>(pixel, value);
+		} else {
+			writePixel<kEnableAlphaTest, false>(pixel, value);
+		}
+	}
+
+	FORCEINLINE void writePixel(int pixel, byte rSrc, byte gSrc, byte bSrc) {
+		writePixel(pixel, 255, rSrc, gSrc, bSrc);
+	}
+
+	FORCEINLINE bool scissorPixel(int x, int y) {
+		return !_clipRectangle.contains(x, y);
+	}
+
+public:
+
+	FORCEINLINE void writePixel(int pixel, byte aSrc, byte rSrc, byte gSrc, byte bSrc) {
+		if (_alphaTestEnabled) {
+			writePixel<true>(pixel, aSrc, rSrc, gSrc, bSrc);
+		} else {
+			writePixel<false>(pixel, aSrc, rSrc, gSrc, bSrc);
+		}
+	}
+
+private:
+
+	template <bool kEnableAlphaTest>
+	FORCEINLINE void writePixel(int pixel, byte aSrc, byte rSrc, byte gSrc, byte bSrc) {
+		if (_blendingEnabled) {
+			writePixel<kEnableAlphaTest, true>(pixel, aSrc, rSrc, gSrc, bSrc);
+		} else {
+			writePixel<kEnableAlphaTest, false>(pixel, aSrc, rSrc, gSrc, bSrc);
+		}
+	}
+
+	template <bool kEnableAlphaTest, bool kBlendingEnabled>
+	FORCEINLINE void writePixel(int pixel, byte aSrc, byte rSrc, byte gSrc, byte bSrc) {
+		writePixel<kEnableAlphaTest, kBlendingEnabled, false>(pixel, aSrc, rSrc, gSrc, bSrc, 0);
+	}
+
+	template <bool kEnableAlphaTest, bool kBlendingEnabled, bool kDepthWrite>
+	FORCEINLINE void writePixel(int pixel, byte aSrc, byte rSrc, byte gSrc, byte bSrc, uint z) {
+		writePixel<kEnableAlphaTest, kBlendingEnabled, kDepthWrite, false>(pixel, aSrc, rSrc, gSrc, bSrc, z, 0.0f, 0, 0, 0);
+	}
+
+	template <bool kEnableAlphaTest, bool kBlendingEnabled, bool kDepthWrite, bool kFogMode>
+	FORCEINLINE void writePixel(int pixel, byte aSrc, byte rSrc, byte gSrc, byte bSrc, float z, uint fog, byte fog_r, byte fog_g, byte fog_b) {
+		if (kEnableAlphaTest) {
+			if (!checkAlphaTest(aSrc))
+				return;
+		}
+
+		if (kDepthWrite) {
+			_zbuf[pixel] = z;
+		}
+
+		if (kFogMode) {
+			int oneMinusFog = (1 << ZB_FOG_BITS) - fog;
+			int finalR = (rSrc * fog + fog_r * oneMinusFog) >> ZB_FOG_BITS;
+			int finalG = (gSrc * fog + fog_g * oneMinusFog) >> ZB_FOG_BITS;
+			int finalB = (bSrc * fog + fog_b * oneMinusFog) >> ZB_FOG_BITS;
+			if (finalR > 255) {
+				rSrc = 255;
+			} else {
+				rSrc = finalR;
+			}
+			if (finalG > 255) {
+				gSrc = 255;
+			} else {
+				gSrc = finalG;
+			}
+			if (finalB > 255) {
+				bSrc = 255;
+			} else {
+				bSrc = finalB;
+			}
+		}
+
+		if (!kBlendingEnabled) {
+			setPixelAt(pixel, _pbufFormat.ARGBToColor(aSrc, rSrc, gSrc, bSrc));
+		} else {
+			byte rDst, gDst, bDst, aDst;
+			_pbufFormat.colorToARGB(getPixelAt(pixel), aDst, rDst, gDst, bDst);
+			switch (_sourceBlendingFactor) {
+			case TGL_ZERO:
+				rSrc = gSrc = bSrc = 0;
+				break;
+			case TGL_ONE:
+				break;
+			case TGL_DST_COLOR:
+				rSrc = (rDst * rSrc) >> 8;
+				gSrc = (gDst * gSrc) >> 8;
+				bSrc = (bDst * bSrc) >> 8;
+				break;
+			case TGL_ONE_MINUS_DST_COLOR:
+				rSrc = (rSrc * (255 - rDst)) >> 8;
+				gSrc = (gSrc * (255 - gDst)) >> 8;
+				bSrc = (bSrc * (255 - bDst)) >> 8;
+				break;
+			case TGL_SRC_ALPHA:
+				rSrc = (rSrc * aSrc) >> 8;
+				gSrc = (gSrc * aSrc) >> 8;
+				bSrc = (bSrc * aSrc) >> 8;
+				break;
+			case TGL_ONE_MINUS_SRC_ALPHA:
+				rSrc = (rSrc * (255 - aSrc)) >> 8;
+				gSrc = (gSrc * (255 - aSrc)) >> 8;
+				bSrc = (bSrc * (255 - aSrc)) >> 8;
+				break;
+			case TGL_DST_ALPHA:
+				rSrc = (rSrc * aDst) >> 8;
+				gSrc = (gSrc * aDst) >> 8;
+				bSrc = (bSrc * aDst) >> 8;
+				break;
+			case TGL_ONE_MINUS_DST_ALPHA:
+				rSrc = (rSrc * (255 - aDst)) >> 8;
+				gSrc = (gSrc * (255 - aDst)) >> 8;
+				bSrc = (bSrc * (255 - aDst)) >> 8;
+				break;
+			default:
+				break;
+			}
+
+			switch (_destinationBlendingFactor) {
+			case TGL_ZERO:
+				rDst = gDst = bDst = 0;
+				break;
+			case TGL_ONE:
+				break;
+			case TGL_DST_COLOR:
+				rDst = (rDst * rSrc) >> 8;
+				gDst = (gDst * gSrc) >> 8;
+				bDst = (bDst * bSrc) >> 8;
+				break;
+			case TGL_ONE_MINUS_DST_COLOR:
+				rDst = (rDst * (255 - rSrc)) >> 8;
+				gDst = (gDst * (255 - gSrc)) >> 8;
+				bDst = (bDst * (255 - bSrc)) >> 8;
+				break;
+			case TGL_SRC_ALPHA:
+				rDst = (rDst * aSrc) >> 8;
+				gDst = (gDst * aSrc) >> 8;
+				bDst = (bDst * aSrc) >> 8;
+				break;
+			case TGL_ONE_MINUS_SRC_ALPHA:
+				rDst = (rDst * (255 - aSrc)) >> 8;
+				gDst = (gDst * (255 - aSrc)) >> 8;
+				bDst = (bDst * (255 - aSrc)) >> 8;
+				break;
+			case TGL_DST_ALPHA:
+				rDst = (rDst * aDst) >> 8;
+				gDst = (gDst * aDst) >> 8;
+				bDst = (bDst * aDst) >> 8;
+				break;
+			case TGL_ONE_MINUS_DST_ALPHA:
+				rDst = (rDst * (255 - aDst)) >> 8;
+				gDst = (gDst * (255 - aDst)) >> 8;
+				bDst = (bDst * (255 - aDst)) >> 8;
+				break;
+			case TGL_SRC_ALPHA_SATURATE: {
+				int factor = aSrc < 1 - aDst ? aSrc : 1 - aDst;
+				rDst = (rDst * factor) >> 8;
+				gDst = (gDst * factor) >> 8;
+				bDst = (bDst * factor) >> 8;
+				}
+				break;
+			default:
+				break;
+			}
+			int finalR = rDst + rSrc;
+			int finalG = gDst + gSrc;
+			int finalB = bDst + bSrc;
+			if (finalR > 255) {
+				finalR = 255;
+			}
+			if (finalG > 255) {
+				finalG = 255;
+			}
+			if (finalB > 255) {
+				finalB = 255;
+			}
+			setPixelAt(pixel, _pbufFormat.RGBToColor(finalR, finalG, finalB));
+		}
+	}
+
+public:
+
+	void clear(int clear_z, int z, int clear_color, int r, int g, int b,
+	           bool clearStencil, int stencilValue);
+	void clearRegion(int x, int y, int w, int h, bool clearZ, int z,
+	                 bool clearColor, int r, int g, int b, bool clearStencil, int stencilValue);
+
+	const Common::Rect &getClippingRectangle() const {
+		return _clipRectangle;
+	}
+
+	void setupScissor(bool enable, const int (&scissor)[4], const Common::Rect *clippingRectangle) {
+		_clippingEnabled = enable || clippingRectangle;
+
+		if (enable && clippingRectangle) {
+			_clipRectangle = clippingRectangle->findIntersectingRect(Common::Rect(
+					scissor[0],
+					// all viewport calculations are already flipped upside down
+					_pbufHeight - scissor[1] - scissor[3],
+					scissor[0] + scissor[2],
+					_pbufHeight - scissor[1]));
+		} else if (enable) {
+			_clipRectangle = Common::Rect(
+					scissor[0],
+					// all viewport calculations are already flipped upside down
+					_pbufHeight - scissor[1] - scissor[3],
+					scissor[0] + scissor[2],
+					_pbufHeight - scissor[1]);
+		} else if (clippingRectangle) {
+			_clipRectangle = *clippingRectangle;
+		} else {
+			_clipRectangle = Common::Rect(0, 0, _pbufWidth, _pbufHeight);
+		}
+	}
+
+	void enableBlending(bool enable) {
+		_blendingEnabled = enable;
+	}
+
+	void setBlendingFactors(int sFactor, int dFactor) {
+		_sourceBlendingFactor = sFactor;
+		_destinationBlendingFactor = dFactor;
+	}
+
+	void enableAlphaTest(bool enable) {
+		_alphaTestEnabled = enable;
+	}
+
+	void setAlphaTestFunc(int func, int ref) {
+		_alphaTestFunc = func;
+		_alphaTestRefVal = ref;
+	}
+
+	void enableDepthTest(bool enable) {
+		_depthTestEnabled = enable;
+	}
+
+	void setDepthFunc(int func) {
+		_depthFunc = func;
+	}
+
+	void enableDepthWrite(bool enable) {
+		_depthWrite = enable;
+	}
+
+	void enableStencilTest(bool enable) {
+		_stencilTestEnabled = enable;
+	}
+
+	void setStencilWriteMask(uint stencilWriteMask) {
+		_stencilWriteMask = stencilWriteMask;
+	}
+
+	void enablePolygonStipple(bool enable) {
+		_polygonStippleEnabled = enable;
+	}
+
+	void setPolygonStipplePattern(const byte *stipple) {
+		_polygonStipplePattern = stipple;
+	}
+
+	void enableTwoColorStipple(bool enable) {
+		_twoColorStippleEnabled = enable;
+	}
+
+	void setStippleColor(int r, int g, int b) {
+		_stippleColor = RGB_TO_PIXEL(r, g, b);
+	}
+
+	void setStencilTestFunc(int stencilFunc, byte stencilValue, byte stencilMask) {
+		_stencilTestFunc = stencilFunc;
+		_stencilRefVal = stencilValue;
+		_stencilMask = stencilMask;
+	}
+
+	void setStencilOp(int stencilSfail, int stencilDpfail, int stencilDppass) {
+		_stencilSfail = stencilSfail;
+		_stencilDpfail = stencilDpfail;
+		_stencilDppass = stencilDppass;
+	}
+
+	void setOffsetStates(int offsetStates) {
+		_offsetStates = offsetStates;
+	}
+
+	void setOffsetFactor(float offsetFactor) {
+		_offsetFactor = offsetFactor;
+	}
+
+	void setOffsetUnits(float offsetUnits) {
+		_offsetUnits = offsetUnits;
+	}
+
+	void setTexture(const TexelBuffer *texture, uint wraps, uint wrapt) {
+		_currentTexture = texture;
+		_wrapS = wraps;
+		_wrapT = wrapt;
+	}
+
+	void setTextureEnvironment(const GLTextureEnv *texEnv) {
+		_textureEnv = texEnv;
+	}
+
+	void setTextureSizeAndMask(int textureSize, int textureSizeMask) {
+		_textureSize = textureSize;
+		_textureSizeMask = textureSizeMask;
+	}
+
+	void setFogEnabled(bool enable) {
+		_fogEnabled = enable;
+	}
+
+	void setFogColor(float colorR, float colorG, float colorB) {
+		_fogColorR = colorR;
+		_fogColorG = colorG;
+		_fogColorB = colorB;
+	}
+
+private:
+
+	/**
+	* Blit the buffer to the screen buffer, checking the depth of the pixels.
+	* Eack pixel is copied if and only if its depth value is bigger than the
+	* depth value of the screen pixel, so if it is 'above'.
+	*/
+	Buffer *genOffscreenBuffer();
+	void delOffscreenBuffer(Buffer *buffer);
+	void blitOffscreenBuffer(Buffer *buffer);
+	void selectOffscreenBuffer(Buffer *buffer);
+	void clearOffscreenBuffer(Buffer *buffer);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode, bool kAlphaTestEnabled, bool kEnableScissor,
+	          bool kBlendingEnabled, bool kStencilEnabled, bool kStippleEnabled, bool kDepthTestEnabled>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode, bool kAlphaTestEnabled, bool kEnableScissor,
+	          bool kBlendingEnabled, bool kStencilEnabled, bool kStippleEnabled>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode, bool kAlphaTestEnabled, bool kEnableScissor,
+	          bool kBlendingEnabled, bool kStencilEnabled>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode, bool enableAlphaTest, bool kEnableScissor, bool kBlendingEnabled>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode, bool enableAlphaTest, bool kEnableScissor>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode, bool enableAlphaTest>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite, bool kFogMode>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode,
+	          bool kDepthWrite>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <ColorMode kColorMode, bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode>
+	void fillTriangle(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <bool kInterpZ, bool kInterpST, bool kInterpSTZ, bool kSmoothMode, bool kDepthWrite>
+	void fillTriangleTextureMapping(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+public:
+
+	void fillTriangleTextureMappingPerspectiveSmooth(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillTriangleTextureMappingPerspectiveFlat(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillTriangleDepthOnly(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillTriangleFlat(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillTriangleSmooth(ZBufferPoint *p0, ZBufferPoint *p1, ZBufferPoint *p2);
+
+	void plot(ZBufferPoint *p);
+	void fillLine(ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillLineZ(ZBufferPoint *p1, ZBufferPoint *p2);
+
+private:
+
+	void fillLineFlatZ(ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillLineInterpZ(ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillLineFlat(ZBufferPoint *p1, ZBufferPoint *p2);
+	void fillLineInterp(ZBufferPoint *p1, ZBufferPoint *p2);
+
+	template <bool kDepthWrite>
+	FORCEINLINE void putPixel(uint pixelOffset, int color, int x, int y, uint z);
+
+	template <bool kDepthWrite, bool kEnableScissor>
+	FORCEINLINE void putPixel(uint pixelOffset, int color, int x, int y, uint z);
+
+	template <bool kEnableScissor>
+	FORCEINLINE void putPixel(uint pixelOffset, int color, int x, int y);
+
+	template <bool kInterpRGB, bool kInterpZ, bool kDepthWrite>
+	void drawLine(const ZBufferPoint *p1, const ZBufferPoint *p2);
+
+	template <bool kInterpRGB, bool kInterpZ, bool kDepthWrite, bool kEnableScissor>
+	void drawLine(const ZBufferPoint *p1, const ZBufferPoint *p2);
+
+	void applyTextureEnvironment(
+		int internalformat,
+		uint previousA, uint previousR, uint previousG, uint previousB,
+		byte &texA, byte &texR, byte &texG, byte &texB);
+
+	// the same as GL_TEXTURE_ENV_MODE == GL_MODULATE as fast-path for the default mode
+	void applyModulation(
+		uint previousA, uint previousR, uint previousG, uint previousB,
+		byte &texA, byte &texR, byte &texG, byte &texB);
+
+	Buffer _offscreenBuffer;
+	byte *_pbuf;
+	int _pbufWidth;
+	int _pbufHeight;
+	int _pbufPitch;
+	Graphics::PixelFormat _pbufFormat;
+	int _pbufBpp;
+
+	uint *_zbuf;
+	byte *_sbuf;
+
+	bool _enableStencil;
+	int _textureSize;
+	int _textureSizeMask;
+
+	Common::Rect _clipRectangle;
+	bool _clippingEnabled;
+
+	const TexelBuffer *_currentTexture;
+	const GLTextureEnv *_textureEnv;
+	uint _wrapS, _wrapT;
+	bool _blendingEnabled;
+	int _sourceBlendingFactor;
+	int _destinationBlendingFactor;
+	bool _alphaTestEnabled;
+	int _alphaTestFunc;
+	int _alphaTestRefVal;
+	bool _depthTestEnabled;
+	bool _depthWrite;
+	bool _stencilTestEnabled;
+	int _stencilTestFunc;
+	byte _stencilRefVal;
+	byte _stencilMask;
+	byte _stencilWriteMask;
+	int _stencilSfail;
+	int _stencilDpfail;
+	int _stencilDppass;
+
+	bool _polygonStippleEnabled;
+	bool _twoColorStippleEnabled;
+	uint32 _stippleColor;
+	const byte *_polygonStipplePattern;
+	int _depthFunc;
+	int _offsetStates;
+	float _offsetFactor;
+	float _offsetUnits;
+	bool _fogEnabled;
+	float _fogColorR;
+	float _fogColorG;
+	float _fogColorB;
+};
+
+// memory.c
+void gl_free(void *p);
+void *gl_malloc(int size);
+void *gl_zalloc(int size);
+void *gl_realloc(void *p, int size);
+
+} // end of namespace TinyGL
+
+#endif