#include <C4DrawGL.h>

Inheritance diagram for CStdGL:

Collaboration diagram for CStdGL:

Public Types
enum	DrawOperation { OP_POINTS, OP_TRIANGLES }

enum	{ DEFAULT_MESSAGE_COLOR = 0xffffffff }

Public Member Functions
	CStdGL ()

	~CStdGL () override

unsigned int	GenVAOID ()

void	FreeVAOID (unsigned int vaoid)

bool	GetVAO (unsigned int vaoid, GLuint &vao)

void	Clear () override

void	Default () override

bool	OnResolutionChanged (unsigned int iXRes, unsigned int iYRes) override

bool	UpdateClipper () override

const StdProjectionMatrix &	GetProjectionMatrix () const

bool	PrepareMaterial (StdMeshMatManager &mat_manager, StdMeshMaterialLoader &loader, StdMeshMaterial &mat) override

bool	PrepareRendering (C4Surface *sfcToSurface) override

bool	PrepareSpriteShader (C4Shader &shader, const char name, int ssc, C4GroupSet pGroups, const char const additionalDefines, const char const additionalSlices) override

bool	EnsureMainContextSelected () override

CStdGLCtx *	CreateContext (C4Window pWindow, C4AbstractApp pApp) override

void	SetupMultiBlt (C4ShaderCall &call, const C4BltTransform pTransform, GLuint baseTex, GLuint overlayTex, GLuint normalTex, DWORD dwOverlayModClr, StdProjectionMatrix out_modelview)

void	PerformMesh (StdMeshInstance &instance, float tx, float ty, float twdt, float thgt, DWORD dwPlayerColor, C4BltTransform *pTransform) override

void	FillBG (DWORD dwClr=0) override

void	PerformMultiPix (C4Surface sfcTarget, const C4BltVertex vertices, unsigned int n_vertices, C4ShaderCall *shader_call) override

void	PerformMultiLines (C4Surface sfcTarget, const C4BltVertex vertices, unsigned int n_vertices, float width, C4ShaderCall *shader_call) override

void	PerformMultiTris (C4Surface sfcTarget, const C4BltVertex vertices, unsigned int n_vertices, const C4BltTransform pTransform, C4TexRef pTex, C4TexRef pOverlay, C4TexRef pNormal, DWORD dwOverlayClrMod, C4ShaderCall *shader_call) override

void	PerformMultiBlt (C4Surface sfcTarget, DrawOperation op, const C4BltVertex vertices, unsigned int n_vertices, bool has_tex, C4ShaderCall *shader_call)

bool	RestoreDeviceObjects () override

bool	InvalidateDeviceObjects () override

bool	DeviceReady () override

bool	InitShaders (C4GroupSet *pGroups)

C4Shader *	GetSpriteShader (int ssc)

C4Shader *	GetSpriteShader (bool haveBase, bool haveOverlay, bool haveNormal)

void	ObjectLabel (uint32_t identifier, uint32_t name, int32_t length, const char *label)

bool	Init (C4AbstractApp *pApp, unsigned int iXRes, unsigned int iYRes, unsigned int iMonitor)

bool	GetPrimaryClipper (int &rX1, int &rY1, int &rX2, int &rY2)

bool	SetPrimaryClipper (int iX1, int iY1, int iX2, int iY2)

bool	SubPrimaryClipper (int iX1, int iY1, int iX2, int iY2)

C4Rect	GetClipRect () const

C4Rect	GetOutRect () const

bool	StorePrimaryClipper ()

bool	RestorePrimaryClipper ()

bool	NoPrimaryClipper ()

bool	ApplyPrimaryClipper (C4Surface *sfcSurface)

bool	DetachPrimaryClipper (C4Surface *sfcSurface)

bool	GetSurfaceSize (C4Surface *sfcSurface, int &iWdt, int &iHgt)

void	Grayscale (C4Surface *sfcSfc, int32_t iOffset=0)

void	LockingPrimary ()

void	PrimaryUnlocked ()

virtual void	BlitLandscape (C4Surface sfcSource, float fx, float fy, C4Surface sfcTarget, float tx, float ty, float wdt, float hgt)

void	Blit8Fast (CSurface8 sfcSource, int fx, int fy, C4Surface sfcTarget, int tx, int ty, int wdt, int hgt)

bool	Blit (C4Surface sfcSource, float fx, float fy, float fwdt, float fhgt, C4Surface sfcTarget, float tx, float ty, float twdt, float thgt, bool fSrcColKey=false, const C4BltTransform *pTransform=nullptr)

bool	BlitUnscaled (C4Surface sfcSource, float fx, float fy, float fwdt, float fhgt, C4Surface sfcTarget, float tx, float ty, float twdt, float thgt, bool fSrcColKey=false, const C4BltTransform *pTransform=nullptr)

bool	RenderMesh (StdMeshInstance &instance, C4Surface sfcTarget, float tx, float ty, float twdt, float thgt, DWORD dwPlayerColor, C4BltTransform pTransform)

bool	Blit8 (C4Surface sfcSource, int fx, int fy, int fwdt, int fhgt, C4Surface sfcTarget, int tx, int ty, int twdt, int thgt, bool fSrcColKey=false, const C4BltTransform *pTransform=nullptr)

bool	BlitSimple (C4Surface sfcSource, int fx, int fy, int fwdt, int fhgt, C4Surface sfcTarget, int tx, int ty, int twdt, int thgt, bool fTransparency=true)

bool	BlitSurface (C4Surface sfcSurface, C4Surface sfcTarget, int tx, int ty, bool fBlitBase)

bool	BlitSurfaceTile (C4Surface sfcSurface, C4Surface sfcTarget, float iToX, float iToY, float iToWdt, float iToHgt, float iOffsetX, float iOffsetY, C4ShaderCall *shader_call)

bool	TextOut (const char szText, CStdFont &rFont, float fZoom, C4Surface sfcDest, float iTx, float iTy, DWORD dwFCol=0xffffffff, BYTE byForm=ALeft, bool fDoMarkup=true)

bool	StringOut (const char szText, CStdFont &rFont, float fZoom, C4Surface sfcDest, float iTx, float iTy, DWORD dwFCol=0xffffffff, BYTE byForm=ALeft, bool fDoMarkup=true)

void	DrawBoxDw (C4Surface *sfcDest, int iX1, int iY1, int iX2, int iY2, DWORD dwClr)

void	DrawBoxFade (C4Surface sfcDest, float iX, float iY, float iWdt, float iHgt, DWORD dwClr1, DWORD dwClr2, DWORD dwClr3, DWORD dwClr4, C4ShaderCall shader_call)

void	DrawPatternedCircle (C4Surface *sfcDest, int x, int y, int r, BYTE col, C4Pattern &Pattern, CStdPalette &rPal)

void	DrawFrameDw (C4Surface *sfcDest, int x1, int y1, int x2, int y2, DWORD dwClr, float width=1.0f)

void	DrawQuadDw (C4Surface sfcTarget, float ipVtx, DWORD dwClr1, DWORD dwClr2, DWORD dwClr3, DWORD dwClr4, C4ShaderCall *shader_call)

void	DrawPix (C4Surface *sfcDest, float tx, float ty, DWORD dwCol)

void	DrawLineDw (C4Surface *sfcTarget, float x1, float y1, float x2, float y2, DWORD dwClr, float width=1.0f)

void	DrawCircleDw (C4Surface *sfcTarget, float cx, float cy, float r, DWORD dwClr, float width=1.0f)

void	SetGamma (float r, float g, float b, int32_t iRampIndex)

void	ResetGamma ()

DWORD	ApplyGammaTo (DWORD dwClr)

void	ActivateBlitModulation (DWORD dwWithClr)

void	DeactivateBlitModulation ()

bool	GetBlitModulation (DWORD &rdwColor)

void	SetBlitMode (DWORD dwBlitMode)

void	ResetBlitMode ()

void	SetFoW (const C4FoWRegion *fow)

const C4FoWRegion *	GetFoW () const

void	SetZoom (float X, float Y, float Zoom)

void	SetZoom (const ZoomData &zoom)

void	GetZoom (ZoomData *r)

void	ApplyZoom (float &X, float &Y)

void	RemoveZoom (float &X, float &Y)

void	SetMeshTransform (const StdMeshMatrix *Transform)

void	SetPerspective (bool fSet)

Public Attributes
struct {
bool	LowMaxVertexUniformCount

bool	ForceSoftwareTransform

}	Workarounds

C4AbstractApp *	pApp

bool	Active

float	gamma [C4MaxGammaRamps][3]

float	gammaOut [3]

int	MaxTexSize {0}

C4ScriptUniform	scriptUniform

float	Zoom

Static Public Attributes
static constexpr int	COLOR_DEPTH = 32

static constexpr int	COLOR_DEPTH_BYTES = COLOR_DEPTH / 8

Protected Member Functions
bool	CheckGLError (const char *szAtOp)

const char *	GLErrorString (GLenum code)

bool	Error (const char *szMsg) override

bool	StringOut (const char szText, C4Surface sfcDest, float iTx, float iTy, DWORD dwFCol, BYTE byForm, bool fDoMarkup, C4Markup &Markup, CStdFont *pFont, float fZoom)

bool	CreatePrimaryClipper (unsigned int iXRes, unsigned int iYRes)

Protected Attributes
int	iPixelFormat

GLenum	sfcFmt

CStdGLCtx *	pMainCtx {nullptr}

CStdGLCtx *	pCurrCtx

GLuint	lines_tex

StdProjectionMatrix	ProjectionMatrix

C4Shader	SpriteShader

C4Shader	SpriteShaderMod2

C4Shader	SpriteShaderBase

C4Shader	SpriteShaderBaseMod2

C4Shader	SpriteShaderBaseOverlay

C4Shader	SpriteShaderBaseOverlayMod2

C4Shader	SpriteShaderLight

C4Shader	SpriteShaderLightMod2

C4Shader	SpriteShaderLightBase

C4Shader	SpriteShaderLightBaseMod2

C4Shader	SpriteShaderLightBaseOverlay

C4Shader	SpriteShaderLightBaseOverlayMod2

C4Shader	SpriteShaderLightBaseNormal

C4Shader	SpriteShaderLightBaseNormalMod2

C4Shader	SpriteShaderLightBaseNormalOverlay

C4Shader	SpriteShaderLightBaseNormalOverlayMod2

GLuint	GenericVBOs [N_GENERIC_VBOS]

unsigned int	GenericVBOSizes [N_GENERIC_VBOS]

unsigned int	CurrentVBO {0}

unsigned int	GenericVAOs [N_GENERIC_VBOS *2]

std::set< unsigned int >	VAOIDs

std::set< unsigned int >::iterator	NextVAOID

float	fClipX1

float	fClipY1

float	fClipX2

float	fClipY2

float	fStClipX1

float	fStClipY1

float	fStClipX2

float	fStClipY2

int32_t	iClipX1

int32_t	iClipY1

int32_t	iClipX2

int32_t	iClipY2

bool	ClipAll

bool	PrimaryLocked

C4Surface *	RenderTarget

bool	BlitModulated

DWORD	BlitModulateClr

DWORD	dwBlitMode

const C4FoWRegion *	pFoW

float	ZoomX

float	ZoomY

const StdMeshMatrix *	MeshTransform

bool	fUsePerspective

Static Protected Attributes
static const unsigned int	N_GENERIC_VBOS = 16

static const unsigned int	GENERIC_VBO_SIZE = 3 * 64

Friends
class	C4Surface

class	C4TexRef

class	C4Pattern

class	CStdGLCtx

class	C4StartupOptionsDlg

class	C4FullScreen

class	C4Window

class	C4ShaderCall

class	C4FoWRegion

Detailed Description

Definition at line 168 of file C4DrawGL.h.

Member Enumeration Documentation

anonymous enum

inherited

Enumerator
DEFAULT_MESSAGE_COLOR

Definition at line 167 of file C4Draw.h.

167 { DEFAULT_MESSAGE_COLOR = 0xffffffff };

C4Draw::DEFAULT_MESSAGE_COLOR

Definition: C4Draw.h:167

enum C4Draw::DrawOperation

inherited

Enumerator
OP_POINTS
OP_TRIANGLES

Definition at line 87 of file C4Draw.h.

87 { OP_POINTS, OP_TRIANGLES };

C4Draw::OP_TRIANGLES

Definition: C4Draw.h:87

C4Draw::OP_POINTS

Definition: C4Draw.h:87

Constructor & Destructor Documentation

CStdGL::CStdGL ( )

Definition at line 98 of file C4DrawGL.cpp.

References Default(), GenericVBOs, lines_tex, and pGL.

               :
     NextVAOID(VAOIDs.end())
 {
     GenericVBOs[0] = 0;
     Default();
     // global ptr
     pGL = this;
     lines_tex = 0;
 }

Here is the call graph for this function:

CStdGL::~CStdGL ( )

override

Definition at line 108 of file C4DrawGL.cpp.

References Clear(), and pGL.

 {
     Clear();
     pGL=nullptr;
 }

Here is the call graph for this function:

Member Function Documentation

void C4Draw::ActivateBlitModulation ( DWORD dwWithClr )

inlineinherited

Definition at line 188 of file C4Draw.h.

Referenced by C4Sky::Draw(), C4Landscape::Draw(), C4MouseControl::Draw(), C4GraphicsOverlay::Draw(), C4GUI::Dialog::Draw(), C4GUI::Tabular::Sheet::DrawCaption(), C4Viewport::DrawMenu(), C4GraphicsOverlay::DrawPicture(), CStdFont::DrawText(), and C4Object::PrepareDrawing().

188 { BlitModulated=true; BlitModulateClr=dwWithClr; } // modulate following blits with a given color

C4Draw::BlitModulateClr

DWORD BlitModulateClr

Definition: C4Draw.h:109

C4Draw::BlitModulated

bool BlitModulated

Definition: C4Draw.h:108

Here is the caller graph for this function:

DWORD C4Draw::ApplyGammaTo ( DWORD dwClr )

inherited

Definition at line 772 of file C4Draw.cpp.

References C4RGB, C4Draw::gammaOut, GetBlueValue, GetGreenValue, and GetRedValue.

 {
     return C4RGB(int(pow(float(GetRedValue(dwClr)) / 255.0f, gammaOut[0]) * 255.0),
                  int(pow(float(GetGreenValue(dwClr)) / 255.0f, gammaOut[1]) * 255.0),
                  int(pow(float(GetBlueValue(dwClr)) / 255.0f, gammaOut[2]) * 255.0));
 }

bool C4Draw::ApplyPrimaryClipper ( C4Surface * sfcSurface )

inherited

Definition at line 227 of file C4Draw.cpp.

 {
     return true;
 }

void C4Draw::ApplyZoom	(	float &	X,
		float &	Y
	)

inherited

Definition at line 784 of file C4Draw.cpp.

References C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

Referenced by C4Draw::Blit8Fast(), C4Draw::BlitUnscaled(), C4LandscapeRenderGL::Draw(), C4GUI::Window::Draw(), and C4GUI::Edit::DrawElement().

 {
     X = (X - ZoomX) * Zoom + ZoomX;
     Y = (Y - ZoomY) * Zoom + ZoomY;
 }

Here is the caller graph for this function:

bool C4Draw::Blit	(	C4Surface *	sfcSource,
		float	fx,
		float	fy,
		float	fwdt,
		float	fhgt,
		C4Surface *	sfcTarget,
		float	tx,
		float	ty,
		float	twdt,
		float	thgt,
		bool	fSrcColKey = `false`,
		const C4BltTransform *	pTransform = `nullptr`
	)

inherited

Definition at line 301 of file C4Draw.cpp.

References C4Draw::BlitUnscaled(), and C4Surface::Scale.

Referenced by C4Draw::BlitLandscape(), C4Draw::BlitSimple(), C4Draw::BlitSurface(), C4FacetSurface::CopyFromSfcMaxSize(), C4Facet::Draw(), C4Object::Draw(), C4Object::DrawFaceImpl(), C4Facet::DrawFullScreen(), C4Facet::DrawT(), CStdFont::DrawText(), C4Object::DrawTopFace(), C4Facet::DrawX(), C4Facet::DrawXFloat(), C4Facet::DrawXR(), C4Facet::DrawXT(), C4MapFolderData::Load(), and C4Game::SaveGameTitle().

 {
     return BlitUnscaled(sfcSource, fx * sfcSource->Scale, fy * sfcSource->Scale, fwdt * sfcSource->Scale, fhgt * sfcSource->Scale,
                         sfcTarget, tx, ty, twdt, thgt, fSrcColKey, pTransform);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::Blit8	(	C4Surface *	sfcSource,
		int	fx,
		int	fy,
		int	fwdt,
		int	fhgt,
		C4Surface *	sfcTarget,
		int	tx,
		int	ty,
		int	twdt,
		int	thgt,
		bool	fSrcColKey = `false`,
		const C4BltTransform *	pTransform = `nullptr`
	)

inherited

Definition at line 424 of file C4Draw.cpp.

References C4Draw::BlitSimple(), C4Surface::BltPix(), C4Surface::Hgt, C4Surface::Lock(), C4BltTransform::SetAsInv(), C4BltTransform::SetMoveScale(), C4BltTransform::TransformPoint(), C4Surface::Unlock(), and C4Surface::Wdt.

Referenced by C4Draw::BlitUnscaled().

 {
     if (!pTransform) return BlitSimple(sfcSource, fx, fy, fwdt, fhgt, sfcTarget, tx, ty, twdt, thgt, fSrcColKey!=false);
     // safety
     if (!fwdt || !fhgt) return true;
     // Lock the surfaces
     if (!sfcSource->Lock())
         return false;
     if (!sfcTarget->Lock())
         { sfcSource->Unlock(); return false; }
     // transformed, emulated blit
     // Calculate transform target rect
     C4BltTransform Transform;
     Transform.SetMoveScale(tx-(float)fx*twdt/fwdt, ty-(float)fy*thgt/fhgt, (float) twdt/fwdt, (float) thgt/fhgt);
     Transform *=* pTransform;
     C4BltTransform TransformBack;
     TransformBack.SetAsInv(Transform);
     auto ttx0=(float)tx, tty0=(float)ty, ttx1=(float)(tx+twdt), tty1=(float)(ty+thgt);
     auto ttx2=(float)ttx0, tty2=(float)tty1, ttx3=(float)ttx1, tty3=(float)tty0;
     pTransform->TransformPoint(ttx0, tty0);
     pTransform->TransformPoint(ttx1, tty1);
     pTransform->TransformPoint(ttx2, tty2);
     pTransform->TransformPoint(ttx3, tty3);
     int ttxMin = std::max<int>((int)floor(std::min(std::min(ttx0, ttx1), std::min(ttx2, ttx3))), 0);
     int ttxMax = std::min<int>((int)ceil(std::max(std::max(ttx0, ttx1), std::max(ttx2, ttx3))), sfcTarget->Wdt);
     int ttyMin = std::max<int>((int)floor(std::min(std::min(tty0, tty1), std::min(tty2, tty3))), 0);
     int ttyMax = std::min<int>((int)ceil(std::max(std::max(tty0, tty1), std::max(tty2, tty3))), sfcTarget->Hgt);
     // blit within target rect
     for (int y = ttyMin; y < ttyMax; ++y)
         for (int x = ttxMin; x < ttxMax; ++x)
         {
             float ffx=(float)x, ffy=(float)y;
             TransformBack.TransformPoint(ffx, ffy);
             int ifx=static_cast<int>(ffx), ify=static_cast<int>(ffy);
             if (ifx<fx || ify<fy || ifx>=fx+fwdt || ify>=fy+fhgt) continue;
             sfcTarget->BltPix(x,y, sfcSource, ifx,ify, !!fSrcColKey);
         }
     // Unlock the surfaces
     sfcSource->Unlock();
     sfcTarget->Unlock();
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::Blit8Fast	(	CSurface8 *	sfcSource,
		int	fx,
		int	fy,
		C4Surface *	sfcTarget,
		int	tx,
		int	ty,
		int	wdt,
		int	hgt
	)

inherited

Definition at line 251 of file C4Draw.cpp.

References C4Draw::ApplyZoom(), DwTo4UB(), C4Surface::fPrimary, C4BltVertex::ftx, C4BltVertex::fty, CStdPalette::GetClr(), CSurface8::GetPix(), C4Surface::IsRenderTarget(), C4Surface::Lock(), C4Draw::PerformMultiPix(), CSurface8::pPal, C4Surface::Unlock(), and C4Draw::Zoom.

Referenced by C4Landscape::Draw().

 {
     // blit 8bit-sfc
     // lock surfaces
     assert(sfcTarget->fPrimary);
     bool fRender = sfcTarget->IsRenderTarget();
     if (!fRender) if (!sfcTarget->Lock())
             { return; }
 
     float tfx = tx, tfy = ty, twdt = wdt, thgt = hgt;
     if (Zoom != 1.0)
     {
         ApplyZoom(tfx, tfy);
         twdt *= Zoom;
         thgt *= Zoom;
     }
 
     // blit 8 bit pix in batches of 1024 pixels
     static const int BUF_SIZE = 1024;
     C4BltVertex* vertices = new C4BltVertex[BUF_SIZE];
     int bufcnt = 0;
 
     for (int ycnt=0; ycnt<thgt; ++ycnt)
     {
         for (int xcnt=0; xcnt<twdt; ++xcnt)
         {
             BYTE byPix = sfcSource->GetPix(fx+wdt*xcnt/twdt, fy+hgt*ycnt/thgt);
             DWORD dwClr = byPix ? sfcSource->pPal->GetClr(byPix) : 0x00000000;
 
             vertices[bufcnt].ftx = (float)(tx + xcnt / Zoom);
             vertices[bufcnt].fty = (float)(ty + ycnt / Zoom);
             DwTo4UB(dwClr, vertices[bufcnt].color);
             ++bufcnt;
 
             if(bufcnt == BUF_SIZE)
             {
                 PerformMultiPix(sfcTarget, vertices, BUF_SIZE, nullptr);
                 bufcnt = 0;
             }
         }
 
     }
     if(bufcnt > 0)
         PerformMultiPix(sfcTarget, vertices, bufcnt, nullptr);
     delete[] vertices;
     // unlock
     if (!fRender) sfcTarget->Unlock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::BlitLandscape	(	C4Surface *	sfcSource,
		float	fx,
		float	fy,
		C4Surface *	sfcTarget,
		float	tx,
		float	ty,
		float	wdt,
		float	hgt
	)

virtualinherited

Definition at line 245 of file C4Draw.cpp.

References C4Draw::Blit().

 {
     Blit(sfcSource, fx, fy, wdt, hgt, sfcTarget, tx, ty, wdt, hgt, false);
 }

Here is the call graph for this function:

bool C4Draw::BlitSimple	(	C4Surface *	sfcSource,
		int	fx,
		int	fy,
		int	fwdt,
		int	fhgt,
		C4Surface *	sfcTarget,
		int	tx,
		int	ty,
		int	twdt,
		int	thgt,
		bool	fTransparency = `true`
	)

inherited

Definition at line 469 of file C4Draw.cpp.

References C4Draw::Blit(), C4Surface::BltPix(), C4Surface::Hgt, Inside(), C4Surface::IsRenderTarget(), C4Surface::Lock(), C4Surface::Unlock(), and C4Surface::Wdt.

Referenced by C4Draw::Blit8().

 {
     // rendertarget?
     if (sfcTarget->IsRenderTarget())
     {
         return Blit(sfcSource, float(fx), float(fy), float(fwdt), float(fhgt), sfcTarget, float(tx), float(ty), float(twdt), float(thgt), true);
     }
     // Object is first stretched to dest rect
     int xcnt,ycnt,tcx,tcy,cpcx,cpcy;
     if (!fwdt || !fhgt || !twdt || !thgt) return false;
     // Lock the surfaces
     if (!sfcSource->Lock())
         return false;
     if (!sfcTarget->Lock())
         { sfcSource->Unlock(); return false; }
     // Rectangle centers
     tcx=twdt/2; tcy=thgt/2;
     for (ycnt=0; ycnt<thgt; ycnt++)
         if (Inside(cpcy=ty+tcy-thgt/2+ycnt,0,sfcTarget->Hgt-1))
             for (xcnt=0; xcnt<twdt; xcnt++)
                 if (Inside(cpcx=tx+tcx-twdt/2+xcnt,0,sfcTarget->Wdt-1))
                     sfcTarget->BltPix(cpcx, cpcy, sfcSource, xcnt*fwdt/twdt+fx, ycnt*fhgt/thgt+fy, fTransparency);
     // Unlock the surfaces
     sfcSource->Unlock();
     sfcTarget->Unlock();
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::BlitSurface	(	C4Surface *	sfcSurface,
		C4Surface *	sfcTarget,
		int	tx,
		int	ty,
		bool	fBlitBase
	)

inherited

Definition at line 517 of file C4Draw.cpp.

References C4Draw::Blit(), C4Surface::Hgt, C4Surface::pMainSfc, and C4Surface::Wdt.

Referenced by C4Surface::Copy().

 {
     if (fBlitBase)
     {
         Blit(sfcSurface, 0.0f, 0.0f, (float)sfcSurface->Wdt, (float)sfcSurface->Hgt, sfcTarget, float(tx), float(ty), float(sfcSurface->Wdt), float(sfcSurface->Hgt), false);
         return true;
     }
     else
     {
         if (!sfcSurface) return false;
         C4Surface *pSfcBase = sfcSurface->pMainSfc;
         sfcSurface->pMainSfc = nullptr;
         Blit(sfcSurface, 0.0f, 0.0f, (float)sfcSurface->Wdt, (float)sfcSurface->Hgt, sfcTarget, float(tx), float(ty), float(sfcSurface->Wdt), float(sfcSurface->Hgt), false);
         sfcSurface->pMainSfc = pSfcBase;
         return true;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::BlitSurfaceTile	(	C4Surface *	sfcSurface,
		C4Surface *	sfcTarget,
		float	iToX,
		float	iToY,
		float	iToWdt,
		float	iToHgt,
		float	iOffsetX,
		float	iOffsetY,
		C4ShaderCall *	shader_call
	)

inherited

Definition at line 535 of file C4Draw.cpp.

References C4SF_Tileable, DwTo4UB(), C4BltVertex::ftx, C4BltVertex::fty, C4BltVertex::ftz, C4Surface::Hgt, C4Surface::IsRenderTarget(), C4Draw::PerformMultiTris(), C4Surface::texture, C4BltVertex::tx, C4BltVertex::ty, and C4Surface::Wdt.

Referenced by C4UpperBoard::Draw(), C4Sky::Draw(), C4Viewport::Draw(), C4GUI::FullscreenDialog::DrawElement(), and C4ViewportList::DrawFullscreenBackground().

 {
     // Only direct rendering from single, tileable, texture
     if (!sfcTarget->IsRenderTarget()) return false;
     if ((sfcSurface->texture->iFlags & C4SF_Tileable) == 0) return false;
 
     // source surface dimensions
     const float sourceWdt = sfcSurface->Wdt;
     const float sourceHgt = sfcSurface->Hgt;
 
     // vertex positions
     C4BltVertex vertices[6];
     vertices[0].ftx = iToX; vertices[0].fty = iToY; vertices[0].ftz = 0.0f;
     vertices[0].tx = (0.0f + iOffsetX) / sourceWdt; vertices[0].ty = (0.0f + iOffsetY) / sourceHgt;
     DwTo4UB(0xffffffff, vertices[0].color);
     vertices[1].ftx = iToX + iToWdt; vertices[1].fty = iToY; vertices[1].ftz = 0.0f;
     vertices[1].tx = (iToWdt + iOffsetX) / sourceWdt; vertices[1].ty = (0.0f + iOffsetY) / sourceHgt;
     DwTo4UB(0xffffffff, vertices[1].color);
     vertices[2].ftx = iToX + iToWdt; vertices[2].fty = iToY + iToHgt; vertices[2].ftz = 0.0f;
     vertices[2].tx = (iToWdt + iOffsetX) / sourceWdt; vertices[2].ty = (iToHgt + iOffsetY) / sourceHgt;
     DwTo4UB(0xffffffff, vertices[2].color);
     vertices[3].ftx = iToX; vertices[3].fty = iToY + iToHgt; vertices[3].ftz = 0.0f;
     vertices[3].tx = (0.0f + iOffsetX) / sourceWdt; vertices[3].ty = (iToHgt + iOffsetY) / sourceHgt;
     DwTo4UB(0xffffffff, vertices[3].color);
     // duplicate vertices
     vertices[4] = vertices[0]; vertices[5] = vertices[2];
 
     // Draw
     PerformMultiTris(sfcTarget, vertices, 6, nullptr, sfcSurface->texture.get(), nullptr, nullptr, 0, shader_call);
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::BlitUnscaled	(	C4Surface *	sfcSource,
		float	fx,
		float	fy,
		float	fwdt,
		float	fhgt,
		C4Surface *	sfcTarget,
		float	tx,
		float	ty,
		float	twdt,
		float	thgt,
		bool	fSrcColKey = `false`,
		const C4BltTransform *	pTransform = `nullptr`
	)

inherited

Definition at line 309 of file C4Draw.cpp.

References C4Draw::ApplyZoom(), C4Draw::Blit8(), C4Draw::ClipAll, C4Surface::ClrByOwnerClr, DwTo4UB(), C4Surface::fPrimary, C4BltVertex::ftx, C4BltVertex::fty, C4TexRef::iSizeX, C4TexRef::iSizeY, C4Surface::IsRenderTarget(), C4Surface::iTexSize, C4BltTransform::mat, C4Draw::PerformMultiTris(), C4Surface::pMainSfc, C4Surface::pNormalSfc, C4Draw::PrepareRendering(), C4BltTransform::Set(), C4Surface::texture, C4BltVertex::tx, C4BltVertex::ty, C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

Referenced by C4Draw::Blit(), and C4Facet::DrawTUnscaled().

 {
     // safety
     if (!sfcSource || !sfcTarget || !twdt || !thgt || !fwdt || !fhgt) return false;
     // emulated blit?
     if (!sfcTarget->IsRenderTarget())
     {
         C4BltTransform t;
         if(pTransform && Zoom != 1.0)
         {
             t.Set(pTransform->mat[0]*Zoom, pTransform->mat[1]*Zoom, pTransform->mat[2]*Zoom + ZoomX*(1-Zoom),
                   pTransform->mat[3]*Zoom, pTransform->mat[4]*Zoom, pTransform->mat[5]*Zoom + ZoomY*(1-Zoom),
                   pTransform->mat[6], pTransform->mat[7], pTransform->mat[8]);
             pTransform = &t;
         }
         else if(Zoom != 1.0)
         {
             ApplyZoom(tx, ty);
             twdt *= Zoom;
             thgt *= Zoom;
         }
 
         return Blit8(sfcSource, int(fx), int(fy), int(fwdt), int(fhgt), sfcTarget, int(tx), int(ty), int(twdt), int(thgt), fSrcColKey, pTransform);
     }
 
     // calc stretch
     float scaleX = twdt/fwdt;
     float scaleY = thgt/fhgt;
     // bound
     if (ClipAll) return true;
     // inside screen?
     if (twdt<=0 || thgt<=0) return false;
     // prepare rendering to surface
     if (!PrepareRendering(sfcTarget)) return false;
     // texture present?
     if (!sfcSource->texture)
     {
         // primary surface?
         if (sfcSource->fPrimary)
         {
             // blit emulated
             return Blit8(sfcSource, int(fx), int(fy), int(fwdt), int(fhgt), sfcTarget, int(tx), int(ty), int(twdt), int(thgt), fSrcColKey);
         }
         return false;
     }
     // blit with basesfc?
     bool fBaseSfc=false;
     if (sfcSource->pMainSfc) if (sfcSource->pMainSfc->texture) fBaseSfc = true;
     // get involved texture offsets
     int iTexSizeX=sfcSource->iTexSize;
     int iTexSizeY=sfcSource->iTexSize;
 
     C4TexRef *pTex = sfcSource->texture.get();
     // set up blit data
     C4BltVertex vertices[6];
     vertices[0].ftx = tx; vertices[0].fty = ty;
     vertices[1].ftx = tx + twdt; vertices[1].fty = ty;
     vertices[2].ftx = tx + twdt; vertices[2].fty = ty + thgt;
     vertices[3].ftx = tx; vertices[3].fty = ty + thgt;
     vertices[0].tx = fx / pTex->iSizeX; vertices[0].ty = fy / pTex->iSizeY;
     vertices[1].tx = (fx + fwdt) / pTex->iSizeX; vertices[1].ty = fy / pTex->iSizeY;
     vertices[2].tx = (fx + fwdt) / pTex->iSizeX; vertices[2].ty = (fy + fhgt) / pTex->iSizeY;
     vertices[3].tx = fx / pTex->iSizeX; vertices[3].ty = (fy + fhgt) / pTex->iSizeY;
     DwTo4UB(0xffffffff, vertices[0].color);
     DwTo4UB(0xffffffff, vertices[1].color);
     DwTo4UB(0xffffffff, vertices[2].color);
     DwTo4UB(0xffffffff, vertices[3].color);
 
     // duplicate vertices
     vertices[4] = vertices[0]; vertices[5] = vertices[2];
 
     C4TexRef * pBaseTex = pTex;
     // is there a base-surface to be blitted first?
     if (fBaseSfc)
     {
         // then get this surface as same offset as from other surface
         // assuming this is only valid as long as there's no texture management,
         // organizing partially used textures together!
         pBaseTex = sfcSource->pMainSfc->texture.get();
     }
 
     C4TexRef* pNormalTex = nullptr;
     if (sfcSource->pNormalSfc)
         pNormalTex = sfcSource->pNormalSfc->texture.get();
 
     // ClrByOwner is always fully opaque
     const DWORD dwOverlayClrMod = 0xff000000 | sfcSource->ClrByOwnerClr;
     PerformMultiTris(sfcTarget, vertices, 6, pTransform, pBaseTex, fBaseSfc ? pTex : nullptr, pNormalTex, dwOverlayClrMod, nullptr);
     // success
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CStdGL::CheckGLError ( const char * szAtOp )

protected

Definition at line 896 of file C4DrawGL.cpp.

References GLErrorString(), and LogF().

 {
     GLenum err = glGetError();
     if (!err) return true;
 
     LogF("GL error with %s: %d - %s", szAtOp, err, GLErrorString(err));
     return false;
 }

Here is the call graph for this function:

void CStdGL::Clear ( )

overridevirtual

Reimplemented from C4Draw.

Definition at line 114 of file C4DrawGL.cpp.

Referenced by ~CStdGL().

 {
     NoPrimaryClipper();
     // cannot unlock TexMgr here or we can't preserve textures across GL reinitialization as required when changing multisampling
     InvalidateDeviceObjects();
     NoPrimaryClipper();
     RenderTarget = nullptr;
     // Clear all shaders
     SpriteShader.Clear();
     SpriteShaderMod2.Clear();
     SpriteShaderBase.Clear();
     SpriteShaderBaseMod2.Clear();
     SpriteShaderBaseOverlay.Clear();
     SpriteShaderBaseOverlayMod2.Clear();
     SpriteShaderLight.Clear();
     SpriteShaderLightMod2.Clear();
     SpriteShaderLightBase.Clear();
     SpriteShaderLightBaseMod2.Clear();
     SpriteShaderLightBaseOverlay.Clear();
     SpriteShaderLightBaseOverlayMod2.Clear();
     SpriteShaderLightBaseNormal.Clear();
     SpriteShaderLightBaseNormalMod2.Clear();
     SpriteShaderLightBaseNormalOverlay.Clear();
     SpriteShaderLightBaseNormalOverlayMod2.Clear();
     // clear context
     if (pCurrCtx) pCurrCtx->Deselect();
     pMainCtx=nullptr;
     C4Draw::Clear();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

CStdGLCtx * CStdGL::CreateContext	(	C4Window *	pWindow,
		C4AbstractApp *	pApp
	)

overridevirtual

Reimplemented from C4Draw.

Definition at line 282 of file C4DrawGL.cpp.

References Config, CStdGLCtx, C4ConfigGraphics::DebugOpenGL, Error(), C4Config::Graphics, CStdGLCtx::Init(), Log(), LogF(), LogSilentF(), C4Draw::pApp, pCurrCtx, pMainCtx, and C4Draw::RenderTarget.

Referenced by C4Surface::C4Surface().

 {
     // safety
     if (!pWindow) return nullptr;
 
     // create it
     CStdGLCtx *pCtx;
 #ifdef WITH_QT_EDITOR
     auto app = dynamic_cast<C4Application*>(pApp);
     if (app->isEditor)
         pCtx = new CStdGLCtxQt();
     else
 #endif
     pCtx = new CStdGLCtx();
     bool first_ctx = !pMainCtx;
     if (first_ctx)
     {
         pMainCtx = pCtx;
         LogF("  gl: Create first %scontext...", Config.Graphics.DebugOpenGL ? "debug " : "");
     }
     bool success = pCtx->Init(pWindow, pApp);
     if (Config.Graphics.DebugOpenGL && glDebugMessageCallbackARB)
     {
         if (first_ctx) Log("  gl: Setting OpenGLDebugProc callback");
         glDebugMessageCallbackARB(&OpenGLDebugProc, nullptr);
         glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
 #ifdef GL_KHR_debug
         if (GLEW_KHR_debug)
             glEnable(GL_DEBUG_OUTPUT);
 #endif
     }
     // First context: Log some information about hardware/drivers
     // Must log after context creation to get valid results
     if (first_ctx)
     {
         const auto *gl_vendor = reinterpret_cast<const char *>(glGetString(GL_VENDOR));
         const auto *gl_renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
         const auto *gl_version = reinterpret_cast<const char *>(glGetString(GL_VERSION));
         LogF("GL %s on %s (%s)", gl_version ? gl_version : "", gl_renderer ? gl_renderer : "", gl_vendor ? gl_vendor : "");
         
         if (Config.Graphics.DebugOpenGL)
         {
             // Dump extension list
             if (glGetStringi)
             {
                 GLint gl_extension_count = 0;
                 glGetIntegerv(GL_NUM_EXTENSIONS, &gl_extension_count);
                 if (gl_extension_count == 0)
                 {
                     LogSilentF("No available extensions.");
                 }
                 else
                 {
                     LogSilentF("%d available extensions:", gl_extension_count);
                     for (GLint i = 0; i < gl_extension_count; ++i)
                     {
                         const char *gl_extension = (const char*)glGetStringi(GL_EXTENSIONS, i);
                         LogSilentF("  %4d: %s", i, gl_extension);
                     }
                 }
             }
             else
             {
                 const char *gl_extensions = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
                 LogSilentF("GLExt: %s", gl_extensions ? gl_extensions : "");
             }
         }
     }
     if (!success)
     {
         delete pCtx; Error("  gl: Error creating secondary context!"); return nullptr;
     }
     // creation selected the new context - switch back to previous context
     RenderTarget = nullptr;
     pCurrCtx = nullptr;
     // done
     return pCtx;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::CreatePrimaryClipper	(	unsigned int	iXRes,
		unsigned int	iYRes
	)

protectedinherited

Definition at line 507 of file C4Draw.cpp.

References C4Draw::SetPrimaryClipper(), C4Draw::StorePrimaryClipper(), and C4Draw::Zoom.

Referenced by C4Draw::Init(), and OnResolutionChanged().

 {
     // simply setup primary viewport
     // assume no zoom has been set yet
     assert(Zoom==1.0f);
     SetPrimaryClipper(0, 0, iXRes - 1, iYRes - 1);
     StorePrimaryClipper();
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DeactivateBlitModulation ( )

inlineinherited

Definition at line 189 of file C4Draw.h.

Referenced by C4Sky::Draw(), C4Landscape::Draw(), C4MouseControl::Draw(), C4GraphicsOverlay::Draw(), C4ParticleList::Draw(), C4GUI::Dialog::Draw(), C4GUI::Tabular::Sheet::DrawCaption(), C4Viewport::DrawMenu(), C4GraphicsOverlay::DrawPicture(), CStdFont::DrawText(), and C4Object::FinishedDrawing().

189 { BlitModulated=false; } // stop color modulation of blits

C4Draw::BlitModulated

bool BlitModulated

Definition: C4Draw.h:108

Here is the caller graph for this function:

void CStdGL::Default ( )

overridevirtual

Reimplemented from C4Draw.

Definition at line 915 of file C4DrawGL.cpp.

References C4Draw::Default(), iPixelFormat, pCurrCtx, sfcFmt, and Workarounds.

Referenced by CStdGL().

 {
     C4Draw::Default();
     pCurrCtx = nullptr;
     iPixelFormat=0;
     sfcFmt=0;
     Workarounds.LowMaxVertexUniformCount = false;
     Workarounds.ForceSoftwareTransform = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::DetachPrimaryClipper ( C4Surface * sfcSurface )

inherited

Definition at line 232 of file C4Draw.cpp.

 {
     return true;
 }

bool CStdGL::DeviceReady ( )

inlineoverridevirtual

Implements C4Draw.

Definition at line 271 of file C4DrawGL.h.

References pMainCtx.

271 { return !!pMainCtx; }

CStdGL::pMainCtx

CStdGLCtx * pMainCtx

Definition: C4DrawGL.h:178

void C4Draw::DrawBoxDw	(	C4Surface *	sfcDest,
		int	iX1,
		int	iY1,
		int	iX2,
		int	iY2,
		DWORD	dwClr
	)

inherited

Definition at line 846 of file C4Draw.cpp.

References C4Draw::DrawBoxFade(), C4Surface::IsRenderTarget(), C4Surface::Lock(), C4Surface::SetPixDw(), and C4Surface::Unlock().

 {
     if (!sfcDest->IsRenderTarget())
     {
         // Box on non-render target: Emulate by setting pixels
         if (!sfcDest->Lock()) return;
         for (int y = iY1; y <= iY2; ++y)
             for (int x = iX1; x <= iX2; ++x)
                 sfcDest->SetPixDw(x,y, dwClr);
         sfcDest->Unlock();
     }
     else
     {
         DrawBoxFade(sfcDest, float(iX1), float(iY1), float(iX2 - iX1 + 1), float(iY2 - iY1 + 1), dwClr, dwClr, dwClr, dwClr, nullptr);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DrawBoxFade	(	C4Surface *	sfcDest,
		float	iX,
		float	iY,
		float	iWdt,
		float	iHgt,
		DWORD	dwClr1,
		DWORD	dwClr2,
		DWORD	dwClr3,
		DWORD	dwClr4,
		C4ShaderCall *	shader_call
	)

inherited

Definition at line 830 of file C4Draw.cpp.

References C4Draw::DrawQuadDw().

Referenced by C4Sky::Draw(), and C4Draw::DrawBoxDw().

 {
     // set vertex buffer data
     // vertex order:
     // 0=upper left   dwClr1
     // 1=lower left   dwClr3
     // 2=lower right  dwClr4
     // 3=upper right  dwClr2
     float vtx[8];
     vtx[0] = iX     ; vtx[1] = iY;
     vtx[2] = iX     ; vtx[3] = iY+iHgt;
     vtx[4] = iX+iWdt; vtx[5] = iY+iHgt;
     vtx[6] = iX+iWdt; vtx[7] = iY;
     DrawQuadDw(sfcDest, vtx, dwClr1, dwClr3, dwClr4, dwClr2, shader_call);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DrawCircleDw	(	C4Surface *	sfcTarget,
		float	cx,
		float	cy,
		float	r,
		DWORD	dwClr,
		float	width = `1.0f`
	)

inherited

Definition at line 624 of file C4Draw.cpp.

References DwTo4UB(), and C4Draw::PerformMultiLines().

Referenced by C4EditCursor::Draw().

 {
     // Draw as line segments
     int32_t num_lines = 12 + int32_t(r / 10);
     std::unique_ptr<C4BltVertex[]> vertices(new C4BltVertex[num_lines * 2]);
     for (int32_t i = 0; i < num_lines; ++i)
     {
         float ang = float(i) * 2 * M_PI / num_lines;
         int32_t iv = i * 2 + 1;
         vertices[iv].ftx = cx + sin(ang) * r;
         vertices[iv].fty = cy + cos(ang) * r;
         DwTo4UB(dwClr, vertices[iv].color);
         vertices[(iv + 1) % (num_lines * 2)] = vertices[iv];
     }
     PerformMultiLines(sfcTarget, vertices.get(), num_lines * 2, width, nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DrawFrameDw	(	C4Surface *	sfcDest,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		DWORD	dwClr,
		float	width = `1.0f`
	)

inherited

Definition at line 641 of file C4Draw.cpp.

References DwTo4UB(), C4BltVertex::ftx, C4BltVertex::fty, and C4Draw::PerformMultiLines().

Referenced by C4TransferZone::Draw(), C4EditCursor::Draw(), C4PathFinderRay::Draw(), C4Object::Draw(), C4ScriptGuiWindow::Draw(), C4GUI::GroupBox::DrawElement(), C4GUI::Edit::DrawElement(), C4GUI::ComboBox::DrawElement(), C4Menu::DrawFrame(), and C4GUI::Screen::DrawToolTip().

 {
     C4BltVertex vertices[8];
     vertices[0].ftx = x1; vertices[0].fty = y1;
     vertices[1].ftx = x2; vertices[1].fty = y1;
     vertices[2] = vertices[1];
     vertices[3].ftx = x2; vertices[3].fty = y2;
     vertices[4] = vertices[3];
     vertices[5].ftx = x1; vertices[5].fty = y2;
     vertices[6] = vertices[5];
     vertices[7] = vertices[0];
 
     for(auto & vertex : vertices)
         DwTo4UB(dwClr, vertex.color);
 
     PerformMultiLines(sfcDest, vertices, 8, width, nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DrawLineDw	(	C4Surface *	sfcTarget,
		float	x1,
		float	y1,
		float	x2,
		float	y2,
		DWORD	dwClr,
		float	width = `1.0f`
	)

inherited

Definition at line 614 of file C4Draw.cpp.

References DwTo4UB(), C4BltVertex::ftx, C4BltVertex::fty, and C4Draw::PerformMultiLines().

Referenced by C4EditCursor::Draw(), C4PathFinderRay::Draw(), C4Object::Draw(), C4GUI::Element::Draw3DFrame(), C4Chart::DrawElement(), C4GUI::HorizontalLine::DrawElement(), C4GUI::GroupBox::DrawElement(), C4GUI::ListBox::DrawElement(), and C4GUI::Tabular::DrawElement().

 {
     C4BltVertex vertices[2];
     vertices[0].ftx = x1; vertices[0].fty = y1;
     vertices[1].ftx = x2; vertices[1].fty = y2;
     DwTo4UB(dwClr, vertices[0].color);
     DwTo4UB(dwClr, vertices[1].color);
     PerformMultiLines(sfcTarget, vertices, 2, width, nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DrawPatternedCircle	(	C4Surface *	sfcDest,
		int	x,
		int	y,
		int	r,
		BYTE	col,
		C4Pattern &	Pattern,
		CStdPalette &	rPal
	)

inherited

Definition at line 675 of file C4Draw.cpp.

References C4Draw::DrawPix(), C4Surface::IsRenderTarget(), C4Surface::Lock(), C4Pattern::PatternClr(), C4Surface::SetPixDw(), and C4Surface::Unlock().

 {
     bool fRenderTarget = sfcDest->IsRenderTarget();
     if (!fRenderTarget) if (!sfcDest->Lock()) return;
     for (int ycnt = -r; ycnt < r; ycnt++)
     {
         int lwdt = (int)sqrt(float(r * r - ycnt * ycnt));
         // Set line
         if (fRenderTarget)
         {
             for (int xcnt = x - lwdt; xcnt < x + lwdt; ++xcnt)
             {
                 DrawPix(sfcDest, xcnt, y + ycnt, Pattern.PatternClr(xcnt, y + ycnt));
             }
         }
         else
         {
             for (int xcnt = x - lwdt; xcnt < x + lwdt; ++xcnt)
             {
                 sfcDest->SetPixDw(xcnt, y + ycnt, Pattern.PatternClr(xcnt, y + ycnt));
             }
         }
     }
     if (!fRenderTarget) sfcDest->Unlock();
 }

Here is the call graph for this function:

void C4Draw::DrawPix	(	C4Surface *	sfcDest,
		float	tx,
		float	ty,
		DWORD	dwCol
	)

inherited

Definition at line 604 of file C4Draw.cpp.

References C4BltVertex::color, DwTo4UB(), C4BltVertex::ftx, C4BltVertex::fty, and C4Draw::PerformMultiPix().

Referenced by C4Draw::DrawPatternedCircle().

 {
     // Draw
     C4BltVertex vtx;
     vtx.ftx = tx;
     vtx.fty = ty;
     DwTo4UB(dwClr, vtx.color);
     PerformMultiPix(sfcDest, &vtx, 1, nullptr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::DrawQuadDw	(	C4Surface *	sfcTarget,
		float *	ipVtx,
		DWORD	dwClr1,
		DWORD	dwClr2,
		DWORD	dwClr3,
		DWORD	dwClr4,
		C4ShaderCall *	shader_call
	)

inherited

Definition at line 659 of file C4Draw.cpp.

References DwTo4UB(), C4BltVertex::ftx, C4BltVertex::fty, and C4Draw::PerformMultiTris().

Referenced by C4Draw::DrawBoxFade(), and C4GUI::Tabular::DrawElement().

 {
     C4BltVertex vertices[6];
     vertices[0].ftx = ipVtx[0]; vertices[0].fty = ipVtx[1];
     vertices[1].ftx = ipVtx[2]; vertices[1].fty = ipVtx[3];
     vertices[2].ftx = ipVtx[4]; vertices[2].fty = ipVtx[5];
     vertices[3].ftx = ipVtx[6]; vertices[3].fty = ipVtx[7];
     DwTo4UB(dwClr1, vertices[0].color);
     DwTo4UB(dwClr2, vertices[1].color);
     DwTo4UB(dwClr3, vertices[2].color);
     DwTo4UB(dwClr4, vertices[3].color);
     vertices[4] = vertices[0];
     vertices[5] = vertices[2];
     PerformMultiTris(sfcTarget, vertices, 6, nullptr, nullptr, nullptr, nullptr, 0, shader_call);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CStdGL::EnsureMainContextSelected ( )

overridevirtual

Implements C4Draw.

Definition at line 755 of file C4DrawGL.cpp.

References pMainCtx, and CStdGLCtx::Select().

 {
     return pMainCtx->Select();
 }

Here is the call graph for this function:

bool CStdGL::Error ( const char * szMsg )

overrideprotectedvirtual

Reimplemented from C4Draw.

Definition at line 853 of file C4DrawGL.cpp.

References C4Draw::Error(), and LogF().

Referenced by CreateContext().

 {
 #ifdef USE_WIN32_WINDOWS
     DWORD err = GetLastError();
 #endif
     bool r = C4Draw::Error(szMsg);
 #ifdef USE_WIN32_WINDOWS
     wchar_t * lpMsgBuf;
     FormatMessage(
         FORMAT_MESSAGE_ALLOCATE_BUFFER |
         FORMAT_MESSAGE_FROM_SYSTEM |
         FORMAT_MESSAGE_IGNORE_INSERTS,
         nullptr,
         err,
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
         (LPTSTR) &lpMsgBuf,
         0, nullptr );
     LogF("  gl: GetLastError() = %d - %s", err, StdStrBuf(lpMsgBuf).getData());
     LocalFree(lpMsgBuf);
 #endif
     LogF("  gl: %s", glGetString(GL_VENDOR));
     LogF("  gl: %s", glGetString(GL_RENDERER));
     LogF("  gl: %s", glGetString(GL_VERSION));
     LogF("  gl: %s", glGetString(GL_EXTENSIONS));
     return r;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CStdGL::FillBG ( DWORD dwClr = 0 )

overridevirtual

Implements C4Draw.

Definition at line 144 of file C4DrawGL.cpp.

References GetBlueValue, GetGreenValue, GetRedValue, and pCurrCtx.

 {
     if (!pCurrCtx) return;
     glClearColor((float)GetRedValue(dwClr)/255.0f, (float)GetGreenValue(dwClr)/255.0f, (float)GetBlueValue(dwClr)/255.0f, 0.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }

void CStdGL::FreeVAOID ( unsigned int vaoid )

Definition at line 967 of file C4DrawGL.cpp.

References CStdGLCtx::contexts, CStdGLCtx::hVAOs, NextVAOID, pCurrCtx, and VAOIDs.

Referenced by C4LandscapeRenderGL::Clear(), InvalidateDeviceObjects(), StdMeshInstance::UpdateIBO(), C4FoWDrawLightTextureStrategy::~C4FoWDrawLightTextureStrategy(), C4FoWDrawWireframeStrategy::~C4FoWDrawWireframeStrategy(), C4FoWRegion::~C4FoWRegion(), StdMesh::~StdMesh(), and StdMeshInstance::~StdMeshInstance().

 {
     std::set<unsigned int>::iterator iter = VAOIDs.find(vaoid);
     assert(iter != VAOIDs.end());
 
     // Delete this VAO in the current context
     if (pCurrCtx)
     {
         if (vaoid < pCurrCtx->hVAOs.size() && pCurrCtx->hVAOs[vaoid] != 0)
         {
             glDeleteVertexArrays(1, &pCurrCtx->hVAOs[vaoid]);
             pCurrCtx->hVAOs[vaoid] = 0;
         }
     }
 
     // For all other contexts, mark it to be deleted as soon as we select
     // that context. Otherwise we would need to do a lot of context
     // switching at this point.
     for (auto ctx : CStdGLCtx::contexts)
     {
         if (ctx != pCurrCtx && vaoid < ctx->hVAOs.size() && ctx->hVAOs[vaoid] != 0)
             if (std::find(ctx->VAOsToBeDeleted.begin(), ctx->VAOsToBeDeleted.end(), vaoid) == ctx->VAOsToBeDeleted.end())
                 ctx->VAOsToBeDeleted.push_back(vaoid);
     }
 
     // Delete the VAO ID from our list of VAO IDs in use
     // If the Next VAO ID is 1, then no matter what we delete we don't need
     // to update anything. If it is not at the beginning, then move it to the
     // gap we just created if it was at a higher place, to make sure we keep
     // the numbers as sequential as possible.
     unsigned int nextVaoID = 1;
     if (NextVAOID != VAOIDs.begin())
     {
         std::set<unsigned int>::iterator next_vao_iter = NextVAOID;
         --next_vao_iter;
         nextVaoID = *next_vao_iter + 1;
     }
 
     assert(vaoid != nextVaoID);
 
     if (vaoid < nextVaoID || iter == NextVAOID)
         NextVAOID = VAOIDs.erase(iter);
     else
         VAOIDs.erase(iter);
 }

Here is the caller graph for this function:

unsigned int CStdGL::GenVAOID ( )

Definition at line 925 of file C4DrawGL.cpp.

References NextVAOID, and VAOIDs.

Referenced by C4FoWDrawLightTextureStrategy::Begin(), C4FoWDrawWireframeStrategy::C4FoWDrawWireframeStrategy(), C4ParticleChunk::Draw(), StdMesh::PostInit(), C4FoWRegion::Render(), RestoreDeviceObjects(), and StdMeshInstance::UpdateIBO().

 {
     // Generate a new VAO ID. Make them sequential so that the actual
     // VAOs in the context can be simply maintained with a lookup table.
     unsigned int id;
     if (NextVAOID == VAOIDs.begin())
     {
         // Insert at the beginning
         id = 1;
     }
     else
     {
         // Insert at the end, or somewhere in the middle
         std::set<unsigned int>::iterator iter = NextVAOID;
         --iter;
 
         id = *iter + 1;
     }
 
     // Actually insert the ID
 #ifdef NDEBUG
     std::set<unsigned int>::iterator inserted_iter = VAOIDs.insert(NextVAOID, id);
 #else
     std::pair<std::set<unsigned int>::iterator, bool> inserted = VAOIDs.insert(id);
     assert(inserted.second == true);
     std::set<unsigned int>::iterator inserted_iter = inserted.first;
 #endif
 
     // Update next VAO ID: increment iterator until we find a gap
     // in the sequence.
     NextVAOID = inserted_iter;
     unsigned int prev_id = id;
     ++NextVAOID;
     while(NextVAOID != VAOIDs.end() && prev_id + 1 == *NextVAOID)
     {
         prev_id = *NextVAOID;
         ++NextVAOID;
     }
 
     return id;
 }

Here is the caller graph for this function:

bool C4Draw::GetBlitModulation ( DWORD & rdwColor )

inlineinherited

Definition at line 190 of file C4Draw.h.

References C4Draw::BlitModulateClr, and C4Draw::BlitModulated.

Referenced by CStdFont::DrawText().

190 { rdwColor=BlitModulateClr; return BlitModulated; }

C4Draw::BlitModulateClr

DWORD BlitModulateClr

Definition: C4Draw.h:109

C4Draw::BlitModulated

bool BlitModulated

Definition: C4Draw.h:108

Here is the caller graph for this function:

C4Rect C4Draw::GetClipRect ( ) const

inherited

Definition at line 730 of file C4Draw.cpp.

References C4Surface::Hgt, C4Draw::iClipX1, C4Draw::iClipX2, C4Draw::iClipY1, C4Draw::iClipY2, C4Draw::RenderTarget, and C4Surface::Wdt.

Referenced by C4LandscapeRenderGL::Draw(), PerformMesh(), SetupMultiBlt(), and UpdateClipper().

 {
     int iWdt=std::min(iClipX2, RenderTarget->Wdt-1)-iClipX1+1;
     int iHgt=std::min(iClipY2, RenderTarget->Hgt-1)-iClipY1+1;
     int iX=iClipX1; if (iX<0) { iWdt+=iX; iX=0; }
     int iY=iClipY1; if (iY<0) { iHgt+=iY; iY=0; }
     return C4Rect(iX, iY, iWdt, iHgt);
 }

Here is the caller graph for this function:

const C4FoWRegion* C4Draw::GetFoW ( ) const

inlineinherited

Definition at line 194 of file C4Draw.h.

References C4Draw::pFoW.

Referenced by C4Sky::Draw(), and C4Object::Draw().

194 { return pFoW; }

C4Draw::pFoW

const C4FoWRegion * pFoW

Definition: C4Draw.h:111

Here is the caller graph for this function:

C4Rect C4Draw::GetOutRect ( ) const

inherited

Definition at line 739 of file C4Draw.cpp.

References C4Surface::Hgt, C4Draw::RenderTarget, and C4Surface::Wdt.

Referenced by C4LandscapeRenderGL::Draw(), PerformMesh(), and SetupMultiBlt().

 {
     return C4Rect(0, 0, RenderTarget->Wdt, RenderTarget->Hgt);
 }

Here is the caller graph for this function:

bool C4Draw::GetPrimaryClipper	(	int &	rX1,
		int &	rY1,
		int &	rX2,
		int &	rY2
	)

inherited

Definition at line 722 of file C4Draw.cpp.

References C4Draw::fClipX1, C4Draw::fClipX2, C4Draw::fClipY1, and C4Draw::fClipY2.

Referenced by C4GUI::Window::Draw(), C4GUI::MultilineLabel::DrawElement(), and C4GUI::Edit::DrawElement().

 {
     // Store drawing clip values
     rX1=fClipX1; rY1=fClipY1; rX2=fClipX2; rY2=fClipY2;
     // Done
     return true;
 }

Here is the caller graph for this function:

const StdProjectionMatrix& CStdGL::GetProjectionMatrix ( ) const

inline

Definition at line 251 of file C4DrawGL.h.

References ProjectionMatrix.

Referenced by C4LandscapeRenderGL::Draw(), and C4FoWRegion::Render().

251 { return ProjectionMatrix; }

CStdGL::ProjectionMatrix

StdProjectionMatrix ProjectionMatrix

Definition: C4DrawGL.h:184

Here is the caller graph for this function:

C4Shader * CStdGL::GetSpriteShader ( int ssc )

Definition at line 674 of file C4DrawGL.cpp.

References SpriteShader, SpriteShaderBase, SpriteShaderBaseMod2, SpriteShaderBaseOverlay, SpriteShaderBaseOverlayMod2, SpriteShaderLight, SpriteShaderLightBase, SpriteShaderLightBaseMod2, SpriteShaderLightBaseNormal, SpriteShaderLightBaseNormalMod2, SpriteShaderLightBaseNormalOverlay, SpriteShaderLightBaseNormalOverlayMod2, SpriteShaderLightBaseOverlay, SpriteShaderLightBaseOverlayMod2, SpriteShaderLightMod2, and SpriteShaderMod2.

Referenced by C4ParticleList::Draw(), GetSpriteShader(), PerformMultiLines(), PerformMultiPix(), and PerformMultiTris().

 {
     C4Shader* shaders[16] = {
         &SpriteShader,
         &SpriteShaderMod2,
         &SpriteShaderBase,
         &SpriteShaderBaseMod2,
         &SpriteShaderBaseOverlay,
         &SpriteShaderBaseOverlayMod2,
 
         &SpriteShaderLight,
         &SpriteShaderLightMod2,
         &SpriteShaderLightBase,
         &SpriteShaderLightBaseMod2,
         &SpriteShaderLightBaseOverlay,
         &SpriteShaderLightBaseOverlayMod2,
         &SpriteShaderLightBaseNormal,
         &SpriteShaderLightBaseNormalMod2,
         &SpriteShaderLightBaseNormalOverlay,
         &SpriteShaderLightBaseNormalOverlayMod2,
     };
 
     int index = 0;
     if(ssc & C4SSC_LIGHT) index += 6;
 
     if(ssc & C4SSC_BASE)
     {
         index += 2;
         if(ssc & C4SSC_OVERLAY)
             index += 2;
         if( (ssc & C4SSC_NORMAL) && (ssc & C4SSC_LIGHT))
             index += 4;
     }
 
     if(ssc & C4SSC_MOD2)
         index += 1;
 
     assert(index < 16);
     return shaders[index];
 }

Here is the caller graph for this function:

C4Shader * CStdGL::GetSpriteShader	(	bool	haveBase,
		bool	haveOverlay,
		bool	haveNormal
	)

Definition at line 663 of file C4DrawGL.cpp.

References C4GFXBLIT_MOD2, C4Draw::dwBlitMode, GetSpriteShader(), and C4Draw::pFoW.

 {
     int ssc = 0;
     if(dwBlitMode & C4GFXBLIT_MOD2) ssc |= C4SSC_MOD2;
     if(haveBase) ssc |= C4SSC_BASE;
     if(haveBase && haveOverlay) ssc |= C4SSC_OVERLAY;
     if(pFoW != nullptr) ssc |= C4SSC_LIGHT;
     if(pFoW != nullptr && haveBase && haveNormal) ssc |= C4SSC_NORMAL;
     return GetSpriteShader(ssc);
 }

Here is the call graph for this function:

bool C4Draw::GetSurfaceSize	(	C4Surface *	sfcSurface,
		int &	iWdt,
		int &	iHgt
	)

inherited

Definition at line 191 of file C4Draw.cpp.

References C4Surface::GetSurfaceSize().

 {
     return sfcSurface->GetSurfaceSize(iWdt, iHgt);
 }

Here is the call graph for this function:

bool CStdGL::GetVAO	(	unsigned int	vaoid,
		GLuint &	vao
	)

Definition at line 1013 of file C4DrawGL.cpp.

References CStdGLCtx::hVAOs, pCurrCtx, and VAOIDs.

Referenced by C4LandscapeRenderGL::Draw(), C4ParticleChunk::Draw(), C4FoWDrawLightTextureStrategy::End(), C4FoWDrawWireframeStrategy::End(), PerformMultiBlt(), and C4FoWRegion::Render().

 {
     assert(pCurrCtx != nullptr);
 
     if (vaoid >= pCurrCtx->hVAOs.size())
     {
         // Resize the VAO array so that all generated VAO IDs fit
         // in it, and not only the one requested in this call.
         // We hope to get away with fewer reallocations this way.
         assert(VAOIDs.find(vaoid) != VAOIDs.end());
         std::set<unsigned int>::iterator iter = VAOIDs.end();
         --iter;
 
         pCurrCtx->hVAOs.resize(*iter + 1);
     }
 
     if (pCurrCtx->hVAOs[vaoid] == 0)
     {
         glGenVertexArrays(1, &pCurrCtx->hVAOs[vaoid]);
         vao = pCurrCtx->hVAOs[vaoid];
         return false;
     }
 
     vao = pCurrCtx->hVAOs[vaoid];
     return true;
 }

Here is the caller graph for this function:

void C4Draw::GetZoom ( ZoomData * r )

inlineinherited

Definition at line 197 of file C4Draw.h.

References ZoomData::X, ZoomData::Y, ZoomData::Zoom, C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

Referenced by C4MouseControl::Draw(), C4GUI::CMouse::Draw(), C4Game::DrawCrewOverheadText(), and ZoomDataStackItem::ZoomDataStackItem().

197 { r->Zoom=Zoom; r->X=ZoomX; r->Y=ZoomY; }

C4Draw::ZoomY

float ZoomY

Definition: C4Draw.h:112

ZoomData::Y

float Y

Definition: C4Draw.h:71

C4Draw::ZoomX

float ZoomX

Definition: C4Draw.h:112

C4Draw::Zoom

float Zoom

Definition: C4Draw.h:116

ZoomData::X

float X

Definition: C4Draw.h:71

ZoomData::Zoom

float Zoom

Definition: C4Draw.h:70

Here is the caller graph for this function:

const char * CStdGL::GLErrorString ( GLenum code )

protected

Definition at line 880 of file C4DrawGL.cpp.

Referenced by CheckGLError().

 {
     switch (code)
     {
     case GL_NO_ERROR: return "No error";
     case GL_INVALID_ENUM: return "An unacceptable value is specified for an enumerated argument";
     case GL_INVALID_VALUE: return "A numeric argument is out of range";
     case GL_INVALID_OPERATION: return "The specified operation is not allowed in the current state";
     case GL_INVALID_FRAMEBUFFER_OPERATION: return "The framebuffer object is not complete";
     case GL_OUT_OF_MEMORY: return "There is not enough memory left to execute the command";
     case GL_STACK_UNDERFLOW: return "An attempt has been made to perform an operation that would cause an internal stack to underflow";
     case GL_STACK_OVERFLOW: return "An attempt has been made to perform an operation that would cause an internal stack to overflow";
     default: assert(false); return "";
     }
 }

Here is the caller graph for this function:

void C4Draw::Grayscale	(	C4Surface *	sfcSfc,
		int32_t	iOffset = `0`
	)

inherited

Definition at line 701 of file C4Draw.cpp.

References a, b, GetBlueValue, GetGreenValue, C4Surface::GetPixDw(), GetRedValue, C4Surface::Hgt, C4Surface::Lock(), RGBA(), C4Surface::SetPixDw(), C4Surface::Unlock(), and C4Surface::Wdt.

Referenced by C4FacetSurface::Grayscale().

 {
     // safety
     if (!sfcSfc) return;
     // change colors
     int xcnt,ycnt,wdt=sfcSfc->Wdt,hgt=sfcSfc->Hgt;
     // Lock surface
     if (!sfcSfc->Lock()) return;
     for (ycnt=0; ycnt<hgt; ycnt++)
     {
         for (xcnt=0; xcnt<wdt; xcnt++)
         {
             DWORD dwColor = sfcSfc->GetPixDw(xcnt,ycnt,false);
             uint32_t r = GetRedValue(dwColor), g = GetGreenValue(dwColor), b = GetBlueValue(dwColor), a = dwColor >> 24;
             int32_t gray = Clamp<int32_t>((r + g + b) / 3 + iOffset, 0, 255);
             sfcSfc->SetPixDw(xcnt, ycnt, RGBA(gray, gray, gray, a));
         }
     }
     sfcSfc->Unlock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::Init	(	C4AbstractApp *	pApp,
		unsigned int	iXRes,
		unsigned int	iYRes,
		unsigned int	iMonitor
	)

inherited

Definition at line 815 of file C4Draw.cpp.

References C4Draw::C4Surface, C4Draw::CreatePrimaryClipper(), C4Draw::Error(), C4Draw::pApp, C4Window::pSurface, C4AbstractApp::pWindow, and C4Draw::RestoreDeviceObjects().

Referenced by DDrawInit().

 {
     this->pApp = pApp;
 
     pApp->pWindow->pSurface = new C4Surface(pApp, pApp->pWindow);
 
     if (!RestoreDeviceObjects())
         return false;
 
     if (!CreatePrimaryClipper(iXRes, iYRes))
         return Error("  Clipper failure.");
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CStdGL::InitShaders ( C4GroupSet * pGroups )

Definition at line 715 of file C4DrawGL.cpp.

References PrepareSpriteShader(), SpriteShader, SpriteShaderBase, SpriteShaderBaseMod2, SpriteShaderBaseOverlay, SpriteShaderBaseOverlayMod2, SpriteShaderLight, SpriteShaderLightBase, SpriteShaderLightBaseMod2, SpriteShaderLightBaseNormal, SpriteShaderLightBaseNormalMod2, SpriteShaderLightBaseNormalOverlay, SpriteShaderLightBaseNormalOverlayMod2, SpriteShaderLightBaseOverlay, SpriteShaderLightBaseOverlayMod2, SpriteShaderLightMod2, and SpriteShaderMod2.

Referenced by C4GraphicsResource::Init().

 {
     // Create sprite blitting shaders
     if(!PrepareSpriteShader(SpriteShader, "sprite", 0, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderMod2, "spriteMod2", C4SSC_MOD2, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderBase, "spriteBase", C4SSC_BASE, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderBaseMod2, "spriteBaseMod2", C4SSC_MOD2 | C4SSC_BASE, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderBaseOverlay, "spriteBaseOverlay", C4SSC_BASE | C4SSC_OVERLAY, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderBaseOverlayMod2, "spriteBaseOverlayMod2", C4SSC_MOD2 | C4SSC_BASE | C4SSC_OVERLAY, pGroups, nullptr, nullptr))
         return false;
 
     if(!PrepareSpriteShader(SpriteShaderLight, "spriteLight", C4SSC_LIGHT, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightMod2, "spriteLightMod2", C4SSC_LIGHT | C4SSC_MOD2, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBase, "spriteLightBase", C4SSC_LIGHT | C4SSC_BASE, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseMod2, "spriteLightBaseMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_MOD2, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseOverlay, "spriteLightBaseOverlay", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseOverlayMod2, "spriteLightBaseOverlayMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY | C4SSC_MOD2, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseNormal, "spriteLightBaseNormal", C4SSC_LIGHT | C4SSC_BASE | C4SSC_NORMAL, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseNormalMod2, "spriteLightBaseNormalMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_NORMAL | C4SSC_MOD2, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseNormalOverlay, "spriteLightBaseNormalOverlay", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY | C4SSC_NORMAL, pGroups, nullptr, nullptr))
         return false;
     if(!PrepareSpriteShader(SpriteShaderLightBaseNormalOverlayMod2, "spriteLightBaseNormalOverlayMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY | C4SSC_NORMAL | C4SSC_MOD2, pGroups, nullptr, nullptr))
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CStdGL::InvalidateDeviceObjects ( )

overridevirtual

Implements C4Draw.

Definition at line 806 of file C4DrawGL.cpp.

References C4Draw::Active, CurrentVBO, FreeVAOID(), GenericVAOs, GenericVBOs, lines_tex, and N_GENERIC_VBOS.

Referenced by Clear(), and RestoreDeviceObjects().

 {
     bool fSuccess=true;
     // deactivate
     Active=false;
     // invalidate font objects
     // invalidate primary surfaces
     if (lines_tex)
     {
         glDeleteTextures(1, &lines_tex);
         lines_tex = 0;
     }
 
     // invalidate generic VBOs
     if (GenericVBOs[0] != 0)
     {
         glDeleteBuffers(N_GENERIC_VBOS, GenericVBOs);
         GenericVBOs[0] = 0;
         CurrentVBO = 0;
         for (unsigned int GenericVAO : GenericVAOs)
             FreeVAOID(GenericVAO);
     }
 
     // invalidate shaders
 
     // TODO: We don't do this here because we cannot re-validate them in
     // RestoreDeviceObjects. This should be refactored.
 
     /*SpriteShader.Clear();
     SpriteShaderMod2.Clear();
     SpriteShaderBase.Clear();
     SpriteShaderBaseMod2.Clear();
     SpriteShaderBaseOverlay.Clear();
     SpriteShaderBaseOverlayMod2.Clear();
     SpriteShaderLight.Clear();
     SpriteShaderLightMod2.Clear();
     SpriteShaderLightBase.Clear();
     SpriteShaderLightBaseMod2.Clear();
     SpriteShaderLightBaseOverlay.Clear();
     SpriteShaderLightBaseOverlayMod2.Clear();
     SpriteShaderLightBaseNormal.Clear();
     SpriteShaderLightBaseNormalMod2.Clear();
     SpriteShaderLightBaseNormalOverlay.Clear();
     SpriteShaderLightBaseNormalOverlayMod2.Clear();*/
     return fSuccess;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::LockingPrimary ( )

inlineinherited

Definition at line 138 of file C4Draw.h.

138 { PrimaryLocked=true; }

C4Draw::PrimaryLocked

bool PrimaryLocked

Definition: C4Draw.h:106

bool C4Draw::NoPrimaryClipper ( )

inherited

Definition at line 237 of file C4Draw.cpp.

References C4Draw::SetPrimaryClipper().

Referenced by Clear(), C4Viewport::Draw(), C4Landscape::DrawChunks(), C4GUI::Edit::DrawElement(), and C4Landscape::P::MapToSurface().

 {
     // apply maximum clipper
     SetPrimaryClipper(0,0,439832,439832);
     // Done
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CStdGL::ObjectLabel	(	uint32_t	identifier,
		uint32_t	name,
		int32_t	length,
		const char *	label
	)

Definition at line 274 of file C4DrawGL.cpp.

Referenced by C4ParticleChunk::Draw(), and C4Shader::Init().

 {
 #ifdef GL_KHR_debug
     if (glObjectLabel)
         glObjectLabel(identifier, name, length, label);
 #endif
 }

Here is the caller graph for this function:

bool CStdGL::OnResolutionChanged	(	unsigned int	iXRes,
		unsigned int	iYRes
	)

overridevirtual

Implements C4Draw.

Definition at line 907 of file C4DrawGL.cpp.

References C4Draw::CreatePrimaryClipper(), and RestoreDeviceObjects().

 {
     // Re-create primary clipper to adapt to new size.
     CreatePrimaryClipper(iXRes, iYRes);
     RestoreDeviceObjects();
     return true;
 }

Here is the call graph for this function:

void CStdGL::PerformMesh	(	StdMeshInstance &	instance,
		float	tx,
		float	ty,
		float	twdt,
		float	thgt,
		DWORD	dwPlayerColor,
		C4BltTransform *	pTransform
	)

overridevirtual

Implements C4Draw.

Definition at line 1024 of file C4DrawMeshGL.cpp.

References b, C4Draw::BlitModulateClr, C4Draw::BlitModulated, C4Draw::fUsePerspective, StdMesh::GetBoundingBox(), StdMesh::GetBoundingRadius(), C4Draw::GetClipRect(), StdMeshInstance::GetMesh(), C4Draw::GetOutRect(), C4Rect::Hgt, C4Draw::MeshTransform, ProjectionMatrix, StdMeshVector::Translate(), ControllerKeys::Up(), C4Rect::Wdt, StdMeshVector::x, C4Rect::x, StdMeshBox::x1, StdMeshBox::x2, StdMeshVector::y, C4Rect::y, StdMeshBox::y1, StdMeshBox::y2, StdMeshVector::z, StdMeshBox::z1, and StdMeshBox::z2.

 {
     // Field of View for perspective projection, in degrees
     static const float FOV = 60.0f;
     static const float TAN_FOV = tan(FOV / 2.0f / 180.0f * M_PI);
 
     // Check mesh transformation; abort when it is degenerate.
     bool mesh_transform_parity = false;
     if (MeshTransform)
     {
         const float det = MeshTransform->Determinant();
         if (fabs(det) < 1e-6)
             return;
         else if (det < 0.0f)
             mesh_transform_parity = true;
     }
 
     const StdMesh& mesh = instance.GetMesh();
 
     bool parity = false;
 
     // Convert bounding box to clonk coordinate system
     // (TODO: We should cache this, not sure where though)
     const StdMeshBox& box = mesh.GetBoundingBox();
     StdMeshVector v1, v2;
     v1.x = box.x1; v1.y = box.y1; v1.z = box.z1;
     v2.x = box.x2; v2.y = box.y2; v2.z = box.z2;
 
     // Vector from origin of mesh to center of mesh
     const StdMeshVector MeshCenter = (v1 + v2)/2.0f;
 
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_BLEND); // TODO: Shouldn't this always be enabled? - blending does not work for meshes without this though.
 
     // TODO: We ignore the additive drawing flag for meshes but instead
     // set the blending mode of the corresponding material. I'm not sure
     // how the two could be combined.
     // TODO: Maybe they can be combined using a pixel shader which does
     // ftransform() and then applies colormod, additive and mod2
     // on the result (with alpha blending).
     //int iAdditive = dwBlitMode & C4GFXBLIT_ADDITIVE;
     //glBlendFunc(GL_SRC_ALPHA, iAdditive ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);
 
     // Mesh extents
     const float b = fabs(v2.x - v1.x)/2.0f;
     const float h = fabs(v2.y - v1.y)/2.0f;
     const float l = fabs(v2.z - v1.z)/2.0f;
 
     // Set up projection matrix first. We do transform and Zoom with the
     // projection matrix, so that lighting is applied to the untransformed/unzoomed
     // mesh.
     StdProjectionMatrix projectionMatrix;
     if (!fUsePerspective)
     {
         // Load the orthographic projection
         projectionMatrix = ProjectionMatrix;
 
         if (!ApplyZoomAndTransform(ZoomX, ZoomY, Zoom, pTransform, projectionMatrix))
             parity = !parity;
 
         // Scale so that the mesh fits in (tx,ty,twdt,thgt)
         const float rx = -std::min(v1.x,v2.x) / fabs(v2.x - v1.x);
         const float ry = -std::min(v1.y,v2.y) / fabs(v2.y - v1.y);
         const float dx = tx + rx*twdt;
         const float dy = ty + ry*thgt;
 
         // Scale so that Z coordinate is between -1 and 1, otherwise parts of
         // the mesh could be clipped away by the near or far clipping plane.
         // Note that this only works for the projection matrix, otherwise
         // lighting is screwed up.
 
         // This technique might also enable us not to clear the depth buffer
         // after every mesh rendering - we could simply scale the first mesh
         // of the scene so that it's Z coordinate is between 0 and 1, scale
         // the second mesh that it is between 1 and 2, and so on.
         // This of course requires an orthogonal projection so that the
         // meshes don't look distorted - if we should ever decide to use
         // a perspective projection we need to think of something different.
         // Take also into account that the depth is not linear but linear
         // in the logarithm (if I am not mistaken), so goes as 1/z
 
         // Don't scale by Z extents since mesh might be transformed
         // by MeshTransformation, so use GetBoundingRadius to be safe.
         // Note this still fails if mesh is scaled in Z direction or
         // there are attached meshes.
         const float scz = 1.0/(mesh.GetBoundingRadius());
 
         Translate(projectionMatrix, dx, dy, 0.0f);
         Scale(projectionMatrix, 1.0f, 1.0f, scz);
     }
     else
     {
         // Perspective projection. This code transforms the projected
         // 3D model into the target area.
         const C4Rect clipRect = GetClipRect();
         projectionMatrix = StdProjectionMatrix::Identity();
 
         // Back to GL device coordinates
         Translate(projectionMatrix, -1.0f, 1.0f, 0.0f);
         Scale(projectionMatrix, 2.0f/clipRect.Wdt, -2.0f/clipRect.Hgt, 1.0f);
 
         Translate(projectionMatrix, -clipRect.x, -clipRect.y, 0.0f);
         if (!ApplyZoomAndTransform(ZoomX, ZoomY, Zoom, pTransform, projectionMatrix))
             parity = !parity;
 
         // Move to target location and compensate for 1.0f aspect
         float ttx = tx, tty = ty, ttwdt = twdt, tthgt = thgt;
         if(twdt > thgt)
         {
             tty += (thgt-twdt)/2.0;
             tthgt = twdt;
         }
         else
         {
             ttx += (twdt-thgt)/2.0;
             ttwdt = thgt;
         }
 
         Translate(projectionMatrix, ttx, tty, 0.0f);
         Scale(projectionMatrix, ((float)ttwdt)/clipRect.Wdt, ((float)tthgt)/clipRect.Hgt, 1.0f);
 
         // Return to Clonk coordinate frame
         Scale(projectionMatrix, clipRect.Wdt/2.0, -clipRect.Hgt/2.0, 1.0f);
         Translate(projectionMatrix, 1.0f, -1.0f, 0.0f);
 
         // Fix for the case when we have different aspect ratios
         const float ta = twdt / thgt;
         const float ma = b / h;
         if(ta <= 1 && ta/ma <= 1)
             Scale(projectionMatrix, std::max(ta, ta/ma), std::max(ta, ta/ma), 1.0f);
         else if(ta >= 1 && ta/ma >= 1)
             Scale(projectionMatrix, std::max(1.0f/ta, ma/ta), std::max(1.0f/ta, ma/ta), 1.0f);
 
         // Apply perspective projection. After this, x and y range from
         // -1 to 1, and this is mapped into tx/ty/twdt/thgt by the above code.
         // Aspect is 1.0f which is changed above as well.
         Perspective(projectionMatrix, 1.0f/TAN_FOV, 1.0f, 0.1f, 100.0f);
     }
 
     // Now set up the modelview matrix
     StdMeshMatrix modelviewMatrix;
     if (fUsePerspective)
     {
         // Setup camera position so that the mesh with uniform transformation
         // fits well into a square target (without distortion).
         const float EyeR = l + std::max(b/TAN_FOV, h/TAN_FOV);
         const StdMeshVector Eye = StdMeshVector::Translate(MeshCenter.x, MeshCenter.y, MeshCenter.z + EyeR);
 
         // Up vector is unit vector in theta direction
         const StdMeshVector Up = StdMeshVector::Translate(0.0f, -1.0f, 0.0f);
 
         // Fix X axis (???)
         modelviewMatrix = StdMeshMatrix::Scale(-1.0f, 1.0f, 1.0f);
 
         // center on mesh's bounding box, so that the mesh is really in the center of the viewport
         modelviewMatrix *= StdMeshMatrix::LookAt(Eye, MeshCenter, Up);
     }
     else
     {
         modelviewMatrix = StdMeshMatrix::Identity();
     }
 
     // Apply mesh transformation matrix
     if (MeshTransform)
     {
         // Apply MeshTransformation (in the Mesh's coordinate system)
         modelviewMatrix *= *MeshTransform;
         // Keep track of parity
         if (mesh_transform_parity) parity = !parity;
     }
 
     DWORD dwModClr = BlitModulated ? BlitModulateClr : 0xffffffff;
 
     const C4Rect clipRect = GetClipRect();
     const C4Rect outRect = GetOutRect();
 
     RenderMeshImpl(projectionMatrix, modelviewMatrix, instance, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
 
     // Reset state
     //glActiveTexture(GL_TEXTURE0);
     glDepthMask(GL_TRUE);
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_CULL_FACE);
     glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
 
     // TODO: glScissor, so that we only clear the area the mesh covered.
     glClear(GL_DEPTH_BUFFER_BIT);
 }

Here is the call graph for this function:

void CStdGL::PerformMultiBlt	(	C4Surface *	sfcTarget,
		DrawOperation	op,
		const C4BltVertex *	vertices,
		unsigned int	n_vertices,
		bool	has_tex,
		C4ShaderCall *	shader_call
	)

Definition at line 598 of file C4DrawGL.cpp.

References C4SSA_Color, C4SSA_Position, C4SSA_TexCoord, CurrentVBO, GenericVAOs, GenericVBOs, GenericVBOSizes, C4ShaderCall::GetAttribute(), GetVAO(), C4Surface::IsRenderTarget(), N_GENERIC_VBOS, C4Draw::OP_POINTS, C4Draw::OP_TRIANGLES, and PrepareRendering().

Referenced by PerformMultiLines(), PerformMultiPix(), and PerformMultiTris().

 {
     // Only direct rendering
     assert(sfcTarget->IsRenderTarget());
     if(!PrepareRendering(sfcTarget)) return;
 
     // Select a buffer
     const unsigned int vbo_index = CurrentVBO;
     CurrentVBO = (CurrentVBO + 1) % N_GENERIC_VBOS;
 
     // Upload data into the buffer, resize buffer if necessary
     glBindBuffer(GL_ARRAY_BUFFER, GenericVBOs[vbo_index]);
     if (GenericVBOSizes[vbo_index] < n_vertices)
     {
         GenericVBOSizes[vbo_index] = n_vertices;
         glBufferData(GL_ARRAY_BUFFER, n_vertices * sizeof(C4BltVertex), vertices, GL_STREAM_DRAW);
     }
     else
     {
         glBufferSubData(GL_ARRAY_BUFFER, 0, n_vertices * sizeof(C4BltVertex), vertices);
     }
 
     // Choose the VAO that corresponds to the chosen VBO. Also, use one
     // that supplies texture coordinates if we have texturing enabled.
     GLuint vao;
     const unsigned int vao_index = vbo_index + (has_tex ? N_GENERIC_VBOS : 0);
     const unsigned int vao_id = GenericVAOs[vao_index];
     const bool has_vao = GetVAO(vao_id, vao);
     glBindVertexArray(vao);
     if (!has_vao)
     {
         // Initialize VAO for this context
         const GLuint position = shader_call->GetAttribute(C4SSA_Position);
         const GLuint color = shader_call->GetAttribute(C4SSA_Color);
         const GLuint texcoord = has_tex ? shader_call->GetAttribute(C4SSA_TexCoord) : 0;
 
         glEnableVertexAttribArray(position);
         glEnableVertexAttribArray(color);
         if (has_tex)
             glEnableVertexAttribArray(texcoord);
 
 
         glVertexAttribPointer(position, 2, GL_FLOAT, GL_FALSE, sizeof(C4BltVertex), reinterpret_cast<const uint8_t*>(offsetof(C4BltVertex, ftx)));
         glVertexAttribPointer(color, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(C4BltVertex), reinterpret_cast<const uint8_t*>(offsetof(C4BltVertex, color)));
         if (has_tex)
             glVertexAttribPointer(texcoord, 2, GL_FLOAT, GL_FALSE, sizeof(C4BltVertex), reinterpret_cast<const uint8_t*>(offsetof(C4BltVertex, tx)));
     }
 
     switch (op)
     {
     case OP_POINTS:
         glDrawArrays(GL_POINTS, 0, n_vertices);
         break;
     case OP_TRIANGLES:
         glDrawArrays(GL_TRIANGLES, 0, n_vertices);
         break;
     default:
         assert(false);
         break;
     }
 
     glBindVertexArray(0);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CStdGL::PerformMultiLines	(	C4Surface *	sfcTarget,
		const C4BltVertex *	vertices,
		unsigned int	n_vertices,
		float	width,
		C4ShaderCall *	shader_call
	)

overridevirtual

Implements C4Draw.

Definition at line 522 of file C4DrawGL.cpp.

References C4BltVertex::color, C4BltVertex::ftx, C4BltVertex::fty, GetSpriteShader(), lines_tex, C4Draw::OP_TRIANGLES, PerformMultiBlt(), SetupMultiBlt(), C4BltVertex::tx, and C4BltVertex::ty.

 {
     // In a first step, we transform the lines array to a triangle array, so that we can draw
     // the lines with some thickness.
     // In principle, this step could be easily (and probably much more efficiently) performed
     // by a geometry shader as well, however that would require OpenGL 3.2.
     C4BltVertex* tri_vertices = new C4BltVertex[n_vertices * 3];
     for(unsigned int i = 0; i < n_vertices; i += 2)
     {
         const float x1 = vertices[i].ftx;
         const float y1 = vertices[i].fty;
         const float x2 = vertices[i+1].ftx;
         const float y2 = vertices[i+1].fty;
 
         float offx = y1 - y2;
         float offy = x2 - x1;
         float l = sqrtf(offx * offx + offy * offy);
         // avoid division by zero
         l += 0.000000005f;
         offx *= width/l;
         offy *= width/l;
 
         tri_vertices[3*i + 0].ftx = x1 + offx; tri_vertices[3*i + 0].fty = y1 + offy;
         tri_vertices[3*i + 1].ftx = x1 - offx; tri_vertices[3*i + 1].fty = y1 - offy;
         tri_vertices[3*i + 2].ftx = x2 - offx; tri_vertices[3*i + 2].fty = y2 - offy;
         tri_vertices[3*i + 3].ftx = x2 + offx; tri_vertices[3*i + 3].fty = y2 + offy;
 
         for(int j = 0; j < 4; ++j)
         {
             tri_vertices[3*i + 0].color[j] = vertices[i].color[j];
             tri_vertices[3*i + 1].color[j] = vertices[i].color[j];
             tri_vertices[3*i + 2].color[j] = vertices[i + 1].color[j];
             tri_vertices[3*i + 3].color[j] = vertices[i + 1].color[j];
         }
 
         tri_vertices[3*i + 0].tx = 0.f; tri_vertices[3*i + 0].ty = 0.f;
         tri_vertices[3*i + 1].tx = 0.f; tri_vertices[3*i + 1].ty = 2.f;
         tri_vertices[3*i + 2].tx = 1.f; tri_vertices[3*i + 2].ty = 2.f;
         tri_vertices[3*i + 3].tx = 1.f; tri_vertices[3*i + 3].ty = 0.f;
 
         tri_vertices[3*i + 4] = tri_vertices[3*i + 2]; // duplicate vertex
         tri_vertices[3*i + 5] = tri_vertices[3*i + 0]; // duplicate vertex
     }
 
     // Then, feed the vertices to the GL
     if (!shader_call)
     {
         C4ShaderCall call(GetSpriteShader(true, false, false));
         SetupMultiBlt(call, nullptr, lines_tex, 0, 0, 0, nullptr);
         PerformMultiBlt(sfcTarget, OP_TRIANGLES, tri_vertices, n_vertices * 3, true, &call);
     }
     else
     {
         SetupMultiBlt(*shader_call, nullptr, lines_tex, 0, 0, 0, nullptr);
         PerformMultiBlt(sfcTarget, OP_TRIANGLES, tri_vertices, n_vertices * 3, true, shader_call);
     }
 
     delete[] tri_vertices;
 }

Here is the call graph for this function:

void CStdGL::PerformMultiPix	(	C4Surface *	sfcTarget,
		const C4BltVertex *	vertices,
		unsigned int	n_vertices,
		C4ShaderCall *	shader_call
	)

overridevirtual

Implements C4Draw.

Definition at line 495 of file C4DrawGL.cpp.

References GetSpriteShader(), C4Draw::OP_POINTS, PerformMultiBlt(), and SetupMultiBlt().

 {
     // Draw on pixel center:
     StdProjectionMatrix transform = StdProjectionMatrix::Translate(0.5f, 0.5f, 0.0f);
 
     // This is a workaround. Instead of submitting the whole vertex array to the GL, we do it
     // in batches of 256 vertices. The intel graphics driver on Linux crashes with
     // significantly larger arrays, such as 400. It's not clear to me why, maybe POINT drawing
     // is just not very well tested.
     const unsigned int BATCH_SIZE = 256;
 
     // Feed the vertices to the GL
     if (!shader_call)
     {
         C4ShaderCall call(GetSpriteShader(false, false, false));
         SetupMultiBlt(call, nullptr, 0, 0, 0, 0, &transform);
         for(unsigned int i = 0; i < n_vertices; i += BATCH_SIZE)
             PerformMultiBlt(sfcTarget, OP_POINTS, &vertices[i], std::min(n_vertices - i, BATCH_SIZE), false, &call);
     }
     else
     {
         SetupMultiBlt(*shader_call, nullptr, 0, 0, 0, 0, &transform);
         for(unsigned int i = 0; i < n_vertices; i += BATCH_SIZE)
             PerformMultiBlt(sfcTarget, OP_POINTS, &vertices[i], std::min(n_vertices - i, BATCH_SIZE), false, shader_call);
     }
 }

Here is the call graph for this function:

void CStdGL::PerformMultiTris	(	C4Surface *	sfcTarget,
		const C4BltVertex *	vertices,
		unsigned int	n_vertices,
		const C4BltTransform *	pTransform,
		C4TexRef *	pTex,
		C4TexRef *	pOverlay,
		C4TexRef *	pNormal,
		DWORD	dwOverlayClrMod,
		C4ShaderCall *	shader_call
	)

overridevirtual

Implements C4Draw.

Definition at line 582 of file C4DrawGL.cpp.

References GetSpriteShader(), C4Draw::OP_TRIANGLES, PerformMultiBlt(), SetupMultiBlt(), and C4TexRef::texName.

 {
     // Feed the vertices to the GL
     if (!shader_call)
     {
         C4ShaderCall call(GetSpriteShader(pTex != nullptr, pOverlay != nullptr, pNormal != nullptr));
         SetupMultiBlt(call, pTransform, pTex ? pTex->texName : 0, pOverlay ? pOverlay->texName : 0, pNormal ? pNormal->texName : 0, dwOverlayModClr, nullptr);
         PerformMultiBlt(sfcTarget, OP_TRIANGLES, vertices, n_vertices, pTex != nullptr, &call);
     }
     else
     {
         SetupMultiBlt(*shader_call, pTransform, pTex ? pTex->texName : 0, pOverlay ? pOverlay->texName : 0, pNormal ? pNormal->texName : 0, dwOverlayModClr, nullptr);
         PerformMultiBlt(sfcTarget, OP_TRIANGLES, vertices, n_vertices, pTex != nullptr, shader_call);
     }
 }

Here is the call graph for this function:

bool CStdGL::PrepareMaterial	(	StdMeshMatManager &	mat_manager,
		StdMeshMaterialLoader &	loader,
		StdMeshMaterial &	mat
	)

overridevirtual

Implements C4Draw.

Definition at line 272 of file C4DrawMeshGL.cpp.

 {
     // TODO: If a technique is not available, show an error message what the problem is
 
     // select context, if not already done
     if (!pCurrCtx) return false;
 
     for (unsigned int i = 0; i < mat.Techniques.size(); ++i)
     {
         StdMeshMaterialTechnique& technique = mat.Techniques[i];
         technique.Available = true;
         for (unsigned int j = 0; j < technique.Passes.size(); ++j)
         {
             StdMeshMaterialPass& pass = technique.Passes[j];
 
             GLint max_texture_units;
             glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_units);
 
             // OpenGL 3.x guarantees at least 16 TIUs. If the above returns
             // less it's probably a driver bug. So just keep going.
             assert(max_texture_units >= 16);
             max_texture_units = std::min<GLint>(max_texture_units, 16);
 
             unsigned int active_texture_units = 0;
             for(auto & TextureUnit : pass.TextureUnits)
                 if(TextureUnit.HasTexture())
                     ++active_texture_units;
 
             if (active_texture_units > static_cast<unsigned int>(max_texture_units))
                 technique.Available = false;
 
             for (auto & texunit : pass.TextureUnits)
             {
                 for (unsigned int l = 0; l < texunit.GetNumTextures(); ++l)
                 {
                     const C4TexRef& texture = texunit.GetTexture(l);
                     glBindTexture(GL_TEXTURE_2D, texture.texName);
                     switch (texunit.TexAddressMode)
                     {
                     case StdMeshMaterialTextureUnit::AM_Wrap:
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
                         break;
                     case StdMeshMaterialTextureUnit::AM_Border:
                         glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, texunit.TexBorderColor);
                         // fallthrough
                     case StdMeshMaterialTextureUnit::AM_Clamp:
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
                         break;
                     case StdMeshMaterialTextureUnit::AM_Mirror:
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
                         break;
                     }
 
                     switch (texunit.Filtering[0]) // min
                     {
                     case StdMeshMaterialTextureUnit::F_None:
                         technique.Available = false;
                         break;
                     case StdMeshMaterialTextureUnit::F_Point:
                         switch (texunit.Filtering[2]) // mip
                         {
                         case StdMeshMaterialTextureUnit::F_None:
                             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                             break;
                         case StdMeshMaterialTextureUnit::F_Point:
                             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
                             break;
                         case StdMeshMaterialTextureUnit::F_Linear:
                             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
                             break;
                         case StdMeshMaterialTextureUnit::F_Anisotropic:
                             technique.Available = false; // invalid
                             break;
                         }
                         break;
                     case StdMeshMaterialTextureUnit::F_Linear:
                         switch (texunit.Filtering[2]) // mip
                         {
                         case StdMeshMaterialTextureUnit::F_None:
                             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                             break;
                         case StdMeshMaterialTextureUnit::F_Point:
                             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                             break;
                         case StdMeshMaterialTextureUnit::F_Linear:
                             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                             break;
                         case StdMeshMaterialTextureUnit::F_Anisotropic:
                             technique.Available = false; // invalid
                             break;
                         }
                         break;
                     case StdMeshMaterialTextureUnit::F_Anisotropic:
                         // unsupported
                         technique.Available = false;
                         break;
                     }
 
                     switch (texunit.Filtering[1]) // max
                     {
                     case StdMeshMaterialTextureUnit::F_None:
                         technique.Available = false; // invalid
                         break;
                     case StdMeshMaterialTextureUnit::F_Point:
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                         break;
                     case StdMeshMaterialTextureUnit::F_Linear:
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                         break;
                     case StdMeshMaterialTextureUnit::F_Anisotropic:
                         // unsupported
                         technique.Available = false;
                         break;
                     }
                 } // loop over textures
             } // loop over texture units
 
             // Create fragment and/or vertex shader
             // if a custom shader is not provided.
             // Re-use existing programs if the generated
             // code is the same (determined by SHA1 hash).
             bool custom_shader = true;
             if(!pass.VertexShader.Shader)
             {
                 StdStrBuf buf = GetVertexShaderCodeForPass(pass, Workarounds.LowMaxVertexUniformCount);
                 StdStrBuf hash = GetSHA1HexDigest(buf.getData(), buf.getLength());
                 pass.VertexShader.Shader = mat_manager.AddShader("auto-generated vertex shader", hash.getData(), "glsl", SMMS_VERTEX, buf.getData(), StdMeshMatManager::SMM_AcceptExisting);
                 custom_shader = false;
             }
 
             if(!pass.FragmentShader.Shader)
             {
                 // TODO: Should use shared_params once we introduce them
                 StdStrBuf buf = GetFragmentShaderCodeForPass(pass, pass.FragmentShader.Parameters);
                 StdStrBuf hash = GetSHA1HexDigest(buf.getData(), buf.getLength());
                 pass.FragmentShader.Shader = mat_manager.AddShader("auto-generated fragment shader", hash.getData(), "glsl", SMMS_FRAGMENT, buf.getData(), StdMeshMatManager::SMM_AcceptExisting);
             }
 
             // Then, link the program, and resolve parameter locations
             StdStrBuf name(FormatString("%s:%s:%s", mat.Name.getData(), technique.Name.getData(), pass.Name.getData()));
             const StdMeshMaterialProgram* added_program = mat_manager.AddProgram(name.getData(), loader, pass.FragmentShader, pass.VertexShader, pass.GeometryShader);
             if(!added_program)
             {
                 // If the program could not be compiled, try again with the LowMaxVertexUniformCount workaround.
                 // See bug #1368.
                 if (!custom_shader && !Workarounds.LowMaxVertexUniformCount)
                 {
                     StdStrBuf buf = GetVertexShaderCodeForPass(pass, true);
                     StdStrBuf hash = GetSHA1HexDigest(buf.getData(), buf.getLength());
                     pass.VertexShader.Shader = mat_manager.AddShader("auto-generated vertex shader", hash.getData(), "glsl", SMMS_VERTEX, buf.getData(), StdMeshMatManager::SMM_AcceptExisting);
 
                     added_program = mat_manager.AddProgram(name.getData(), loader, pass.FragmentShader, pass.VertexShader, pass.GeometryShader);
                     if(added_program)
                     {
                         // If this actually work, cache the result, so we don't
                         // need to fail again next time before trying the workaround.
                         Workarounds.LowMaxVertexUniformCount = true;
                         Log("  gl: Enabling low max vertex uniform workaround");
                     }
                 }
             }
 
             if (!added_program)
             {
                 technique.Available = false;
             }
             else
             {
                 std::unique_ptr<StdMeshMaterialPass::ProgramInstance> program_instance(new StdMeshMaterialPass::ProgramInstance(added_program, &pass.FragmentShader, &pass.VertexShader, &pass.GeometryShader));
                 pass.Program = std::move(program_instance);
             }
         }
 
         if (technique.Available && mat.BestTechniqueIndex == -1)
             mat.BestTechniqueIndex = i;
     }
 
     return mat.BestTechniqueIndex != -1;
 }

Here is the call graph for this function:

bool CStdGL::PrepareRendering ( C4Surface * sfcToSurface )

overridevirtual

Implements C4Draw.

Definition at line 169 of file C4DrawGL.cpp.

References C4Draw::Active, C4AbstractApp::AssertMainThread(), C4Surface::IsRenderTarget(), C4Surface::Locked, C4Draw::pApp, C4Surface::pCtx, pCurrCtx, C4Draw::RenderTarget, CStdGLCtx::Select(), and UpdateClipper().

Referenced by C4LandscapeRenderGL::Draw(), PerformMultiBlt(), and C4GUI::DialogWindow::PerformUpdate().

 {
     // call from gfx thread only!
     if (!pApp || !pApp->AssertMainThread()) return false;
     // not ready?
     if (!Active)
         return false;
     // target?
     if (!sfcToSurface) return false;
     // target locked?
     if (sfcToSurface->Locked) return false;
     // target is already set as render target?
     if (sfcToSurface != RenderTarget)
     {
         // target is a render-target?
         if (!sfcToSurface->IsRenderTarget()) return false;
         // context
         if (sfcToSurface->pCtx && sfcToSurface->pCtx != pCurrCtx)
             if (!sfcToSurface->pCtx->Select()) return false;
         // set target
         RenderTarget=sfcToSurface;
         // new target has different size; needs other clipping rect
         UpdateClipper();
     }
     // done
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CStdGL::PrepareSpriteShader	(	C4Shader &	shader,
		const char *	name,
		int	ssc,
		C4GroupSet *	pGroups,
		const char const	additionalDefines,
		const char const	additionalSlices
	)

overridevirtual

Implements C4Draw.

Definition at line 198 of file C4DrawGL.cpp.

References C4Shader::AddDefine(), C4SSA_BoneIndices0, C4SSA_BoneIndices1, C4SSA_BoneWeights0, C4SSA_BoneWeights1, C4SSA_Color, C4SSA_Count, C4SSA_Normal, C4SSA_Position, C4SSA_TexCoord, C4SSU_AmbientBrightness, C4SSU_AmbientTex, C4SSU_AmbientTransform, C4SSU_BaseTex, C4SSU_Bones, C4SSU_ClrMod, C4SSU_Count, C4SSU_CullMode, C4SSU_FrameCounter, C4SSU_Gamma, C4SSU_LightTex, C4SSU_LightTransform, C4SSU_MaterialAmbient, C4SSU_MaterialDiffuse, C4SSU_MaterialEmission, C4SSU_MaterialShininess, C4SSU_MaterialSpecular, C4SSU_ModelViewMatrix, C4SSU_NormalMatrix, C4SSU_NormalTex, C4SSU_OverlayClr, C4SSU_OverlayTex, C4SSU_ProjectionMatrix, C4Shader::Clear(), C4Shader::ClearSlices(), C4Shader::Init(), C4Shader::LoadFragmentSlices(), C4Shader::LoadVertexSlices(), and C4Shader::SetScriptCategories().

Referenced by InitShaders().

 {
     const char* uniformNames[C4SSU_Count + 1];
     uniformNames[C4SSU_ProjectionMatrix] = "projectionMatrix";
     uniformNames[C4SSU_ModelViewMatrix] = "modelviewMatrix";
     uniformNames[C4SSU_NormalMatrix] = "normalMatrix";
     uniformNames[C4SSU_ClrMod] = "clrMod";
     uniformNames[C4SSU_Gamma] = "gamma";
     uniformNames[C4SSU_BaseTex] = "baseTex";
     uniformNames[C4SSU_OverlayTex] = "overlayTex";
     uniformNames[C4SSU_OverlayClr] = "overlayClr";
     uniformNames[C4SSU_LightTex] = "lightTex";
     uniformNames[C4SSU_LightTransform] = "lightTransform";
     uniformNames[C4SSU_NormalTex] = "normalTex";
     uniformNames[C4SSU_AmbientTex] = "ambientTex";
     uniformNames[C4SSU_AmbientTransform] = "ambientTransform";
     uniformNames[C4SSU_AmbientBrightness] = "ambientBrightness";
     uniformNames[C4SSU_MaterialAmbient] = "materialAmbient"; // unused
     uniformNames[C4SSU_MaterialDiffuse] = "materialDiffuse"; // unused
     uniformNames[C4SSU_MaterialSpecular] = "materialSpecular"; // unused
     uniformNames[C4SSU_MaterialEmission] = "materialEmission"; // unused
     uniformNames[C4SSU_MaterialShininess] = "materialShininess"; // unused
     uniformNames[C4SSU_Bones] = "bones"; // unused
     uniformNames[C4SSU_CullMode] = "cullMode"; // unused
     uniformNames[C4SSU_FrameCounter] = "frameCounter";
     uniformNames[C4SSU_Count] = nullptr;
 
     const char* attributeNames[C4SSA_Count + 1];
     attributeNames[C4SSA_Position] = "oc_Position";
     attributeNames[C4SSA_Normal] = "oc_Normal"; // unused
     attributeNames[C4SSA_TexCoord] = "oc_TexCoord"; // only used if C4SSC_Base is set
     attributeNames[C4SSA_Color] = "oc_Color";
     attributeNames[C4SSA_BoneIndices0] = "oc_BoneIndices0"; // unused
     attributeNames[C4SSA_BoneIndices1] = "oc_BoneIndices1"; // unused
     attributeNames[C4SSA_BoneWeights0] = "oc_BoneWeights0"; // unused
     attributeNames[C4SSA_BoneWeights1] = "oc_BoneWeights1"; // unused
     attributeNames[C4SSA_Count] = nullptr;
 
     // Clear previous content
     shader.Clear();
     shader.ClearSlices();
 
     // Start with #defines
     shader.AddDefine("OPENCLONK");
     shader.AddDefine("OC_SPRITE");
     if (ssc & C4SSC_MOD2) shader.AddDefine("OC_CLRMOD_MOD2");
     if (ssc & C4SSC_NORMAL) shader.AddDefine("OC_WITH_NORMALMAP");
     if (ssc & C4SSC_LIGHT) shader.AddDefine("OC_DYNAMIC_LIGHT");
     if (ssc & C4SSC_BASE) shader.AddDefine("OC_HAVE_BASE");
     if (ssc & C4SSC_OVERLAY) shader.AddDefine("OC_HAVE_OVERLAY");
 
     if (additionalDefines)
         for (const char* const* define = additionalDefines; *define != nullptr; ++define)
             shader.AddDefine(*define);
 
     // Then load slices for fragment and vertex shader
     shader.LoadVertexSlices(pGroups, "SpriteVertexShader.glsl");
     shader.LoadFragmentSlices(pGroups, "CommonShader.glsl");
     shader.LoadFragmentSlices(pGroups, "ObjectShader.glsl");
 
     // Categories for script shaders.
     shader.SetScriptCategories({"Common", "Object"});
 
     if (additionalSlices)
         for (const char* const* slice = additionalSlices; *slice != nullptr; ++slice)
             shader.LoadFragmentSlices(pGroups, *slice);
 
     if (!shader.Init(name, uniformNames, attributeNames))
     {
         shader.ClearSlices();
         return false;
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::PrimaryUnlocked ( )

inlineinherited

Definition at line 139 of file C4Draw.h.

139 { PrimaryLocked=false; }

C4Draw::PrimaryLocked

bool PrimaryLocked

Definition: C4Draw.h:106

void C4Draw::RemoveZoom	(	float &	X,
		float &	Y
	)

inherited

Definition at line 790 of file C4Draw.cpp.

References C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

 {
     X = (X - ZoomX) / Zoom + ZoomX;
     Y = (Y - ZoomY) / Zoom + ZoomY;
 }

bool C4Draw::RenderMesh	(	StdMeshInstance &	instance,
		C4Surface *	sfcTarget,
		float	tx,
		float	ty,
		float	twdt,
		float	thgt,
		DWORD	dwPlayerColor,
		C4BltTransform *	pTransform
	)

inherited

Definition at line 403 of file C4Draw.cpp.

References C4Surface::IsRenderTarget(), C4Draw::MeshTransform, C4Draw::PerformMesh(), C4Draw::PrepareRendering(), StdMeshInstance::ReorderFaces(), and StdMeshInstance::UpdateBoneTransforms().

Referenced by C4DefGraphics::Draw(), C4GraphicsOverlay::Draw(), and C4Object::DrawFaceImpl().

 {
     // TODO: Emulate rendering
     if (!sfcTarget->IsRenderTarget()) return false;
 
     // TODO: Clip
 
     // prepare rendering to surface
     if (!PrepareRendering(sfcTarget)) return false;
     // Update bone matrices and vertex data (note this also updates attach transforms and child transforms)
     instance.UpdateBoneTransforms();
     // Order faces according to MeshTransformation (note pTransform does not affect Z coordinate, so does not need to be taken into account for correct ordering)
     StdMeshMatrix mat = StdMeshMatrix::Identity();
     if(MeshTransform) mat = *MeshTransform * mat;
     instance.ReorderFaces(&mat);
     // Render mesh
     PerformMesh(instance, tx, ty, twdt, thgt, dwPlayerColor, pTransform);
     // success
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::ResetBlitMode ( )

inlineinherited

Definition at line 192 of file C4Draw.h.

Referenced by C4GraphicsOverlay::Draw(), C4ParticleList::Draw(), C4GUI::Tabular::Sheet::DrawCaption(), C4GUI::Button::DrawElement(), C4GUI::IconButton::DrawElement(), C4GUI::ArrowButton::DrawElement(), C4GUI::CheckBox::DrawElement(), C4GUI::ContextButton::DrawElement(), C4GUI::ComboBox::DrawElement(), C4EditCursor::DrawObject(), C4GraphicsOverlay::DrawPicture(), and C4Object::FinishedDrawing().

192 { dwBlitMode=0; }

C4Draw::dwBlitMode

DWORD dwBlitMode

Definition: C4Draw.h:110

Here is the caller graph for this function:

void C4Draw::ResetGamma ( )

inherited

Definition at line 760 of file C4Draw.cpp.

References C4Draw::gamma, and C4Draw::gammaOut.

Referenced by C4Draw::Clear(), C4Draw::Default(), and C4Game::SetDefaultGamma().

 {
     for (auto & i : gamma) {
         i[0] = 1.0f;
         i[1] = 1.0f;
         i[2] = 1.0f;
     }
     gammaOut[0] = 1.0f;
     gammaOut[1] = 1.0f;
     gammaOut[2] = 1.0f;
 }

Here is the caller graph for this function:

bool CStdGL::RestoreDeviceObjects ( )

overridevirtual

Implements C4Draw.

Definition at line 760 of file C4DrawGL.cpp.

References C4Draw::Active, C4Draw::dwBlitMode, GENERIC_VBO_SIZE, GenericVAOs, GenericVBOs, GenericVBOSizes, GenVAOID(), InvalidateDeviceObjects(), lines_tex, C4Draw::MaxTexSize, N_GENERIC_VBOS, C4Draw::pApp, pMainCtx, C4Window::pSurface, C4AbstractApp::pWindow, C4Draw::RenderTarget, s, and CStdGLCtx::Select().

Referenced by OnResolutionChanged().

 {
     assert(pMainCtx);
     // delete any previous objects
     InvalidateDeviceObjects();
 
     // set states
     Active = pMainCtx->Select();
     RenderTarget = pApp->pWindow->pSurface;
 
     // lines texture
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     glGenTextures(1, &lines_tex);
     glBindTexture(GL_TEXTURE_2D, lines_tex);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     static const char * linedata = "\xff\xff\xff\x00\xff\xff\xff\xff";
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 2, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, linedata);
 
     MaxTexSize = 64;
     GLint s = 0;
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &s);
     if (s>0) MaxTexSize = s;
 
     // Generic VBOs
     glGenBuffers(N_GENERIC_VBOS, GenericVBOs);
     for (unsigned int i = 0; i < N_GENERIC_VBOS; ++i)
     {
         GenericVBOSizes[i] = GENERIC_VBO_SIZE;
         glBindBuffer(GL_ARRAY_BUFFER, GenericVBOs[i]);
         glBufferData(GL_ARRAY_BUFFER, GenericVBOSizes[i] * sizeof(C4BltVertex), nullptr, GL_STREAM_DRAW);
         GenericVAOs[i] = GenVAOID();
         GenericVAOs[i + N_GENERIC_VBOS] = GenVAOID();
     }
 
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 
     // reset blit states
     dwBlitMode = 0;
 
     // done
     return Active;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::RestorePrimaryClipper ( )

inherited

Definition at line 210 of file C4Draw.cpp.

References C4Draw::fStClipX1, C4Draw::fStClipX2, C4Draw::fStClipY1, C4Draw::fStClipY2, and C4Draw::SetPrimaryClipper().

Referenced by C4ScriptGuiWindow::DrawChildren(), C4MenuItem::DrawElement(), C4GUI::WoodenLabel::DrawElement(), C4GUI::ComboBox::DrawElement(), and C4FoWRegion::Render().

 {
     // Restore primary clipper
     SetPrimaryClipper(fStClipX1, fStClipY1, fStClipX2, fStClipY2);
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::SetBlitMode ( DWORD dwBlitMode )

inlineinherited

Definition at line 191 of file C4Draw.h.

References C4GFXBLIT_ALL.

Referenced by C4MouseControl::Draw(), C4GraphicsOverlay::Draw(), C4GUI::Tabular::Sheet::DrawCaption(), C4GUI::Button::DrawElement(), C4GUI::IconButton::DrawElement(), C4GUI::ArrowButton::DrawElement(), C4GUI::CheckBox::DrawElement(), C4GUI::ContextButton::DrawElement(), C4GUI::ComboBox::DrawElement(), C4EditCursor::DrawObject(), C4GraphicsOverlay::DrawPicture(), and C4Object::PrepareDrawing().

191 { this->dwBlitMode=dwBlitMode & C4GFXBLIT_ALL; } // set blit mode extra flags (additive blits, mod2-modulation, etc.)

C4GFXBLIT_ALL

#define C4GFXBLIT_ALL

Definition: C4Surface.h:32

C4Draw::dwBlitMode

DWORD dwBlitMode

Definition: C4Draw.h:110

Here is the caller graph for this function:

void C4Draw::SetFoW ( const C4FoWRegion * fow )

inlineinherited

Definition at line 193 of file C4Draw.h.

Referenced by C4Viewport::Draw(), and C4Object::Draw().

193 { pFoW = fow; }

C4Draw::pFoW

const C4FoWRegion * pFoW

Definition: C4Draw.h:111

Here is the caller graph for this function:

void C4Draw::SetGamma	(	float	r,
		float	g,
		float	b,
		int32_t	iRampIndex
	)

inherited

Definition at line 744 of file C4Draw.cpp.

References b, C4Draw::gamma, and C4Draw::gammaOut.

Referenced by C4Game::SetDefaultGamma(), and C4Weather::SetSeasonGamma().

 {
     // Set
     gamma[iRampIndex][0] = r;
     gamma[iRampIndex][1] = g;
     gamma[iRampIndex][2] = b;
     // Recalculate resulting gamma. Note that we flip gamma direction here,
     // because higher gammaOut means darker.
     gammaOut[0] = gammaOut[1] = gammaOut[2] = 1.0f;
     for (auto & i : gamma) {
         gammaOut[0] /= i[0];
         gammaOut[1] /= i[1];
         gammaOut[2] /= i[2];
     }
 }

Here is the caller graph for this function:

void C4Draw::SetMeshTransform ( const StdMeshMatrix * Transform )

inlineinherited

Definition at line 200 of file C4Draw.h.

Referenced by C4DefGraphics::Draw(), C4GraphicsOverlay::Draw(), and C4Object::DrawFaceImpl().

200 { MeshTransform = Transform; } // if non-nullptr make sure to keep matrix valid

C4Draw::MeshTransform

const StdMeshMatrix * MeshTransform

Definition: C4Draw.h:113

Here is the caller graph for this function:

void C4Draw::SetPerspective ( bool fSet )

inlineinherited

Definition at line 201 of file C4Draw.h.

Referenced by C4DefGraphics::Draw().

201 { fUsePerspective = fSet; }

C4Draw::fUsePerspective

bool fUsePerspective

Definition: C4Draw.h:114

Here is the caller graph for this function:

bool C4Draw::SetPrimaryClipper	(	int	iX1,
		int	iY1,
		int	iX2,
		int	iY2
	)

inherited

Definition at line 217 of file C4Draw.cpp.

References C4Draw::fClipX1, C4Draw::fClipX2, C4Draw::fClipY1, C4Draw::fClipY2, C4Draw::iClipX1, C4Draw::iClipX2, C4Draw::iClipY1, C4Draw::iClipY2, and C4Draw::UpdateClipper().

Referenced by C4Draw::CreatePrimaryClipper(), C4Viewport::Draw(), C4GUI::Window::Draw(), C4ScriptGuiWindow::DrawChildren(), C4GUI::WoodenLabel::DrawElement(), C4GUI::Edit::DrawElement(), C4Draw::NoPrimaryClipper(), C4Draw::RestorePrimaryClipper(), and C4Draw::SubPrimaryClipper().

 {
     // set clipper
     fClipX1=iX1; fClipY1=iY1; fClipX2=iX2; fClipY2=iY2;
     iClipX1=iX1; iClipY1=iY1; iClipX2=iX2; iClipY2=iY2;
     UpdateClipper();
     // Done
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void CStdGL::SetupMultiBlt	(	C4ShaderCall &	call,
		const C4BltTransform *	pTransform,
		GLuint	baseTex,
		GLuint	overlayTex,
		GLuint	normalTex,
		DWORD	dwOverlayModClr,
		StdProjectionMatrix *	out_modelview
	)

Definition at line 361 of file C4DrawGL.cpp.

References C4ShaderCall::AllocTexUnit(), C4FoW::Ambient, C4ScriptUniform::Apply(), C4Draw::BlitModulateClr, C4Draw::BlitModulated, C4GFXBLIT_ADDITIVE, C4SSU_AmbientBrightness, C4SSU_AmbientTex, C4SSU_AmbientTransform, C4SSU_BaseTex, C4SSU_ClrMod, C4SSU_CullMode, C4SSU_Gamma, C4SSU_LightTex, C4SSU_LightTransform, C4SSU_ModelViewMatrix, C4SSU_NormalMatrix, C4SSU_NormalTex, C4SSU_OverlayClr, C4SSU_OverlayTex, C4SSU_ProjectionMatrix, C4Draw::dwBlitMode, C4Draw::gammaOut, C4FoWAmbient::GetBrightness(), C4Draw::GetClipRect(), C4FoWRegion::getFoW(), C4FoWRegion::GetFragTransform(), C4FoWAmbient::GetFragTransform(), C4Draw::GetOutRect(), C4FoWRegion::getSurfaceName(), C4FoWRegion::getViewportRegion(), C4BltTransform::mat, C4Draw::pFoW, ProjectionMatrix, C4Draw::scriptUniform, C4ShaderCall::SetUniform1f(), C4ShaderCall::SetUniform3fv(), C4ShaderCall::SetUniform4fv(), C4ShaderCall::SetUniformMatrix2x3fv(), C4ShaderCall::SetUniformMatrix3x3Transpose(), C4ShaderCall::SetUniformMatrix4x4(), C4ShaderCall::Start(), C4FoWAmbient::Tex, C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

Referenced by C4ParticleList::Draw(), PerformMultiLines(), PerformMultiPix(), and PerformMultiTris().

 {
     // Initialize multi blit shader.
     int iAdditive = dwBlitMode & C4GFXBLIT_ADDITIVE;
     glBlendFunc(GL_SRC_ALPHA, iAdditive ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);
 
     call.Start();
 
     // Upload uniforms
     const DWORD dwModClr = BlitModulated ? BlitModulateClr : 0xffffffff;
     const float fMod[4] = {
         ((dwModClr >> 16) & 0xff) / 255.0f,
         ((dwModClr >>  8) & 0xff) / 255.0f,
         ((dwModClr      ) & 0xff) / 255.0f,
         ((dwModClr >> 24) & 0xff) / 255.0f
     };
 
     call.SetUniform4fv(C4SSU_ClrMod, 1, fMod);
     call.SetUniform3fv(C4SSU_Gamma, 1, gammaOut);
 
     if(baseTex != 0)
     {
         call.AllocTexUnit(C4SSU_BaseTex);
         glBindTexture(GL_TEXTURE_2D, baseTex);
     }
 
     if(overlayTex != 0)
     {
         call.AllocTexUnit(C4SSU_OverlayTex);
         glBindTexture(GL_TEXTURE_2D, overlayTex);
 
         const float fOverlayModClr[4] = {
             ((dwOverlayModClr >> 16) & 0xff) / 255.0f,
             ((dwOverlayModClr >>  8) & 0xff) / 255.0f,
             ((dwOverlayModClr      ) & 0xff) / 255.0f,
             ((dwOverlayModClr >> 24) & 0xff) / 255.0f
         };
 
         call.SetUniform4fv(C4SSU_OverlayClr, 1, fOverlayModClr);
     }
 
     if(pFoW != nullptr && normalTex != 0)
     {
         call.AllocTexUnit(C4SSU_NormalTex);
         glBindTexture(GL_TEXTURE_2D, normalTex);
     }
 
     if(pFoW != nullptr)
     {
         const C4Rect OutRect = GetOutRect();
         const C4Rect ClipRect = GetClipRect();
         const FLOAT_RECT vpRect = pFoW->getViewportRegion();
 
         // Dynamic Light
         call.AllocTexUnit(C4SSU_LightTex);
         glBindTexture(GL_TEXTURE_2D, pFoW->getSurfaceName());
 
         float lightTransform[6];
         pFoW->GetFragTransform(ClipRect, OutRect, lightTransform);
         call.SetUniformMatrix2x3fv(C4SSU_LightTransform, 1, lightTransform);
 
         // Ambient Light
         call.AllocTexUnit(C4SSU_AmbientTex);
         glBindTexture(GL_TEXTURE_2D, pFoW->getFoW()->Ambient.Tex);
         call.SetUniform1f(C4SSU_AmbientBrightness, pFoW->getFoW()->Ambient.GetBrightness());
 
         float ambientTransform[6];
         pFoW->getFoW()->Ambient.GetFragTransform(vpRect, ClipRect, OutRect, ambientTransform);
         call.SetUniformMatrix2x3fv(C4SSU_AmbientTransform, 1, ambientTransform);
     }
 
     call.SetUniform1f(C4SSU_CullMode, 0.0f);
 
     // The primary reason we use a 4x4 matrix for the modelview matrix is that
     // that the C4BltTransform pTransform parameter can have projection components
     // (see SetObjDrawTransform2). Still, for sprites the situation is a bit
     // unsatisfactory because there's no distinction between modelview and projection
     // components in the BltTransform. Object rotation is part of the BltTransform
     // for sprites, which should be part of the modelview matrix, so that lighting
     // is correct for rotated sprites. This is much more common than projection
     // components in the BltTransform, and therefore we turn the BltTransform into
     // the modelview matrix and not the projection matrix.
     StdProjectionMatrix default_modelview = StdProjectionMatrix::Identity();
     StdProjectionMatrix& modelview = out_modelview ? *out_modelview : default_modelview;
 
     // Apply zoom and transform
     Translate(modelview, ZoomX, ZoomY, 0.0f);
     // Scale Z as well so that we don't distort normals.
     Scale(modelview, Zoom, Zoom, Zoom);
     Translate(modelview, -ZoomX, -ZoomY, 0.0f);
 
     if(pTransform)
     {
         float sz = 1.0f;
         if (pFoW != nullptr && normalTex != 0)
         {
             // Decompose scale factors and scale Z accordingly to X and Y, again to avoid distorting normals
             // We could instead work around this by using the projection matrix, but then for object rotations (SetR)
             // the normals would not be correct.
             const float sx = sqrt(pTransform->mat[0]*pTransform->mat[0] + pTransform->mat[1]*pTransform->mat[1]);
             const float sy = sqrt(pTransform->mat[3]*pTransform->mat[3] + pTransform->mat[4]*pTransform->mat[4]);
             sz = sqrt(sx * sy);
         }
 
         // Multiply modelview matrix with transform
         StdProjectionMatrix transform;
         transform(0, 0) = pTransform->mat[0];
         transform(0, 1) = pTransform->mat[1];
         transform(0, 2) = 0.0f;
         transform(0, 3) = pTransform->mat[2];
         transform(1, 0) = pTransform->mat[3];
         transform(1, 1) = pTransform->mat[4];
         transform(1, 2) = 0.0f;
         transform(1, 3) = pTransform->mat[5];
         transform(2, 0) = 0.0f;
         transform(2, 1) = 0.0f;
         transform(2, 2) = sz;
         transform(2, 3) = 0.0f;
         transform(3, 0) = pTransform->mat[6];
         transform(3, 1) = pTransform->mat[7];
         transform(3, 2) = 0.0f;
         transform(3, 3) = pTransform->mat[8];
         modelview *= transform;
     }
 
     call.SetUniformMatrix4x4(C4SSU_ProjectionMatrix, ProjectionMatrix);
     call.SetUniformMatrix4x4(C4SSU_ModelViewMatrix, modelview);
 
     if (pFoW != nullptr && normalTex != 0)
         call.SetUniformMatrix3x3Transpose(C4SSU_NormalMatrix, StdMeshMatrix::Inverse(StdProjectionMatrix::Upper3x4(modelview)));
 
     scriptUniform.Apply(call);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void C4Draw::SetZoom	(	float	X,
		float	Y,
		float	Zoom
	)

inherited

Definition at line 779 of file C4Draw.cpp.

References X, C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

Referenced by C4Viewport::Draw(), C4MouseControl::Draw(), C4GUI::CMouse::Draw(), C4Game::DrawCrewOverheadText(), C4Viewport::DrawMenu(), ZoomDataStackItem::ZoomDataStackItem(), and ZoomDataStackItem::~ZoomDataStackItem().

 {
     this->ZoomX = X; this->ZoomY = Y; this->Zoom = Zoom;
 }

Here is the caller graph for this function:

void C4Draw::SetZoom ( const ZoomData & zoom )

inlineinherited

Definition at line 196 of file C4Draw.h.

References C4Draw::SetZoom(), ZoomData::X, ZoomData::Y, and ZoomData::Zoom.

Referenced by C4Draw::SetZoom().

196 { SetZoom(zoom.X, zoom.Y, zoom.Zoom); }

ZoomData::Y

float Y

Definition: C4Draw.h:71

ZoomData::X

float X

Definition: C4Draw.h:71

C4Draw::SetZoom

void SetZoom(float X, float Y, float Zoom)

Definition: C4Draw.cpp:779

ZoomData::Zoom

float Zoom

Definition: C4Draw.h:70

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::StorePrimaryClipper ( )

inherited

Definition at line 203 of file C4Draw.cpp.

References C4Draw::fClipX1, C4Draw::fClipX2, C4Draw::fClipY1, C4Draw::fClipY2, C4Draw::fStClipX1, C4Draw::fStClipX2, C4Draw::fStClipY1, and C4Draw::fStClipY2.

Referenced by C4Draw::CreatePrimaryClipper(), C4ScriptGuiWindow::DrawChildren(), C4MenuItem::DrawElement(), C4GUI::WoodenLabel::DrawElement(), C4GUI::ComboBox::DrawElement(), and C4FoWRegion::Render().

 {
     // Store current primary clipper
     fStClipX1=fClipX1; fStClipY1=fClipY1; fStClipX2=fClipX2; fStClipY2=fClipY2;
     return true;
 }

Here is the caller graph for this function:

bool C4Draw::StringOut	(	const char *	szText,
		CStdFont &	rFont,
		float	fZoom,
		C4Surface *	sfcDest,
		float	iTx,
		float	iTy,
		DWORD	dwFCol = `0xffffffff`,
		BYTE	byForm = `ALeft`,
		bool	fDoMarkup = `true`
	)

inherited

Definition at line 576 of file C4Draw.cpp.

Referenced by C4LoaderScreen::Draw(), C4MessageBoard::Draw(), and C4Draw::TextOut().

 {
     // init markup
     C4Markup Markup(true);
     // output string
     return StringOut(szText, sfcDest, iTx, iTy, dwFCol, byForm, fDoMarkup, Markup, &rFont, fZoom);
 }

Here is the caller graph for this function:

bool C4Draw::StringOut	(	const char *	szText,
		C4Surface *	sfcDest,
		float	iTx,
		float	iTy,
		DWORD	dwFCol,
		BYTE	byForm,
		bool	fDoMarkup,
		C4Markup &	Markup,
		CStdFont *	pFont,
		float	fZoom
	)

protectedinherited

Definition at line 584 of file C4Draw.cpp.

References ACenter, ARight, C4Draw::ClipAll, CStdFont::DrawText(), C4Draw::PrepareRendering(), STDFONT_CENTERED, STDFONT_NOMARKUP, and STDFONT_RIGHTALGN.

 {
     // clip
     if (ClipAll) return true;
     // safety
     if (!PrepareRendering(sfcDest)) return false;
     // convert align
     int iFlags=0;
     switch (byForm)
     {
     case ACenter: iFlags |= STDFONT_CENTERED; break;
     case ARight: iFlags |= STDFONT_RIGHTALGN; break;
     }
     if (!fDoMarkup) iFlags|=STDFONT_NOMARKUP;
     // draw text
     pFont->DrawText(sfcDest, iTx  , iTy  , dwFCol, szText, iFlags, Markup, fZoom);
     // done, success
     return true;
 }

Here is the call graph for this function:

bool C4Draw::SubPrimaryClipper	(	int	iX1,
		int	iY1,
		int	iX2,
		int	iY2
	)

inherited

Definition at line 196 of file C4Draw.cpp.

References C4Draw::iClipX1, C4Draw::iClipX2, C4Draw::iClipY1, C4Draw::iClipY2, and C4Draw::SetPrimaryClipper().

Referenced by C4GUI::Window::Draw(), C4MenuItem::DrawElement(), and C4GUI::ComboBox::DrawElement().

 {
     // Set sub primary clipper
     SetPrimaryClipper(std::max(iX1,iClipX1),std::max(iY1,iClipY1),std::min(iX2,iClipX2),std::min(iY2,iClipY2));
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool C4Draw::TextOut	(	const char *	szText,
		CStdFont &	rFont,
		float	fZoom,
		C4Surface *	sfcDest,
		float	iTx,
		float	iTy,
		DWORD	dwFCol = `0xffffffff`,
		BYTE	byForm = `ALeft`,
		bool	fDoMarkup = `true`
	)

inherited

Definition at line 567 of file C4Draw.cpp.

References CStdFont::GetLineHeight(), SCopySegmentEx(), and C4Draw::StringOut().

 {
     C4Markup Markup(true);
     static char szLinebuf[2500+1];
     for (int cnt=0; SCopySegmentEx(szText,cnt,szLinebuf,fDoMarkup ? '|' : '\n','\n',2500); cnt++,iTy+=int(fZoom*rFont.GetLineHeight()))
         if (!StringOut(szLinebuf,sfcDest,iTx,iTy,dwFCol,byForm,fDoMarkup,Markup,&rFont,fZoom)) return false;
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CStdGL::UpdateClipper ( )

overridevirtual

Implements C4Draw.

Definition at line 151 of file C4DrawGL.cpp.

References C4Draw::Active, C4Draw::ClipAll, C4Draw::GetClipRect(), C4Rect::Hgt, C4Surface::Hgt, ProjectionMatrix, C4Draw::RenderTarget, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by PrepareRendering().

 {
     // no render target? do nothing
     if (!RenderTarget || !Active) return true;
     // negative/zero?
     C4Rect clipRect = GetClipRect();
     if (clipRect.Wdt<=0 || clipRect.Hgt<=0)
     {
         ClipAll=true;
         return true;
     }
     ClipAll=false;
     // set it
     glViewport(clipRect.x, RenderTarget->Hgt-clipRect.y-clipRect.Hgt, clipRect.Wdt, clipRect.Hgt);
     ProjectionMatrix = StdProjectionMatrix::Orthographic(clipRect.x, clipRect.x + clipRect.Wdt, clipRect.y + clipRect.Hgt, clipRect.y);
     return true;
 }