Xargon/Supermodel
1
0
Fork 0
mirror of https://github.com/RetroDECK/Supermodel.git synced 2024-11-28 00:25:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Supermodel/Src/Graphics/New3D/R3DShader.h

135 lines
3.1 KiB
C
Raw Normal View History

Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
#ifndef _R3DSHADER_H_
#define _R3DSHADER_H_
Update glew version
2020-07-31 19:18:51 +00:00
#include <GL/glew.h>
Added support for loading shaders from files for new engine and tile renderer. Changed help text to reflect new engine being default.
2017-08-11 00:41:10 +00:00
#include "Util/NewConfig.h"
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
#include "Model.h"
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
#include <map>
Composite the alpha layers at the end of rendering. To do this we need to mask the alpha pixels with the opaque pixels from the next priority layer. Fixes some overlapping shadows in vf3tb that have different priority layers. I assume that was a game bug, but it works on the real h/w.
2019-01-21 14:30:42 +00:00
#include <string>
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
namespace New3D {
class R3DShader
{
public:
Added support for loading shaders from files for new engine and tile renderer. Changed help text to reflect new engine being default.
2017-08-11 00:41:10 +00:00
R3DShader(const Util::Config::Node &config);
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
Fix attribute locations. glBindAttribLocation must be called linking
2017-08-11 11:59:41 +00:00
bool LoadShader (const char* vertexShader = nullptr, const char* fragmentShader = nullptr);
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
void UnloadShader ();
Fix attribute locations. glBindAttribLocation must be called linking
2017-08-11 11:59:41 +00:00
void SetMeshUniforms (const Mesh* m);
void SetModelStates (const Model* model);
void SetViewportUniforms (const Viewport *vp);
void Start ();
void SetShader (bool enable = true);
Composite the alpha layers at the end of rendering. To do this we need to mask the alpha pixels with the opaque pixels from the next priority layer. Fixes some overlapping shadows in vf3tb that have different priority layers. I assume that was a game bug, but it works on the real h/w.
2019-01-21 14:30:42 +00:00
GLint GetVertexAttribPos (const std::string& attrib);
Render the opaque part of texture transparency in the first pass. Fixes numerous transparency related issues in lemans24 and some in ocean hunter. I don't really know if this is the 'correct' way of solving this because the real3d pro-1000 is a complete black box. There is still a lot we don't understand about how it handles transparency.
2018-05-02 20:10:02 +00:00
void DiscardAlpha (bool discard); // use to remove alpha from texture alpha only polys for 1st pass
Rewrite the renderer a bit to spit out the finished graphics from the 3d chip on separate buffers. One buffer is for opaque pixels, and 2 more for translucent pixels. Before the frame was composited on the back buffer, which meant the tilegen had to have been drawn first. This way the images are now totally independant of the tilegen chip so can be drawn as soon as the register write 0xC is written to the tilegen. Some games update the tilegen after the ping_ping bit has flipped at 66% of the frame, so we need to split the tilegen drawing up into two stages to get some effects to work. So having the tilegen draw independantly of the 3d chip can make this happen.
2023-10-14 19:05:00 +00:00
void SetLayer (Layer layer);
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
private:
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
void PrintShaderResult(GLuint shader);
void PrintProgramResult(GLuint program);
Added support for loading shaders from files for new engine and tile renderer. Changed help text to reflect new engine being default.
2017-08-11 00:41:10 +00:00
// run-time config
const Util::Config::Node &m_config;
finish front/back face culling code based on matrix determinant. Optimised opengl to avoid redundant state changes.
2016-03-22 23:39:59 +00:00
// shader IDs
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
GLuint m_shaderProgram;
GLuint m_vertexShader;
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
GLuint m_geoShader;
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
GLuint m_fragmentShader;
finish front/back face culling code based on matrix determinant. Optimised opengl to avoid redundant state changes.
2016-03-22 23:39:59 +00:00
// mesh uniform locations
Performance improvements The old texture code was being bottle necked by the texture reads. We mirrored the real3d texture memory directly, including the mipmaps in a single large texture. I *think* most h/w has some sort of texture cache for a 2x2 or 4x4 block of pixels for a texture. What we were doing was reading the base texture, then reading the mipmap data from a totally separate part of the same texture which I can only assume flushed this cache. What I did was to create mipmap chains for the texture sheet, then copy the mipmap data there. Doing this basically doubles performance.
2024-06-13 12:36:30 +00:00
GLint m_locTextureBank[2]; // 2 banks
GLint m_locTexture1Enabled; // base texture
GLint m_locTexture2Enabled; // micro texture
GLint m_locTexturePage;
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
GLint m_locTextureAlpha;
GLint m_locAlphaTest;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
GLint m_locMicroTexScale;
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
GLint m_locMicroTexID;
GLint m_locBaseTexInfo;
GLint m_locBaseTexType;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
GLint m_locTextureInverted;
Correctly emulate the real3d pro-1000 texture modes in our shader.
2018-10-13 13:29:45 +00:00
GLint m_locTexWrapMode;
The translator map seems to work with paletted colour values too, and the result is not clamped. Colours are passed to the GPU as unsigned bytes to multiplying by 16 will overflow, so we do the logic in the shader. If we passed floats we could skip the shader logic.
2020-05-11 09:05:46 +00:00
GLint m_locTranslatorMap;
Rewrite the renderer a bit to spit out the finished graphics from the 3d chip on separate buffers. One buffer is for opaque pixels, and 2 more for translucent pixels. Before the frame was composited on the back buffer, which meant the tilegen had to have been drawn first. This way the images are now totally independant of the tilegen chip so can be drawn as soon as the register write 0xC is written to the tilegen. Some games update the tilegen after the ping_ping bit has flipped at 66% of the frame, so we need to split the tilegen drawing up into two stages to get some effects to work. So having the tilegen draw independantly of the 3d chip can make this happen.
2023-10-14 19:05:00 +00:00
GLint m_locColourLayer;
Added new uniform bool polyAlpha to shaders Added original matrix functions back into Mat4 class though they are currently unused
2023-12-22 16:31:05 +00:00
GLint m_locPolyAlpha;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
// cached mesh values
bool m_textured1;
preliminary microtexture
2016-05-04 00:35:07 +00:00
bool m_textured2;
finish front/back face culling code based on matrix determinant. Optimised opengl to avoid redundant state changes.
2016-03-22 23:39:59 +00:00
bool m_textureAlpha; // use alpha in texture
bool m_alphaTest; // discard fragment based on alpha (ogl does this with fixed function)
float m_fogIntensity;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
bool m_lightEnabled;
float m_shininess;
float m_specularValue;
bool m_specularEnabled;
Fixed shading (per vertex poly colours) on step 1.5 hardware have the viewport ambient value added to them. This fixes various shading on scud. To do this had to switch the maths to the vertex shader.
2017-08-14 09:14:06 +00:00
bool m_fixedShading;
The translator map seems to work with paletted colour values too, and the result is not clamped. Colours are passed to the GPU as unsigned bytes to multiplying by 16 will overflow, so we do the logic in the shader. If we passed floats we could skip the shader logic.
2020-05-11 09:05:46 +00:00
bool m_translatorMap;
Added new uniform bool polyAlpha to shaders Added original matrix functions back into Mat4 class though they are currently unused
2023-12-22 16:31:05 +00:00
bool m_polyAlpha;
Performance improvements The old texture code was being bottle necked by the texture reads. We mirrored the real3d texture memory directly, including the mipmaps in a single large texture. I *think* most h/w has some sort of texture cache for a 2x2 or 4x4 block of pixels for a texture. What we were doing was reading the base texture, then reading the mipmap data from a totally separate part of the same texture which I can only assume flushed this cache. What I did was to create mipmap chains for the texture sheet, then copy the mipmap data there. Doing this basically doubles performance.
2024-06-13 12:36:30 +00:00
int m_texturePage;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
bool m_layered;
Fix the line of sight function. Polygons have a line of sight value that's either a 0 or 1. We write this value into the stencil buffer, then read the app can read it back to determine the polygon attribute is visible or not. The returned value is 1/depth value in world coordinates. The first bit of the float is actually a control bit, 1 indicates no geometry hit, 0 indicates geometry hit.
2023-11-03 13:24:59 +00:00
bool m_noLosReturn;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
float m_microTexScale;
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
int m_microTexID;
int m_baseTexInfo[4];
int m_baseTexType;
Correctly emulate the real3d pro-1000 texture modes in our shader.
2018-10-13 13:29:45 +00:00
int m_texWrapMode[2];
use generic vertex attributes
2017-08-10 15:43:03 +00:00
bool m_textureInverted;
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
use generic vertex attributes
2017-08-10 15:43:03 +00:00
// cached model values
We were force normalising the result of matrix * normal, which looked correct in most cases. But this didn't preserve the scaling of the matrix, or the scaling of the model normals which resulted in many over bright areas. On it's own this generally worked, but games like Star Wars looked quite broken. Harry correctly figured out if you scale these normals by the scaling value that is sometimes present in the culling nodes the lighting looks correct. Still more work to do to correctly figure out the model3's lighting model.
2017-07-29 16:30:30 +00:00
float m_modelScale;
Rewrite the renderer a bit to spit out the finished graphics from the 3d chip on separate buffers. One buffer is for opaque pixels, and 2 more for translucent pixels. Before the frame was composited on the back buffer, which meant the tilegen had to have been drawn first. This way the images are now totally independant of the tilegen chip so can be drawn as soon as the register write 0xC is written to the tilegen. Some games update the tilegen after the ping_ping bit has flipped at 66% of the frame, so we need to split the tilegen drawing up into two stages to get some effects to work. So having the tilegen draw independantly of the 3d chip can make this happen.
2023-10-14 19:05:00 +00:00
float m_nodeAlpha;
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
int m_transX;
int m_transY;
int m_transPage;
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
finish front/back face culling code based on matrix determinant. Optimised opengl to avoid redundant state changes.
2016-03-22 23:39:59 +00:00
// are our cache values dirty
bool m_dirtyMesh;
bool m_dirtyModel;
// viewport uniform locations
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
GLint m_locFogIntensity;
Daytona seems to use this completely undocumented feature of the real3d pro-1000, the ability to invert texture colours. This patch fixes the colours on the cars, and the signs which should flash by alternating their colours.
2017-04-05 17:57:38 +00:00
GLint m_locFogDensity;
GLint m_locFogStart;
GLint m_locFogColour;
GLint m_locFogAttenuation;
GLint m_locFogAmbient;
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
GLint m_locProjMat;
Daytona seems to use this completely undocumented feature of the real3d pro-1000, the ability to invert texture colours. This patch fixes the colours on the cars, and the signs which should flash by alternating their colours.
2017-04-05 17:57:38 +00:00
We were force normalising the result of matrix * normal, which looked correct in most cases. But this didn't preserve the scaling of the matrix, or the scaling of the model normals which resulted in many over bright areas. On it's own this generally worked, but games like Star Wars looked quite broken. Harry correctly figured out if you scale these normals by the scaling value that is sometimes present in the culling nodes the lighting looks correct. Still more work to do to correctly figure out the model3's lighting model.
2017-07-29 16:30:30 +00:00
// lighting / other
Daytona seems to use this completely undocumented feature of the real3d pro-1000, the ability to invert texture colours. This patch fixes the colours on the cars, and the signs which should flash by alternating their colours.
2017-04-05 17:57:38 +00:00
GLint m_locLighting;
Sometime ago I managed to work out that specular on the model3 is not real specular, and really is just an extension of diffuse lighting. But attempts were derailed by corner cases and the fact we were not handling the normals correctly. Anyway Harry managed to successfully come up with an algorithm, and coefficients that give an almost perfect match to specular on the model3, based soley on observations from video footage! He also worked out that the lighting on hardware 1.5 onwards appears to be unclamped (ie greater than 1). This quite radically changes the brightness of some of the games, but much better matches the original hardware.
2017-08-09 16:56:56 +00:00
GLint m_locLightEnabled;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
GLint m_locSunClamp;
GLint m_locIntensityClamp;
GLint m_locShininess;
GLint m_locSpecularValue;
GLint m_locSpecularEnabled;
Fixed shading (per vertex poly colours) on step 1.5 hardware have the viewport ambient value added to them. This fixes various shading on scud. To do this had to switch the maths to the vertex shader.
2017-08-14 09:14:06 +00:00
GLint m_locFixedShading;
use generic vertex attributes
2017-08-10 15:43:03 +00:00
GLint m_locSpotEllipse;
GLint m_locSpotRange;
GLint m_locSpotColor;
GLint m_locSpotFogColor;
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
use generic vertex attributes
2017-08-10 15:43:03 +00:00
// model uniforms
GLint m_locModelScale;
Rewrite the renderer a bit to spit out the finished graphics from the 3d chip on separate buffers. One buffer is for opaque pixels, and 2 more for translucent pixels. Before the frame was composited on the back buffer, which meant the tilegen had to have been drawn first. This way the images are now totally independant of the tilegen chip so can be drawn as soon as the register write 0xC is written to the tilegen. Some games update the tilegen after the ping_ping bit has flipped at 66% of the frame, so we need to split the tilegen drawing up into two stages to get some effects to work. So having the tilegen draw independantly of the 3d chip can make this happen.
2023-10-14 19:05:00 +00:00
GLint m_locNodeAlpha;
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
GLint m_locModelMat;
Fixed shading (per vertex poly colours) on step 1.5 hardware have the viewport ambient value added to them. This fixes various shading on scud. To do this had to switch the maths to the vertex shader.
2017-08-14 09:14:06 +00:00
// global uniforms
GLint m_locHardwareStep;
Render the opaque part of texture transparency in the first pass. Fixes numerous transparency related issues in lemans24 and some in ocean hunter. I don't really know if this is the 'correct' way of solving this because the real3d pro-1000 is a complete black box. There is still a lot we don't understand about how it handles transparency.
2018-05-02 20:10:02 +00:00
GLint m_locDiscardAlpha;
Composite the alpha layers at the end of rendering. To do this we need to mask the alpha pixels with the opaque pixels from the next priority layer. Fixes some overlapping shadows in vf3tb that have different priority layers. I assume that was a game bug, but it works on the real h/w.
2019-01-21 14:30:42 +00:00
// vertex attribute position cache
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
std::map<std::string, GLint> m_vertexLocCache;
Composite the alpha layers at the end of rendering. To do this we need to mask the alpha pixels with the opaque pixels from the next priority layer. Fixes some overlapping shadows in vf3tb that have different priority layers. I assume that was a game bug, but it works on the real h/w.
2019-01-21 14:30:42 +00:00
Daytona seems to use this completely undocumented feature of the real3d pro-1000, the ability to invert texture colours. This patch fixes the colours on the cars, and the signs which should flash by alternating their colours.
2017-04-05 17:57:38 +00:00
};
Quad rendering engine. Set QuadRendering = 1 in the ini file to use, or -quad-rendering at the end of the command line to use.
2018-09-13 12:50:34 +00:00
Daytona seems to use this completely undocumented feature of the real3d pro-1000, the ability to invert texture colours. This patch fixes the colours on the cars, and the signs which should flash by alternating their colours.
2017-04-05 17:57:38 +00:00
} // New3D
Adding new 3D engine by Ian Curtis. Old engine moved to Graphics/Legacy3D/.
2016-03-21 04:10:14 +00:00
Rewrite the whole project for GL4+. I figured if we removed the limitation of a legacy rendering API we could improve things a bit. With GL4+ we can do unsigned integer math in the shaders. This allows us to upload a direct copy of the real3d texture sheet, and texture directly from this memory given the x/y pos and type. This massively simplifies the binding and invalidation code. Also the crazy corner cases will work because it essentially works the same way as the original hardware. The standard triangle render requires gl 4.1 core, so should work on mac. The quad renderer runs on 4.5 core. The legacy renderer should still work, and when enabled a regular opengl context will be created, which allows functions marked depreciated in the core profiles to still work. This will only work in windows/linux I think. Apple doesn't support this. A GL 4.1 GPU is now the min required spec. Sorry if you have an OLDER gpu. GL 4.1 is over 12 years old now. This is a big update so I apologise in advance if I accidently broke something :]
2022-11-07 21:33:01 +00:00
#endif
Reference in a new issue Copy permalink