#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

bool	has_khr_debug

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 169 of file C4DrawGL.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

inherited

Enumerator
DEFAULT_MESSAGE_COLOR

Definition at line 167 of file C4Draw.h.

167 { DEFAULT_MESSAGE_COLOR = 0xffffffff };

C4Draw::DEFAULT_MESSAGE_COLOR

@ DEFAULT_MESSAGE_COLOR

Definition: C4Draw.h:167

◆ DrawOperation

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

@ OP_TRIANGLES

Definition: C4Draw.h:87

C4Draw::OP_POINTS

@ OP_POINTS

Definition: C4Draw.h:87

Constructor & Destructor Documentation

◆ CStdGL()

CStdGL::CStdGL ( )

Definition at line 90 of file C4DrawGL.cpp.

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

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

Here is the call graph for this function:

◆ ~CStdGL()

CStdGL::~CStdGL ( )

override

Definition at line 100 of file C4DrawGL.cpp.

 {
     Clear();
     pGL=nullptr;
 }

References Clear(), and pGL.

Here is the call graph for this function:

Member Function Documentation

◆ ActivateBlitModulation()

void C4Draw::ActivateBlitModulation ( DWORD dwWithClr )

inlineinherited

Definition at line 188 of file C4Draw.h.

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

C4Draw::BlitModulated

bool BlitModulated

Definition: C4Draw.h:108

C4Draw::BlitModulateClr

DWORD BlitModulateClr

Definition: C4Draw.h:109

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

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

Here is the caller graph for this function:

◆ ApplyGammaTo()

DWORD C4Draw::ApplyGammaTo ( DWORD dwClr )

inherited

Definition at line 766 of file C4Draw.cpp.

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

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

◆ ApplyPrimaryClipper()

bool C4Draw::ApplyPrimaryClipper ( C4Surface * sfcSurface )

inherited

Definition at line 227 of file C4Draw.cpp.

 {
     return true;
 }

◆ ApplyZoom()

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

inherited

Definition at line 778 of file C4Draw.cpp.

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

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

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

Here is the caller graph for this function:

◆ Blit()

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.

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

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Blit8()

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 418 of file C4Draw.cpp.

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

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

Referenced by C4Draw::BlitUnscaled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Blit8Fast()

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.

 {
     // 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();
 }

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BlitLandscape()

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.

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

References C4Draw::Blit().

Here is the call graph for this function:

◆ BlitSimple()

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 463 of file C4Draw.cpp.

 {
     // 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;
 }

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

Referenced by C4Draw::Blit8().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BlitSurface()

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

inherited

Definition at line 511 of file C4Draw.cpp.

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

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

Referenced by C4Surface::Copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BlitSurfaceTile()

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 529 of file C4Draw.cpp.

 {
     // 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;
 }

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BlitUnscaled()

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.

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

References C4Draw::ApplyZoom(), C4Draw::Blit8(), C4Draw::ClipAll, C4Surface::ClrByOwnerClr, DwTo4UB(), C4Surface::fPrimary, C4BltVertex::ftx, C4BltVertex::fty, C4TexRef::iSizeX, C4TexRef::iSizeY, C4Surface::IsRenderTarget(), 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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckGLError()

bool CStdGL::CheckGLError ( const char * szAtOp )

protected

Definition at line 898 of file C4DrawGL.cpp.

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

References GLErrorString(), and LogF().

Here is the call graph for this function:

◆ Clear()

void CStdGL::Clear ( )

overridevirtual

Reimplemented from C4Draw.

Definition at line 106 of file C4DrawGL.cpp.

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

Referenced by ~CStdGL().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateContext()

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

overridevirtual

Reimplemented from C4Draw.

Definition at line 273 of file C4DrawGL.cpp.

 {
     // 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 " : "");
     }
     if (!pCtx->Init(pWindow, pApp))
     {
         Log("  gl: failed to create context.");
         delete pCtx;
         return NULL;
     }
     has_khr_debug = epoxy_has_gl_extension("GL_KHR_debug") || epoxy_gl_version() >= 43;
     if (Config.Graphics.DebugOpenGL && (has_khr_debug || epoxy_has_gl_extension("GL_ARB_debug_output")))
     {
         if (first_ctx) Log("  gl: Setting OpenGLDebugProc callback");
         glDebugMessageCallback(&OpenGLDebugProc, nullptr);
         glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
         if (has_khr_debug)
             glEnable(GL_DEBUG_OUTPUT);
     }
     // 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 (epoxy_is_desktop_gl() && epoxy_gl_version() >= 30)
             {
                 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 : "");
             }
         }
     }
     // creation selected the new context - switch back to previous context
     RenderTarget = nullptr;
 #ifdef WITH_QT_EDITOR
     // FIXME This is a hackfix for #1813 / #1956. The proper way to fix them would probably be to select a drawing context before invoking C4Player::FinalInit
     if (!app->isEditor)
 #endif
     pCurrCtx = nullptr;
     // done
     return pCtx;
 }

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

Referenced by C4Surface::C4Surface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreatePrimaryClipper()

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

protectedinherited

Definition at line 501 of file C4Draw.cpp.

 {
     // 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;
 }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeactivateBlitModulation()

void C4Draw::DeactivateBlitModulation ( )

inlineinherited

Definition at line 189 of file C4Draw.h.

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

References C4Draw::BlitModulated.

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

Here is the caller graph for this function:

◆ Default()

void CStdGL::Default ( )

overridevirtual

Reimplemented from C4Draw.

Definition at line 917 of file C4DrawGL.cpp.

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

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

Referenced by CStdGL().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DetachPrimaryClipper()

bool C4Draw::DetachPrimaryClipper ( C4Surface * sfcSurface )

inherited

Definition at line 232 of file C4Draw.cpp.

 {
     return true;
 }

◆ DeviceReady()

bool CStdGL::DeviceReady ( )

inlineoverridevirtual

Implements C4Draw.

Definition at line 274 of file C4DrawGL.h.

274 { return !!pMainCtx; }

References pMainCtx.

◆ DrawBoxDw()

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

inherited

Definition at line 840 of file C4Draw.cpp.

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

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

Referenced by C4MessageBoard::Draw(), C4Def::Draw(), C4LoaderScreen::Draw(), C4Sky::Draw(), C4GUI::Dialog::Draw(), C4Viewport::Draw(), C4GUI::Screen::Draw(), C4GUI::FrameDecoration::Draw(), C4ScriptGuiWindow::Draw(), C4GUI::GroupBox::DrawElement(), C4GUI::Edit::DrawElement(), C4GUI::ListBox::DrawElement(), C4GUI::Tabular::DrawElement(), C4GUI::TextWindow::DrawElement(), C4GUI::ContextMenu::DrawElement(), C4GUI::ComboBox::DrawElement(), C4GUI::Dialog::DrawElement(), C4MenuItem::DrawElement(), C4StartupNetListEntry::DrawElement(), and C4GUI::Screen::DrawToolTip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawBoxFade()

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 824 of file C4Draw.cpp.

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

References C4Draw::DrawQuadDw().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawCircleDw()

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

inherited

Definition at line 618 of file C4Draw.cpp.

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

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

Referenced by C4EditCursor::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawFrameDw()

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

inherited

Definition at line 635 of file C4Draw.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawLineDw()

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

inherited

Definition at line 608 of file C4Draw.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawPatternedCircle()

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

inherited

Definition at line 669 of file C4Draw.cpp.

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

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

Here is the call graph for this function:

◆ DrawPix()

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

inherited

Definition at line 598 of file C4Draw.cpp.

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

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

Referenced by C4Draw::DrawPatternedCircle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawQuadDw()

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

inherited

Definition at line 653 of file C4Draw.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnsureMainContextSelected()

bool CStdGL::EnsureMainContextSelected ( )

overridevirtual

Implements C4Draw.

Definition at line 757 of file C4DrawGL.cpp.

 {
     return pMainCtx->Select();
 }

References pMainCtx, and CStdGLCtx::Select().

Referenced by InitShaders().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Error()

bool CStdGL::Error ( const char * szMsg )

overrideprotectedvirtual

Reimplemented from C4Draw.

Definition at line 855 of file C4DrawGL.cpp.

 {
 #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;
 }

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

Here is the call graph for this function:

◆ FillBG()

void CStdGL::FillBG ( DWORD dwClr = 0 )

overridevirtual

Implements C4Draw.

Definition at line 136 of file C4DrawGL.cpp.

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

References GetBlueValue, GetGreenValue, GetRedValue, and pCurrCtx.

◆ FreeVAOID()

void CStdGL::FreeVAOID ( unsigned int vaoid )

Definition at line 969 of file C4DrawGL.cpp.

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

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().

Here is the caller graph for this function:

◆ GenVAOID()

unsigned int CStdGL::GenVAOID ( )

Definition at line 927 of file C4DrawGL.cpp.

 {
     // 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;
 }

References NextVAOID, and VAOIDs.

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

Here is the caller graph for this function:

◆ GetBlitModulation()

bool C4Draw::GetBlitModulation ( DWORD & rdwColor )

inlineinherited

Definition at line 190 of file C4Draw.h.

190 { rdwColor=BlitModulateClr; return BlitModulated; }

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

Referenced by CStdFont::DrawText().

Here is the caller graph for this function:

◆ GetClipRect()

C4Rect C4Draw::GetClipRect ( ) const

inherited

Definition at line 724 of file C4Draw.cpp.

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

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

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

Here is the caller graph for this function:

◆ GetFoW()

const C4FoWRegion* C4Draw::GetFoW ( ) const

inlineinherited

Definition at line 194 of file C4Draw.h.

194 { return pFoW; }

C4Draw::pFoW

const C4FoWRegion * pFoW

Definition: C4Draw.h:111

References C4Draw::pFoW.

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

Here is the caller graph for this function:

◆ GetOutRect()

C4Rect C4Draw::GetOutRect ( ) const

inherited

Definition at line 733 of file C4Draw.cpp.

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

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

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

Here is the caller graph for this function:

◆ GetPrimaryClipper()

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

inherited

Definition at line 716 of file C4Draw.cpp.

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

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

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

Here is the caller graph for this function:

◆ GetProjectionMatrix()

const StdProjectionMatrix& CStdGL::GetProjectionMatrix ( ) const

inline

Definition at line 254 of file C4DrawGL.h.

254 { return ProjectionMatrix; }

CStdGL::ProjectionMatrix

StdProjectionMatrix ProjectionMatrix

Definition: C4DrawGL.h:185

References ProjectionMatrix.

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

Here is the caller graph for this function:

◆ GetSpriteShader() [1/2]

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

Definition at line 662 of file C4DrawGL.cpp.

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

References C4GFXBLIT_MOD2, and C4Draw::dwBlitMode.

◆ GetSpriteShader() [2/2]

C4Shader * CStdGL::GetSpriteShader ( int ssc )

Definition at line 673 of file C4DrawGL.cpp.

 {
     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];
 }

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

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

Here is the caller graph for this function:

◆ GetSurfaceSize()

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

inherited

Definition at line 191 of file C4Draw.cpp.

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

References C4Surface::GetSurfaceSize().

Here is the call graph for this function:

◆ GetVAO()

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

Definition at line 1015 of file C4DrawGL.cpp.

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

References CStdGLCtx::hVAOs, pCurrCtx, and VAOIDs.

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

Here is the caller graph for this function:

◆ GetZoom()

void C4Draw::GetZoom ( ZoomData * r )

inlineinherited

Definition at line 197 of file C4Draw.h.

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

ZoomData::Zoom

float Zoom

Definition: C4Draw.h:70

ZoomData::X

float X

Definition: C4Draw.h:71

ZoomData::Y

float Y

Definition: C4Draw.h:71

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().

Here is the caller graph for this function:

◆ GLErrorString()

const char * CStdGL::GLErrorString ( GLenum code )

protected

Definition at line 882 of file C4DrawGL.cpp.

 {
     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 "";
     }
 }

Referenced by CheckGLError().

Here is the caller graph for this function:

◆ Grayscale()

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

inherited

Definition at line 695 of file C4Draw.cpp.

 {
     // 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();
 }

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

Referenced by C4FacetSurface::Grayscale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Init()

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

inherited

Definition at line 809 of file C4Draw.cpp.

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

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

Referenced by DDrawInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitShaders()

bool CStdGL::InitShaders ( C4GroupSet * pGroups )

Definition at line 714 of file C4DrawGL.cpp.

 {
     if (!pCurrCtx)
         EnsureMainContextSelected();
  
     // 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;
 }

References EnsureMainContextSelected(), pCurrCtx, PrepareSpriteShader(), SpriteShader, and SpriteShaderMod2.

Referenced by C4GraphicsResource::Init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InvalidateDeviceObjects()

bool CStdGL::InvalidateDeviceObjects ( )

overridevirtual

Implements C4Draw.

Definition at line 808 of file C4DrawGL.cpp.

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

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

Referenced by Clear(), and RestoreDeviceObjects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LockingPrimary()

void C4Draw::LockingPrimary ( )

inlineinherited

Definition at line 138 of file C4Draw.h.

138 { PrimaryLocked=true; }

C4Draw::PrimaryLocked

bool PrimaryLocked

Definition: C4Draw.h:106

References C4Draw::PrimaryLocked.

◆ NoPrimaryClipper()

bool C4Draw::NoPrimaryClipper ( )

inherited

Definition at line 237 of file C4Draw.cpp.

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

References C4Draw::SetPrimaryClipper().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ObjectLabel()

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

Definition at line 267 of file C4DrawGL.cpp.

 {
     if (has_khr_debug)
         glObjectLabel(identifier, name, length, label);
 }

References has_khr_debug.

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

Here is the caller graph for this function:

◆ OnResolutionChanged()

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

overridevirtual

Implements C4Draw.

Definition at line 909 of file C4DrawGL.cpp.

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

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

Here is the call graph for this function:

◆ PerformMesh()

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

overridevirtual

Implements C4Draw.

Definition at line 1025 of file C4DrawMeshGL.cpp.

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

References b, C4Draw::BlitModulateClr, C4Draw::BlitModulated, StdMeshMatrix::Determinant(), C4Draw::dwBlitMode, C4Draw::fUsePerspective, StdMesh::GetBoundingBox(), StdMesh::GetBoundingRadius(), C4Draw::GetClipRect(), StdMeshInstance::GetMesh(), C4Draw::GetOutRect(), C4Rect::Hgt, StdMeshMatrix::Identity(), StdProjectionMatrix::Identity(), StdMeshMatrix::LookAt(), C4Draw::MeshTransform, Perspective(), C4Draw::pFoW, ProjectionMatrix, StdMeshMatrix::Scale(), Scale(), StdMeshVector::Translate(), Translate(), ControllerKeys::Up(), C4Rect::Wdt, C4Rect::x, StdMeshVector::x, StdMeshBox::x1, StdMeshBox::x2, C4Rect::y, StdMeshVector::y, StdMeshBox::y1, StdMeshBox::y2, StdMeshVector::z, StdMeshBox::z1, StdMeshBox::z2, C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

Here is the call graph for this function:

◆ PerformMultiBlt()

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

Definition at line 593 of file C4DrawGL.cpp.

 {
     // Only direct rendering
     assert(sfcTarget->IsRenderTarget());
     if(!PrepareRendering(sfcTarget)) return;
  
     // Set resolution. The other uniforms are set in SetupMultiBlt, but the
     // surface size is still unknown there.
     shader_call->SetUniform2f(C4SSU_Resolution, sfcTarget->Wdt, sfcTarget->Hgt);
  
     // 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);
 }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PerformMultiLines()

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

overridevirtual

Implements C4Draw.

Definition at line 517 of file C4DrawGL.cpp.

 {
     // 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;
 }

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

Here is the call graph for this function:

◆ PerformMultiPix()

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

overridevirtual

Implements C4Draw.

Definition at line 490 of file C4DrawGL.cpp.

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

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

Here is the call graph for this function:

◆ PerformMultiTris()

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 577 of file C4DrawGL.cpp.

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

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

Here is the call graph for this function:

◆ PrepareMaterial()

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:

◆ PrepareRendering()

bool CStdGL::PrepareRendering ( C4Surface * sfcToSurface )

overridevirtual

Implements C4Draw.

Definition at line 161 of file C4DrawGL.cpp.

 {
     // 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;
 }

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareSpriteShader()

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 190 of file C4DrawGL.cpp.

 {
     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_Resolution] = "resolution";
     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;
 }

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, C4SSU_Resolution, C4Shader::Clear(), and C4Shader::ClearSlices().

Referenced by InitShaders().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrimaryUnlocked()

void C4Draw::PrimaryUnlocked ( )

inlineinherited

Definition at line 139 of file C4Draw.h.

139 { PrimaryLocked=false; }

References C4Draw::PrimaryLocked.

◆ RemoveZoom()

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

inherited

Definition at line 784 of file C4Draw.cpp.

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

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

◆ RenderMesh()

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

inherited

Definition at line 397 of file C4Draw.cpp.

 {
     // 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;
 }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResetBlitMode()

void C4Draw::ResetBlitMode ( )

inlineinherited

Definition at line 192 of file C4Draw.h.

192 { dwBlitMode=0; }

References C4Draw::dwBlitMode.

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().

Here is the caller graph for this function:

◆ ResetGamma()

void C4Draw::ResetGamma ( )

inherited

Definition at line 754 of file C4Draw.cpp.

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

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

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

Here is the caller graph for this function:

◆ RestoreDeviceObjects()

bool CStdGL::RestoreDeviceObjects ( )

overridevirtual

Implements C4Draw.

Definition at line 762 of file C4DrawGL.cpp.

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

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().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RestorePrimaryClipper()

bool C4Draw::RestorePrimaryClipper ( )

inherited

Definition at line 210 of file C4Draw.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBlitMode()

void C4Draw::SetBlitMode ( DWORD dwBlitMode )

inlineinherited

Definition at line 191 of file C4Draw.h.

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

References C4GFXBLIT_ALL, and C4Draw::dwBlitMode.

Referenced by C4GraphicsOverlay::Draw(), C4MouseControl::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().

Here is the caller graph for this function:

◆ SetFoW()

void C4Draw::SetFoW ( const C4FoWRegion * fow )

inlineinherited

Definition at line 193 of file C4Draw.h.

193 { pFoW = fow; }

References C4Draw::pFoW.

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

Here is the caller graph for this function:

◆ SetGamma()

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

inherited

Definition at line 738 of file C4Draw.cpp.

 {
     // 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];
     }
 }

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

Referenced by C4Game::SetDefaultGamma().

Here is the caller graph for this function:

◆ SetMeshTransform()

void C4Draw::SetMeshTransform ( const StdMeshMatrix * Transform )

inlineinherited

Definition at line 200 of file C4Draw.h.

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

References C4Draw::MeshTransform.

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

Here is the caller graph for this function:

◆ SetPerspective()

void C4Draw::SetPerspective ( bool fSet )

inlineinherited

Definition at line 201 of file C4Draw.h.

201 { fUsePerspective = fSet; }

References C4Draw::fUsePerspective.

Referenced by C4DefGraphics::Draw().

Here is the caller graph for this function:

◆ SetPrimaryClipper()

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

inherited

Definition at line 217 of file C4Draw.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetupMultiBlt()

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

Definition at line 356 of file C4DrawGL.cpp.

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

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(), StdProjectionMatrix::Identity(), StdMeshMatrix::Inverse(), C4BltTransform::mat, C4Draw::pFoW, ProjectionMatrix, Scale(), C4Draw::scriptUniform, C4ShaderCall::SetUniform1f(), C4ShaderCall::SetUniform3fv(), C4ShaderCall::SetUniform4fv(), C4ShaderCall::SetUniformMatrix2x3fv(), C4ShaderCall::SetUniformMatrix3x3Transpose(), C4ShaderCall::SetUniformMatrix4x4(), C4ShaderCall::Start(), C4FoWAmbient::Tex, Translate(), StdProjectionMatrix::Upper3x4(), C4Draw::Zoom, C4Draw::ZoomX, and C4Draw::ZoomY.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetZoom() [1/2]

void C4Draw::SetZoom ( const ZoomData & zoom )

inlineinherited

Definition at line 196 of file C4Draw.h.

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

C4Draw::SetZoom

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

Definition: C4Draw.cpp:773

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

Referenced by C4Draw::SetZoom().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetZoom() [2/2]

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

inherited

Definition at line 773 of file C4Draw.cpp.

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

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().

Here is the caller graph for this function:

◆ StorePrimaryClipper()

bool C4Draw::StorePrimaryClipper ( )

inherited

Definition at line 203 of file C4Draw.cpp.

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

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

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

Here is the caller graph for this function:

◆ StringOut() [1/2]

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 578 of file C4Draw.cpp.

 {
     // 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;
 }

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

Here is the call graph for this function:

◆ StringOut() [2/2]

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 570 of file C4Draw.cpp.

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

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

Here is the caller graph for this function:

◆ SubPrimaryClipper()

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

inherited

Definition at line 196 of file C4Draw.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TextOut()

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 561 of file C4Draw.cpp.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateClipper()

bool CStdGL::UpdateClipper ( )

overridevirtual

Implements C4Draw.

Definition at line 143 of file C4DrawGL.cpp.

 {
     // 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;
 }