2019-10-17 07:42:11 +00:00
/*
* * glbackend . cpp
* *
* * OpenGL API abstraction
* *
* * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* * Copyright 2019 Christoph Oelckers
* * All rights reserved .
* *
* * Redistribution and use in source and binary forms , with or without
* * modification , are permitted provided that the following conditions
* * are met :
* *
* * 1. Redistributions of source code must retain the above copyright
* * notice , this list of conditions and the following disclaimer .
* * 2. Redistributions in binary form must reproduce the above copyright
* * notice , this list of conditions and the following disclaimer in the
* * documentation and / or other materials provided with the distribution .
* * 3. The name of the author may not be used to endorse or promote products
* * derived from this software without specific prior written permission .
* *
* * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ` ` AS IS ' ' AND ANY EXPRESS OR
* * IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE IMPLIED WARRANTIES
* * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED .
* * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT , INDIRECT ,
* * INCIDENTAL , SPECIAL , EXEMPLARY , OR CONSEQUENTIAL DAMAGES ( INCLUDING , BUT
* * NOT LIMITED TO , PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE ,
* * DATA , OR PROFITS ; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY
* * THEORY OF LIABILITY , WHETHER IN CONTRACT , STRICT LIABILITY , OR TORT
* * ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF
* * THIS SOFTWARE , EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE .
* * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* *
*/
2019-10-04 21:29:00 +00:00
# include <memory>
2019-12-23 14:40:17 +00:00
# include "gl_load.h"
2019-10-06 17:32:35 +00:00
# include "glbackend.h"
2019-09-16 20:56:48 +00:00
# include "gl_samplers.h"
2019-10-05 10:28:08 +00:00
# include "gl_shader.h"
2019-10-17 18:29:58 +00:00
# include "textures.h"
# include "palette.h"
2019-11-07 19:31:16 +00:00
# include "imgui.h"
2019-11-09 13:05:52 +00:00
# include "gamecontrol.h"
2019-11-07 19:31:16 +00:00
# include "imgui_impl_sdl.h"
# include "imgui_impl_opengl3.h"
2019-10-04 19:13:04 +00:00
# include "baselayer.h"
2019-12-23 18:37:40 +00:00
# include "gl_interface.h"
2019-12-28 21:36:47 +00:00
# include "v_2ddrawer.h"
# include "v_video.h"
2020-01-18 12:23:01 +00:00
# include "flatvertices.h"
2019-12-28 21:36:47 +00:00
# include "gl_renderer.h"
2019-10-04 21:29:00 +00:00
2019-12-31 21:53:03 +00:00
float shadediv [ MAXPALOOKUPS ] ;
2019-10-24 22:47:40 +00:00
2020-01-03 09:09:38 +00:00
static int blendstyles [ ] = { GL_ZERO , GL_ONE , GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA , GL_SRC_COLOR , GL_ONE_MINUS_SRC_COLOR , GL_DST_COLOR , GL_ONE_MINUS_DST_COLOR , GL_DST_ALPHA , GL_ONE_MINUS_DST_ALPHA } ;
static int renderops [ ] = { GL_FUNC_ADD , GL_FUNC_ADD , GL_FUNC_SUBTRACT , GL_FUNC_REVERSE_SUBTRACT } ;
2020-01-03 10:43:44 +00:00
int depthf [ ] = { GL_ALWAYS , GL_LESS , GL_EQUAL , GL_LEQUAL } ;
2020-01-03 09:09:38 +00:00
2020-01-19 22:27:59 +00:00
TArray < VSMatrix > matrixArray ;
2020-01-03 09:09:38 +00:00
2019-10-24 22:47:40 +00:00
FileReader GetResource ( const char * fn )
{
2019-12-07 09:14:51 +00:00
auto fr = fileSystem . OpenFileReader ( fn , 0 ) ;
2019-10-24 22:47:40 +00:00
if ( ! fr . isOpen ( ) )
2019-10-04 21:29:00 +00:00
{
2019-11-07 19:31:16 +00:00
I_Error ( " Fatal: '%s' not found " , fn ) ;
2019-10-04 21:29:00 +00:00
}
2019-10-24 22:47:40 +00:00
return fr ;
2019-10-04 21:29:00 +00:00
}
2019-09-23 21:33:59 +00:00
2019-09-16 17:35:04 +00:00
GLInstance GLInterface ;
2019-10-06 19:15:53 +00:00
GLInstance : : GLInstance ( )
: palmanager ( this )
{
2020-01-19 13:08:48 +00:00
VSMatrix mat ( 0 ) ;
matrixArray . Push ( mat ) ;
2019-10-06 19:15:53 +00:00
}
2019-11-07 19:31:16 +00:00
void ImGui_Init_Backend ( ) ;
ImGuiContext * im_ctx ;
TArray < uint8_t > ttf ;
void GLInstance : : Init ( int ydim )
2019-09-16 20:56:48 +00:00
{
2019-09-18 18:44:21 +00:00
if ( ! mSamplers )
{
mSamplers = new FSamplerManager ;
}
2019-10-04 19:13:04 +00:00
2019-12-23 18:37:40 +00:00
//glinfo.bufferstorage = !!strstr(glinfo.extensions, "GL_ARB_buffer_storage");
2019-10-04 19:13:04 +00:00
glGetFloatv ( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT , & glinfo . maxanisotropy ) ;
2019-12-23 18:37:40 +00:00
2019-10-05 10:28:08 +00:00
new ( & renderState ) PolymostRenderState ; // reset to defaults.
2019-11-07 19:31:16 +00:00
LoadSurfaceShader ( ) ;
LoadPolymostShader ( ) ;
2019-12-23 19:03:03 +00:00
#if 0
2019-11-07 19:31:16 +00:00
IMGUI_CHECKVERSION ( ) ;
im_ctx = ImGui : : CreateContext ( ) ;
ImGuiIO & io = ImGui : : GetIO ( ) ; ( void ) io ;
io . ConfigFlags | = ImGuiConfigFlags_NavEnableKeyboard ; // Enable Keyboard Controls
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Dear ImGui style
ImGui : : StyleColorsDark ( ) ;
ImGui_Init_Backend ( ) ;
ImGui_ImplOpenGL3_Init ( ) ;
2019-11-09 13:05:52 +00:00
if ( ! ttf . Size ( ) )
{
2019-12-26 13:04:53 +00:00
//ttf = fileSystem.LoadFile("engine/Capsmall_clean.ttf", 0);
ttf = fileSystem . LoadFile ( " engine/Roboto-Regular.ttf " , 0 ) ;
2019-11-09 13:05:52 +00:00
}
2019-11-07 19:31:16 +00:00
if ( ttf . Size ( ) ) io . Fonts - > AddFontFromMemoryTTF ( ttf . Data ( ) , ttf . Size ( ) , std : : clamp ( ydim / 40 , 10 , 30 ) ) ;
2019-12-23 19:03:03 +00:00
# endif
2019-09-16 20:56:48 +00:00
}
2019-10-05 10:28:08 +00:00
void GLInstance : : LoadPolymostShader ( )
{
2019-12-26 13:04:53 +00:00
auto fr1 = GetResource ( " engine/shaders/glsl/polymost.vp " ) ;
2019-10-05 11:38:02 +00:00
TArray < uint8_t > Vert = fr1 . Read ( ) ;
2019-12-26 13:04:53 +00:00
fr1 = GetResource ( " engine/shaders/glsl/polymost.fp " ) ;
2019-10-05 11:38:02 +00:00
TArray < uint8_t > Frag = fr1 . Read ( ) ;
2019-10-05 10:28:08 +00:00
// Zero-terminate both strings.
2019-10-05 11:38:02 +00:00
Vert . Push ( 0 ) ;
Frag . Push ( 0 ) ;
2019-10-05 10:28:08 +00:00
polymostShader = new PolymostShader ( ) ;
2019-10-06 08:19:51 +00:00
polymostShader - > Load ( " PolymostShader " , ( const char * ) Vert . Data ( ) , ( const char * ) Frag . Data ( ) ) ;
2019-10-05 10:28:08 +00:00
SetPolymostShader ( ) ;
}
2019-10-05 11:09:15 +00:00
void GLInstance : : LoadSurfaceShader ( )
{
2019-12-26 13:04:53 +00:00
auto fr1 = GetResource ( " engine/shaders/glsl/glsurface.vp " ) ;
2019-10-05 11:09:15 +00:00
TArray < uint8_t > Vert = fr1 . Read ( ) ;
2019-12-26 13:04:53 +00:00
fr1 = GetResource ( " engine/shaders/glsl/glsurface.fp " ) ;
2019-10-05 11:09:15 +00:00
TArray < uint8_t > Frag = fr1 . Read ( ) ;
// Zero-terminate both strings.
Vert . Push ( 0 ) ;
Frag . Push ( 0 ) ;
surfaceShader = new SurfaceShader ( ) ;
2019-10-06 08:19:51 +00:00
surfaceShader - > Load ( " SurfaceShader " , ( const char * ) Vert . Data ( ) , ( const char * ) Frag . Data ( ) ) ;
2019-10-05 11:09:15 +00:00
}
2019-10-05 10:28:08 +00:00
2019-10-04 16:12:03 +00:00
void GLInstance : : InitGLState ( int fogmode , int multisample )
{
glShadeModel ( GL_SMOOTH ) ; // GL_FLAT
glEnable ( GL_TEXTURE_2D ) ;
glPixelStorei ( GL_PACK_ALIGNMENT , 1 ) ;
glPixelStorei ( GL_UNPACK_ALIGNMENT , 1 ) ;
if ( multisample > 0 )
{
2019-12-23 14:40:17 +00:00
//glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
2019-10-04 16:12:03 +00:00
glEnable ( GL_MULTISAMPLE ) ;
}
glGetIntegerv ( GL_MAX_TEXTURE_SIZE , & maxTextureSize ) ;
2019-12-28 21:36:47 +00:00
// This is a bad place to call this but without deconstructing the entire render loops in all front ends there is no way to have a well defined spot for this stuff.
// Before doing that the backend needs to work in some fashion, so we have to make sure everything is set up when the first render call is performed.
screen - > BeginFrame ( ) ;
2020-01-03 17:34:43 +00:00
bool useSSAO = ( gl_ssao ! = 0 ) ;
OpenGLRenderer : : GLRenderer - > mBuffers - > BindSceneFB ( useSSAO ) ;
2020-01-18 12:23:01 +00:00
ClearBufferState ( ) ;
2019-12-28 21:36:47 +00:00
}
2019-09-16 20:56:48 +00:00
void GLInstance : : Deinit ( )
{
2019-12-23 19:03:03 +00:00
#if 0
2019-11-07 19:31:16 +00:00
if ( im_ctx )
{
ImGui_ImplOpenGL3_Shutdown ( ) ;
ImGui_ImplSDL2_Shutdown ( ) ;
ImGui : : DestroyContext ( im_ctx ) ;
}
2019-12-23 19:03:03 +00:00
# endif
2019-09-16 20:56:48 +00:00
if ( mSamplers ) delete mSamplers ;
2019-09-23 21:33:59 +00:00
mSamplers = nullptr ;
2019-10-05 10:28:08 +00:00
if ( polymostShader ) delete polymostShader ;
polymostShader = nullptr ;
2019-10-06 19:15:53 +00:00
if ( surfaceShader ) delete surfaceShader ;
surfaceShader = nullptr ;
2019-10-05 10:28:08 +00:00
activeShader = nullptr ;
2019-11-06 22:40:10 +00:00
palmanager . DeleteAllTextures ( ) ;
2019-10-06 22:07:45 +00:00
lastPalswapIndex = - 1 ;
2019-09-16 20:56:48 +00:00
}
2020-01-02 22:15:16 +00:00
FHardwareTexture * GLInstance : : NewTexture ( )
{
return new FHardwareTexture ;
}
2020-01-05 08:38:44 +00:00
void GLInstance : : ResetFrame ( )
{
GLState s ;
lastState = s ; // Back to defaults.
lastState . Style . BlendOp = - 1 ; // invalidate. This forces a reset for the next operation
}
2020-01-18 21:41:08 +00:00
void GLInstance : : SetVertexBuffer ( IVertexBuffer * vb , int offset1 , int offset2 )
2020-01-18 12:23:01 +00:00
{
2020-01-18 21:41:08 +00:00
int o [ ] = { offset1 , offset2 } ;
static_cast < OpenGLRenderer : : GLVertexBuffer * > ( vb ) - > Bind ( o ) ;
}
2020-01-18 12:23:01 +00:00
2020-01-18 21:41:08 +00:00
void GLInstance : : SetIndexBuffer ( IIndexBuffer * vb )
{
if ( vb ) static_cast < OpenGLRenderer : : GLIndexBuffer * > ( vb ) - > Bind ( ) ;
else glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER , 0 ) ;
2020-01-18 12:23:01 +00:00
}
2020-01-18 21:41:08 +00:00
void GLInstance : : ClearBufferState ( )
2019-09-16 17:35:04 +00:00
{
2020-01-18 21:41:08 +00:00
SetVertexBuffer ( screen - > mVertexData - > GetBufferObjects ( ) . first , 0 , 0 ) ;
SetIndexBuffer ( nullptr ) ;
2019-09-16 17:35:04 +00:00
}
2020-01-18 21:41:08 +00:00
2019-10-17 12:21:51 +00:00
static GLint primtypes [ ] =
2019-09-16 17:35:04 +00:00
{
GL_TRIANGLES ,
GL_TRIANGLE_STRIP ,
GL_TRIANGLE_FAN ,
GL_LINES
} ;
2020-01-18 12:23:01 +00:00
2020-01-18 21:41:08 +00:00
void GLInstance : : Draw ( EDrawType type , size_t start , size_t count )
{
renderState . vindex = start ;
renderState . vcount = count ;
renderState . primtype = type ;
rendercommands . Push ( renderState ) ;
SetIdentityMatrix ( Matrix_Texture ) ;
SetIdentityMatrix ( Matrix_Detail ) ;
renderState . StateFlags & = ~ ( STF_CLEARCOLOR | STF_CLEARDEPTH | STF_VIEWPORTSET | STF_SCISSORSET ) ;
2020-01-18 12:23:01 +00:00
}
2020-01-18 21:41:08 +00:00
void GLInstance : : DrawElement ( EDrawType type , size_t start , size_t count , PolymostRenderState & renderState )
2019-09-16 17:35:04 +00:00
{
2019-10-10 19:24:09 +00:00
if ( activeShader = = polymostShader )
{
2020-01-03 10:43:44 +00:00
glVertexAttrib4fv ( 2 , renderState . Color ) ;
if ( renderState . Color [ 3 ] ! = 1.f ) renderState . Flags & = ~ RF_Brightmapping ; // The way the colormaps are set up means that brightmaps cannot be used on translucent content at all.
2020-01-02 22:15:16 +00:00
renderState . Apply ( polymostShader , lastState ) ;
2019-10-10 19:24:09 +00:00
}
2020-01-18 21:41:08 +00:00
if ( type ! = DT_LINES )
2019-11-05 22:35:38 +00:00
{
glDrawElements ( primtypes [ type ] , count , GL_UNSIGNED_INT , ( void * ) ( intptr_t ) ( start * sizeof ( uint32_t ) ) ) ;
2019-09-16 17:35:04 +00:00
}
2019-12-31 18:02:55 +00:00
else
{
glDrawArrays ( primtypes [ type ] , start , count ) ;
}
2020-01-18 21:41:08 +00:00
}
void GLInstance : : DoDraw ( )
{
for ( auto & rs : rendercommands )
2020-01-03 22:38:50 +00:00
{
2020-01-18 21:41:08 +00:00
glVertexAttrib4fv ( 2 , rs . Color ) ;
if ( rs . Color [ 3 ] ! = 1.f ) rs . Flags & = ~ RF_Brightmapping ; // The way the colormaps are set up means that brightmaps cannot be used on translucent content at all.
rs . Apply ( polymostShader , lastState ) ;
glDrawArrays ( primtypes [ rs . primtype ] , rs . vindex , rs . vcount ) ;
2020-01-03 22:38:50 +00:00
}
2020-01-18 21:41:08 +00:00
rendercommands . Clear ( ) ;
2020-01-19 13:08:48 +00:00
matrixArray . Resize ( 1 ) ;
2019-09-16 17:35:04 +00:00
}
2019-09-16 20:56:48 +00:00
2019-10-04 16:12:03 +00:00
2020-01-19 13:08:48 +00:00
int GLInstance : : SetMatrix ( int num , const VSMatrix * mat )
2019-10-04 16:12:03 +00:00
{
2020-01-19 13:08:48 +00:00
int r = renderState . matrixIndex [ num ] ;
2020-01-04 08:54:47 +00:00
if ( num = = Matrix_Projection ) mProjectionM5 = mat - > get ( ) [ 5 ] ;
2020-01-03 22:38:50 +00:00
renderState . matrixIndex [ num ] = matrixArray . Size ( ) ;
matrixArray . Push ( * mat ) ;
2020-01-19 13:08:48 +00:00
return r ;
2019-10-04 16:12:03 +00:00
}
2019-10-04 19:13:04 +00:00
void GLInstance : : ReadPixels ( int xdim , int ydim , uint8_t * buffer )
{
glReadPixels ( 0 , 0 , xdim , ydim , GL_RGB , GL_UNSIGNED_BYTE , buffer ) ;
2019-10-05 10:28:08 +00:00
}
void GLInstance : : SetPolymostShader ( )
{
if ( activeShader ! = polymostShader )
{
polymostShader - > Bind ( ) ;
activeShader = polymostShader ;
}
}
2019-10-05 11:09:15 +00:00
void GLInstance : : SetSurfaceShader ( )
{
if ( activeShader ! = surfaceShader )
{
surfaceShader - > Bind ( ) ;
activeShader = surfaceShader ;
2019-10-05 11:38:02 +00:00
}
}
2019-10-05 11:09:15 +00:00
2019-10-06 19:15:53 +00:00
void GLInstance : : SetPalette ( int index )
{
palmanager . BindPalette ( index ) ;
}
2019-10-05 10:28:08 +00:00
2019-10-07 20:11:09 +00:00
void GLInstance : : SetPalswap ( int index )
{
2019-10-07 23:08:08 +00:00
palmanager . BindPalswap ( index ) ;
2020-01-01 10:49:32 +00:00
renderState . ShadeDiv = shadediv [ index ] = = 0 ? 1.f / ( renderState . NumShades - 2 ) : shadediv [ index ] ;
2019-10-07 20:11:09 +00:00
}
2019-11-07 19:31:16 +00:00
void GLInstance : : DrawImGui ( ImDrawData * data )
{
2019-12-23 19:03:03 +00:00
#if 0
2019-11-07 19:31:16 +00:00
ImGui_ImplOpenGL3_RenderDrawData ( data ) ;
2019-12-23 19:03:03 +00:00
# endif
2019-11-07 19:31:16 +00:00
}
2020-01-04 22:58:26 +00:00
2020-01-03 09:09:38 +00:00
void PolymostRenderState : : Apply ( PolymostShader * shader , GLState & oldState )
2019-10-05 10:28:08 +00:00
{
2020-01-04 22:58:26 +00:00
bool reset = false ;
2020-01-05 11:56:32 +00:00
for ( int i = 0 ; i < MAX_TEXTURES ; i + + )
2020-01-04 22:58:26 +00:00
{
if ( texIds [ i ] ! = oldState . TexId [ i ] | | samplerIds [ i ] ! = oldState . SamplerId [ i ] )
{
if ( i ! = 0 )
{
glActiveTexture ( GL_TEXTURE0 + i ) ;
reset = true ;
}
glBindTexture ( GL_TEXTURE_2D , texIds [ i ] ) ;
2020-01-05 16:37:28 +00:00
GLInterface . mSamplers - > Bind ( i , samplerIds [ i ] , - 1 ) ;
2020-01-04 22:58:26 +00:00
oldState . TexId [ i ] = texIds [ i ] ;
oldState . SamplerId [ i ] = samplerIds [ i ] ;
}
if ( reset ) glActiveTexture ( GL_TEXTURE0 ) ;
}
2020-01-03 09:09:38 +00:00
if ( StateFlags ! = oldState . Flags )
2020-01-02 22:22:59 +00:00
{
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & STF_DEPTHTEST )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & STF_DEPTHTEST ) glEnable ( GL_DEPTH_TEST ) ;
else glDisable ( GL_DEPTH_TEST ) ;
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & STF_BLEND )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & STF_BLEND ) glEnable ( GL_BLEND ) ;
else glDisable ( GL_BLEND ) ;
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & STF_MULTISAMPLE )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & STF_MULTISAMPLE ) glEnable ( GL_MULTISAMPLE ) ;
else glDisable ( GL_MULTISAMPLE ) ;
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & ( STF_STENCILTEST | STF_STENCILWRITE ) )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & STF_STENCILWRITE )
{
glEnable ( GL_STENCIL_TEST ) ;
glClear ( GL_STENCIL_BUFFER_BIT ) ;
glStencilOp ( GL_REPLACE , GL_REPLACE , GL_REPLACE ) ;
glStencilFunc ( GL_ALWAYS , 1 /*value*/ , 0xFF ) ;
}
else if ( StateFlags & STF_STENCILTEST )
{
glEnable ( GL_STENCIL_TEST ) ;
glStencilFunc ( GL_EQUAL , 1 /*value*/ , 0xFF ) ;
glStencilOp ( GL_KEEP , GL_KEEP , GL_KEEP ) ;
}
else
{
glDisable ( GL_STENCIL_TEST ) ;
}
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & ( STF_CULLCW | STF_CULLCCW ) )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & ( STF_CULLCW | STF_CULLCCW ) )
{
glFrontFace ( StateFlags & STF_CULLCW ? GL_CW : GL_CCW ) ;
glEnable ( GL_CULL_FACE ) ;
glCullFace ( GL_BACK ) ; // Cull_Front is not being used.
}
else
{
glDisable ( GL_CULL_FACE ) ;
}
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & STF_COLORMASK )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & STF_COLORMASK ) glColorMask ( 1 , 1 , 1 , 1 ) ;
else glColorMask ( 0 , 0 , 0 , 0 ) ;
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & STF_DEPTHMASK )
2020-01-02 22:22:59 +00:00
{
if ( StateFlags & STF_DEPTHMASK ) glDepthMask ( 1 ) ;
else glDepthMask ( 0 ) ;
}
2020-01-03 09:09:38 +00:00
if ( ( StateFlags ^ oldState . Flags ) & STF_WIREFRAME )
2020-01-02 22:22:59 +00:00
{
glPolygonMode ( GL_FRONT_AND_BACK , ( StateFlags & STF_WIREFRAME ) ? GL_LINE : GL_FILL ) ;
}
2020-01-02 22:56:35 +00:00
if ( StateFlags & ( STF_CLEARCOLOR | STF_CLEARDEPTH ) )
{
glClearColor ( ClearColor . r / 255.f , ClearColor . g / 255.f , ClearColor . b / 255.f , 1.f ) ;
int bit = 0 ;
if ( StateFlags & STF_CLEARCOLOR ) bit | = GL_COLOR_BUFFER_BIT ;
if ( StateFlags & STF_CLEARDEPTH ) bit | = GL_DEPTH_BUFFER_BIT ;
glClear ( bit ) ;
}
2020-01-03 09:48:01 +00:00
if ( StateFlags & STF_VIEWPORTSET )
{
glViewport ( vp_x , vp_y , vp_w , vp_h ) ;
}
if ( StateFlags & STF_SCISSORSET )
{
2020-01-05 09:21:34 +00:00
if ( sc_x > SHRT_MIN )
2020-01-03 09:48:01 +00:00
{
glScissor ( sc_x , sc_y , sc_w , sc_h ) ;
glEnable ( GL_SCISSOR_TEST ) ;
}
else
glDisable ( GL_SCISSOR_TEST ) ;
}
StateFlags & = ~ ( STF_CLEARCOLOR | STF_CLEARDEPTH | STF_VIEWPORTSET | STF_SCISSORSET ) ;
2020-01-03 09:09:38 +00:00
oldState . Flags = StateFlags ;
}
if ( Style ! = oldState . Style )
{
glBlendFunc ( blendstyles [ Style . SrcAlpha ] , blendstyles [ Style . DestAlpha ] ) ;
if ( Style . BlendOp ! = oldState . Style . BlendOp ) glBlendEquation ( renderops [ Style . BlendOp ] ) ;
oldState . Style = Style ;
// Flags are not being checked yet, the current shader has no implementation for them.
2020-01-02 22:22:59 +00:00
}
2020-01-03 10:43:44 +00:00
if ( DepthFunc ! = oldState . DepthFunc )
{
glDepthFunc ( depthf [ DepthFunc ] ) ;
oldState . DepthFunc = DepthFunc ;
}
2019-11-10 18:42:26 +00:00
// Disable brightmaps if non-black fog is used.
if ( ! ( Flags & RF_FogDisabled ) & & ! FogColor . isBlack ( ) ) Flags & = ~ RF_Brightmapping ;
2019-10-19 20:46:37 +00:00
shader - > Flags . Set ( Flags ) ;
2019-10-05 10:28:08 +00:00
shader - > Shade . Set ( Shade ) ;
shader - > NumShades . Set ( NumShades ) ;
2019-10-19 23:14:48 +00:00
shader - > ShadeDiv . Set ( ShadeDiv ) ;
2019-10-05 10:28:08 +00:00
shader - > VisFactor . Set ( VisFactor ) ;
2019-10-19 20:46:37 +00:00
shader - > Flags . Set ( Flags ) ;
2019-10-05 10:28:08 +00:00
shader - > NPOTEmulationFactor . Set ( NPOTEmulationFactor ) ;
shader - > NPOTEmulationXOffset . Set ( NPOTEmulationXOffset ) ;
2019-11-10 09:01:31 +00:00
shader - > AlphaThreshold . Set ( AlphaTest ? AlphaThreshold : - 1.f ) ;
2019-10-05 10:28:08 +00:00
shader - > Brightness . Set ( Brightness ) ;
2019-10-06 10:42:35 +00:00
shader - > FogColor . Set ( FogColor ) ;
2020-01-11 21:18:06 +00:00
shader - > TintFlags . Set ( hictint_flags ) ;
shader - > TintModulate . Set ( hictint ) ;
shader - > TintOverlay . Set ( hictint_overlay ) ;
2020-01-03 22:38:50 +00:00
if ( matrixIndex [ Matrix_View ] ! = - 1 )
shader - > RotMatrix . Set ( matrixArray [ matrixIndex [ Matrix_View ] ] . get ( ) ) ;
if ( matrixIndex [ Matrix_Projection ] ! = - 1 )
shader - > ProjectionMatrix . Set ( matrixArray [ matrixIndex [ Matrix_Projection ] ] . get ( ) ) ;
2020-01-19 15:06:31 +00:00
if ( matrixIndex [ Matrix_Model ] ! = - 1 )
shader - > ModelMatrix . Set ( matrixArray [ matrixIndex [ Matrix_Model ] ] . get ( ) ) ;
2020-01-03 22:38:50 +00:00
if ( matrixIndex [ Matrix_Detail ] ! = - 1 )
shader - > DetailMatrix . Set ( matrixArray [ matrixIndex [ Matrix_Detail ] ] . get ( ) ) ;
if ( matrixIndex [ Matrix_Texture ] ! = - 1 )
shader - > TextureMatrix . Set ( matrixArray [ matrixIndex [ Matrix_Texture ] ] . get ( ) ) ;
memset ( matrixIndex , - 1 , sizeof ( matrixIndex ) ) ;
2019-10-05 10:28:08 +00:00
}