forked from Mirrors/openclonk
1104 lines
45 KiB
C++
1104 lines
45 KiB
C++
/*
|
|
* OpenClonk, http://www.openclonk.org
|
|
*
|
|
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
|
|
* Copyright (c) 2013-2015, 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 Mesh Rendering */
|
|
|
|
#include "C4Include.h"
|
|
#include "object/C4Object.h"
|
|
#include "graphics/C4DrawGL.h"
|
|
#include "landscape/fow/C4FoWRegion.h"
|
|
#include "lib/SHA1.h"
|
|
|
|
#include "lib/StdMesh.h"
|
|
#include "graphics/C4GraphicsResource.h"
|
|
#include <locale.h>
|
|
#include <stdexcept>
|
|
|
|
#ifndef USE_CONSOLE
|
|
|
|
namespace
|
|
{
|
|
template<int category>
|
|
class ScopedLocale
|
|
{
|
|
// We need to make a copy of the return value of setlocale, because
|
|
// it's using TLS
|
|
std::string saved_loc;
|
|
public:
|
|
explicit ScopedLocale(const char *locale)
|
|
{
|
|
const char *old_loc = setlocale(category, locale);
|
|
if (old_loc == nullptr)
|
|
throw std::invalid_argument("Argument to setlocale was invalid");
|
|
saved_loc = old_loc;
|
|
}
|
|
~ScopedLocale()
|
|
{
|
|
setlocale(category, saved_loc.c_str());
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////
|
|
// Shader code generation
|
|
// This translates the fixed function instructions in a material script
|
|
// to an equivalent fragment shader. The generated code can certainly
|
|
// be optimized more.
|
|
////////////////////////////////////////////
|
|
StdStrBuf Texture2DToCode(int index, bool hasTextureAnimation)
|
|
{
|
|
if (hasTextureAnimation) return FormatString("texture(oc_Texture%d, (oc_TextureMatrix%d * vec4(texcoord, 0.0, 1.0)).xy)", index, index);
|
|
return FormatString("texture(oc_Texture%d, texcoord)", index);
|
|
}
|
|
|
|
StdStrBuf TextureUnitSourceToCode(int index, StdMeshMaterialTextureUnit::BlendOpSourceType source, const float manualColor[3], float manualAlpha, bool hasTextureAnimation)
|
|
{
|
|
switch(source)
|
|
{
|
|
case StdMeshMaterialTextureUnit::BOS_Current: return StdStrBuf("currentColor");
|
|
case StdMeshMaterialTextureUnit::BOS_Texture: return Texture2DToCode(index, hasTextureAnimation);
|
|
case StdMeshMaterialTextureUnit::BOS_Diffuse: return StdStrBuf("diffuse");
|
|
case StdMeshMaterialTextureUnit::BOS_Specular: return StdStrBuf("diffuse"); // TODO: Should be specular
|
|
case StdMeshMaterialTextureUnit::BOS_PlayerColor: return StdStrBuf("vec4(oc_PlayerColor, 1.0)");
|
|
case StdMeshMaterialTextureUnit::BOS_Manual: return FormatString("vec4(%f, %f, %f, %f)", manualColor[0], manualColor[1], manualColor[2], manualAlpha);
|
|
default: assert(false); return StdStrBuf("vec4(0.0, 0.0, 0.0, 0.0)");
|
|
}
|
|
}
|
|
|
|
StdStrBuf TextureUnitBlendToCode(int index, StdMeshMaterialTextureUnit::BlendOpExType blend_type, const char* source1, const char* source2, float manualFactor, bool hasTextureAnimation)
|
|
{
|
|
switch(blend_type)
|
|
{
|
|
case StdMeshMaterialTextureUnit::BOX_Source1: return StdStrBuf(source1);
|
|
case StdMeshMaterialTextureUnit::BOX_Source2: return StdStrBuf(source2);
|
|
case StdMeshMaterialTextureUnit::BOX_Modulate: return FormatString("%s * %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_ModulateX2: return FormatString("2.0 * %s * %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_ModulateX4: return FormatString("4.0 * %s * %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_Add: return FormatString("%s + %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_AddSigned: return FormatString("%s + %s - 0.5", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_AddSmooth: return FormatString("%s + %s - %s*%s", source1, source2, source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_Subtract: return FormatString("%s - %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_BlendDiffuseAlpha: return FormatString("diffuse.a * %s + (1.0 - diffuse.a) * %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_BlendTextureAlpha: return FormatString("%s.a * %s + (1.0 - %s.a) * %s", Texture2DToCode(index, hasTextureAnimation).getData(), source1, Texture2DToCode(index, hasTextureAnimation).getData(), source2);
|
|
case StdMeshMaterialTextureUnit::BOX_BlendCurrentAlpha: return FormatString("currentColor.a * %s + (1.0 - currentColor.a) * %s", source1, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_BlendManual: return FormatString("%f * %s + (1.0 - %f) * %s", manualFactor, source1, manualFactor, source2);
|
|
case StdMeshMaterialTextureUnit::BOX_Dotproduct: return FormatString("vec3(4.0 * dot(%s - 0.5, %s - 0.5), 4.0 * dot(%s - 0.5, %s - 0.5), 4.0 * dot(%s - 0.5, %s - 0.5))", source1, source2, source1, source2, source1, source2); // TODO: Needs special handling for the case of alpha
|
|
case StdMeshMaterialTextureUnit::BOX_BlendDiffuseColor: return FormatString("diffuse.rgb * %s + (1.0 - diffuse.rgb) * %s", source1, source2);
|
|
default: assert(false); return StdStrBuf(source1);
|
|
}
|
|
}
|
|
|
|
StdStrBuf TextureUnitToCode(int index, const StdMeshMaterialTextureUnit& texunit)
|
|
{
|
|
ScopedLocale<LC_NUMERIC> scoped_c_locale("C");
|
|
const bool hasTextureAnimation = texunit.HasTexCoordAnimation();
|
|
|
|
StdStrBuf color_source1 = FormatString("%s.rgb", TextureUnitSourceToCode(index, texunit.ColorOpSources[0], texunit.ColorOpManualColor1, texunit.AlphaOpManualAlpha1, hasTextureAnimation).getData());
|
|
StdStrBuf color_source2 = FormatString("%s.rgb", TextureUnitSourceToCode(index, texunit.ColorOpSources[1], texunit.ColorOpManualColor2, texunit.AlphaOpManualAlpha2, hasTextureAnimation).getData());
|
|
StdStrBuf alpha_source1 = FormatString("%s.a", TextureUnitSourceToCode(index, texunit.AlphaOpSources[0], texunit.ColorOpManualColor1, texunit.AlphaOpManualAlpha1, hasTextureAnimation).getData());
|
|
StdStrBuf alpha_source2 = FormatString("%s.a", TextureUnitSourceToCode(index, texunit.AlphaOpSources[1], texunit.ColorOpManualColor2, texunit.AlphaOpManualAlpha2, hasTextureAnimation).getData());
|
|
|
|
return FormatString("currentColor = vec4(%s, %s);\n", TextureUnitBlendToCode(index, texunit.ColorOpEx, color_source1.getData(), color_source2.getData(), texunit.ColorOpManualFactor, hasTextureAnimation).getData(), TextureUnitBlendToCode(index, texunit.AlphaOpEx, alpha_source1.getData(), alpha_source2.getData(), texunit.AlphaOpManualFactor, hasTextureAnimation).getData());
|
|
}
|
|
|
|
StdStrBuf AlphaTestToCode(const StdMeshMaterialPass& pass)
|
|
{
|
|
ScopedLocale<LC_NUMERIC> scoped_c_locale("C");
|
|
switch (pass.AlphaRejectionFunction)
|
|
{
|
|
case StdMeshMaterialPass::DF_AlwaysPass:
|
|
return StdStrBuf("");
|
|
case StdMeshMaterialPass::DF_AlwaysFail:
|
|
return StdStrBuf("discard;");
|
|
case StdMeshMaterialPass::DF_Less:
|
|
return FormatString("if (!(fragColor.a < %f)) discard;", pass.AlphaRejectionValue);
|
|
case StdMeshMaterialPass::DF_LessEqual:
|
|
return FormatString("if (!(fragColor.a <= %f)) discard;", pass.AlphaRejectionValue);
|
|
case StdMeshMaterialPass::DF_Equal:
|
|
return FormatString("if (!(fragColor.a == %f)) discard;", pass.AlphaRejectionValue);
|
|
case StdMeshMaterialPass::DF_NotEqual:
|
|
return FormatString("if (!(fragColor.a != %f)) discard;", pass.AlphaRejectionValue);
|
|
case StdMeshMaterialPass::DF_Greater:
|
|
return FormatString("if (!(fragColor.a > %f)) discard;", pass.AlphaRejectionValue);
|
|
case StdMeshMaterialPass::DF_GreaterEqual:
|
|
return FormatString("if (!(fragColor.a >= %f)) discard;", pass.AlphaRejectionValue);
|
|
default:
|
|
assert(false);
|
|
return StdStrBuf();
|
|
}
|
|
}
|
|
|
|
// Simple helper function
|
|
inline GLenum OgreBlendTypeToGL(StdMeshMaterialPass::SceneBlendType blend)
|
|
{
|
|
switch(blend)
|
|
{
|
|
case StdMeshMaterialPass::SB_One: return GL_ONE;
|
|
case StdMeshMaterialPass::SB_Zero: return GL_ZERO;
|
|
case StdMeshMaterialPass::SB_DestColor: return GL_DST_COLOR;
|
|
case StdMeshMaterialPass::SB_SrcColor: return GL_SRC_COLOR;
|
|
case StdMeshMaterialPass::SB_OneMinusDestColor: return GL_ONE_MINUS_DST_COLOR;
|
|
case StdMeshMaterialPass::SB_OneMinusSrcColor: return GL_ONE_MINUS_SRC_COLOR;
|
|
case StdMeshMaterialPass::SB_DestAlpha: return GL_DST_ALPHA;
|
|
case StdMeshMaterialPass::SB_SrcAlpha: return GL_SRC_ALPHA;
|
|
case StdMeshMaterialPass::SB_OneMinusDestAlpha: return GL_ONE_MINUS_DST_ALPHA;
|
|
case StdMeshMaterialPass::SB_OneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;
|
|
default: assert(false); return GL_ZERO;
|
|
}
|
|
}
|
|
|
|
StdStrBuf GetVertexShaderCodeForPass(const StdMeshMaterialPass& pass, bool LowMaxVertexUniformCount)
|
|
{
|
|
StdStrBuf buf;
|
|
|
|
if (!::GraphicsResource.Files.LoadEntryString("MeshVertexShader.glsl", &buf))
|
|
{
|
|
// Fall back just in case
|
|
buf.Copy(
|
|
"attribute vec3 oc_Position;\n"
|
|
"attribute vec3 oc_Normal;\n"
|
|
"attribute vec2 oc_TexCoord;\n"
|
|
"varying vec3 vtxNormal;\n"
|
|
"varying vec2 texcoord;\n"
|
|
"uniform mat4 projectionMatrix;\n"
|
|
"uniform mat4 modelviewMatrix;\n"
|
|
"uniform mat3 normalMatrix;\n"
|
|
"\n"
|
|
"slice(position)\n"
|
|
"{\n"
|
|
" gl_Position = projectionMatrix * modelviewMatrix * vec4(oc_Position, 1.0);\n"
|
|
"}\n"
|
|
"\n"
|
|
"slice(texcoord)\n"
|
|
"{\n"
|
|
" texcoord = oc_TexCoord;\n"
|
|
"}\n"
|
|
"\n"
|
|
"slice(normal)\n"
|
|
"{\n"
|
|
" vtxNormal = normalize(normalMatrix * oc_Normal);\n"
|
|
"}\n"
|
|
);
|
|
}
|
|
|
|
if (LowMaxVertexUniformCount)
|
|
return StdStrBuf("#define OC_WA_LOW_MAX_VERTEX_UNIFORM_COMPONENTS\n") + buf;
|
|
else
|
|
return buf;
|
|
}
|
|
|
|
// Note this only gets the code which inserts the slices specific for the pass
|
|
// -- other slices are independent from this!
|
|
StdStrBuf GetFragmentShaderCodeForPass(const StdMeshMaterialPass& pass, StdMeshMaterialShaderParameters& params)
|
|
{
|
|
StdStrBuf buf;
|
|
|
|
// Produce the fragment shader... first we create one code fragment for each
|
|
// texture unit, and we count the number of active textures, i.e. texture
|
|
// units that actually use a texture.
|
|
unsigned int texIndex = 0;
|
|
StdStrBuf textureUnitCode(""), textureUnitDeclCode("");
|
|
for(unsigned int i = 0; i < pass.TextureUnits.size(); ++i)
|
|
{
|
|
const StdMeshMaterialTextureUnit& texunit = pass.TextureUnits[i];
|
|
textureUnitCode.Append(TextureUnitToCode(texIndex, texunit));
|
|
|
|
if(texunit.HasTexture())
|
|
{
|
|
textureUnitDeclCode.Append(FormatString("uniform sampler2D oc_Texture%u;\n", texIndex).getData());
|
|
params.AddParameter(FormatString("oc_Texture%u", texIndex).getData(), StdMeshMaterialShaderParameter::INT).GetInt() = texIndex;
|
|
|
|
// If the texture unit has texture coordinate transformations,
|
|
// add a corresponding texture matrix uniform.
|
|
if(texunit.HasTexCoordAnimation())
|
|
{
|
|
textureUnitDeclCode.Append(FormatString("uniform mat4 oc_TextureMatrix%u;\n", texIndex).getData());
|
|
params.AddParameter(FormatString("oc_TextureMatrix%u", texIndex).getData(), StdMeshMaterialShaderParameter::AUTO_TEXTURE_MATRIX).GetInt() = texIndex;
|
|
}
|
|
|
|
++texIndex;
|
|
}
|
|
}
|
|
|
|
return FormatString(
|
|
"%s\n" // Texture units with active textures, only if >0 texture units
|
|
"uniform vec3 oc_PlayerColor;\n" // This needs to be in-sync with the naming in StdMeshMaterialProgram::CompileShader()
|
|
"\n"
|
|
"slice(texture)\n"
|
|
"{\n"
|
|
" vec4 diffuse = fragColor;\n"
|
|
" vec4 currentColor = diffuse;\n"
|
|
" %s\n"
|
|
" fragColor = currentColor;\n"
|
|
"}\n"
|
|
"\n"
|
|
"slice(finish)\n"
|
|
"{\n"
|
|
" %s\n"
|
|
"}\n",
|
|
textureUnitDeclCode.getData(),
|
|
textureUnitCode.getData(),
|
|
AlphaTestToCode(pass).getData()
|
|
);
|
|
}
|
|
|
|
StdStrBuf GetSHA1HexDigest(const char* text, std::size_t len)
|
|
{
|
|
sha1 ctx;
|
|
ctx.process_bytes(text, len);
|
|
unsigned int digest[5];
|
|
ctx.get_digest(digest);
|
|
|
|
return FormatString("%08x%08x%08x%08x%08x", digest[0], digest[1], digest[2], digest[3], digest[4]);
|
|
}
|
|
} // anonymous namespace
|
|
|
|
bool CStdGL::PrepareMaterial(StdMeshMatManager& mat_manager, StdMeshMaterialLoader& loader, StdMeshMaterial& mat)
|
|
{
|
|
// 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(unsigned int k = 0; k < pass.TextureUnits.size(); ++k)
|
|
if(pass.TextureUnits[k].HasTexture())
|
|
++active_texture_units;
|
|
|
|
if (active_texture_units > static_cast<unsigned int>(max_texture_units))
|
|
technique.Available = false;
|
|
|
|
for (unsigned int k = 0; k < pass.TextureUnits.size(); ++k)
|
|
{
|
|
StdMeshMaterialTextureUnit& texunit = pass.TextureUnits[k];
|
|
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;
|
|
}
|
|
|
|
// TODO: We should add a class, C4MeshRenderer, which contains all the functions
|
|
// in this namespace, and avoids passing around so many parameters.
|
|
namespace
|
|
{
|
|
// Apply Zoom and Transformation to the current matrix stack. Return
|
|
// parity of the transformation.
|
|
bool ApplyZoomAndTransform(float ZoomX, float ZoomY, float Zoom, C4BltTransform* pTransform, StdProjectionMatrix& projection)
|
|
{
|
|
// Apply zoom
|
|
Translate(projection, ZoomX, ZoomY, 0.0f);
|
|
Scale(projection, Zoom, Zoom, 1.0f);
|
|
Translate(projection, -ZoomX, -ZoomY, 0.0f);
|
|
|
|
// Apply transformation
|
|
if (pTransform)
|
|
{
|
|
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) = 1.0f;
|
|
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];
|
|
projection *= transform;
|
|
|
|
// Compute parity of the transformation matrix - if parity is swapped then
|
|
// we need to cull front faces instead of back faces.
|
|
const float det = transform(0,0)*transform(1,1)*transform(3,3)
|
|
+ transform(1,0)*transform(3,1)*transform(0,3)
|
|
+ transform(3,0)*transform(0,1)*transform(1,3)
|
|
- transform(0,0)*transform(3,1)*transform(1,3)
|
|
- transform(1,0)*transform(0,1)*transform(3,3)
|
|
- transform(3,0)*transform(1,1)*transform(0,3);
|
|
|
|
return det > 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SetStandardUniforms(C4ShaderCall& call, DWORD dwModClr, DWORD dwPlayerColor, DWORD dwBlitMode, bool cullFace, const C4FoWRegion* pFoW, const C4Rect& clipRect, const C4Rect& outRect)
|
|
{
|
|
// Draw transform
|
|
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, pDraw->gammaOut);
|
|
|
|
// Player color
|
|
const float fPlrClr[3] = {
|
|
((dwPlayerColor >> 16) & 0xff) / 255.0f,
|
|
((dwPlayerColor >> 8) & 0xff) / 255.0f,
|
|
((dwPlayerColor ) & 0xff) / 255.0f,
|
|
};
|
|
call.SetUniform3fv(C4SSU_OverlayClr, 1, fPlrClr);
|
|
|
|
// Backface culling flag
|
|
call.SetUniform1f(C4SSU_CullMode, cullFace ? 0.0f : 1.0f);
|
|
|
|
// Dynamic light
|
|
if(pFoW != NULL)
|
|
{
|
|
call.AllocTexUnit(C4SSU_LightTex);
|
|
glBindTexture(GL_TEXTURE_2D, pFoW->getSurfaceName());
|
|
float lightTransform[6];
|
|
pFoW->GetFragTransform(clipRect, outRect, lightTransform);
|
|
call.SetUniformMatrix2x3fv(C4SSU_LightTransform, 1, lightTransform);
|
|
|
|
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(pFoW->getViewportRegion(), clipRect, outRect, ambientTransform);
|
|
call.SetUniformMatrix2x3fv(C4SSU_AmbientTransform, 1, ambientTransform);
|
|
}
|
|
|
|
// Current frame counter
|
|
call.SetUniform1i(C4SSU_FrameCounter, ::Game.FrameCounter);
|
|
}
|
|
|
|
bool ResolveAutoParameter(C4ShaderCall& call, StdMeshMaterialShaderParameter& parameter, StdMeshMaterialShaderParameter::Auto value, DWORD dwModClr, DWORD dwPlayerColor, DWORD dwBlitMode, const C4FoWRegion* pFoW, const C4Rect& clipRect)
|
|
{
|
|
// There are no auto parameters implemented yet
|
|
assert(false);
|
|
return false;
|
|
}
|
|
|
|
StdProjectionMatrix ResolveAutoTextureMatrix(const StdSubMeshInstance& instance, const StdMeshMaterialTechnique& technique, unsigned int passIndex, unsigned int texUnitIndex)
|
|
{
|
|
assert(passIndex < technique.Passes.size());
|
|
const StdMeshMaterialPass& pass = technique.Passes[passIndex];
|
|
|
|
assert(texUnitIndex < pass.TextureUnits.size());
|
|
const StdMeshMaterialTextureUnit& texunit = pass.TextureUnits[texUnitIndex];
|
|
|
|
StdProjectionMatrix matrix = StdProjectionMatrix::Identity();
|
|
const double Position = instance.GetTexturePosition(passIndex, texUnitIndex);
|
|
|
|
for (unsigned int k = 0; k < texunit.Transformations.size(); ++k)
|
|
{
|
|
const StdMeshMaterialTextureUnit::Transformation& trans = texunit.Transformations[k];
|
|
StdProjectionMatrix temp_matrix;
|
|
switch (trans.TransformType)
|
|
{
|
|
case StdMeshMaterialTextureUnit::Transformation::T_SCROLL:
|
|
Translate(matrix, trans.Scroll.X, trans.Scroll.Y, 0.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::T_SCROLL_ANIM:
|
|
Translate(matrix, trans.GetScrollX(Position), trans.GetScrollY(Position), 0.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::T_ROTATE:
|
|
Rotate(matrix, trans.Rotate.Angle, 0.0f, 0.0f, 1.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::T_ROTATE_ANIM:
|
|
Rotate(matrix, trans.GetRotate(Position), 0.0f, 0.0f, 1.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::T_SCALE:
|
|
Scale(matrix, trans.Scale.X, trans.Scale.Y, 1.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::T_TRANSFORM:
|
|
for (int i = 0; i < 16; ++i)
|
|
temp_matrix(i / 4, i % 4) = trans.Transform.M[i];
|
|
matrix *= temp_matrix;
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::T_WAVE_XFORM:
|
|
switch (trans.WaveXForm.XForm)
|
|
{
|
|
case StdMeshMaterialTextureUnit::Transformation::XF_SCROLL_X:
|
|
Translate(matrix, trans.GetWaveXForm(Position), 0.0f, 0.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::XF_SCROLL_Y:
|
|
Translate(matrix, 0.0f, trans.GetWaveXForm(Position), 0.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::XF_ROTATE:
|
|
Rotate(matrix, trans.GetWaveXForm(Position), 0.0f, 0.0f, 1.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::XF_SCALE_X:
|
|
Scale(matrix, trans.GetWaveXForm(Position), 1.0f, 1.0f);
|
|
break;
|
|
case StdMeshMaterialTextureUnit::Transformation::XF_SCALE_Y:
|
|
Scale(matrix, 1.0f, trans.GetWaveXForm(Position), 1.0f);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return matrix;
|
|
}
|
|
|
|
void RenderSubMeshImpl(const StdProjectionMatrix& projectionMatrix, const StdMeshMatrix& modelviewMatrix, const StdMeshInstance& mesh_instance, const StdSubMeshInstance& instance, DWORD dwModClr, DWORD dwBlitMode, DWORD dwPlayerColor, const C4FoWRegion* pFoW, const C4Rect& clipRect, const C4Rect& outRect, bool parity)
|
|
{
|
|
const StdMeshMaterial& material = instance.GetMaterial();
|
|
assert(material.BestTechniqueIndex != -1);
|
|
const StdMeshMaterialTechnique& technique = material.Techniques[material.BestTechniqueIndex];
|
|
|
|
bool using_shared_vertices = instance.GetSubMesh().GetVertices().empty();
|
|
GLuint vbo = mesh_instance.GetMesh().GetVBO();
|
|
GLuint ibo = mesh_instance.GetIBO();
|
|
unsigned int vaoid = mesh_instance.GetVAOID();
|
|
size_t vertex_buffer_offset = using_shared_vertices ? 0 : instance.GetSubMesh().GetOffsetInVBO();
|
|
size_t index_buffer_offset = instance.GetSubMesh().GetOffsetInIBO(); // note this is constant
|
|
|
|
// Cook the bone transform matrixes into something that OpenGL can use. This could be moved into RenderMeshImpl.
|
|
// Or, even better, we could upload them into a UBO, but Intel doesn't support them prior to Sandy Bridge.
|
|
struct BoneTransform
|
|
{
|
|
float m[3][4];
|
|
};
|
|
std::vector<BoneTransform> bones;
|
|
if (mesh_instance.GetBoneCount() == 0)
|
|
{
|
|
// Upload dummy bone so we don't have to do branching in the vertex shader
|
|
static const BoneTransform dummy_bone = {
|
|
1.0f, 0.0f, 0.0f, 0.0f,
|
|
0.0f, 1.0f, 0.0f, 0.0f,
|
|
0.0f, 0.0f, 1.0f, 0.0f
|
|
};
|
|
bones.push_back(dummy_bone);
|
|
}
|
|
else
|
|
{
|
|
bones.reserve(mesh_instance.GetBoneCount());
|
|
for (size_t bone_index = 0; bone_index < mesh_instance.GetBoneCount(); ++bone_index)
|
|
{
|
|
const StdMeshMatrix &bone = mesh_instance.GetBoneTransform(bone_index);
|
|
BoneTransform cooked_bone = {
|
|
bone(0, 0), bone(0, 1), bone(0, 2), bone(0, 3),
|
|
bone(1, 0), bone(1, 1), bone(1, 2), bone(1, 3),
|
|
bone(2, 0), bone(2, 1), bone(2, 2), bone(2, 3)
|
|
};
|
|
bones.push_back(cooked_bone);
|
|
}
|
|
}
|
|
|
|
// Don't render with degenerate matrix
|
|
if (fabs(modelviewMatrix.Determinant()) < 1e-6)
|
|
return;
|
|
// Modelview matrix does not change between passes, so cache it here
|
|
const StdMeshMatrix normalMatrixTranspose = StdMeshMatrix::Inverse(modelviewMatrix);
|
|
|
|
// Render each pass
|
|
for (unsigned int i = 0; i < technique.Passes.size(); ++i)
|
|
{
|
|
const StdMeshMaterialPass& pass = technique.Passes[i];
|
|
|
|
if(!pass.DepthCheck)
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
glDepthMask(pass.DepthWrite ? GL_TRUE : GL_FALSE);
|
|
|
|
if(pass.AlphaToCoverage)
|
|
glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
|
|
else
|
|
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
|
|
|
|
glFrontFace(parity ? GL_CW : GL_CCW);
|
|
if(mesh_instance.GetCompletion() < 1.0f)
|
|
{
|
|
// Backfaces might be visible when completion is < 1.0f since front
|
|
// faces might be omitted.
|
|
glDisable(GL_CULL_FACE);
|
|
}
|
|
else
|
|
{
|
|
switch (pass.CullHardware)
|
|
{
|
|
case StdMeshMaterialPass::CH_Clockwise:
|
|
glEnable(GL_CULL_FACE);
|
|
glCullFace(GL_BACK);
|
|
break;
|
|
case StdMeshMaterialPass::CH_CounterClockwise:
|
|
glEnable(GL_CULL_FACE);
|
|
glCullFace(GL_FRONT);
|
|
break;
|
|
case StdMeshMaterialPass::CH_None:
|
|
glDisable(GL_CULL_FACE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Overwrite blend mode with default alpha blending when alpha in clrmod
|
|
// is <255. This makes sure that normal non-blended meshes can have
|
|
// blending disabled in their material script (which disables expensive
|
|
// face ordering) but when they are made translucent via clrmod
|
|
if(!(dwBlitMode & C4GFXBLIT_ADDITIVE))
|
|
{
|
|
if( ((dwModClr >> 24) & 0xff) < 0xff) // && (!(dwBlitMode & C4GFXBLIT_MOD2)) )
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
else
|
|
glBlendFunc(OgreBlendTypeToGL(pass.SceneBlendFactors[0]),
|
|
OgreBlendTypeToGL(pass.SceneBlendFactors[1]));
|
|
}
|
|
else
|
|
{
|
|
if( ((dwModClr >> 24) & 0xff) < 0xff) // && (!(dwBlitMode & C4GFXBLIT_MOD2)) )
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
|
else
|
|
glBlendFunc(OgreBlendTypeToGL(pass.SceneBlendFactors[0]), GL_ONE);
|
|
}
|
|
|
|
assert(pass.Program.get() != NULL);
|
|
|
|
// Upload all parameters to the shader
|
|
int ssc = 0;
|
|
if(dwBlitMode & C4GFXBLIT_MOD2) ssc |= C4SSC_MOD2;
|
|
if(pFoW != NULL) ssc |= C4SSC_LIGHT;
|
|
const C4Shader* shader = pass.Program->Program->GetShader(ssc);
|
|
if (!shader) return;
|
|
C4ShaderCall call(shader);
|
|
call.Start();
|
|
|
|
// Upload projection, modelview and normal matrices
|
|
call.SetUniformMatrix4x4(C4SSU_ProjectionMatrix, projectionMatrix);
|
|
call.SetUniformMatrix4x4(C4SSU_ModelViewMatrix, modelviewMatrix);
|
|
call.SetUniformMatrix3x3Transpose(C4SSU_NormalMatrix, normalMatrixTranspose);
|
|
|
|
|
|
// Upload material properties
|
|
call.SetUniform4fv(C4SSU_MaterialAmbient, 1, pass.Ambient);
|
|
call.SetUniform4fv(C4SSU_MaterialDiffuse, 1, pass.Diffuse);
|
|
call.SetUniform4fv(C4SSU_MaterialSpecular, 1, pass.Specular);
|
|
call.SetUniform4fv(C4SSU_MaterialEmission, 1, pass.Emissive);
|
|
call.SetUniform1f(C4SSU_MaterialShininess, pass.Shininess);
|
|
|
|
// Upload the current bone transformation matrixes (if there are any)
|
|
if (!bones.empty())
|
|
{
|
|
if (pGL->Workarounds.LowMaxVertexUniformCount)
|
|
glUniformMatrix3x4fv(shader->GetUniform(C4SSU_Bones), bones.size(), GL_FALSE, &bones[0].m[0][0]);
|
|
else
|
|
glUniformMatrix4x3fv(shader->GetUniform(C4SSU_Bones), bones.size(), GL_TRUE, &bones[0].m[0][0]);
|
|
}
|
|
|
|
GLuint vao;
|
|
const bool has_vao = pGL->GetVAO(vaoid, vao);
|
|
glBindVertexArray(vao);
|
|
if (!has_vao)
|
|
{
|
|
// Bind the vertex data of the mesh
|
|
// Note this relies on the fact that all vertex
|
|
// attributes for all shaders are at the same
|
|
// locations.
|
|
// TODO: And this fails if the mesh changes
|
|
// from a material with texture to one without
|
|
// or vice versa.
|
|
glBindBuffer(GL_ARRAY_BUFFER, vbo);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
|
|
#define VERTEX_OFFSET(field) reinterpret_cast<const uint8_t *>(offsetof(StdMeshVertex, field))
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_Position), 3, GL_FLOAT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(x));
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_Normal), 3, GL_FLOAT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(nx));
|
|
if (shader->GetAttribute(C4SSA_TexCoord) != -1)
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_TexCoord), 2, GL_FLOAT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(u));
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_BoneWeights0), 4, GL_FLOAT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(bone_weight));
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_BoneWeights1), 4, GL_FLOAT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(bone_weight) + 4 * sizeof(std::remove_all_extents<decltype(StdMeshVertex::bone_weight)>::type));
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_BoneIndices0), 4, GL_SHORT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(bone_index));
|
|
glVertexAttribPointer(shader->GetAttribute(C4SSA_BoneIndices1), 4, GL_SHORT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(bone_index) + 4 * sizeof(std::remove_all_extents<decltype(StdMeshVertex::bone_index)>::type));
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_Position));
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_Normal));
|
|
if (shader->GetAttribute(C4SSA_TexCoord) != -1)
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_TexCoord));
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneWeights0));
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneWeights1));
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneIndices0));
|
|
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneIndices1));
|
|
#undef VERTEX_OFFSET
|
|
}
|
|
|
|
// Bind textures
|
|
for (unsigned int j = 0; j < pass.TextureUnits.size(); ++j)
|
|
{
|
|
const StdMeshMaterialTextureUnit& texunit = pass.TextureUnits[j];
|
|
if (texunit.HasTexture())
|
|
{
|
|
call.AllocTexUnit(-1);
|
|
const unsigned int Phase = instance.GetTexturePhase(i, j);
|
|
glBindTexture(GL_TEXTURE_2D, texunit.GetTexture(Phase).texName);
|
|
}
|
|
}
|
|
|
|
// Set uniforms and instance parameters
|
|
SetStandardUniforms(call, dwModClr, dwPlayerColor, dwBlitMode, pass.CullHardware != StdMeshMaterialPass::CH_None, pFoW, clipRect, outRect);
|
|
for(unsigned int j = 0; j < pass.Program->Parameters.size(); ++j)
|
|
{
|
|
const int uniform = pass.Program->Parameters[j].UniformIndex;
|
|
if(!shader->HaveUniform(uniform)) continue; // optimized out
|
|
|
|
const StdMeshMaterialShaderParameter* parameter = pass.Program->Parameters[j].Parameter;
|
|
|
|
StdMeshMaterialShaderParameter auto_resolved;
|
|
if(parameter->GetType() == StdMeshMaterialShaderParameter::AUTO)
|
|
{
|
|
if(!ResolveAutoParameter(call, auto_resolved, parameter->GetAuto(), dwModClr, dwPlayerColor, dwBlitMode, pFoW, clipRect))
|
|
continue;
|
|
parameter = &auto_resolved;
|
|
}
|
|
|
|
switch(parameter->GetType())
|
|
{
|
|
case StdMeshMaterialShaderParameter::AUTO_TEXTURE_MATRIX:
|
|
call.SetUniformMatrix4x4(uniform, ResolveAutoTextureMatrix(instance, technique, i, parameter->GetInt()));
|
|
break;
|
|
case StdMeshMaterialShaderParameter::INT:
|
|
call.SetUniform1i(uniform, parameter->GetInt());
|
|
break;
|
|
case StdMeshMaterialShaderParameter::FLOAT:
|
|
call.SetUniform1f(uniform, parameter->GetFloat());
|
|
break;
|
|
case StdMeshMaterialShaderParameter::FLOAT2:
|
|
call.SetUniform2fv(uniform, 1, parameter->GetFloatv());
|
|
break;
|
|
case StdMeshMaterialShaderParameter::FLOAT3:
|
|
call.SetUniform3fv(uniform, 1, parameter->GetFloatv());
|
|
break;
|
|
case StdMeshMaterialShaderParameter::FLOAT4:
|
|
call.SetUniform4fv(uniform, 1, parameter->GetFloatv());
|
|
break;
|
|
case StdMeshMaterialShaderParameter::MATRIX_4X4:
|
|
call.SetUniformMatrix4x4fv(uniform, 1, parameter->GetMatrix());
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
size_t vertex_count = 3 * instance.GetNumFaces();
|
|
assert (vertex_buffer_offset % sizeof(StdMeshVertex) == 0);
|
|
size_t base_vertex = vertex_buffer_offset / sizeof(StdMeshVertex);
|
|
glDrawElementsBaseVertex(GL_TRIANGLES, vertex_count, GL_UNSIGNED_INT, reinterpret_cast<void*>(index_buffer_offset), base_vertex);
|
|
glBindVertexArray(0);
|
|
call.Finish();
|
|
|
|
if(!pass.DepthCheck)
|
|
glEnable(GL_DEPTH_TEST);
|
|
}
|
|
}
|
|
|
|
void RenderMeshImpl(const StdProjectionMatrix& projectionMatrix, const StdMeshMatrix& modelviewMatrix, StdMeshInstance& instance, DWORD dwModClr, DWORD dwBlitMode, DWORD dwPlayerColor, const C4FoWRegion* pFoW, const C4Rect& clipRect, const C4Rect& outRect, bool parity); // Needed by RenderAttachedMesh
|
|
|
|
void RenderAttachedMesh(const StdProjectionMatrix& projectionMatrix, const StdMeshMatrix& modelviewMatrix, StdMeshInstance::AttachedMesh* attach, DWORD dwModClr, DWORD dwBlitMode, DWORD dwPlayerColor, const C4FoWRegion* pFoW, const C4Rect& clipRect, const C4Rect& outRect, bool parity)
|
|
{
|
|
const StdMeshMatrix& FinalTrans = attach->GetFinalTransformation();
|
|
|
|
// Take the player color from the C4Object, if the attached object is not a definition
|
|
// This is a bit unfortunate because it requires access to C4Object which is otherwise
|
|
// avoided in this code. It could be replaced by virtual function calls to StdMeshDenumerator
|
|
C4MeshDenumerator* denumerator = dynamic_cast<C4MeshDenumerator*>(attach->ChildDenumerator);
|
|
if(denumerator && denumerator->GetObject())
|
|
{
|
|
dwModClr = denumerator->GetObject()->ColorMod;
|
|
dwBlitMode = denumerator->GetObject()->BlitMode;
|
|
dwPlayerColor = denumerator->GetObject()->Color;
|
|
}
|
|
|
|
// TODO: Take attach transform's parity into account
|
|
StdMeshMatrix newModelviewMatrix = modelviewMatrix * FinalTrans;
|
|
RenderMeshImpl(projectionMatrix, newModelviewMatrix, *attach->Child, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
|
|
}
|
|
|
|
void RenderMeshImpl(const StdProjectionMatrix& projectionMatrix, const StdMeshMatrix& modelviewMatrix, StdMeshInstance& instance, DWORD dwModClr, DWORD dwBlitMode, DWORD dwPlayerColor, const C4FoWRegion* pFoW, const C4Rect& clipRect, const C4Rect& outRect, bool parity)
|
|
{
|
|
const StdMesh& mesh = instance.GetMesh();
|
|
|
|
// Render AM_DrawBefore attached meshes
|
|
StdMeshInstance::AttachedMeshIter attach_iter = instance.AttachedMeshesBegin();
|
|
|
|
for (; attach_iter != instance.AttachedMeshesEnd() && ((*attach_iter)->GetFlags() & StdMeshInstance::AM_DrawBefore); ++attach_iter)
|
|
RenderAttachedMesh(projectionMatrix, modelviewMatrix, *attach_iter, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
|
|
|
|
// Check if we should draw in wireframe or normal mode
|
|
if(dwBlitMode & C4GFXBLIT_WIREFRAME)
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
|
|
// Render each submesh
|
|
for (unsigned int i = 0; i < mesh.GetNumSubMeshes(); ++i)
|
|
RenderSubMeshImpl(projectionMatrix, modelviewMatrix, instance, instance.GetSubMeshOrdered(i), dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
|
|
|
|
// reset old mode to prevent rendering errors
|
|
if(dwBlitMode & C4GFXBLIT_WIREFRAME)
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
|
|
// Render non-AM_DrawBefore attached meshes
|
|
for (; attach_iter != instance.AttachedMeshesEnd(); ++attach_iter)
|
|
RenderAttachedMesh(projectionMatrix, modelviewMatrix, *attach_iter, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
|
|
}
|
|
}
|
|
|
|
void CStdGL::PerformMesh(StdMeshInstance &instance, float tx, float ty, float twdt, float thgt, DWORD dwPlayerColor, C4BltTransform* pTransform)
|
|
{
|
|
// 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);
|
|
}
|
|
|
|
#endif // USE_CONSOLE
|