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

1214 lines
48 KiB
C++
Raw Normal View History

Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
/*
* OpenClonk, http://www.openclonk.org
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
Update all copyright notices for 2016
2016-04-03 18:18:29 +00:00
* Copyright (c) 2013-2016, The OpenClonk Team and contributors
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
*
Update copyright notices As discussed in http://forum.openclonk.org/topic_show.pl?tid=2917, I have merged all copyright notices into a single file and referenced that merged file from each source file. For the updated source files, the timeline has been split into three parts: 1. Pre-RWD code (before 2001) 2. RWD code (2001 through 2009) 3. OpenClonk code (2009 and later) All pre-RWD copyright notices have been left intact, as have RWD-era copyright notices where the file did not have a RedWolf design copyright notice but only individual author ones. All copyright notices of the OpenClonk era have been replaced by a single notice ranging from the first recorded year to the current year (2013). Mape code did not get a OpenClonk Team copyright notice because it is somewhat separate from the main OpenClonk codebase and has only been touched by Armin Burgmeier.
2013-12-17 20:01:09 +00:00
* To redistribute this file separately, substitute the full license texts
* for the above references.
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
*/
/* OpenGL implementation of Mesh Rendering */
#include "C4Include.h"
Prevent using USE_CONSOLE in lib{misc,c4script}
2016-10-22 11:19:22 +00:00
#include "C4ForbidLibraryCompilation.h"
Rewrite header inclusions to #include "path/to/file.h" style
2016-04-03 18:07:56 +00:00
#include "object/C4Object.h"
#include "graphics/C4DrawGL.h"
#include "landscape/fow/C4FoWRegion.h"
#include "lib/SHA1.h"
Twiddle with header organization: lib{misc,c4script} do no longer include GL/glew.h (Yes, it is just that complicated.)
2016-10-20 16:30:05 +00:00
#include "src/object/C4MeshDenumerator.h"
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Rewrite header inclusions to #include "path/to/file.h" style
2016-04-03 18:07:56 +00:00
#include "lib/StdMesh.h"
Load default object vertex shader from Graphics.ocg Instead of having the default vertex shader hard-coded into the engine, allow to load it from Graphics.ocg. There's still a fall-back version wired into the engine because we can't return an error from GetVertexShaderCodeForPass.
2015-02-26 20:04:12 +00:00
#include "graphics/C4GraphicsResource.h"
Temporarily change to C locale before formatting shader floats In the game initialization code, we're setting the thread locale to the user's default locale. This is bad when generating shader code because it may lead to floats being written with commas instead of dots for the decimal separator, which in turn confuses the GLSL compiler (because it parses the comma as the comma operator). So now we just temporarily set the C locale while generating shader code.
2015-12-27 00:20:00 +00:00
#include <locale.h>
#include <stdexcept>
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Remove remains of Direct3D support Direct3D hasn't worked for more than a year now, and there don't seem to be any efforts to revive it. Remove it and concentrate on better OpenGL support.
2013-10-29 13:27:18 +00:00
#ifndef USE_CONSOLE
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
namespace
{
Temporarily change to C locale before formatting shader floats In the game initialization code, we're setting the thread locale to the user's default locale. This is bad when generating shader code because it may lead to floats being written with commas instead of dots for the decimal separator, which in turn confuses the GLSL compiler (because it parses the comma as the comma operator). So now we just temporarily set the C locale while generating shader code.
2015-12-27 00:20:00 +00:00
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());
}
};
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
////////////////////////////////////////////
// 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.
////////////////////////////////////////////
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
StdStrBuf Texture2DToCode(int index, bool hasTextureAnimation)
{
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
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);
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
}
StdStrBuf TextureUnitSourceToCode(int index, StdMeshMaterialTextureUnit::BlendOpSourceType source, const float manualColor[3], float manualAlpha, bool hasTextureAnimation)
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
{
switch(source)
{
case StdMeshMaterialTextureUnit::BOS_Current: return StdStrBuf("currentColor");
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
case StdMeshMaterialTextureUnit::BOS_Texture: return Texture2DToCode(index, hasTextureAnimation);
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
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)");
}
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
StdStrBuf TextureUnitBlendToCode(int index, StdMeshMaterialTextureUnit::BlendOpExType blend_type, const char* source1, const char* source2, float manualFactor, bool hasTextureAnimation)
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
{
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);
Make sure not to use integers in generated shader code (#920)
2013-02-12 21:39:56 +00:00
case StdMeshMaterialTextureUnit::BOX_BlendDiffuseAlpha: return FormatString("diffuse.a * %s + (1.0 - diffuse.a) * %s", source1, source2);
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
case StdMeshMaterialTextureUnit::BOX_BlendTextureAlpha: return FormatString("%s.a * %s + (1.0 - %s.a) * %s", Texture2DToCode(index, hasTextureAnimation).getData(), source1, Texture2DToCode(index, hasTextureAnimation).getData(), source2);
Make sure not to use integers in generated shader code (#920)
2013-02-12 21:39:56 +00:00
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);
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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
Make sure not to use integers in generated shader code (#920)
2013-02-12 21:39:56 +00:00
case StdMeshMaterialTextureUnit::BOX_BlendDiffuseColor: return FormatString("diffuse.rgb * %s + (1.0 - diffuse.rgb) * %s", source1, source2);
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
default: assert(false); return StdStrBuf(source1);
}
}
StdStrBuf TextureUnitToCode(int index, const StdMeshMaterialTextureUnit& texunit)
{
Temporarily change to C locale before formatting shader floats In the game initialization code, we're setting the thread locale to the user's default locale. This is bad when generating shader code because it may lead to floats being written with commas instead of dots for the decimal separator, which in turn confuses the GLSL compiler (because it parses the comma as the comma operator). So now we just temporarily set the C locale while generating shader code.
2015-12-27 00:20:00 +00:00
ScopedLocale<LC_NUMERIC> scoped_c_locale("C");
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
const bool hasTextureAnimation = texunit.HasTexCoordAnimation();
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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());
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
}
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
StdStrBuf AlphaTestToCode(const StdMeshMaterialPass& pass)
{
Temporarily change to C locale before formatting shader floats In the game initialization code, we're setting the thread locale to the user's default locale. This is bad when generating shader code because it may lead to floats being written with commas instead of dots for the decimal separator, which in turn confuses the GLSL compiler (because it parses the comma as the comma operator). So now we just temporarily set the C locale while generating shader code.
2015-12-27 00:20:00 +00:00
ScopedLocale<LC_NUMERIC> scoped_c_locale("C");
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
switch (pass.AlphaRejectionFunction)
{
case StdMeshMaterialPass::DF_AlwaysPass:
return StdStrBuf("");
case StdMeshMaterialPass::DF_AlwaysFail:
return StdStrBuf("discard;");
case StdMeshMaterialPass::DF_Less:
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
return FormatString("if (!(fragColor.a < %f)) discard;", pass.AlphaRejectionValue);
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
case StdMeshMaterialPass::DF_LessEqual:
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
return FormatString("if (!(fragColor.a <= %f)) discard;", pass.AlphaRejectionValue);
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
case StdMeshMaterialPass::DF_Equal:
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
return FormatString("if (!(fragColor.a == %f)) discard;", pass.AlphaRejectionValue);
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
case StdMeshMaterialPass::DF_NotEqual:
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
return FormatString("if (!(fragColor.a != %f)) discard;", pass.AlphaRejectionValue);
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
case StdMeshMaterialPass::DF_Greater:
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
return FormatString("if (!(fragColor.a > %f)) discard;", pass.AlphaRejectionValue);
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
case StdMeshMaterialPass::DF_GreaterEqual:
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
return FormatString("if (!(fragColor.a >= %f)) discard;", pass.AlphaRejectionValue);
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
default:
assert(false);
return StdStrBuf();
}
}
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
// 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;
}
}
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
StdStrBuf GetVertexShaderCodeForPass(const StdMeshMaterialPass& pass, bool LowMaxVertexUniformCount)
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
{
StdStrBuf buf;
Use generic vertex attributes for sprites, meshes, particles
2016-01-02 21:08:53 +00:00
if (!::GraphicsResource.Files.LoadEntryString("MeshVertexShader.glsl", &buf))
Load default object vertex shader from Graphics.ocg Instead of having the default vertex shader hard-coded into the engine, allow to load it from Graphics.ocg. There's still a fall-back version wired into the engine because we can't return an error from GetVertexShaderCodeForPass.
2015-02-26 20:04:12 +00:00
{
// Fall back just in case
buf.Copy(
Use generic vertex attributes for sprites, meshes, particles
2016-01-02 21:08:53 +00:00
"attribute vec3 oc_Position;\n"
"attribute vec3 oc_Normal;\n"
"attribute vec2 oc_TexCoord;\n"
"varying vec3 vtxNormal;\n"
"varying vec2 texcoord;\n"
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
"uniform mat4 projectionMatrix;\n"
"uniform mat4 modelviewMatrix;\n"
"uniform mat3 normalMatrix;\n"
Load default object vertex shader from Graphics.ocg Instead of having the default vertex shader hard-coded into the engine, allow to load it from Graphics.ocg. There's still a fall-back version wired into the engine because we can't return an error from GetVertexShaderCodeForPass.
2015-02-26 20:04:12 +00:00
"\n"
"slice(position)\n"
"{\n"
Use generic vertex attributes for sprites, meshes, particles
2016-01-02 21:08:53 +00:00
" gl_Position = projectionMatrix * modelviewMatrix * vec4(oc_Position, 1.0);\n"
Load default object vertex shader from Graphics.ocg Instead of having the default vertex shader hard-coded into the engine, allow to load it from Graphics.ocg. There's still a fall-back version wired into the engine because we can't return an error from GetVertexShaderCodeForPass.
2015-02-26 20:04:12 +00:00
"}\n"
"\n"
"slice(texcoord)\n"
"{\n"
Use generic vertex attributes for sprites, meshes, particles
2016-01-02 21:08:53 +00:00
" texcoord = oc_TexCoord;\n"
Load default object vertex shader from Graphics.ocg Instead of having the default vertex shader hard-coded into the engine, allow to load it from Graphics.ocg. There's still a fall-back version wired into the engine because we can't return an error from GetVertexShaderCodeForPass.
2015-02-26 20:04:12 +00:00
"}\n"
"\n"
"slice(normal)\n"
"{\n"
Use generic vertex attributes for sprites, meshes, particles
2016-01-02 21:08:53 +00:00
" vtxNormal = normalize(normalMatrix * oc_Normal);\n"
Load default object vertex shader from Graphics.ocg Instead of having the default vertex shader hard-coded into the engine, allow to load it from Graphics.ocg. There's still a fall-back version wired into the engine because we can't return an error from GetVertexShaderCodeForPass.
2015-02-26 20:04:12 +00:00
"}\n"
);
}
Use 3x4 bones on low MAX_VTX_UNIFORM_COMPS (#1285) 4x3 matrices use the same number of uniform components as 4x4 ones. If we're short on uniform components, don't transpose the transformation matrix before sending it to the shader, and transpose it in the shader itself instead, saving 4 components per bone.
2015-03-18 20:11:19 +00:00
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (pGL->Workarounds.ForceSoftwareTransform)
Fix shader code memory lifetime problem I love StdBuf SO MUCH!
2016-06-27 10:40:35 +00:00
buf.Take(StdStrBuf("#define OC_WA_FORCE_SOFTWARE_TRANSFORM\n") + buf);
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
if (LowMaxVertexUniformCount)
Revert "revert workaround made for #1368, doesn't work on (certain) Intel chipsets. Instead, limit the maximum bone count to 64 so to meet the limit of 1024 uniform components by certain graphics cards (#1285)" This reverts commit f57bfa089c4e3c0924cf4f1f7ee9642337dca685. This was committed by mistake. Fixes #1375.
2015-09-04 00:38:53 +00:00
return StdStrBuf("#define OC_WA_LOW_MAX_VERTEX_UNIFORM_COMPONENTS\n") + buf;
else
return buf;
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
}
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// Note this only gets the code which inserts the slices specific for the pass
// -- other slices are independent from this!
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
StdStrBuf GetFragmentShaderCodeForPass(const StdMeshMaterialPass& pass, StdMeshMaterialShaderParameters& params)
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
{
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;
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
StdStrBuf textureUnitCode(""), textureUnitDeclCode("");
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
for(unsigned int i = 0; i < pass.TextureUnits.size(); ++i)
{
const StdMeshMaterialTextureUnit& texunit = pass.TextureUnits[i];
textureUnitCode.Append(TextureUnitToCode(texIndex, texunit));
if(texunit.HasTexture())
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
{
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
textureUnitDeclCode.Append(FormatString("uniform sampler2D oc_Texture%u;\n", texIndex).getData());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
params.AddParameter(FormatString("oc_Texture%u", texIndex).getData(), StdMeshMaterialShaderParameter::INT).GetInt() = texIndex;
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// 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;
}
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
++texIndex;
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
}
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
}
return FormatString(
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
"%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"
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
" vec4 diffuse = fragColor;\n"
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
" vec4 currentColor = diffuse;\n"
" %s\n"
Switch shader code to OpenGL 3 style
2016-01-08 02:35:14 +00:00
" fragColor = currentColor;\n"
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
"}\n"
"\n"
"slice(finish)\n"
"{\n"
" %s\n"
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
"}\n",
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
textureUnitDeclCode.getData(),
Move alpha test into the fragment shader
2015-12-20 01:03:38 +00:00
textureUnitCode.getData(),
AlphaTestToCode(pass).getData()
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
);
}
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]);
}
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
} // anonymous namespace
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
bool CStdGL::PrepareMaterial(StdMeshMatManager& mat_manager, StdMeshMaterialLoader& loader, StdMeshMaterial& mat)
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
// 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;
Replace obsolete GL_MAX_TEXTURE_UNITS (#1641) The replacement is GL_MAX_TEXTURE_IMAGE_UNITS.
2016-01-20 02:05:57 +00:00
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);
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
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))
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
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
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
} // loop over texture units
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// 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).
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
bool custom_shader = true;
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
if(!pass.VertexShader.Shader)
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
{
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
StdStrBuf buf = GetVertexShaderCodeForPass(pass, Workarounds.LowMaxVertexUniformCount);
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
StdStrBuf hash = GetSHA1HexDigest(buf.getData(), buf.getLength());
Meshes: Enable reload for custom material shaders
2016-04-02 20:54:54 +00:00
pass.VertexShader.Shader = mat_manager.AddShader("auto-generated vertex shader", hash.getData(), "glsl", SMMS_VERTEX, buf.getData(), StdMeshMatManager::SMM_AcceptExisting);
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
custom_shader = false;
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
}
Keep track of shaders in StdMeshMatManager This replaces the fragile ShaderRef construction in StdMeshMaterialPass, and it allows to re-use shaders and/or programs between different materials. This is some more preparatory work for custom shaders.
2014-10-07 16:38:08 +00:00
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
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());
Meshes: Enable reload for custom material shaders
2016-04-02 20:54:54 +00:00
pass.FragmentShader.Shader = mat_manager.AddShader("auto-generated fragment shader", hash.getData(), "glsl", SMMS_FRAGMENT, buf.getData(), StdMeshMatManager::SMM_AcceptExisting);
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
}
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// 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)
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
{
// 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());
Meshes: Enable reload for custom material shaders
2016-04-02 20:54:54 +00:00
pass.VertexShader.Shader = mat_manager.AddShader("auto-generated vertex shader", hash.getData(), "glsl", SMMS_VERTEX, buf.getData(), StdMeshMatManager::SMM_AcceptExisting);
Try to compile vertex shader before trying work-around (#1368) It looks like sometimes graphics drivers don't report the correct number for maximum uniforms, since the workaround was enabled even though Newton confirmed disabling the workaround worked just fine on his GPU. Therefore, don't listen to what the graphics driver is saying but just try to compile the shader, and fall back to the workaround if the compilation fails.
2015-10-03 18:45:54 +00:00
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)
Implement texture unit blending in material scripts with a shader This might make the rendering a bit quicker, since the whole texture environment setup that we do every frame is no longer required -- instead only the shader is bound and a few variables uploaded. However, this was not the main motivation behind this change. It also simplifies the code a bit. The texture environment setup is replaced by GLSL code generation. Another small benefit is that for texture units in material scripts that do not use an actual texture image no hardware TIU is being used. This reduces the number of hardware TIUs required for rendering the Clonk from 3 to 2. The main benefit of this change, however, is that material specific and clonk specific color variations can be applied correctly. This mainly concerns ClrModulation and MOD2 drawing. Before, the ClrModulation was mixed with the material color, which could lead to incorrect results depending on what the texture units were doing. Now it is being applied by the shader after all texture units in the material scripts have been processed. Another motivation of this change is to implement support for custom shaders, which is already foreseen by OGRE material scripts. The specification has only to be implemented. With this change in place, both custom shaders and "fixed" processing can share the same code in the engine, since both end up using a shader for the mesh rendering. The shader currently works only for directional lights, but should be easy to extend to also support point lights.
2013-02-03 15:26:01 +00:00
{
technique.Available = false;
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
}
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);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
}
if (technique.Available && mat.BestTechniqueIndex == -1)
mat.BestTechniqueIndex = i;
}
return mat.BestTechniqueIndex != -1;
}
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
// TODO: We should add a class, C4MeshRenderer, which contains all the functions
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
// in this namespace, and avoids passing around so many parameters.
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
namespace
{
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
// Apply Zoom and Transformation to the current matrix stack. Return
// parity of the transformation.
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
bool ApplyZoomAndTransform(float ZoomX, float ZoomY, float Zoom, C4BltTransform* pTransform, StdProjectionMatrix& projection)
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
{
// Apply zoom
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Translate(projection, ZoomX, ZoomY, 0.0f);
Scale(projection, Zoom, Zoom, 1.0f);
Translate(projection, -ZoomX, -ZoomY, 0.0f);
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
// Apply transformation
if (pTransform)
{
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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;
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
// Compute parity of the transformation matrix - if parity is swapped then
// we need to cull front faces instead of back faces.
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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);
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
return det > 0;
}
return true;
}
Illuminate materials with no backface culling from both sides This might need adaptions in some materials, but is probably the right thing to do.
2015-07-21 02:11:19 +00:00
void SetStandardUniforms(C4ShaderCall& call, DWORD dwModClr, DWORD dwPlayerColor, DWORD dwBlitMode, bool cullFace, const C4FoWRegion* pFoW, const C4Rect& clipRect, const C4Rect& outRect)
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
{
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// 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);
Shader gamma implementation In comparison to the old system, this is a downgrade - instead of being able to set a full color mapping by gamma ramp, we now get just a value per colour channel. Upside is that we do not need to play around with the global gamma ramps any more, which was arguably the wrong way to do it. This commit will likely break everything that has been using gamma so far.
2015-08-31 15:34:01 +00:00
call.SetUniform3fv(C4SSU_Gamma, 1, pDraw->gammaOut);
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// 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);
Illuminate materials with no backface culling from both sides This might need adaptions in some materials, but is probably the right thing to do.
2015-07-21 02:11:19 +00:00
// Backface culling flag
call.SetUniform1f(C4SSU_CullMode, cullFace ? 0.0f : 1.0f);
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// Dynamic light
if(pFoW != NULL)
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
{
Don't enable textures in C4ShaderCall::AllocTexUnit This was only necessary with the fixed function pipeline, but not when using shaders.
2015-09-17 00:52:34 +00:00
call.AllocTexUnit(C4SSU_LightTex);
C4FoWRegion: Make more private Code outside of C4FoWRegion should not care about the internals of the class. Therefore, we remove direct access to the backing surface (and secondary buffer surface) and replace it instead with accessors that return those few values that are required by outside code.
2015-12-28 18:29:13 +00:00
glBindTexture(GL_TEXTURE_2D, pFoW->getSurfaceName());
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
float lightTransform[6];
Fix fragment coordinate transforms (#1192) There were two problems with the previous transforms: 1) For inverting the Y axis for the ambient map, the total height of the output window is needed, not only the viewport region. 2) The Y offset to only use the part of the light texture that is being rendered to was not applied. In order to keep the transformations more readable, a new lightweight class C4FragTransform has been introduced which can only handle translations and scales in x and y.
2014-12-26 15:16:09 +00:00
pFoW->GetFragTransform(clipRect, outRect, lightTransform);
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniformMatrix2x3fv(C4SSU_LightTransform, 1, lightTransform);
Apply ClrModMap to meshes pixel-by-pixel The support is not yet fully implemented; there are some transformations missing. However, since the FoW support at the moment seems to be broken (#1168) this feature cannot be tested properly.
2014-10-21 21:26:22 +00:00
Don't enable textures in C4ShaderCall::AllocTexUnit This was only necessary with the fixed function pipeline, but not when using shaders.
2015-09-17 00:52:34 +00:00
call.AllocTexUnit(C4SSU_AmbientTex);
Add ambient lighting This introduces a new texture, an ambient light map, that is generated automatically at the beginning of the round by the sky portion of the landscape. This basically makes everything that is close to sky visible by default. The shaders have been adapted so that they deploy direction-independent lighting for the ambient component, and the current (diffuse) behaviour for the diffuse component. This makes the shaders use an additional texture unit that represents the ambient light. We can think about merging this information into the light texture, but the coordinate systems are different at the moment, so this could be performed at the stage of light texture generation. For meshes, the ambient material is not actually used, but instead a diffuse light from the front is used. This makes many meshes look more interesting, maybe also because the ambient material setting of most meshes are not set correctly at the moment.
2014-11-17 14:35:50 +00:00
glBindTexture(GL_TEXTURE_2D, pFoW->getFoW()->Ambient.Tex);
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniform1f(C4SSU_AmbientBrightness, pFoW->getFoW()->Ambient.GetBrightness());
float ambientTransform[6];
Allow independent viewport and light regions in C4FoWRegion (#1211) With this change, an additional rectangle is stored in C4FoWRegion that represents the area covered by the viewport in fractional floating point coordinates. This allows the light texture to be created for an arbitrary portion of the landscape, and the coordinate transformations for the shaders will still work. Also, since the additional rectangle uses floating point precision, the computed coordinate transformations do now give the exact same result as for the landscape pixel-by-pixel, and there should not be any offsets left. I also hope that this change improves or fixes the single-pixel-lines of sky that are sometimes seen at the edges of the viewport.
2015-01-07 16:29:48 +00:00
pFoW->getFoW()->Ambient.GetFragTransform(pFoW->getViewportRegion(), clipRect, outRect, ambientTransform);
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniformMatrix2x3fv(C4SSU_AmbientTransform, 1, ambientTransform);
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
}
GL: Add "frameCounter" uniform Add the current frame counter as a uniform variable to the shaders, so people can use it to do time-based animation.
2016-03-30 23:44:44 +00:00
// Current frame counter
call.SetUniform1i(C4SSU_FrameCounter, ::Game.FrameCounter);
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
}
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
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;
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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;
}
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
struct BoneTransform
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
float m[3][4];
};
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
std::vector<BoneTransform> CookBoneTransforms(const StdMeshInstance& mesh_instance)
{
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
// 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.
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
std::vector<BoneTransform> bones;
Upload dummy bone for boneless meshes (#1278) As long as we're not actually using a different shader for meshes without bones, we need to upload an identity matrix so there's defined data in the bone slot.
2015-03-05 12:09:40 +00:00
if (mesh_instance.GetBoneCount() == 0)
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
{
Upload dummy bone for boneless meshes (#1278) As long as we're not actually using a different shader for meshes without bones, we need to upload an identity matrix so there's defined data in the bone slot.
2015-03-05 12:09:40 +00:00
// 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,
Revert "revert workaround made for #1368, doesn't work on (certain) Intel chipsets. Instead, limit the maximum bone count to 64 so to meet the limit of 1024 uniform components by certain graphics cards (#1285)" This reverts commit f57bfa089c4e3c0924cf4f1f7ee9642337dca685. This was committed by mistake. Fixes #1375.
2015-09-04 00:38:53 +00:00
0.0f, 0.0f, 1.0f, 0.0f
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
};
Upload dummy bone for boneless meshes (#1278) As long as we're not actually using a different shader for meshes without bones, we need to upload an identity matrix so there's defined data in the bone slot.
2015-03-05 12:09:40 +00:00
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),
Revert "revert workaround made for #1368, doesn't work on (certain) Intel chipsets. Instead, limit the maximum bone count to 64 so to meet the limit of 1024 uniform components by certain graphics cards (#1285)" This reverts commit f57bfa089c4e3c0924cf4f1f7ee9642337dca685. This was committed by mistake. Fixes #1375.
2015-09-04 00:38:53 +00:00
bone(2, 0), bone(2, 1), bone(2, 2), bone(2, 3)
Upload dummy bone for boneless meshes (#1278) As long as we're not actually using a different shader for meshes without bones, we need to upload an identity matrix so there's defined data in the bone slot.
2015-03-05 12:09:40 +00:00
};
bones.push_back(cooked_bone);
}
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
}
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
return bones;
}
struct PretransformedMeshVertex
{
float nx, ny, nz;
float x, y, z;
};
void PretransformMeshVertex(PretransformedMeshVertex *out, const StdMeshVertex &in, const StdMeshInstance &mesh_instance)
{
// If the first bone assignment has a weight of 0, all others are zero
// as well, or the loader would have overwritten the assignment
GL Legacy: Survive skinning meshes with no bones
2016-06-26 23:05:18 +00:00
if (in.bone_weight[0] == 0.0f || mesh_instance.GetBoneCount() == 0)
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
{
out->x = in.x;
out->y = in.y;
out->z = in.z;
out->nx = in.nx;
out->ny = in.ny;
out->nz = in.nz;
}
else
{
PretransformedMeshVertex vtx{ 0, 0, 0, 0, 0, 0 };
for (int i = 0; i < StdMeshVertex::MaxBoneWeightCount && in.bone_weight[i] > 0; ++i)
{
float weight = in.bone_weight[i];
const auto &bone = mesh_instance.GetBoneTransform(in.bone_index[i]);
auto vertex = weight * (bone * in);
vtx.nx += vertex.nx;
vtx.ny += vertex.ny;
vtx.nz += vertex.nz;
vtx.x += vertex.x;
vtx.y += vertex.y;
vtx.z += vertex.z;
}
*out = vtx;
}
}
void PretransformMeshVertices(const StdMeshInstance &mesh_instance, const StdSubMeshInstance& instance, GLuint vbo)
{
assert(pGL->Workarounds.ForceSoftwareTransform);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
const auto &original_vertices = mesh_instance.GetSharedVertices().empty() ? instance.GetSubMesh().GetVertices() : mesh_instance.GetSharedVertices();
const size_t vertex_count = original_vertices.size();
// Unmapping the buffer may fail for certain reasons, in which case we need to try again.
do
{
glBufferData(GL_ARRAY_BUFFER, vertex_count * sizeof(PretransformedMeshVertex), NULL, GL_STREAM_DRAW);
void *map = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
PretransformedMeshVertex *buffer = new (map) PretransformedMeshVertex[vertex_count];
for (size_t i = 0; i < vertex_count; ++i)
{
PretransformMeshVertex(&buffer[i], original_vertices[i], mesh_instance);
}
} while (glUnmapBuffer(GL_ARRAY_BUFFER) == GL_FALSE);
// Unbind the buffer so following rendering calls do not use it
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
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)
{
// Don't render with degenerate matrix
if (fabs(modelviewMatrix.Determinant()) < 1e-6)
return;
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
const bool ForceSoftwareTransform = pGL->Workarounds.ForceSoftwareTransform;
GLuint pretransform_vbo;
std::vector<BoneTransform> bones;
if (!ForceSoftwareTransform)
{
bones = CookBoneTransforms(mesh_instance);
}
else
{
glGenBuffers(1, &pretransform_vbo);
PretransformMeshVertices(mesh_instance, instance, pretransform_vbo);
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Modelview matrix does not change between passes, so cache it here
const StdMeshMatrix normalMatrixTranspose = StdMeshMatrix::Inverse(modelviewMatrix);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// Render each pass
for (unsigned int i = 0; i < technique.Passes.size(); ++i)
{
const StdMeshMaterialPass& pass = technique.Passes[i];
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (!pass.DepthCheck)
Implement depth_check for material scripts
2013-03-31 14:59:17 +00:00
glDisable(GL_DEPTH_TEST);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
glDepthMask(pass.DepthWrite ? GL_TRUE : GL_FALSE);
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (pass.AlphaToCoverage)
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
else
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
glFrontFace(parity ? GL_CW : GL_CCW);
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (mesh_instance.GetCompletion() < 1.0f)
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
// 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
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (!(dwBlitMode & C4GFXBLIT_ADDITIVE))
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (((dwModClr >> 24) & 0xff) < 0xff) // && (!(dwBlitMode & C4GFXBLIT_MOD2)) )
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
else
glBlendFunc(OgreBlendTypeToGL(pass.SceneBlendFactors[0]),
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
OgreBlendTypeToGL(pass.SceneBlendFactors[1]));
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
else
{
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (((dwModClr >> 24) & 0xff) < 0xff) // && (!(dwBlitMode & C4GFXBLIT_MOD2)) )
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else
glBlendFunc(OgreBlendTypeToGL(pass.SceneBlendFactors[0]), GL_ONE);
}
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
assert(pass.Program.get() != NULL);
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Upload all parameters to the shader
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
int ssc = 0;
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (dwBlitMode & C4GFXBLIT_MOD2) ssc |= C4SSC_MOD2;
if (pFoW != NULL) ssc |= C4SSC_LIGHT;
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
const C4Shader* shader = pass.Program->Program->GetShader(ssc);
Shader gamma implementation In comparison to the old system, this is a downgrade - instead of being able to set a full color mapping by gamma ramp, we now get just a value per colour channel. Upside is that we do not need to play around with the global gamma ramps any more, which was arguably the wrong way to do it. This commit will likely break everything that has been using gamma so far.
2015-08-31 15:34:01 +00:00
if (!shader) return;
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
C4ShaderCall call(shader);
call.Start();
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Upload projection, modelview and normal matrices
call.SetUniformMatrix4x4(C4SSU_ProjectionMatrix, projectionMatrix);
call.SetUniformMatrix4x4(C4SSU_ModelViewMatrix, modelviewMatrix);
call.SetUniformMatrix3x3Transpose(C4SSU_NormalMatrix, normalMatrixTranspose);
Make the mesh material properties uniform variables Instead of relying on the obsolete glMaterial call.
2016-01-05 04:25:26 +00:00
// 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);
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
// Upload the current bone transformation matrixes (if there are any)
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (!ForceSoftwareTransform)
Illuminate materials with no backface culling from both sides This might need adaptions in some materials, but is probably the right thing to do.
2015-07-21 02:11:19 +00:00
{
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
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]);
}
Illuminate materials with no backface culling from both sides This might need adaptions in some materials, but is probably the right thing to do.
2015-07-21 02:11:19 +00:00
}
Use 3x4 bones on low MAX_VTX_UNIFORM_COMPS (#1285) 4x3 matrices use the same number of uniform components as 4x4 ones. If we're short on uniform components, don't transpose the transformation matrix before sending it to the shader, and transpose it in the shader itself instead, saving 4 components per bone.
2015-03-18 20:11:19 +00:00
For each VBO, use a VAO to render it For OpenGL 3.2 core compatibility, and to reduce the number of state changes during rendering.
2016-01-04 00:45:23 +00:00
GLuint vao;
const bool has_vao = pGL->GetVAO(vaoid, vao);
glBindVertexArray(vao);
if (!has_vao)
{
Use an element array buffer (IBO) for meshes This is required for glDrawElements() with a core profile. Furthermore, for meshes that have a fixed face ordering (non-transparent meshes at 100% completion), this puts more static data on the GPU that we don't have to upload every frame. For meshes with non-fixed face ordering, we still have to upload faces every frame, since the ordering might change if the mesh rotates. We could still improve this by figuring out if the order actually changed after the sort step, and only update to the GPU if it has. In many cases it hasn't, so there is some potential for more optimization there. But that's for later.
2016-01-15 02:32:27 +00:00
// Bind the vertex data of the mesh
Fix mesh rendering for meshes with more than one submesh The buffer offset was encoded in the VAO which would be shared across all submeshes. Instead, don't encode the buffer offset into the VAO but apply it with glDrawElementsBaseVertex().
2016-01-17 19:34:14 +00:00
// 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.
Use an element array buffer (IBO) for meshes This is required for glDrawElements() with a core profile. Furthermore, for meshes that have a fixed face ordering (non-transparent meshes at 100% completion), this puts more static data on the GPU that we don't have to upload every frame. For meshes with non-fixed face ordering, we still have to upload faces every frame, since the ordering might change if the mesh rotates. We could still improve this by figuring out if the order actually changed after the sort step, and only update to the GPU if it has. In many cases it hasn't, so there is some potential for more optimization there. But that's for later.
2016-01-15 02:32:27 +00:00
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
For each VBO, use a VAO to render it For OpenGL 3.2 core compatibility, and to reduce the number of state changes during rendering.
2016-01-04 00:45:23 +00:00
#define VERTEX_OFFSET(field) reinterpret_cast<const uint8_t *>(offsetof(StdMeshVertex, field))
if (shader->GetAttribute(C4SSA_TexCoord) != -1)
Fix mesh rendering for meshes with more than one submesh The buffer offset was encoded in the VAO which would be shared across all submeshes. Instead, don't encode the buffer offset into the VAO but apply it with glDrawElementsBaseVertex().
2016-01-17 19:34:14 +00:00
glVertexAttribPointer(shader->GetAttribute(C4SSA_TexCoord), 2, GL_FLOAT, GL_FALSE, sizeof(StdMeshVertex), VERTEX_OFFSET(u));
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (!ForceSoftwareTransform)
{
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));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_Position));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_Normal));
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_BoneWeights0));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneWeights1));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneIndices0));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_BoneIndices1));
}
For each VBO, use a VAO to render it For OpenGL 3.2 core compatibility, and to reduce the number of state changes during rendering.
2016-01-04 00:45:23 +00:00
if (shader->GetAttribute(C4SSA_TexCoord) != -1)
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_TexCoord));
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
#undef VERTEX_OFFSET
}
if (ForceSoftwareTransform)
{
glBindBuffer(GL_ARRAY_BUFFER, pretransform_vbo);
#define VERTEX_OFFSET(field) reinterpret_cast<const uint8_t *>(offsetof(PretransformedMeshVertex, field))
glVertexAttribPointer(shader->GetAttribute(C4SSA_Position), 3, GL_FLOAT, GL_FALSE, sizeof(PretransformedMeshVertex), VERTEX_OFFSET(x));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_Position));
glVertexAttribPointer(shader->GetAttribute(C4SSA_Normal), 3, GL_FLOAT, GL_FALSE, sizeof(PretransformedMeshVertex), VERTEX_OFFSET(nx));
glEnableVertexAttribArray(shader->GetAttribute(C4SSA_Normal));
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
#undef VERTEX_OFFSET
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
glBindBuffer(GL_ARRAY_BUFFER, 0);
For each VBO, use a VAO to render it For OpenGL 3.2 core compatibility, and to reduce the number of state changes during rendering.
2016-01-04 00:45:23 +00:00
}
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Bind textures
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
for (unsigned int j = 0; j < pass.TextureUnits.size(); ++j)
{
const StdMeshMaterialTextureUnit& texunit = pass.TextureUnits[j];
if (texunit.HasTexture())
{
Don't enable textures in C4ShaderCall::AllocTexUnit This was only necessary with the fixed function pipeline, but not when using shaders.
2015-09-17 00:52:34 +00:00
call.AllocTexUnit(-1);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
const unsigned int Phase = instance.GetTexturePhase(i, j);
glBindTexture(GL_TEXTURE_2D, texunit.GetTexture(Phase).texName);
}
}
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
// Set uniforms and instance parameters
Illuminate materials with no backface culling from both sides This might need adaptions in some materials, but is probably the right thing to do.
2015-07-21 02:11:19 +00:00
SetStandardUniforms(call, dwModClr, dwPlayerColor, dwBlitMode, pass.CullHardware != StdMeshMaterialPass::CH_None, pFoW, clipRect, outRect);
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
for(unsigned int j = 0; j < pass.Program->Parameters.size(); ++j)
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
{
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
const int uniform = pass.Program->Parameters[j].UniformIndex;
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
if(!shader->HaveUniform(uniform)) continue; // optimized out
Avoid setting oc_ClrModMap shader parameter when clrmodmap is not used Otherwise, ResolveAutoParameter() does not set the correct parameter type, and the code would try to set a sampler2D parameter as a float4. It does not matter in principle since the shader would not use the texture anyway, but it generates a GL error that is avoid this way.
2014-11-03 19:39:17 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
const StdMeshMaterialShaderParameter* parameter = pass.Program->Parameters[j].Parameter;
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
StdMeshMaterialShaderParameter auto_resolved;
if(parameter->GetType() == StdMeshMaterialShaderParameter::AUTO)
{
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
if(!ResolveAutoParameter(call, auto_resolved, parameter->GetAuto(), dwModClr, dwPlayerColor, dwBlitMode, pFoW, clipRect))
Avoid setting oc_ClrModMap shader parameter when clrmodmap is not used Otherwise, ResolveAutoParameter() does not set the correct parameter type, and the code would try to set a sampler2D parameter as a float4. It does not matter in principle since the shader would not use the texture anyway, but it generates a GL error that is avoid this way.
2014-11-03 19:39:17 +00:00
continue;
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
parameter = &auto_resolved;
}
switch(parameter->GetType())
{
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
case StdMeshMaterialShaderParameter::AUTO_TEXTURE_MATRIX:
call.SetUniformMatrix4x4(uniform, ResolveAutoTextureMatrix(instance, technique, i, parameter->GetInt()));
break;
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
case StdMeshMaterialShaderParameter::INT:
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniform1i(uniform, parameter->GetInt());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
break;
case StdMeshMaterialShaderParameter::FLOAT:
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniform1f(uniform, parameter->GetFloat());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
break;
case StdMeshMaterialShaderParameter::FLOAT2:
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniform2fv(uniform, 1, parameter->GetFloatv());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
break;
case StdMeshMaterialShaderParameter::FLOAT3:
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniform3fv(uniform, 1, parameter->GetFloatv());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
break;
case StdMeshMaterialShaderParameter::FLOAT4:
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniform4fv(uniform, 1, parameter->GetFloatv());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
break;
case StdMeshMaterialShaderParameter::MATRIX_4X4:
Make mesh shaders use the C4Shader slice machinery
2014-12-22 16:15:46 +00:00
call.SetUniformMatrix4x4fv(uniform, 1, parameter->GetMatrix());
Add support for custom shaders in mesh material scripts
2014-10-21 19:12:09 +00:00
break;
default:
assert(false);
break;
}
}
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
size_t vertex_count = 3 * instance.GetNumFaces();
Fix mesh rendering for meshes with more than one submesh The buffer offset was encoded in the VAO which would be shared across all submeshes. Instead, don't encode the buffer offset into the VAO but apply it with glDrawElementsBaseVertex().
2016-01-17 19:34:14 +00:00
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);
For each VBO, use a VAO to render it For OpenGL 3.2 core compatibility, and to reduce the number of state changes during rendering.
2016-01-04 00:45:23 +00:00
glBindVertexArray(0);
Do skinning in hardware Instead of transforming all vertices on the CPU every time an animation progresses, we now only recalculate the skeleton, leaving the heavy lifting for the GPU. This also means we no longer have to push all vertices onto the bus every frame, because the mesh isn't changing and can therefore be stored in a GL_STATIC_DRAW VBO when it's first loaded. The downside of this approach is that there's only a limited number of uniforms and vertex attributes we can pass to the shader. At the moment these limits are a maximum of 128 bones per skeleton, and no vertex can be influenced by more than 8 bones at once. So far this is no problem, as the most complex skeleton in the base game uses less than 64 bones and no more than 6 bone weights per vertex.
2015-02-27 20:24:29 +00:00
call.Finish();
Implement depth_check for material scripts
2013-03-31 14:59:17 +00:00
if(!pass.DepthCheck)
glEnable(GL_DEPTH_TEST);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
GL: Disable hardware-based skinning on old Intel devices Our hardware-based skinning doesn't work on certain Intel graphics devices. Fall back to software skinning on GPUs that return an OpenGL 3.1 context even though we explicitly request a 3.2 one. Might fix #1459, #1689.
2016-06-19 11:45:12 +00:00
if (ForceSoftwareTransform)
glDeleteBuffers(1, &pretransform_vbo);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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)
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
const StdMeshMatrix& FinalTrans = attach->GetFinalTransformation();
Make attached meshes use their own blit parameters (#1095) This might break some scenarios which for example change the color modulation of a clonk and then expect that also its shovel or other objects get colored. Such scenarios need to be fixed by also coloring the attached objects. This might not be very convenient, and maybe we should introduce an option for attached meshes to use the old behaviour (take blit parameters from main object). However, let's see how this change turns out in practise and then we see whether further modifications are needed.
2014-10-16 15:46:44 +00:00
// 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;
}
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// TODO: Take attach transform's parity into account
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
StdMeshMatrix newModelviewMatrix = modelviewMatrix * FinalTrans;
RenderMeshImpl(projectionMatrix, newModelviewMatrix, *attach->Child, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
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)
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
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)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
RenderAttachedMesh(projectionMatrix, modelviewMatrix, *attach_iter, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// 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)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
RenderSubMeshImpl(projectionMatrix, modelviewMatrix, instance, instance.GetSubMeshOrdered(i), dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// reset old mode to prevent rendering errors
if(dwBlitMode & C4GFXBLIT_WIREFRAME)
Fix GL state reset of wireframe mode (#1636) Not sure why this broke, maybe glGetIntegerv does not return the current polygon mode anymore. Either way, we don't need to remember the previous setting but can just always reset it to GL_FILL afterwards.
2016-01-18 05:32:48 +00:00
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// Render non-AM_DrawBefore attached meshes
for (; attach_iter != instance.AttachedMeshesEnd(); ++attach_iter)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
RenderAttachedMesh(projectionMatrix, modelviewMatrix, *attach_iter, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
}
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);
Fix assertion failure when rendering mesh with degenerate transform (#1519) The DynamiteBox sets the PictureTransformation to a degenerate matrix, to prevent it from being rendered. Exit early in this case, since we are not going to render anything anyway, and avoid the assertion when inverting the matrix.
2016-01-01 19:34:04 +00:00
// 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;
}
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
const StdMesh& mesh = instance.GetMesh();
Transform all mesh data to Clonk reference frame on load Instead of doing the transformation when drawing a mesh. This allows making the OpenGL normal matrix more consistent, since it does not include the Ogre-To-Clonk transformation, and so that the transformation does not need to be inverted in the shader. As a side effect, all Attach transformations were updated, since before they were specified in the OGRE reference frame, not the Clonk reference frame.
2015-08-05 03:16:36 +00:00
bool parity = false;
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// 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;
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// 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;
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
if (!fUsePerspective)
{
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Load the orthographic projection
projectionMatrix = ProjectionMatrix;
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
if (!ApplyZoomAndTransform(ZoomX, ZoomY, Zoom, pTransform, projectionMatrix))
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
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());
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Translate(projectionMatrix, dx, dy, 0.0f);
Scale(projectionMatrix, 1.0f, 1.0f, scz);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
else
{
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Perspective projection. This code transforms the projected
// 3D model into the target area.
const C4Rect clipRect = GetClipRect();
projectionMatrix = StdProjectionMatrix::Identity();
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// Back to GL device coordinates
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Translate(projectionMatrix, -1.0f, 1.0f, 0.0f);
Scale(projectionMatrix, 2.0f/clipRect.Wdt, -2.0f/clipRect.Hgt, 1.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Translate(projectionMatrix, -clipRect.x, -clipRect.y, 0.0f);
if (!ApplyZoomAndTransform(ZoomX, ZoomY, Zoom, pTransform, projectionMatrix))
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
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;
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Translate(projectionMatrix, ttx, tty, 0.0f);
Scale(projectionMatrix, ((float)ttwdt)/clipRect.Wdt, ((float)tthgt)/clipRect.Hgt, 1.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// Return to Clonk coordinate frame
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Scale(projectionMatrix, clipRect.Wdt/2.0, -clipRect.Hgt/2.0, 1.0f);
Translate(projectionMatrix, 1.0f, -1.0f, 0.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Fix for the case when we have different aspect ratios
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
const float ta = twdt / thgt;
const float ma = b / h;
if(ta <= 1 && ta/ma <= 1)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Scale(projectionMatrix, std::max(ta, ta/ma), std::max(ta, ta/ma), 1.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
else if(ta >= 1 && ta/ma >= 1)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
Scale(projectionMatrix, std::max(1.0f/ta, ma/ta), std::max(1.0f/ta, ma/ta), 1.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// 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.
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Aspect is 1.0f which is changed above as well.
Perspective(projectionMatrix, 1.0f/TAN_FOV, 1.0f, 0.1f, 100.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
// Now set up the modelview matrix
StdMeshMatrix modelviewMatrix;
Remove fixed-function lighting for meshes The light direction is now taken from the light texture, so the only thing that is still needed is the material definitions.
2014-11-07 17:08:06 +00:00
if (fUsePerspective)
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
{
// 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);
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
const StdMeshVector Eye = StdMeshVector::Translate(MeshCenter.x, MeshCenter.y, MeshCenter.z + EyeR);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// Up vector is unit vector in theta direction
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
const StdMeshVector Up = StdMeshVector::Translate(0.0f, -1.0f, 0.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// Fix X axis (???)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
modelviewMatrix = StdMeshMatrix::Scale(-1.0f, 1.0f, 1.0f);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
// center on mesh's bounding box, so that the mesh is really in the center of the viewport
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
modelviewMatrix *= StdMeshMatrix::LookAt(Eye, MeshCenter, Up);
}
else
{
modelviewMatrix = StdMeshMatrix::Identity();
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
// Apply mesh transformation matrix
if (MeshTransform)
{
// Apply MeshTransformation (in the Mesh's coordinate system)
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
modelviewMatrix *= *MeshTransform;
Fix assertion failure when rendering mesh with degenerate transform (#1519) The DynamiteBox sets the PictureTransformation to a degenerate matrix, to prevent it from being rendered. Exit early in this case, since we are not going to render anything anyway, and avoid the assertion when inverting the matrix.
2016-01-01 19:34:04 +00:00
// Keep track of parity
if (mesh_transform_parity) parity = !parity;
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
}
DWORD dwModClr = BlitModulated ? BlitModulateClr : 0xffffffff;
Fix fragment coordinate transforms (#1192) There were two problems with the previous transforms: 1) For inverting the Y axis for the ambient map, the total height of the output window is needed, not only the viewport region. 2) The Y offset to only use the part of the light texture that is being rendered to was not applied. In order to keep the transformations more readable, a new lightweight class C4FragTransform has been introduced which can only handle translations and scales in x and y.
2014-12-26 15:16:09 +00:00
const C4Rect clipRect = GetClipRect();
const C4Rect outRect = GetOutRect();
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Avoid built-in GL matrices for mesh rendering Instead, compute the projection, modelview and normal matrices explictly and upload them as shader uniforms.
2015-12-25 06:47:51 +00:00
RenderMeshImpl(projectionMatrix, modelviewMatrix, instance, dwModClr, dwBlitMode, dwPlayerColor, pFoW, clipRect, outRect, parity);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
Use generic vertex attributes for sprites, meshes, particles
2016-01-02 21:08:53 +00:00
// Reset state
//glActiveTexture(GL_TEXTURE0);
Split the mesh drawing into C4DrawMeshGL.cpp
2013-01-27 22:52:16 +00:00
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);
}
Remove remains of Direct3D support Direct3D hasn't worked for more than a year now, and there don't seem to be any efforts to revive it. Remove it and concentrate on better OpenGL support.
2013-10-29 13:27:18 +00:00
#endif // USE_CONSOLE