318 lines
9.7 KiB
C++
318 lines
9.7 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/>.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2006-2010 - Frictional Games
|
|
*
|
|
* This file is part of HPL1 Engine.
|
|
*/
|
|
|
|
#ifndef HPL_LOWLEVELGRAPHICS_SDL_H
|
|
#define HPL_LOWLEVELGRAPHICS_SDL_H
|
|
|
|
#include "common/ptr.h"
|
|
#include "graphics/pixelformat.h"
|
|
#include "graphics/surface.h"
|
|
#include "hpl1/engine/graphics/LowLevelGraphics.h"
|
|
#include "hpl1/engine/math/MathTypes.h"
|
|
#include "hpl1/opengl.h"
|
|
|
|
#ifdef HPL1_USE_OPENGL
|
|
|
|
namespace hpl {
|
|
|
|
//-------------------------------------------------
|
|
|
|
GLenum ColorFormatToGL(eColorDataFormat format);
|
|
|
|
GLenum TextureTargetToGL(eTextureTarget target);
|
|
|
|
//-------------------------------------------------
|
|
|
|
class cLowLevelGraphicsSDL : public iLowLevelGraphics {
|
|
public:
|
|
cLowLevelGraphicsSDL();
|
|
~cLowLevelGraphicsSDL();
|
|
|
|
bool Init(int alWidth, int alHeight, int alBpp, int abFullscreen, int alMultisampling,
|
|
const tString &asWindowCaption);
|
|
|
|
int GetCaps(eGraphicCaps aType) const;
|
|
|
|
void ShowCursor(bool abX);
|
|
|
|
void SetMultisamplingActive(bool abX);
|
|
|
|
void SetGammaCorrection(float afX);
|
|
float GetGammaCorrection();
|
|
|
|
int GetMultisampling() { return mlMultisampling; }
|
|
|
|
void SetClipPlane(int alIdx, const cPlanef &aPlane);
|
|
cPlanef GetClipPlane(int alIdx, const cPlanef &aPlane);
|
|
void SetClipPlaneActive(int alIdx, bool abX);
|
|
|
|
cVector2f GetScreenSize();
|
|
cVector2f GetVirtualSize();
|
|
void SetVirtualSize(cVector2f avSize);
|
|
|
|
Bitmap2D *CreateBitmap2D(const cVector2l &avSize);
|
|
FontData *CreateFontData(const tString &asName);
|
|
|
|
iTexture *CreateTexture(bool abUseMipMaps, eTextureType aType, eTextureTarget aTarget);
|
|
iTexture *CreateTexture(const tString &asName, bool abUseMipMaps, eTextureType aType, eTextureTarget aTarget);
|
|
iTexture *CreateTexture(Bitmap2D *apBmp, bool abUseMipMaps, eTextureType aType, eTextureTarget aTarget);
|
|
iTexture *CreateTexture(const cVector2l &avSize, int alBpp, cColor aFillCol,
|
|
bool abUseMipMaps, eTextureType aType, eTextureTarget aTarget);
|
|
|
|
Graphics::PixelFormat *GetPixelFormat();
|
|
|
|
iGpuProgram *CreateGpuProgram(const tString &vertex, const tString &fragment);
|
|
|
|
void SaveScreenToBMP(const tString &asFile);
|
|
|
|
/////////// MATRIX METHODS /////////////////////////
|
|
|
|
void PushMatrix(eMatrix aMtxType);
|
|
void PopMatrix(eMatrix aMtxType);
|
|
void SetIdentityMatrix(eMatrix aMtxType);
|
|
|
|
void SetMatrix(eMatrix aMtxType, const cMatrixf &a_mtxA);
|
|
|
|
void TranslateMatrix(eMatrix aMtxType, const cVector3f &avPos);
|
|
void RotateMatrix(eMatrix aMtxType, const cVector3f &avRot);
|
|
void ScaleMatrix(eMatrix aMtxType, const cVector3f &avScale);
|
|
|
|
void SetOrthoProjection(const cVector2f &avSize, float afMin, float afMax);
|
|
|
|
/////////// DRAWING METHODS /////////////////////////
|
|
|
|
// OCCLUSION
|
|
iOcclusionQuery *CreateOcclusionQuery();
|
|
void DestroyOcclusionQuery(iOcclusionQuery *apQuery);
|
|
|
|
// CLEARING THE FRAMEBUFFER
|
|
void ClearScreen();
|
|
|
|
void SetClearColor(const cColor &aCol);
|
|
void SetClearDepth(float afDepth);
|
|
void SetClearStencil(int alVal);
|
|
|
|
void SetClearColorActive(bool abX);
|
|
void SetClearDepthActive(bool abX);
|
|
void SetClearStencilActive(bool abX);
|
|
|
|
void SetColorWriteActive(bool abR, bool abG, bool abB, bool abA);
|
|
void SetDepthWriteActive(bool abX);
|
|
|
|
void SetCullActive(bool abX);
|
|
void SetCullMode(eCullMode aMode);
|
|
|
|
// DEPTH
|
|
void SetDepthTestActive(bool abX);
|
|
void SetDepthTestFunc(eDepthTestFunc aFunc);
|
|
|
|
// ALPHA
|
|
void SetAlphaTestActive(bool abX);
|
|
void SetAlphaTestFunc(eAlphaTestFunc aFunc, float afRef);
|
|
|
|
// STENCIL
|
|
void SetStencilActive(bool abX);
|
|
/*void SetStencilTwoSideActive(bool abX);
|
|
void SetStencilFace(eStencilFace aFace);
|
|
void SetStencilFunc(eStencilFunc aFunc,int alRef, unsigned int aMask);
|
|
void SetStencilOp(eStencilOp aFailOp,eStencilOp aZFailOp,eStencilOp aZPassOp);*/
|
|
void SetStencil(eStencilFunc aFunc, int alRef, unsigned int aMask,
|
|
eStencilOp aFailOp, eStencilOp aZFailOp, eStencilOp aZPassOp);
|
|
void SetStencilTwoSide(eStencilFunc aFrontFunc, eStencilFunc aBackFunc,
|
|
int alRef, unsigned int aMask,
|
|
eStencilOp aFrontFailOp, eStencilOp aFrontZFailOp, eStencilOp aFrontZPassOp,
|
|
eStencilOp aBackFailOp, eStencilOp aBackZFailOp, eStencilOp aBackZPassOp);
|
|
void SetStencilTwoSide(bool abX);
|
|
|
|
// SCISSOR
|
|
void SetScissorActive(bool abX);
|
|
void SetScissorRect(const cRect2l &aRect);
|
|
|
|
// BLENDING
|
|
void SetBlendActive(bool abX);
|
|
void SetBlendFunc(eBlendFunc aSrcFactor, eBlendFunc aDestFactor);
|
|
void SetBlendFuncSeparate(eBlendFunc aSrcFactorColor, eBlendFunc aDestFactorColor,
|
|
eBlendFunc aSrcFactorAlpha, eBlendFunc aDestFactorAlpha);
|
|
|
|
// TEXTURE
|
|
void SetTexture(unsigned int alUnit, iTexture *apTex);
|
|
void SetActiveTextureUnit(unsigned int alUnit);
|
|
void SetTextureEnv(eTextureParam aParam, int alVal);
|
|
void SetTextureConstantColor(const cColor &color);
|
|
|
|
void SetColor(const cColor &aColor);
|
|
|
|
// POLYGONS
|
|
iVertexBuffer *CreateVertexBuffer(tVertexFlag aFlags, eVertexBufferDrawType aDrawType,
|
|
eVertexBufferUsageType aUsageType,
|
|
int alReserveVtxSize = 0, int alReserveIdxSize = 0);
|
|
|
|
void DrawRect(const cVector2f &avPos, const cVector2f &avSize, float afZ);
|
|
|
|
void DrawTri(const tVertexVec &avVtx);
|
|
void DrawTri(const cVertex *avVtx);
|
|
|
|
void DrawQuad(const tVertexVec &avVtx);
|
|
void DrawQuad(const tVertexVec &avVtx, const cColor aCol);
|
|
void DrawQuad(const tVertexVec &avVtx, const float afZ);
|
|
void DrawQuad(const tVertexVec &avVtx, const float afZ, const cColor &aCol);
|
|
void DrawQuadMultiTex(const tVertexVec &avVtx, const tVector3fVec &avExtraUvs);
|
|
|
|
void AddVertexToBatch(const cVertex &apVtx);
|
|
void AddVertexToBatch(const cVertex *apVtx, const cVector3f *avTransform);
|
|
void AddVertexToBatch(const cVertex *apVtx, const cMatrixf *aMtx);
|
|
|
|
void AddVertexToBatch_Size2D(const cVertex *apVtx, const cVector3f *avTransform,
|
|
const cColor *apCol, const float &mfW, const float &mfH);
|
|
|
|
void AddVertexToBatch_Raw(const cVector3f &avPos, const cColor &aColor,
|
|
const cVector3f &avTex);
|
|
|
|
void AddTexCoordToBatch(unsigned int alUnit, const cVector3f *apCoord);
|
|
void SetBatchTextureUnitActive(unsigned int alUnit, bool abActive);
|
|
|
|
void AddIndexToBatch(int alIndex);
|
|
|
|
void FlushTriBatch(tVtxBatchFlag aTypeFlags, bool abAutoClear = true);
|
|
void FlushQuadBatch(tVtxBatchFlag aTypeFlags, bool abAutoClear = true);
|
|
void ClearBatch();
|
|
|
|
// PRIMITIVES
|
|
void DrawLine(const cVector3f &avBegin, const cVector3f &avEnd, cColor aCol);
|
|
void DrawBoxMaxMin(const cVector3f &avMax, const cVector3f &avMin, cColor aCol);
|
|
void DrawSphere(const cVector3f &avPos, float afRadius, cColor aCol);
|
|
|
|
void DrawLine2D(const cVector2f &avBegin, const cVector2f &avEnd, float afZ, cColor aCol);
|
|
void DrawLineRect2D(const cRect2f &aRect, float afZ, cColor aCol);
|
|
void DrawLineCircle2D(const cVector2f &avCenter, float afRadius, float afZ, cColor aCol);
|
|
|
|
void DrawFilledRect2D(const cRect2f &aRect, float afZ, cColor aCol);
|
|
|
|
// FRAMEBUFFER
|
|
void CopyContextToTexure(iTexture *apTex, const cVector2l &avPos,
|
|
const cVector2l &avSize, const cVector2l &avTexOffset = 0);
|
|
void SetRenderTarget(iTexture *pTex);
|
|
bool RenderTargetHasZBuffer();
|
|
void FlushRenderTarget();
|
|
|
|
void FlushRendering();
|
|
void SwapBuffers();
|
|
|
|
///// SDL Specific ////////////////////////////
|
|
|
|
void SetupGL();
|
|
|
|
GLenum GetGLTextureTargetEnum(eTextureTarget aType);
|
|
|
|
private:
|
|
cVector2l mvScreenSize;
|
|
cVector2f mvVirtualSize;
|
|
int mlMultisampling;
|
|
int mlBpp;
|
|
|
|
// Gamma
|
|
// uint16 mvStartGammaArray[3][256];
|
|
float mfGammaCorrection;
|
|
|
|
// Clipping
|
|
cPlanef mvClipPlanes[kMaxClipPlanes];
|
|
|
|
// SDL Variables
|
|
// SDL_Surface *mpScreen;
|
|
Graphics::PixelFormat mpPixelFormat;
|
|
|
|
// Vertex Array variables
|
|
// The vertex arrays used:
|
|
float *mpVertexArray;
|
|
unsigned int mlVertexCount;
|
|
unsigned int *mpIndexArray;
|
|
unsigned int mlIndexCount;
|
|
|
|
unsigned int mlBatchStride;
|
|
|
|
float *mpTexCoordArray[MAX_TEXTUREUNITS];
|
|
bool mbTexCoordArrayActive[MAX_TEXTUREUNITS];
|
|
unsigned int mlTexCoordArrayCount[MAX_TEXTUREUNITS];
|
|
|
|
unsigned int mlBatchArraySize;
|
|
|
|
// Clearing
|
|
bool mbClearColor;
|
|
bool mbClearDepth;
|
|
bool mbClearStencil;
|
|
|
|
// Rendertarget variables
|
|
iTexture *mpRenderTarget;
|
|
|
|
// Texture
|
|
iTexture *mpCurrentTexture[MAX_TEXTUREUNITS];
|
|
|
|
iTexture *_screenBuffer;
|
|
iGpuProgram *_gammaCorrectionProgram;
|
|
|
|
// CG Compiler Variables
|
|
// CGcontext mCG_Context;
|
|
|
|
// Multisample
|
|
void CheckMultisampleCaps();
|
|
|
|
void applyGammaCorrection();
|
|
|
|
// Batch helper
|
|
void SetUpBatchArrays();
|
|
|
|
// Depth helper
|
|
GLenum GetGLDepthTestFuncEnum(eDepthTestFunc aType);
|
|
|
|
// Alpha Helper
|
|
GLenum GetGLAlphaTestFuncEnum(eAlphaTestFunc aType);
|
|
|
|
// Stencil helper
|
|
GLenum GetGLStencilFuncEnum(eStencilFunc aType);
|
|
GLenum GetGLStencilOpEnum(eStencilOp aType);
|
|
|
|
// Matrix Helper
|
|
void SetMatrixMode(eMatrix mType);
|
|
|
|
// Texture helper
|
|
GLenum GetGLTextureParamEnum(eTextureParam aType);
|
|
GLenum GetGLTextureOpEnum(eTextureOp aType);
|
|
GLenum GetGLTextureFuncEnum(eTextureFunc aType);
|
|
GLenum GetGLTextureSourceEnum(eTextureSource aType);
|
|
|
|
// Blend helper
|
|
GLenum GetGLBlendEnum(eBlendFunc aType);
|
|
|
|
// Vtx helper
|
|
void SetVtxBatchStates(tVtxBatchFlag flags);
|
|
};
|
|
|
|
} // namespace hpl
|
|
|
|
#endif // HPL1_USE_OPENGL
|
|
#endif // HPL_LOWLEVELGRAPHICS_SDL_H
|