Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-22 11:28:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Always use Multitexture

Browse Source
This commit is contained in:
Chris Sarbora 2024-08-04 23:01:02 -05:00
parent d25bf5e4e1
commit a5081982f6
No known key found for this signature in database
8 changed files with 29 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
Descent3/render.cpp
View File

@ -1905,7 +1905,7 @@ void RenderFace(room *rp, int facenum) {
else else
rend_SetColorModel(CM_RGB); rend_SetColorModel(CM_RGB);
// Set lighting map // Set lighting map
if ((fp->flags & FF_LIGHTMAP) && (!StateLimited || UseMultitexture)) { if ((fp->flags & FF_LIGHTMAP) != 0) {
if (GameTextures[fp->tmap].flags & TF_SATURATE) if (GameTextures[fp->tmap].flags & TF_SATURATE)
rend_SetOverlayType(OT_NONE); rend_SetOverlayType(OT_NONE);
else else
@ -2345,23 +2345,6 @@ void RenderRoomUnsorted(room *rp) {
for (i = rcount - 1; i >= 0; i--) { for (i = rcount - 1; i >= 0; i--) {
RenderFace(rp, State_elements[i].facenum); RenderFace(rp, State_elements[i].facenum);
} }
if (!UseMultitexture) {
// Since we're state limited, we have to render lightmap faces completely separate
// Now render lightmap faces
rend_SetAlphaType(AT_LIGHTMAP_BLEND);
rend_SetLighting(LS_GOURAUD);
rend_SetColorModel(CM_MONO);
rend_SetOverlayType(OT_NONE);
rend_SetTextureType(TT_PERSPECTIVE);
rend_SetWrapType(WT_CLAMP);
rend_SetMipState(0);
for (i = rcount - 1; i >= 0; i--) {
RenderLightmapFace(rp, State_elements[i].facenum);
}
rend_SetWrapType(WT_WRAP);
rend_SetMipState(1);
}
} }
} }

3
Descent3/terrainrender.cpp
View File

@ -2582,8 +2582,7 @@ void DisplayTerrainList(int cellcount, bool from_automap) {
rend_SetTextureType(TT_LINEAR); rend_SetTextureType(TT_LINEAR);
rend_SetAlphaType(ATF_CONSTANT + ATF_TEXTURE); rend_SetAlphaType(ATF_CONSTANT + ATF_TEXTURE);
rend_SetLighting(LS_NONE); rend_SetLighting(LS_NONE);
if (!StateLimited || UseMultitexture) draw_lightmap = true;
draw_lightmap = true;
} }
RotateTerrainList(cellcount, from_automap); RotateTerrainList(cellcount, from_automap);
if (!UseHardware) { if (!UseHardware) {

1
editor/TextureGrWnd.cpp
View File

@ -610,7 +610,6 @@ void CTextureGrWnd::TexGrStartOpenGL() {
// rend_SetOpenGLWindowState (1,Descent,NULL); // LGT: not defined anymore // rend_SetOpenGLWindowState (1,Descent,NULL); // LGT: not defined anymore
rend_ClearScreen(0); rend_ClearScreen(0);
StateLimited = 1; StateLimited = 1;
UseMultitexture = 0;
NoLightmaps = false; NoLightmaps = false;
} }
} }

1
lib/renderer.h
View File

@ -329,7 +329,6 @@ extern float Z_bias;
extern bool UseHardware; extern bool UseHardware;
extern bool StateLimited; extern bool StateLimited;
extern bool NoLightmaps; extern bool NoLightmaps;
extern bool UseMultitexture;
class NewBitmap; class NewBitmap;

23
model/newstyle.cpp
View File

@ -791,26 +791,6 @@ void RenderSubmodelFacesUnsorted(poly_model *pm, bsp_info *sm) {
int facenum = State_elements[i].facenum; int facenum = State_elements[i].facenum;
RenderSubmodelFace(pm, sm, facenum); RenderSubmodelFace(pm, sm, facenum);
} }
if (!NoLightmaps) {
if (!UseMultitexture && Polymodel_light_type == POLYMODEL_LIGHTING_LIGHTMAP) {
rend_SetAlphaType(AT_LIGHTMAP_BLEND);
rend_SetLighting(LS_GOURAUD);
rend_SetColorModel(CM_MONO);
rend_SetOverlayType(OT_NONE);
rend_SetTextureType(TT_PERSPECTIVE);
rend_SetWrapType(WT_CLAMP);
rend_SetMipState(0);
for (i = rcount - 1; i >= 0; i--) {
int facenum = State_elements[i].facenum;
RenderSubmodelLightmapFace(pm, sm, facenum);
}
rend_SetWrapType(WT_WRAP);
rend_SetMipState(1);
}
}
} }
// Now render all alpha faces // Now render all alpha faces
@ -1027,8 +1007,7 @@ void RenderSubmodel(poly_model *pm, bsp_info *sm, uint32_t f_render_sub) {
// Turn off bumpmapping if not needed // Turn off bumpmapping if not needed
rend_SetBumpmapReadyState(0, 0); rend_SetBumpmapReadyState(0, 0);
} else { } else {
if (!StateLimited || UseMultitexture) rend_SetOverlayType(OT_BLEND);
rend_SetOverlayType(OT_BLEND);
} }
if (Multicolor_texture == -1 && Polymodel_use_effect && (Polymodel_effect.type & PEF_CUSTOM_COLOR)) if (Multicolor_texture == -1 && Polymodel_use_effect && (Polymodel_effect.type & PEF_CUSTOM_COLOR))

11
renderer/HardwareBaseGPU.cpp
View File

@ -41,7 +41,6 @@ char Renderer_error_message[256] = "Generic renderer error";
bool UseHardware = true; bool UseHardware = true;
bool NoLightmaps = false; bool NoLightmaps = false;
bool StateLimited = false; bool StateLimited = false;
bool UseMultitexture = false;
bool UseWBuffer = false; bool UseWBuffer = false;
// General renderer states // General renderer states
@ -443,9 +442,7 @@ void rend_DrawPolygon2D(int handle, g3Point **p, int nv) {
g3_RefreshTransforms(true); g3_RefreshTransforms(true);
if (UseMultitexture) { gpu_SetMultitextureBlendMode(false);
gpu_SetMultitextureBlendMode(false);
}
int xAdd = gpu_state.clip_x1; int xAdd = gpu_state.clip_x1;
int yAdd = gpu_state.clip_y1; int yAdd = gpu_state.clip_y1;
@ -514,14 +511,12 @@ void rend_DrawPolygon3D(int handle, g3Point **p, int nv, int map_type) {
return; return;
} }
if (gpu_Overlay_type != OT_NONE && UseMultitexture) { if (gpu_Overlay_type != OT_NONE) {
rend_DrawMultitexturePolygon3D(handle, p, nv, map_type); rend_DrawMultitexturePolygon3D(handle, p, nv, map_type);
return; return;
} }
if (UseMultitexture) { gpu_SetMultitextureBlendMode(false);
gpu_SetMultitextureBlendMode(false);
}
gpu_BindTexture(handle, map_type, 0); gpu_BindTexture(handle, map_type, 0);

99
renderer/HardwareOpenGL.cpp
View File

@ -157,7 +157,6 @@ static int OpenGL_packed_pixels = 0;
static int Cur_texture_object_num = 1; static int Cur_texture_object_num = 1;
static int OpenGL_cache_initted = 0; static int OpenGL_cache_initted = 0;
static int OpenGL_last_bound[2]; static int OpenGL_last_bound[2];
static int Last_texel_unit_set = -1;
extern int gpu_last_frame_polys_drawn; extern int gpu_last_frame_polys_drawn;
extern int gpu_last_frame_verts_processed; extern int gpu_last_frame_verts_processed;
@ -230,12 +229,7 @@ int opengl_MakeTextureObject(int tn) {
Cur_texture_object_num++; Cur_texture_object_num++;
if (UseMultitexture && Last_texel_unit_set != tn) { dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
Last_texel_unit_set = tn;
#endif
}
dglBindTexture(GL_TEXTURE_2D, num); dglBindTexture(GL_TEXTURE_2D, num);
dglPixelStorei(GL_UNPACK_ALIGNMENT, 2); dglPixelStorei(GL_UNPACK_ALIGNMENT, 2);
@ -315,7 +309,6 @@ void opengl_SetDefaults() {
rend_SetGammaValue(gpu_preferred_state.gamma); rend_SetGammaValue(gpu_preferred_state.gamma);
OpenGL_last_bound[0] = 9999999; OpenGL_last_bound[0] = 9999999;
OpenGL_last_bound[1] = 9999999; OpenGL_last_bound[1] = 9999999;
Last_texel_unit_set = -1;
OpenGL_multitexture_state = false; OpenGL_multitexture_state = false;
dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
@ -327,19 +320,14 @@ void opengl_SetDefaults() {
gpu_BindTexture(BAD_BITMAP_HANDLE, MAP_TYPE_BITMAP, 0); gpu_BindTexture(BAD_BITMAP_HANDLE, MAP_TYPE_BITMAP, 0);
gpu_BindTexture(BAD_BITMAP_HANDLE, MAP_TYPE_BITMAP, 1); gpu_BindTexture(BAD_BITMAP_HANDLE, MAP_TYPE_BITMAP, 1);
if (UseMultitexture) { dglActiveTextureARB(GL_TEXTURE0_ARB + 1);
#if (defined(_USE_OGL_ACTIVE_TEXTURES)) dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
dglActiveTextureARB(GL_TEXTURE0_ARB + 1); dglHint(GL_FOG_HINT, GL_NICEST);
dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); gRenderer->setTextureEnabled(1, false);
dglHint(GL_FOG_HINT, GL_NICEST); dglEnable(GL_BLEND);
dglEnable(GL_DITHER);
gRenderer->setTextureEnabled(1, false); dglBlendFunc(GL_DST_COLOR, GL_ZERO);
dglEnable(GL_BLEND); dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
dglEnable(GL_DITHER);
dglBlendFunc(GL_DST_COLOR, GL_ZERO);
dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
#endif
}
} }
extern bool linux_permit_gamma; extern bool linux_permit_gamma;
@ -587,20 +575,11 @@ int opengl_Init(oeApplication *app, renderer_preferred_state *pref_state) {
// Get some info // Get some info
opengl_GetInformation(); opengl_GetInformation();
// Determine if Multitexture is supported
UseMultitexture = !FindArg("-NoMultitexture") && dglActiveTextureARB && dglMultiTexCoord4f;
// Do we have packed pixel formats? // Do we have packed pixel formats?
OpenGL_packed_pixels = opengl_CheckExtension("GL_EXT_packed_pixels"); OpenGL_packed_pixels = opengl_CheckExtension("GL_EXT_packed_pixels");
opengl_InitCache(); opengl_InitCache();
if (UseMultitexture) {
mprintf(0, "Using multitexture.");
} else {
mprintf(0, "Not using multitexture.");
}
if (OpenGL_packed_pixels) { if (OpenGL_packed_pixels) {
opengl_packed_Upload_data = (uint16_t *)mem_malloc(2048 * 2048 * 2); opengl_packed_Upload_data = (uint16_t *)mem_malloc(2048 * 2048 * 2);
opengl_packed_Translate_table = (uint16_t *)mem_malloc(65536 * 2); opengl_packed_Translate_table = (uint16_t *)mem_malloc(65536 * 2);
@ -801,12 +780,7 @@ void opengl_TranslateBitmapToOpenGL(int texnum, int bm_handle, int map_type, int
int w, h; int w, h;
int size; int size;
if (UseMultitexture && Last_texel_unit_set != tn) { dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
Last_texel_unit_set = tn;
#endif
}
if (map_type == MAP_TYPE_LIGHTMAP) { if (map_type == MAP_TYPE_LIGHTMAP) {
if (GameLightmaps[bm_handle].flags & LF_BRAND_NEW) if (GameLightmaps[bm_handle].flags & LF_BRAND_NEW)
@ -1039,12 +1013,7 @@ int opengl_MakeBitmapCurrent(int handle, int map_type, int tn) {
} }
if (OpenGL_last_bound[tn] != texnum) { if (OpenGL_last_bound[tn] != texnum) {
if (UseMultitexture && Last_texel_unit_set != tn) { dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
Last_texel_unit_set = tn;
#endif
}
dglBindTexture(GL_TEXTURE_2D, texnum); dglBindTexture(GL_TEXTURE_2D, texnum);
OpenGL_last_bound[tn] = texnum; OpenGL_last_bound[tn] = texnum;
@ -1073,12 +1042,7 @@ void opengl_MakeWrapTypeCurrent(int handle, int map_type, int tn) {
if (uwrap == dest_wrap) if (uwrap == dest_wrap)
return; return;
if (UseMultitexture && Last_texel_unit_set != tn) { dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
Last_texel_unit_set = tn;
#endif
}
OpenGL_sets_this_frame[1]++; OpenGL_sets_this_frame[1]++;
@ -1120,12 +1084,8 @@ void opengl_MakeFilterTypeCurrent(int handle, int map_type, int tn) {
if (magf == dest_state) if (magf == dest_state)
return; return;
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set != tn) { dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
dglActiveTextureARB(GL_TEXTURE0_ARB + tn);
Last_texel_unit_set = tn;
}
#endif
OpenGL_sets_this_frame[2]++; OpenGL_sets_this_frame[2]++;
@ -1163,16 +1123,11 @@ void gpu_SetMultitextureBlendMode(bool state) {
return; return;
OpenGL_multitexture_state = state; OpenGL_multitexture_state = state;
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
gRenderer->setTextureEnabled(1, state); gRenderer->setTextureEnabled(1, state);
Last_texel_unit_set = 0;
#endif
} }
void gpu_DrawFlatPolygon3D(g3Point **p, int nv) { void gpu_DrawFlatPolygon3D(g3Point **p, int nv) {
if (UseMultitexture) { gpu_SetMultitextureBlendMode(false);
gpu_SetMultitextureBlendMode(false);
}
std::array<PosColorUVVertex, 100> vertices{}; std::array<PosColorUVVertex, 100> vertices{};
std::transform(p, p + nv, std::begin(vertices), [](auto pnt) { std::transform(p, p + nv, std::begin(vertices), [](auto pnt) {
@ -1445,12 +1400,8 @@ void rend_SetRendererType(renderer_type state) {
void rend_SetLighting(light_state state) { void rend_SetLighting(light_state state) {
if (state == gpu_state.cur_light_state) if (state == gpu_state.cur_light_state)
return; // No redundant state setting return; // No redundant state setting
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set != 0) { dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
Last_texel_unit_set = 0;
}
#endif
OpenGL_sets_this_frame[4]++; OpenGL_sets_this_frame[4]++;
@ -1490,12 +1441,8 @@ void rend_SetColorModel(color_model state) {
void rend_SetTextureType(texture_type state) { void rend_SetTextureType(texture_type state) {
if (state == gpu_state.cur_texture_type) if (state == gpu_state.cur_texture_type)
return; // No redundant state setting return; // No redundant state setting
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set != 0) { dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
Last_texel_unit_set = 0;
}
#endif
OpenGL_sets_this_frame[3]++; OpenGL_sets_this_frame[3]++;
switch (state) { switch (state) {
@ -1740,12 +1687,8 @@ void rend_SetFogColor(ddgr_color color) {
void rend_SetAlphaType(int8_t atype) { void rend_SetAlphaType(int8_t atype) {
if (atype == gpu_state.cur_alpha_type) if (atype == gpu_state.cur_alpha_type)
return; // don't set it redundantly return; // don't set it redundantly
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set != 0) { dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
dglActiveTextureARB(GL_TEXTURE0_ARB + 0);
Last_texel_unit_set = 0;
}
#endif
OpenGL_sets_this_frame[6]++; OpenGL_sets_this_frame[6]++;
if (atype == AT_ALWAYS) { if (atype == AT_ALWAYS) {

21
renderer/dyna_gl.h
View File

@ -38,21 +38,6 @@
#define GLFUNCCALL #define GLFUNCCALL
#endif #endif
// ryan's adds. 04/18/2000.
// There was a bunch of stuff that was, I guess, not supported by
// Mesa when Outrage did the original port. So buttloads of code
// involving glActiveTextureARB() were #ifdef'd to only WIN32.
// To make use of the extension more generic, platforms that can handle
// it (Linux and Win32, as far as I care), define
// _USE_OGL_ACTIVE_TEXTURES, and check that define instead of WIN32 when
// using the extension.
#if (!defined(_USE_OGL_ACTIVE_TEXTURES))
#if (defined(WIN32))
#define _USE_OGL_ACTIVE_TEXTURES
#endif
#endif
// end ryan's adds.
inline void CheckError() { inline void CheckError() {
#if defined(_DEBUG) #if defined(_DEBUG)
static auto _dglGetError = reinterpret_cast<GLenum (*)()>(SDL_GL_GetProcAddress("glGetError")); static auto _dglGetError = reinterpret_cast<GLenum (*)()>(SDL_GL_GetProcAddress("glGetError"));
@ -222,10 +207,8 @@ DYNAEXTERN(glGenFramebuffersEXT);
DYNAEXTERN(glGenRenderbuffersEXT); DYNAEXTERN(glGenRenderbuffersEXT);
DYNAEXTERN(glRenderbufferStorageEXT); DYNAEXTERN(glRenderbufferStorageEXT);
#if defined(_USE_OGL_ACTIVE_TEXTURES) DYNAEXTERN(glActiveTextureARB);
DYNAEXTERN_OPT(glActiveTextureARB, true); DYNAEXTERN(glMultiTexCoord4f);
DYNAEXTERN_OPT(glMultiTexCoord4f, true);
#endif
#if defined(WIN32) #if defined(WIN32)
DYNAEXTERN(wglCreateContext); DYNAEXTERN(wglCreateContext);