marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
openclonk/src/graphics/C4DrawGL.cpp

1031 lines
33 KiB
C++
Raw Blame History

/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2009-2016, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
/* OpenGL implementation of NewGfx */
#include "C4Include.h"
#include "graphics/C4DrawGL.h"
#include "graphics/C4Surface.h"
#include "platform/C4Window.h"
#include "landscape/fow/C4FoWRegion.h"
#include "lib/C4Rect.h"
#include "config/C4Config.h"
#include "platform/C4App.h"
#include "lib/StdColors.h"
#ifndef USE_CONSOLE
// MSVC doesn't define M_PI in math.h unless requested
#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif /* _MSC_VER */
#include <stdio.h>
#include <math.h>
namespace
{
const char *MsgSourceToStr(GLenum source)
{
switch (source)
{
case GL_DEBUG_SOURCE_API_ARB: return "API";
case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: return "window system";
case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: return "shader compiler";
case GL_DEBUG_SOURCE_THIRD_PARTY_ARB: return "third party";
case GL_DEBUG_SOURCE_APPLICATION_ARB: return "application";
case GL_DEBUG_SOURCE_OTHER_ARB: return "other";
default: return "<unknown>";
}
}
const char *MsgTypeToStr(GLenum type)
{
switch (type)
{
case GL_DEBUG_TYPE_ERROR_ARB: return "error";
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: return "deprecation warning";
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: return "undefined behavior warning";
case GL_DEBUG_TYPE_PORTABILITY_ARB: return "portability warning";
case GL_DEBUG_TYPE_PERFORMANCE_ARB: return "performance warning";
case GL_DEBUG_TYPE_OTHER_ARB: return "other message";
default: return "unknown message";
}
}
const char *MsgSeverityToStr(GLenum severity)
{
switch (severity)
{
case GL_DEBUG_SEVERITY_HIGH_ARB: return "high";
case GL_DEBUG_SEVERITY_MEDIUM_ARB: return "medium";
case GL_DEBUG_SEVERITY_LOW_ARB: return "low";
#ifdef GL_DEBUG_SEVERITY_NOTIFICATION
case GL_DEBUG_SEVERITY_NOTIFICATION: return "notification";
#endif
default: return "<unknown>";
}
}
#ifdef GLDEBUGPROCARB_USERPARAM_IS_CONST
#define USERPARAM_CONST const
#else
#define USERPARAM_CONST
#endif
void GLAPIENTRY OpenGLDebugProc(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char* message, USERPARAM_CONST void* userParam)
{
const char *msg_source = MsgSourceToStr(source);
const char *msg_type = MsgTypeToStr(type);
const char *msg_severity = MsgSeverityToStr(severity);
LogSilentF(" gl: %s severity %s %s: %s", msg_severity, msg_source, msg_type, message);
#ifdef USE_WIN32_WINDOWS
if (IsDebuggerPresent() && severity == GL_DEBUG_SEVERITY_HIGH_ARB)
BREAKPOINT_HERE;
#endif
}
}
#undef USERPARAM_CONST
CStdGL::CStdGL():
pMainCtx(0), CurrentVBO(0), NextVAOID(VAOIDs.end())
{
GenericVBOs[0] = 0;
Default();
// global ptr
pGL = this;
lines_tex = 0;
}
CStdGL::~CStdGL()
{
Clear();
pGL=NULL;
}
void CStdGL::Clear()
{
NoPrimaryClipper();
// cannot unlock TexMgr here or we can't preserve textures across GL reinitialization as required when changing multisampling
InvalidateDeviceObjects();
NoPrimaryClipper();
RenderTarget = NULL;
// 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=0;
C4Draw::Clear();
}
void CStdGL::FillBG(DWORD dwClr)
{
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);
}
bool CStdGL::UpdateClipper()
{
// 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;
}
bool CStdGL::PrepareRendering(C4Surface * sfcToSurface)
{
// 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;
}
bool CStdGL::PrepareSpriteShader(C4Shader& shader, const char* name, int ssc, C4GroupSet* pGroups, const char* const* additionalDefines, const char* const* additionalSlices)
{
const char* uniformNames[C4SSU_Count + 1];
uniformNames[C4SSU_ProjectionMatrix] = "projectionMatrix";
uniformNames[C4SSU_ModelViewMatrix] = "modelviewMatrix";
uniformNames[C4SSU_NormalMatrix] = "normalMatrix";
uniformNames[C4SSU_ClrMod] = "clrMod";
uniformNames[C4SSU_Gamma] = "gamma";
uniformNames[C4SSU_BaseTex] = "baseTex";
uniformNames[C4SSU_OverlayTex] = "overlayTex";
uniformNames[C4SSU_OverlayClr] = "overlayClr";
uniformNames[C4SSU_LightTex] = "lightTex";
uniformNames[C4SSU_LightTransform] = "lightTransform";
uniformNames[C4SSU_NormalTex] = "normalTex";
uniformNames[C4SSU_AmbientTex] = "ambientTex";
uniformNames[C4SSU_AmbientTransform] = "ambientTransform";
uniformNames[C4SSU_AmbientBrightness] = "ambientBrightness";
uniformNames[C4SSU_MaterialAmbient] = "materialAmbient"; // unused
uniformNames[C4SSU_MaterialDiffuse] = "materialDiffuse"; // unused
uniformNames[C4SSU_MaterialSpecular] = "materialSpecular"; // unused
uniformNames[C4SSU_MaterialEmission] = "materialEmission"; // unused
uniformNames[C4SSU_MaterialShininess] = "materialShininess"; // unused
uniformNames[C4SSU_Bones] = "bones"; // unused
uniformNames[C4SSU_CullMode] = "cullMode"; // unused
uniformNames[C4SSU_FrameCounter] = "frameCounter";
uniformNames[C4SSU_Count] = NULL;
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] = NULL;
// 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 != NULL; ++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");
if (additionalSlices)
for (const char* const* slice = additionalSlices; *slice != NULL; ++slice)
shader.LoadFragmentSlices(pGroups, *slice);
if (!shader.Init(name, uniformNames, attributeNames))
{
shader.ClearSlices();
return false;
}
return true;
}
void CStdGL::ObjectLabel(uint32_t identifier, uint32_t name, int32_t length, const char * label)
{
#ifdef GL_KHR_debug
if (glObjectLabel)
glObjectLabel(identifier, name, length, label);
#endif
}
CStdGLCtx *CStdGL::CreateContext(C4Window * pWindow, C4AbstractApp *pApp)
{
// safety
if (!pWindow) return NULL;
// create it
CStdGLCtx *pCtx = new CStdGLCtx();
bool first_ctx = !pMainCtx;
if (first_ctx)
{
pMainCtx = pCtx;
LogF(" gl: Create first %scontext...", Config.Graphics.DebugOpenGL ? "debug " : "");
}
bool success = pCtx->Init(pWindow, pApp);
if (Config.Graphics.DebugOpenGL && glDebugMessageCallbackARB)
{
if (first_ctx) Log(" gl: Setting OpenGLDebugProc callback");
glDebugMessageCallbackARB(&OpenGLDebugProc, nullptr);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
#ifdef GL_KHR_debug
if (GLEW_KHR_debug)
glEnable(GL_DEBUG_OUTPUT);
#endif
}
// First context: Log some information about hardware/drivers
// Must log after context creation to get valid results
if (first_ctx)
{
const char *gl_vendor = reinterpret_cast<const char *>(glGetString(GL_VENDOR));
const char *gl_renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
const char *gl_version = reinterpret_cast<const char *>(glGetString(GL_VERSION));
LogF("GL %s on %s (%s)", gl_version ? gl_version : "", gl_renderer ? gl_renderer : "", gl_vendor ? gl_vendor : "");
if (Config.Graphics.DebugOpenGL)
{
// Dump extension list
if (glGetStringi)
{
GLint gl_extension_count = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &gl_extension_count);
if (gl_extension_count == 0)
{
LogSilentF("No available extensions.");
}
else
{
LogSilentF("%d available extensions:", gl_extension_count);
for (GLint i = 0; i < gl_extension_count; ++i)
{
const char *gl_extension = (const char*)glGetStringi(GL_EXTENSIONS, i);
LogSilentF(" %4d: %s", i, gl_extension);
}
}
}
else
{
const char *gl_extensions = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
LogSilentF("GLExt: %s", gl_extensions ? gl_extensions : "");
}
}
}
if (!success)
{
delete pCtx; Error(" gl: Error creating secondary context!"); return NULL;
}
// creation selected the new context - switch back to previous context
RenderTarget = NULL;
pCurrCtx = NULL;
// done
return pCtx;
}
void CStdGL::SetupMultiBlt(C4ShaderCall& call, const C4BltTransform* pTransform, GLuint baseTex, GLuint overlayTex, GLuint normalTex, DWORD dwOverlayModClr, StdProjectionMatrix* out_modelview)
{
// 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 != NULL && normalTex != 0)
{
call.AllocTexUnit(C4SSU_NormalTex);
glBindTexture(GL_TEXTURE_2D, normalTex);
}
if(pFoW != NULL)
{
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 != NULL && 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 != NULL && normalTex != 0)
call.SetUniformMatrix3x3Transpose(C4SSU_NormalMatrix, StdMeshMatrix::Inverse(StdProjectionMatrix::Upper3x4(modelview)));
}
void CStdGL::PerformMultiPix(C4Surface* sfcTarget, const C4BltVertex* vertices, unsigned int n_vertices, C4ShaderCall* shader_call)
{
// 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, NULL, 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, NULL, 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);
}
}
void CStdGL::PerformMultiLines(C4Surface* sfcTarget, const C4BltVertex* vertices, unsigned int n_vertices, float width, C4ShaderCall* shader_call)
{
// 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, NULL, lines_tex, 0, 0, 0, NULL);
PerformMultiBlt(sfcTarget, OP_TRIANGLES, tri_vertices, n_vertices * 3, true, &call);
}
else
{
SetupMultiBlt(*shader_call, NULL, lines_tex, 0, 0, 0, NULL);
PerformMultiBlt(sfcTarget, OP_TRIANGLES, tri_vertices, n_vertices * 3, true, shader_call);
}
delete[] tri_vertices;
}
void CStdGL::PerformMultiTris(C4Surface* sfcTarget, const C4BltVertex* vertices, unsigned int n_vertices, const C4BltTransform* pTransform, C4TexRef* pTex, C4TexRef* pOverlay, C4TexRef* pNormal, DWORD dwOverlayModClr, C4ShaderCall* shader_call)
{
// Feed the vertices to the GL
if (!shader_call)
{
C4ShaderCall call(GetSpriteShader(pTex != NULL, pOverlay != NULL, pNormal != NULL));
SetupMultiBlt(call, pTransform, pTex ? pTex->texName : 0, pOverlay ? pOverlay->texName : 0, pNormal ? pNormal->texName : 0, dwOverlayModClr, NULL);
PerformMultiBlt(sfcTarget, OP_TRIANGLES, vertices, n_vertices, pTex != NULL, &call);
}
else
{
SetupMultiBlt(*shader_call, pTransform, pTex ? pTex->texName : 0, pOverlay ? pOverlay->texName : 0, pNormal ? pNormal->texName : 0, dwOverlayModClr, NULL);
PerformMultiBlt(sfcTarget, OP_TRIANGLES, vertices, n_vertices, pTex != NULL, shader_call);
}
}
void CStdGL::PerformMultiBlt(C4Surface* sfcTarget, DrawOperation op, const C4BltVertex* vertices, unsigned int n_vertices, bool has_tex, C4ShaderCall* shader_call)
{
// Only direct rendering
assert(sfcTarget->IsRenderTarget());
if(!PrepareRendering(sfcTarget)) return;
// Select a buffer
const unsigned int vbo_index = CurrentVBO;
CurrentVBO = (CurrentVBO + 1) % N_GENERIC_VBOS;
// Upload data into the buffer, resize buffer if necessary
glBindBuffer(GL_ARRAY_BUFFER, GenericVBOs[vbo_index]);
if (GenericVBOSizes[vbo_index] < n_vertices)
{
GenericVBOSizes[vbo_index] = n_vertices;
glBufferData(GL_ARRAY_BUFFER, n_vertices * sizeof(C4BltVertex), vertices, GL_STREAM_DRAW);
}
else
{
glBufferSubData(GL_ARRAY_BUFFER, 0, n_vertices * sizeof(C4BltVertex), vertices);
}
// Choose the VAO that corresponds to the chosen VBO. Also, use one
// that supplies texture coordinates if we have texturing enabled.
GLuint vao;
const unsigned int vao_index = vbo_index + (has_tex ? N_GENERIC_VBOS : 0);
const unsigned int vao_id = GenericVAOs[vao_index];
const bool has_vao = GetVAO(vao_id, vao);
glBindVertexArray(vao);
if (!has_vao)
{
// Initialize VAO for this context
const GLuint position = shader_call->GetAttribute(C4SSA_Position);
const GLuint color = shader_call->GetAttribute(C4SSA_Color);
const GLuint texcoord = has_tex ? shader_call->GetAttribute(C4SSA_TexCoord) : 0;
glEnableVertexAttribArray(position);
glEnableVertexAttribArray(color);
if (has_tex)
glEnableVertexAttribArray(texcoord);
glVertexAttribPointer(position, 2, GL_FLOAT, GL_FALSE, sizeof(C4BltVertex), reinterpret_cast<const uint8_t*>(offsetof(C4BltVertex, ftx)));
glVertexAttribPointer(color, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(C4BltVertex), reinterpret_cast<const uint8_t*>(offsetof(C4BltVertex, color)));
if (has_tex)
glVertexAttribPointer(texcoord, 2, GL_FLOAT, GL_FALSE, sizeof(C4BltVertex), reinterpret_cast<const uint8_t*>(offsetof(C4BltVertex, tx)));
}
switch (op)
{
case OP_POINTS:
glDrawArrays(GL_POINTS, 0, n_vertices);
break;
case OP_TRIANGLES:
glDrawArrays(GL_TRIANGLES, 0, n_vertices);
break;
default:
assert(false);
break;
}
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
C4Shader* CStdGL::GetSpriteShader(bool haveBase, bool haveOverlay, bool haveNormal)
{
int ssc = 0;
if(dwBlitMode & C4GFXBLIT_MOD2) ssc |= C4SSC_MOD2;
if(haveBase) ssc |= C4SSC_BASE;
if(haveBase && haveOverlay) ssc |= C4SSC_OVERLAY;
if(pFoW != NULL) ssc |= C4SSC_LIGHT;
if(pFoW != NULL && haveBase && haveNormal) ssc |= C4SSC_NORMAL;
return GetSpriteShader(ssc);
}
C4Shader* CStdGL::GetSpriteShader(int ssc)
{
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];
}
bool CStdGL::InitShaders(C4GroupSet* pGroups)
{
// Create sprite blitting shaders
if(!PrepareSpriteShader(SpriteShader, "sprite", 0, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderMod2, "spriteMod2", C4SSC_MOD2, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderBase, "spriteBase", C4SSC_BASE, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderBaseMod2, "spriteBaseMod2", C4SSC_MOD2 | C4SSC_BASE, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderBaseOverlay, "spriteBaseOverlay", C4SSC_BASE | C4SSC_OVERLAY, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderBaseOverlayMod2, "spriteBaseOverlayMod2", C4SSC_MOD2 | C4SSC_BASE | C4SSC_OVERLAY, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLight, "spriteLight", C4SSC_LIGHT, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightMod2, "spriteLightMod2", C4SSC_LIGHT | C4SSC_MOD2, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBase, "spriteLightBase", C4SSC_LIGHT | C4SSC_BASE, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseMod2, "spriteLightBaseMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_MOD2, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseOverlay, "spriteLightBaseOverlay", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseOverlayMod2, "spriteLightBaseOverlayMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY | C4SSC_MOD2, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseNormal, "spriteLightBaseNormal", C4SSC_LIGHT | C4SSC_BASE | C4SSC_NORMAL, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseNormalMod2, "spriteLightBaseNormalMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_NORMAL | C4SSC_MOD2, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseNormalOverlay, "spriteLightBaseNormalOverlay", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY | C4SSC_NORMAL, pGroups, NULL, NULL))
return false;
if(!PrepareSpriteShader(SpriteShaderLightBaseNormalOverlayMod2, "spriteLightBaseNormalOverlayMod2", C4SSC_LIGHT | C4SSC_BASE | C4SSC_OVERLAY | C4SSC_NORMAL | C4SSC_MOD2, pGroups, NULL, NULL))
return false;
return true;
}
bool CStdGL::RestoreDeviceObjects()
{
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), NULL, 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;
}
bool CStdGL::InvalidateDeviceObjects()
{
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 i = 0; i < N_GENERIC_VBOS * 2; ++i)
FreeVAOID(GenericVAOs[i]);
}
// 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;
}
bool CStdGL::Error(const char *szMsg)
{
#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,
NULL,
err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
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;
}
const char* CStdGL::GLErrorString(GLenum code)
{
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 "";
}
}
bool CStdGL::CheckGLError(const char *szAtOp)
{
GLenum err = glGetError();
if (!err) return true;
LogF("GL error with %s: %d - %s", szAtOp, err, GLErrorString(err));
return false;
}
CStdGL *pGL=NULL;
bool CStdGL::OnResolutionChanged(unsigned int iXRes, unsigned int iYRes)
{
// Re-create primary clipper to adapt to new size.
CreatePrimaryClipper(iXRes, iYRes);
RestoreDeviceObjects();
return true;
}
void CStdGL::Default()
{
C4Draw::Default();
pCurrCtx = NULL;
iPixelFormat=0;
sfcFmt=0;
Workarounds.LowMaxVertexUniformCount = false;
}
unsigned int CStdGL::GenVAOID()
{
// 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;
}
void CStdGL::FreeVAOID(unsigned int vaoid)
{
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 (std::list<CStdGLCtx*>::iterator iter = CStdGLCtx::contexts.begin(); iter != CStdGLCtx::contexts.end(); ++iter)
{
CStdGLCtx* ctx = *iter;
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);
}
bool CStdGL::GetVAO(unsigned int vaoid, GLuint& vao)
{
assert(pCurrCtx != NULL);
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;
}
#endif // USE_CONSOLE
Reference in New Issue View Git Blame Copy Permalink