2006-02-24 04:48:15 +00:00
|
|
|
// Emacs style mode select -*- C++ -*-
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// $Id:$
|
|
|
|
//
|
|
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
|
|
//
|
|
|
|
// This source is available for distribution and/or modification
|
|
|
|
// only under the terms of the DOOM Source Code License as
|
|
|
|
// published by id Software. All rights reserved.
|
|
|
|
//
|
|
|
|
// The source is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
|
|
|
// for more details.
|
|
|
|
//
|
|
|
|
// $Log:$
|
|
|
|
//
|
|
|
|
// DESCRIPTION:
|
|
|
|
// Rendering main loop and setup functions,
|
|
|
|
// utility functions (BSP, geometry, trigonometry).
|
|
|
|
// See tables.c, too.
|
|
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
// HEADER FILES ------------------------------------------------------------
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
#include "templates.h"
|
|
|
|
#include "doomdef.h"
|
|
|
|
#include "d_net.h"
|
|
|
|
#include "doomstat.h"
|
|
|
|
#include "m_random.h"
|
|
|
|
#include "m_bbox.h"
|
|
|
|
#include "r_local.h"
|
2011-07-07 15:37:47 +00:00
|
|
|
#include "r_plane.h"
|
|
|
|
#include "r_bsp.h"
|
|
|
|
#include "r_3dfloors.h"
|
2006-02-24 04:48:15 +00:00
|
|
|
#include "r_sky.h"
|
|
|
|
#include "st_stuff.h"
|
|
|
|
#include "c_cvars.h"
|
2011-07-06 15:31:05 +00:00
|
|
|
#include "c_dispatch.h"
|
2006-02-24 04:48:15 +00:00
|
|
|
#include "v_video.h"
|
|
|
|
#include "stats.h"
|
|
|
|
#include "i_video.h"
|
|
|
|
#include "i_system.h"
|
2006-07-01 00:21:36 +00:00
|
|
|
#include "a_sharedglobal.h"
|
2011-07-06 08:50:15 +00:00
|
|
|
#include "r_data/r_translate.h"
|
2008-03-18 18:18:18 +00:00
|
|
|
#include "p_3dmidtex.h"
|
2011-07-06 08:50:15 +00:00
|
|
|
#include "r_data/r_interpolate.h"
|
2008-09-15 14:11:05 +00:00
|
|
|
#include "v_palette.h"
|
2010-07-23 05:56:25 +00:00
|
|
|
#include "po_man.h"
|
2011-07-06 15:31:05 +00:00
|
|
|
#include "p_effect.h"
|
2011-07-05 10:02:38 +00:00
|
|
|
#include "st_start.h"
|
|
|
|
#include "v_font.h"
|
2011-07-06 07:35:36 +00:00
|
|
|
#include "r_data/colormaps.h"
|
2011-07-06 14:20:54 +00:00
|
|
|
#include "farchive.h"
|
2014-12-16 16:08:48 +00:00
|
|
|
#include "portal.h"
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// MACROS ------------------------------------------------------------------
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
#define TEST_X 32343794
|
|
|
|
#define TEST_Y 111387517
|
|
|
|
#define TEST_Z 2164524
|
|
|
|
#define TEST_ANGLE 2468347904
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// TYPES -------------------------------------------------------------------
|
|
|
|
|
|
|
|
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
|
|
|
|
|
|
|
|
void R_SpanInitData ();
|
2011-07-07 19:53:42 +00:00
|
|
|
void R_DeinitSprites();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
|
|
|
|
|
|
|
|
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
|
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
static void R_ShutdownRenderer();
|
2006-05-12 03:14:40 +00:00
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
|
|
|
|
|
|
|
|
extern short *openings;
|
|
|
|
extern bool r_fakingunderwater;
|
|
|
|
extern "C" int fuzzviewheight;
|
2011-07-07 15:37:47 +00:00
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// PRIVATE DATA DECLARATIONS -----------------------------------------------
|
|
|
|
|
|
|
|
static float CurrentVisibility = 8.f;
|
|
|
|
static fixed_t MaxVisForWall;
|
|
|
|
static fixed_t MaxVisForFloor;
|
2011-07-07 15:37:47 +00:00
|
|
|
extern bool r_showviewer;
|
2006-06-18 15:49:00 +00:00
|
|
|
bool r_dontmaplines;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// PUBLIC DATA DEFINITIONS -------------------------------------------------
|
|
|
|
|
|
|
|
CVAR (String, r_viewsize, "", CVAR_NOSET)
|
2011-05-11 04:16:45 +00:00
|
|
|
CVAR (Bool, r_shadercolormaps, true, CVAR_ARCHIVE)
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
fixed_t r_BaseVisibility;
|
|
|
|
fixed_t r_WallVisibility;
|
|
|
|
fixed_t r_FloorVisibility;
|
|
|
|
float r_TiltVisibility;
|
|
|
|
fixed_t r_SpriteVisibility;
|
|
|
|
fixed_t r_ParticleVisibility;
|
|
|
|
fixed_t r_SkyVisibility;
|
|
|
|
|
|
|
|
fixed_t GlobVis;
|
2011-01-02 18:02:27 +00:00
|
|
|
fixed_t viewingrangerecip;
|
2006-02-24 04:48:15 +00:00
|
|
|
fixed_t FocalLengthX;
|
|
|
|
fixed_t FocalLengthY;
|
|
|
|
float FocalLengthXfloat;
|
- Updated lempar.c to v1.31.
- Added .txt files to the list of types (wad, zip, and pk3) that can be
loaded without listing them after -file.
- Fonts that are created by the ACS setfont command to wrap a texture now
support animated textures.
- FON2 fonts can now use their full palette for CR_UNTRANSLATED when drawn
with the hardware 2D path instead of being restricted to the game palette.
- Fixed: Toggling vid_vsync would reset the displayed fullscreen gamma to 1
on a Radeon 9000.
- Added back the off-by-one palette handling, but in a much more limited
scope than before. The skipped entry is assumed to always be at 248, and
it is assumed that all Shader Model 1.4 cards suffer from this. That's
because all SM1.4 cards are based on variants of the ATI R200 core, and the
RV250 in a Radeon 9000 craps up like this. I see no reason to assume that
other flavors of the R200 are any different. (Interesting note: With the
Radeon 9000, D3DTADDRESS_CLAMP is an invalid address mode when using the
debug Direct3D 9 runtime, but it works perfectly fine with the retail
Direct3D 9 runtime.) (Insight: The R200 probably uses bytes for all its
math inside pixel shaders. That would explain perfectly why I can't use
constants greater than 1 with PS1.4 and why it can't do an exact mapping to
every entry in the color palette.
- Fixed: The software shaded drawer did not work for 2D, because its selected
"color"map was replaced with the identitymap before being used.
- Fixed: I cannot use Printf to output messages before the framebuffer was
completely setup, meaning that Shader Model 1.4 cards could not change
resolution.
- I have decided to let remap palettes specify variable alpha values for
their colors. D3DFB no longer forces them to 255.
- Updated re2c to version 0.12.3.
- Fixed: A_Wander used threshold as a timer, when it should have used
reactiontime.
- Fixed: A_CustomRailgun would not fire at all for actors without a target
when the aim parameter was disabled.
- Made the warp command work in multiplayer, again courtesy of Karate Chris.
- Fixed: Trying to spawn a bot while not in a game made for a crashing time.
(Patch courtesy of Karate Chris.)
- Removed some floating point math from hu_scores.cpp that somebody's GCC
gave warnings for (not mine, though).
- Fixed: The SBarInfo drawbar command crashed if the sprite image was
unavailable.
- Fixed: FString::operator=(const char *) did not release its old buffer when
being assigned to the null string.
- The scanner no longer has an upper limit on the length of strings it
accepts, though short strings will be faster than long ones.
- Moved all the text scanning functions into a class. Mainly, this means that
multiple script scanner states can be stored without being forced to do so
recursively. I think I might be taking advantage of that in the near
future. Possibly. Maybe.
- Removed some potential buffer overflows from the decal parser.
- Applied Blzut3's SBARINFO update #9:
* Fixed: When using even length values in drawnumber it would cap to a 98
value instead of a 99 as intended.
* The SBarInfo parser can now accept negatives for coordinates. This
doesn't allow much right now, but later I plan to add better fullscreen
hud support in which the negatives will be more useful. This also cleans
up the source a bit since all calls for (x, y) coordinates are with the
function getCoordinates().
- Added support for stencilling actors.
- Added support for non-black colors specified with DTA_ColorOverlay to the
software renderer.
- Fixed: The inverse, gold, red, and green fixed colormaps each allocated
space for 32 different colormaps, even though each only used the first one.
- Added two new blending flags to make reverse subtract blending more useful:
STYLEF_InvertSource and STYLEF_InvertOverlay. These invert the color that
gets blended with the background, since that seems like a good idea for
reverse subtraction. They also work with the other two blending operations.
- Added subtract and reverse subtract blending operations to the renderer.
Since the ERenderStyle enumeration was getting rather unwieldy, I converted
it into a new FRenderStyle structure that lets each parameter of the
blending equation be set separately. This simplified the set up for the
blend quite a bit, and it means a number of new combinations are available
by setting the parameters properly.
SVN r710 (trunk)
2008-01-25 23:57:44 +00:00
|
|
|
FDynamicColormap*basecolormap; // [RH] colormap currently drawing with
|
2006-02-24 04:48:15 +00:00
|
|
|
int fixedlightlev;
|
|
|
|
lighttable_t *fixedcolormap;
|
2009-09-22 04:21:27 +00:00
|
|
|
FSpecialColormap *realfixedcolormap;
|
2006-02-24 04:48:15 +00:00
|
|
|
float WallTMapScale2;
|
|
|
|
|
|
|
|
|
|
|
|
bool bRenderingToCanvas; // [RH] True if rendering to a special canvas
|
|
|
|
fixed_t globaluclip, globaldclip;
|
|
|
|
fixed_t centerxfrac;
|
|
|
|
fixed_t centeryfrac;
|
|
|
|
fixed_t yaspectmul;
|
2011-01-02 18:02:27 +00:00
|
|
|
fixed_t baseyaspectmul; // yaspectmul without a forced aspect ratio
|
2006-02-24 04:48:15 +00:00
|
|
|
float iyaspectmulfloat;
|
|
|
|
fixed_t InvZtoScale;
|
|
|
|
|
|
|
|
// just for profiling purposes
|
|
|
|
int linecount;
|
|
|
|
int loopcount;
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// precalculated math tables
|
|
|
|
//
|
|
|
|
|
|
|
|
// The xtoviewangleangle[] table maps a screen pixel
|
|
|
|
// to the lowest viewangle that maps back to x ranges
|
|
|
|
// from clipangle to -clipangle.
|
|
|
|
angle_t xtoviewangle[MAXWIDTH+1];
|
|
|
|
|
|
|
|
bool foggy; // [RH] ignore extralight and fullbright?
|
|
|
|
int r_actualextralight;
|
|
|
|
|
|
|
|
void (*colfunc) (void);
|
|
|
|
void (*basecolfunc) (void);
|
|
|
|
void (*fuzzcolfunc) (void);
|
|
|
|
void (*transcolfunc) (void);
|
|
|
|
void (*spanfunc) (void);
|
|
|
|
|
|
|
|
void (*hcolfunc_pre) (void);
|
|
|
|
void (*hcolfunc_post1) (int hx, int sx, int yl, int yh);
|
|
|
|
void (*hcolfunc_post2) (int hx, int sx, int yl, int yh);
|
2008-02-27 03:11:35 +00:00
|
|
|
void (STACK_ARGS *hcolfunc_post4) (int sx, int yl, int yh);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
cycle_t WallCycles, PlaneCycles, MaskedCycles, WallScanCycles;
|
|
|
|
|
|
|
|
// PRIVATE DATA DEFINITIONS ------------------------------------------------
|
|
|
|
|
|
|
|
static int lastcenteryfrac;
|
|
|
|
|
|
|
|
// CODE --------------------------------------------------------------------
|
|
|
|
|
2011-04-24 17:05:50 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// viewangletox
|
|
|
|
//
|
|
|
|
// Used solely for construction the xtoviewangle table.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
static inline int viewangletox(int i)
|
|
|
|
{
|
|
|
|
if (finetangent[i] > FRACUNIT*2)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else if (finetangent[i] < -FRACUNIT*2)
|
|
|
|
{
|
|
|
|
return viewwidth+1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int t = FixedMul(finetangent[i], FocalLengthX);
|
|
|
|
t = (centerxfrac - t + FRACUNIT-1) >> FRACBITS;
|
|
|
|
return clamp(t, -1, viewwidth+1);
|
|
|
|
}
|
|
|
|
}
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_InitTextureMapping
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void R_InitTextureMapping ()
|
|
|
|
{
|
2011-04-24 17:05:50 +00:00
|
|
|
int i, x;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// Calc focallength so FieldOfView fineangles covers viewwidth.
|
2011-07-07 19:53:42 +00:00
|
|
|
FocalLengthX = FixedDiv (centerxfrac, FocalTangent);
|
|
|
|
FocalLengthY = Scale (centerxfrac, yaspectmul, FocalTangent);
|
2006-02-24 04:48:15 +00:00
|
|
|
FocalLengthXfloat = (float)FocalLengthX / 65536.f;
|
|
|
|
|
2011-01-02 18:02:27 +00:00
|
|
|
// This is 1/FocalTangent before the widescreen extension of FOV.
|
|
|
|
viewingrangerecip = DivScale32(1, finetangent[FINEANGLES/4+(FieldOfView/2)]);
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
// [RH] Do not generate viewangletox, because texture mapping is no
|
|
|
|
// longer done with trig, so it's not needed.
|
2011-04-24 17:05:50 +00:00
|
|
|
|
|
|
|
// Now generate xtoviewangle for sky texture mapping.
|
|
|
|
// We do this with a hybrid approach: The center 90 degree span is
|
|
|
|
// constructed as per the original code:
|
|
|
|
// Scan xtoviewangle to find the smallest view angle that maps to x.
|
|
|
|
// (viewangletox is sorted in non-increasing order.)
|
|
|
|
// This reduces the chances of "doubling-up" of texture columns in
|
|
|
|
// the drawn sky texture.
|
|
|
|
// The remaining arcs are done with tantoangle instead.
|
|
|
|
|
|
|
|
const int t1 = MAX<int>(centerx - (FocalLengthX >> FRACBITS), 0);
|
|
|
|
const int t2 = MIN<int>(centerx + (FocalLengthX >> FRACBITS), viewwidth);
|
2006-02-24 04:48:15 +00:00
|
|
|
const fixed_t dfocus = FocalLengthX >> DBITS;
|
|
|
|
|
2011-04-24 17:05:50 +00:00
|
|
|
for (i = 0, x = t2; x >= t1; --x)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2011-04-24 17:05:50 +00:00
|
|
|
while(viewangletox(i) > x)
|
|
|
|
{
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
xtoviewangle[x] = (i << ANGLETOFINESHIFT) - ANGLE_90;
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
2011-04-24 17:05:50 +00:00
|
|
|
for (x = t2 + 1; x <= viewwidth; ++x)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2011-04-24 17:05:50 +00:00
|
|
|
xtoviewangle[x] = ANGLE_270 + tantoangle[dfocus / (x - centerx)];
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
2011-04-24 17:05:50 +00:00
|
|
|
for (x = 0; x < t1; ++x)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2011-04-24 17:05:50 +00:00
|
|
|
xtoviewangle[x] = (angle_t)(-(signed)xtoviewangle[viewwidth - x]);
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_SetVisibility
|
|
|
|
//
|
|
|
|
// Changes how rapidly things get dark with distance
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void R_SetVisibility (float vis)
|
|
|
|
{
|
|
|
|
// Allow negative visibilities, just for novelty's sake
|
2015-11-27 09:44:37 +00:00
|
|
|
vis = clamp (vis, -204.7f, 204.7f); // (205 and larger do not work in 5:4 aspect ratio)
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
CurrentVisibility = vis;
|
|
|
|
|
2013-06-23 08:28:12 +00:00
|
|
|
if (FocalTangent == 0 || FocalLengthY == 0)
|
2006-02-24 04:48:15 +00:00
|
|
|
{ // If r_visibility is called before the renderer is all set up, don't
|
|
|
|
// divide by zero. This will be called again later, and the proper
|
|
|
|
// values can be initialized then.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-20 05:34:20 +00:00
|
|
|
r_BaseVisibility = xs_RoundToInt(vis * 65536.f);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// Prevent overflow on walls
|
|
|
|
if (r_BaseVisibility < 0 && r_BaseVisibility < -MaxVisForWall)
|
|
|
|
r_WallVisibility = -MaxVisForWall;
|
|
|
|
else if (r_BaseVisibility > 0 && r_BaseVisibility > MaxVisForWall)
|
|
|
|
r_WallVisibility = MaxVisForWall;
|
|
|
|
else
|
|
|
|
r_WallVisibility = r_BaseVisibility;
|
|
|
|
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
r_WallVisibility = FixedMul (Scale (InvZtoScale, SCREENWIDTH*BaseRatioSizes[WidescreenRatio][1],
|
|
|
|
viewwidth*SCREENHEIGHT*3), FixedMul (r_WallVisibility, FocalTangent));
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// Prevent overflow on floors/ceilings. Note that the calculation of
|
|
|
|
// MaxVisForFloor means that planes less than two units from the player's
|
|
|
|
// view could still overflow, but there is no way to totally eliminate
|
|
|
|
// that while still using fixed point math.
|
|
|
|
if (r_BaseVisibility < 0 && r_BaseVisibility < -MaxVisForFloor)
|
|
|
|
r_FloorVisibility = -MaxVisForFloor;
|
|
|
|
else if (r_BaseVisibility > 0 && r_BaseVisibility > MaxVisForFloor)
|
|
|
|
r_FloorVisibility = MaxVisForFloor;
|
|
|
|
else
|
|
|
|
r_FloorVisibility = r_BaseVisibility;
|
|
|
|
|
|
|
|
r_FloorVisibility = Scale (160*FRACUNIT, r_FloorVisibility, FocalLengthY);
|
|
|
|
|
|
|
|
r_TiltVisibility = vis * (float)FocalTangent * (16.f * 320.f) / (float)viewwidth;
|
|
|
|
r_SpriteVisibility = r_WallVisibility;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_GetVisibility
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
float R_GetVisibility ()
|
|
|
|
{
|
|
|
|
return CurrentVisibility;
|
|
|
|
}
|
|
|
|
|
2011-07-06 15:31:05 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// CCMD r_visibility
|
|
|
|
//
|
|
|
|
// Controls how quickly light ramps across a 1/z range. Set this, and it
|
|
|
|
// sets all the r_*Visibility variables (except r_SkyVisibilily, which is
|
|
|
|
// currently unused).
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
CCMD (r_visibility)
|
|
|
|
{
|
|
|
|
if (argv.argc() < 2)
|
|
|
|
{
|
|
|
|
Printf ("Visibility is %g\n", R_GetVisibility());
|
|
|
|
}
|
|
|
|
else if (!netgame)
|
|
|
|
{
|
|
|
|
R_SetVisibility ((float)atof (argv[1]));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Printf ("Visibility cannot be changed in net games.\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_SetWindow
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
void R_SWRSetWindow(int windowSize, int fullWidth, int fullHeight, int stHeight, int trueratio)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2011-07-07 15:37:47 +00:00
|
|
|
int virtheight, virtwidth, virtwidth2, virtheight2;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
if (!bRenderingToCanvas)
|
|
|
|
{ // Set r_viewsize cvar to reflect the current view size
|
|
|
|
UCVarValue value;
|
|
|
|
char temp[16];
|
|
|
|
|
About a week's worth of changes here. As a heads-up, I wouldn't be
surprised if this doesn't build in Linux right now. The CMakeLists.txt
were checked with MinGW and NMake, but how they fair under Linux is an
unknown to me at this time.
- Converted most sprintf (and all wsprintf) calls to either mysnprintf or
FStrings, depending on the situation.
- Changed the strings in the wbstartstruct to be FStrings.
- Changed myvsnprintf() to output nothing if count is greater than INT_MAX.
This is so that I can use a series of mysnprintf() calls and advance the
pointer for each one. Once the pointer goes beyond the end of the buffer,
the count will go negative, but since it's an unsigned type it will be
seen as excessively huge instead. This should not be a problem, as there's
no reason for ZDoom to be using text buffers larger than 2 GB anywhere.
- Ripped out the disabled bit from FGameConfigFile::MigrateOldConfig().
- Changed CalcMapName() to return an FString instead of a pointer to a static
buffer.
- Changed startmap in d_main.cpp into an FString.
- Changed CheckWarpTransMap() to take an FString& as the first argument.
- Changed d_mapname in g_level.cpp into an FString.
- Changed DoSubstitution() in ct_chat.cpp to place the substitutions in an
FString.
- Fixed: The MAPINFO parser wrote into the string buffer to construct a map
name when given a Hexen map number. This was fine with the old scanner
code, but only a happy coincidence prevents it from crashing with the new
code
- Added the 'B' conversion specifier to StringFormat::VWorker() for printing
binary numbers.
- Added CMake support for building with MinGW, MSYS, and NMake. Linux support
is probably broken until I get around to booting into Linux again. Niceties
provided over the existing Makefiles they're replacing:
* All command-line builds can use the same build system, rather than having
a separate one for MinGW and another for Linux.
* Microsoft's NMake tool is supported as a target.
* Progress meters.
* Parallel makes work from a fresh checkout without needing to be primed
first with a single-threaded make.
* Porting to other architectures should be simplified, whenever that day
comes.
- Replaced the makewad tool with zipdir. This handles the dependency tracking
itself instead of generating an external makefile to do it, since I couldn't
figure out how to generate a makefile with an external tool and include it
with a CMake-generated makefile. Where makewad used a master list of files
to generate the package file, zipdir just zips the entire contents of one or
more directories.
- Added the gdtoa package from netlib's fp library so that ZDoom's printf-style
formatting can be entirely independant of the CRT.
SVN r1082 (trunk)
2008-07-23 04:57:26 +00:00
|
|
|
mysnprintf (temp, countof(temp), "%d x %d", viewwidth, viewheight);
|
2006-02-24 04:48:15 +00:00
|
|
|
value.String = temp;
|
|
|
|
r_viewsize.ForceSet (value, CVAR_String);
|
|
|
|
}
|
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
fuzzviewheight = viewheight - 2; // Maximum row the fuzzer can draw to
|
|
|
|
halfviewwidth = (viewwidth >> 1) - 1;
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
lastcenteryfrac = 1<<30;
|
|
|
|
centerxfrac = centerx<<FRACBITS;
|
|
|
|
centeryfrac = centery<<FRACBITS;
|
|
|
|
|
2011-01-02 18:02:27 +00:00
|
|
|
virtwidth = virtwidth2 = fullWidth;
|
|
|
|
virtheight = virtheight2 = fullHeight;
|
|
|
|
|
|
|
|
if (trueratio & 4)
|
|
|
|
{
|
|
|
|
virtheight2 = virtheight2 * BaseRatioSizes[trueratio][3] / 48;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
virtwidth2 = virtwidth2 * BaseRatioSizes[trueratio][3] / 48;
|
|
|
|
}
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
if (WidescreenRatio & 4)
|
|
|
|
{
|
|
|
|
virtheight = virtheight * BaseRatioSizes[WidescreenRatio][3] / 48;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
virtwidth = virtwidth * BaseRatioSizes[WidescreenRatio][3] / 48;
|
|
|
|
}
|
|
|
|
|
2011-01-02 18:02:27 +00:00
|
|
|
baseyaspectmul = Scale(320 << FRACBITS, virtheight2, r_Yaspect * virtwidth2);
|
2006-02-24 04:48:15 +00:00
|
|
|
yaspectmul = Scale ((320<<FRACBITS), virtheight, r_Yaspect * virtwidth);
|
|
|
|
iyaspectmulfloat = (float)virtwidth * r_Yaspect / 320.f / (float)virtheight;
|
|
|
|
InvZtoScale = yaspectmul * centerx;
|
|
|
|
|
2014-08-08 03:43:23 +00:00
|
|
|
WallTMapScale2 = iyaspectmulfloat * 64.f / (float)centerx;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// psprite scales
|
|
|
|
pspritexscale = (centerxwide << FRACBITS) / 160;
|
|
|
|
pspriteyscale = FixedMul (pspritexscale, yaspectmul);
|
|
|
|
pspritexiscale = FixedDiv (FRACUNIT, pspritexscale);
|
|
|
|
|
|
|
|
// thing clipping
|
|
|
|
clearbufshort (screenheightarray, viewwidth, (short)viewheight);
|
|
|
|
|
|
|
|
R_InitTextureMapping ();
|
|
|
|
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
MaxVisForWall = FixedMul (Scale (InvZtoScale, SCREENWIDTH*r_Yaspect,
|
|
|
|
viewwidth*SCREENHEIGHT), FocalTangent);
|
2006-02-24 04:48:15 +00:00
|
|
|
MaxVisForWall = FixedDiv (0x7fff0000, MaxVisForWall);
|
|
|
|
MaxVisForFloor = Scale (FixedDiv (0x7fff0000, viewheight<<(FRACBITS-2)), FocalLengthY, 160*FRACUNIT);
|
|
|
|
|
|
|
|
// Reset r_*Visibility vars
|
|
|
|
R_SetVisibility (R_GetVisibility ());
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// CVAR r_columnmethod
|
|
|
|
//
|
|
|
|
// Selects which version of the seg renderers to use.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
CUSTOM_CVAR (Int, r_columnmethod, 1, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
{
|
|
|
|
if (self != 0 && self != 1)
|
|
|
|
{
|
|
|
|
self = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // Trigger the change
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
setsizeneeded = true;
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_Init
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
void R_InitRenderer()
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2011-07-07 15:37:47 +00:00
|
|
|
atterm(R_ShutdownRenderer);
|
2006-02-24 04:48:15 +00:00
|
|
|
// viewwidth / viewheight are set by the defaults
|
2011-07-07 15:37:47 +00:00
|
|
|
clearbufshort (zeroarray, MAXWIDTH, 0);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
R_InitPlanes ();
|
2011-07-06 10:55:04 +00:00
|
|
|
R_InitShadeMaps();
|
Note: I have not tried compiling these recent changes under Linux. I wouldn't
be surprised if it doesn't work.
- Reorganized the network startup loops so now they are event driven. There is
a single function that gets called to drive it, and it uses callbacks to
perform the different stages of the synchronization. This lets me have a nice,
responsive abort button instead of the previous unannounced hit-escape-to-
abort behavior, and I think the rearranged code is slightly easier to
understand too.
- Increased the number of bytes for version info during D_ArbitrateNetStart(),
in preparation for the day when NETGAMEVERSION requires more than one byte.
- I noticed an issue with Vista RC1 and the new fatal error setup. Even after
releasing a DirectDraw or Direct3D interface, the DWM can still use the
last image drawn using them when it composites the window. It doesn't always
do it but it does often enough that it is a real problem. At this point, I
don't know if it's a problem with the release version of Vista or not.
After messing around, I discovered the problem was caused by ~Win32Video()
hiding the window and then having it immediately shown soon after. The DWM
kept an image of the window to do the transition effect with, and then when
it didn't get a chance to do the transition, it didn't properly forget about
its saved image and kept plastering it on top of everything else
underneath.
- Added a network synchronization panel to the window during netgame startup.
- Fixed: PClass::CreateDerivedClass() must initialize StateList to NULL.
Otherwise, classic DECORATE definitions generate a big, fat crash.
- Resurrected the R_Init progress bar, now as a standard Windows control.
- Removed the sound failure dialog. The FMOD setup already defaulted to no
sound if initialization failed, so this only applies when snd_output is set
to "alternate" which now also falls back to no sound. In addition, it wasn't
working right, and I didn't feel like fixing it for the probably 0% of users
it affected.
- Fixed: The edit control used for logging output added text in reverse order
on Win9x.
- Went back to the roots and made graphics initialization one of the last
things to happen during setup. Now the startup text is visible again. More
importantly, the main window is no longer created invisible, which seems
to cause trouble with it not always appearing in the taskbar. The fatal
error dialog is now also embedded in the main window instead of being a
separate modal dialog, so you can play with the log window to see any
problems that might be reported there.
Rather than completely restoring the original startup order, I tried to
keep things as close to the way they were with early graphics startup. In
particular, V_Init() now creates a dummy screen so that things that need
screen dimensions can get them. It gets replaced by the real screen later
in I_InitGraphics(). Will need to check this under Linux to make sure it
didn't cause any problems there.
- Removed the following stubs that just called functions in Video:
- I_StartModeIterator()
- I_NextMode()
- I_DisplayType()
I_FullscreenChanged() was also removed, and a new fullscreen parameter
was added to IVideo::StartModeIterator(), since that's all it controlled.
- Renamed I_InitHardware() back to I_InitGraphics(), since that's all it's
initialized post-1.22.
SVN r416 (trunk)
2006-12-19 04:09:10 +00:00
|
|
|
R_InitColumnDrawers ();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
colfunc = basecolfunc = R_DrawColumn;
|
|
|
|
fuzzcolfunc = R_DrawFuzzColumn;
|
|
|
|
transcolfunc = R_DrawTranslatedColumn;
|
|
|
|
spanfunc = R_DrawSpan;
|
|
|
|
|
|
|
|
// [RH] Horizontal column drawers
|
|
|
|
hcolfunc_pre = R_DrawColumnHoriz;
|
|
|
|
hcolfunc_post1 = rt_map1col;
|
|
|
|
hcolfunc_post4 = rt_map4cols;
|
|
|
|
}
|
|
|
|
|
2006-05-12 03:14:40 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
2011-07-07 15:37:47 +00:00
|
|
|
// R_ShutdownRenderer
|
2006-05-12 03:14:40 +00:00
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
static void R_ShutdownRenderer()
|
2006-05-12 03:14:40 +00:00
|
|
|
{
|
2011-07-07 19:53:42 +00:00
|
|
|
R_DeinitSprites();
|
2006-05-12 03:14:40 +00:00
|
|
|
R_DeinitPlanes();
|
2011-07-05 10:02:38 +00:00
|
|
|
// Free openings
|
|
|
|
if (openings != NULL)
|
|
|
|
{
|
|
|
|
M_Free (openings);
|
|
|
|
openings = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Free drawsegs
|
|
|
|
if (drawsegs != NULL)
|
|
|
|
{
|
|
|
|
M_Free (drawsegs);
|
|
|
|
drawsegs = NULL;
|
|
|
|
}
|
2006-05-12 03:14:40 +00:00
|
|
|
}
|
|
|
|
|
2007-02-04 01:12:50 +00:00
|
|
|
//==========================================================================
|
2006-02-24 04:48:15 +00:00
|
|
|
//
|
|
|
|
// R_CopyStackedViewParameters
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void R_CopyStackedViewParameters()
|
|
|
|
{
|
|
|
|
stacked_viewx = viewx;
|
|
|
|
stacked_viewy = viewy;
|
|
|
|
stacked_viewz = viewz;
|
|
|
|
stacked_angle = viewangle;
|
|
|
|
stacked_extralight = extralight;
|
|
|
|
stacked_visibility = R_GetVisibility();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
2011-07-07 15:37:47 +00:00
|
|
|
// R_SetupColormap
|
|
|
|
//
|
|
|
|
// Sets up special fixed colormaps
|
2006-02-24 04:48:15 +00:00
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
void R_SetupColormap(player_t *player)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2009-09-22 04:21:27 +00:00
|
|
|
realfixedcolormap = NULL;
|
2006-02-24 04:48:15 +00:00
|
|
|
fixedcolormap = NULL;
|
2009-09-20 03:50:05 +00:00
|
|
|
fixedlightlev = -1;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2009-09-20 03:50:05 +00:00
|
|
|
if (player != NULL && camera == player->mo)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2009-09-21 13:15:36 +00:00
|
|
|
if (player->fixedcolormap >= 0 && player->fixedcolormap < (int)SpecialColormaps.Size())
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2009-09-22 04:21:27 +00:00
|
|
|
realfixedcolormap = &SpecialColormaps[player->fixedcolormap];
|
2011-05-11 04:16:45 +00:00
|
|
|
if (RenderTarget == screen && (DFrameBuffer *)screen->Accel2D && r_shadercolormaps)
|
2009-09-22 04:21:27 +00:00
|
|
|
{
|
|
|
|
// Render everything fullbright. The copy to video memory will
|
|
|
|
// apply the special colormap, so it won't be restricted to the
|
|
|
|
// palette.
|
|
|
|
fixedcolormap = realcolormaps;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fixedcolormap = SpecialColormaps[player->fixedcolormap].Colormap;
|
|
|
|
}
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
2009-09-20 03:50:05 +00:00
|
|
|
else if (player->fixedlightlevel >= 0 && player->fixedlightlevel < NUMCOLORMAPS)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2009-09-20 03:50:05 +00:00
|
|
|
fixedlightlev = player->fixedlightlevel * 256;
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// [RH] Inverse light for shooting the Sigil
|
2009-09-20 03:50:05 +00:00
|
|
|
if (fixedcolormap == NULL && extralight == INT_MIN)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2009-09-21 13:15:36 +00:00
|
|
|
fixedcolormap = SpecialColormaps[INVERSECOLORMAP].Colormap;
|
2006-02-24 04:48:15 +00:00
|
|
|
extralight = 0;
|
|
|
|
}
|
2011-07-07 15:37:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_SetupFreelook
|
|
|
|
//
|
|
|
|
// [RH] freelook stuff
|
|
|
|
//
|
|
|
|
//==========================================================================
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2011-07-07 15:37:47 +00:00
|
|
|
void R_SetupFreelook()
|
|
|
|
{
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
|
|
|
fixed_t dy;
|
|
|
|
|
|
|
|
if (camera != NULL)
|
|
|
|
{
|
|
|
|
dy = FixedMul (FocalLengthY, finetangent[(ANGLE_90-viewpitch)>>ANGLETOFINESHIFT]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dy = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
centeryfrac = (viewheight << (FRACBITS-1)) + dy;
|
|
|
|
centery = centeryfrac >> FRACBITS;
|
|
|
|
globaluclip = FixedDiv (-centeryfrac, InvZtoScale);
|
|
|
|
globaldclip = FixedDiv ((viewheight<<FRACBITS)-centeryfrac, InvZtoScale);
|
|
|
|
|
|
|
|
//centeryfrac &= 0xffff0000;
|
|
|
|
int e, i;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
e = viewheight;
|
|
|
|
fixed_t focus = FocalLengthY;
|
|
|
|
fixed_t den;
|
|
|
|
if (i < centery)
|
|
|
|
{
|
|
|
|
den = centeryfrac - (i << FRACBITS) - FRACUNIT/2;
|
|
|
|
if (e <= centery)
|
|
|
|
{
|
|
|
|
do {
|
|
|
|
yslope[i] = FixedDiv (focus, den);
|
|
|
|
den -= FRACUNIT;
|
|
|
|
} while (++i < e);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
do {
|
|
|
|
yslope[i] = FixedDiv (focus, den);
|
|
|
|
den -= FRACUNIT;
|
|
|
|
} while (++i < centery);
|
|
|
|
den = (i << FRACBITS) - centeryfrac + FRACUNIT/2;
|
|
|
|
do {
|
|
|
|
yslope[i] = FixedDiv (focus, den);
|
|
|
|
den += FRACUNIT;
|
|
|
|
} while (++i < e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
den = (i << FRACBITS) - centeryfrac + FRACUNIT/2;
|
|
|
|
do {
|
|
|
|
yslope[i] = FixedDiv (focus, den);
|
|
|
|
den += FRACUNIT;
|
|
|
|
} while (++i < e);
|
|
|
|
}
|
|
|
|
}
|
2011-07-07 15:37:47 +00:00
|
|
|
}
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
2014-12-16 16:08:48 +00:00
|
|
|
// R_EnterPortal
|
2006-02-24 04:48:15 +00:00
|
|
|
//
|
|
|
|
// [RH] Draw the reflection inside a mirror
|
2014-12-16 16:08:48 +00:00
|
|
|
// [ZZ] Merged with portal code, originally called R_EnterMirror
|
2006-02-24 04:48:15 +00:00
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2014-12-16 17:48:06 +00:00
|
|
|
CVAR(Int, r_portal_recursions, 4, CVAR_ARCHIVE)
|
|
|
|
CVAR(Bool, r_highlight_portals, false, CVAR_ARCHIVE)
|
|
|
|
|
|
|
|
void R_HighlightPortal (PortalDrawseg* pds)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2014-12-16 17:48:06 +00:00
|
|
|
// [ZZ] NO OVERFLOW CHECKS HERE
|
|
|
|
// I believe it won't break. if it does, blame me. :(
|
|
|
|
|
|
|
|
BYTE color = (BYTE)BestColor((DWORD *)GPalette.BaseColors, 255, 0, 0, 0, 255);
|
|
|
|
|
|
|
|
BYTE* pixels = RenderTarget->GetBuffer();
|
|
|
|
// top edge
|
2016-02-05 05:10:46 +00:00
|
|
|
for (int x = pds->x1; x < pds->x2; x++)
|
2014-12-16 17:48:06 +00:00
|
|
|
{
|
|
|
|
if (x < 0 || x >= RenderTarget->GetWidth())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
int p = x - pds->x1;
|
|
|
|
int Ytop = pds->ceilingclip[p];
|
|
|
|
int Ybottom = pds->floorclip[p];
|
|
|
|
|
2016-02-05 05:10:46 +00:00
|
|
|
if (x == pds->x1 || x == pds->x2-1)
|
2014-12-16 19:31:21 +00:00
|
|
|
{
|
2014-12-16 20:54:49 +00:00
|
|
|
RenderTarget->DrawLine(x, Ytop, x, Ybottom+1, color, 0);
|
2014-12-16 19:31:21 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-12-16 17:48:06 +00:00
|
|
|
int YtopPrev = pds->ceilingclip[p-1];
|
|
|
|
int YbottomPrev = pds->floorclip[p-1];
|
|
|
|
|
|
|
|
if (abs(Ytop-YtopPrev) > 1)
|
|
|
|
RenderTarget->DrawLine(x, YtopPrev, x, Ytop, color, 0);
|
|
|
|
else *(pixels + Ytop * RenderTarget->GetPitch() + x) = color;
|
|
|
|
|
|
|
|
if (abs(Ybottom-YbottomPrev) > 1)
|
|
|
|
RenderTarget->DrawLine(x, YbottomPrev, x, Ybottom, color, 0);
|
|
|
|
else *(pixels + Ybottom * RenderTarget->GetPitch() + x) = color;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
void R_EnterPortal (PortalDrawseg* pds, int depth)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2014-12-16 16:08:48 +00:00
|
|
|
// [ZZ] check depth. fill portal with black if it's exceeding the visual recursion limit, and continue like nothing happened.
|
2016-01-10 03:22:33 +00:00
|
|
|
if (depth >= r_portal_recursions)
|
2014-12-16 16:08:48 +00:00
|
|
|
{
|
|
|
|
BYTE color = (BYTE)BestColor((DWORD *)GPalette.BaseColors, 0, 0, 0, 0, 255);
|
|
|
|
int spacing = RenderTarget->GetPitch();
|
2016-02-05 05:10:46 +00:00
|
|
|
for (int x = pds->x1; x < pds->x2; x++)
|
2014-12-16 16:08:48 +00:00
|
|
|
{
|
2014-12-16 17:48:06 +00:00
|
|
|
if (x < 0 || x >= RenderTarget->GetWidth())
|
|
|
|
continue;
|
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
int Ytop = pds->ceilingclip[x-pds->x1];
|
|
|
|
int Ybottom = pds->floorclip[x-pds->x1];
|
|
|
|
|
|
|
|
BYTE *dest = RenderTarget->GetBuffer() + x + Ytop * spacing;
|
|
|
|
|
|
|
|
for (int y = Ytop; y <= Ybottom; y++)
|
|
|
|
{
|
|
|
|
*dest = color;
|
|
|
|
dest += spacing;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-16 17:48:06 +00:00
|
|
|
if (r_highlight_portals)
|
|
|
|
R_HighlightPortal(pds);
|
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
angle_t startang = viewangle;
|
|
|
|
fixed_t startx = viewx;
|
|
|
|
fixed_t starty = viewy;
|
2014-12-16 19:31:21 +00:00
|
|
|
fixed_t startz = viewz;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
CurrentPortalUniq++;
|
2011-01-29 11:09:38 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
unsigned int portalsAtStart = WallPortals.Size ();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
if (pds->mirror)
|
|
|
|
{
|
|
|
|
//vertex_t *v1 = ds->curline->v1;
|
|
|
|
vertex_t *v1 = pds->src->v1;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
// Reflect the current view behind the mirror.
|
|
|
|
if (pds->src->dx == 0)
|
|
|
|
{ // vertical mirror
|
|
|
|
viewx = v1->x - startx + v1->x;
|
|
|
|
}
|
|
|
|
else if (pds->src->dy == 0)
|
|
|
|
{ // horizontal mirror
|
|
|
|
viewy = v1->y - starty + v1->y;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // any mirror--use floats to avoid integer overflow
|
|
|
|
vertex_t *v2 = pds->src->v2;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
float dx = FIXED2FLOAT(v2->x - v1->x);
|
|
|
|
float dy = FIXED2FLOAT(v2->y - v1->y);
|
|
|
|
float x1 = FIXED2FLOAT(v1->x);
|
|
|
|
float y1 = FIXED2FLOAT(v1->y);
|
|
|
|
float x = FIXED2FLOAT(startx);
|
|
|
|
float y = FIXED2FLOAT(starty);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
// the above two cases catch len == 0
|
|
|
|
float r = ((x - x1)*dx + (y - y1)*dy) / (dx*dx + dy*dy);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
viewx = FLOAT2FIXED((x1 + r * dx)*2 - x);
|
|
|
|
viewy = FLOAT2FIXED((y1 + r * dy)*2 - y);
|
|
|
|
}
|
|
|
|
viewangle = 2*R_PointToAngle2 (pds->src->v1->x, pds->src->v1->y,
|
|
|
|
pds->src->v2->x, pds->src->v2->y) - startang;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
}
|
2014-12-16 16:08:48 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
P_TranslatePortalXY(pds->src, pds->dst, viewx, viewy);
|
|
|
|
P_TranslatePortalZ(pds->src, pds->dst, viewz);
|
|
|
|
P_TranslatePortalAngle(pds->src, pds->dst, viewangle);
|
|
|
|
}
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
|
|
|
|
viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
|
|
|
|
|
|
|
|
viewtansin = FixedMul (FocalTangent, viewsin);
|
|
|
|
viewtancos = FixedMul (FocalTangent, viewcos);
|
|
|
|
|
|
|
|
R_CopyStackedViewParameters();
|
|
|
|
|
|
|
|
validcount++;
|
2014-12-16 16:08:48 +00:00
|
|
|
PortalDrawseg* prevpds = CurrentPortal;
|
|
|
|
CurrentPortal = pds;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
R_ClearPlanes (false);
|
2016-02-05 05:10:46 +00:00
|
|
|
R_ClearClipSegs (pds->x1, pds->x2);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
WindowLeft = pds->x1;
|
|
|
|
WindowRight = pds->x2;
|
2014-12-16 19:31:21 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
// RF_XFLIP should be removed before calling the root function
|
|
|
|
int prevmf = MirrorFlags;
|
|
|
|
if (pds->mirror)
|
|
|
|
{
|
|
|
|
if (MirrorFlags & RF_XFLIP)
|
|
|
|
MirrorFlags &= ~RF_XFLIP;
|
|
|
|
else MirrorFlags |= RF_XFLIP;
|
|
|
|
}
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 19:31:21 +00:00
|
|
|
// some portals have height differences, account for this here
|
|
|
|
R_3D_EnterSkybox(); // push 3D floor height map
|
2016-01-10 03:45:26 +00:00
|
|
|
CurrentPortalInSkybox = false; // first portal in a skybox should set this variable to false for proper clipping in skyboxes.
|
2014-12-16 19:31:21 +00:00
|
|
|
|
|
|
|
// first pass, set clipping
|
|
|
|
memcpy (ceilingclip + pds->x1, &pds->ceilingclip[0], pds->len*sizeof(*ceilingclip));
|
|
|
|
memcpy (floorclip + pds->x1, &pds->floorclip[0], pds->len*sizeof(*floorclip));
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
R_RenderBSPNode (nodes + numnodes - 1);
|
2011-01-29 11:09:38 +00:00
|
|
|
R_3D_ResetClip(); // reset clips (floor/ceiling)
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
PlaneCycles.Clock();
|
2006-02-24 04:48:15 +00:00
|
|
|
R_DrawPlanes ();
|
|
|
|
R_DrawSkyBoxes ();
|
2014-12-16 16:08:48 +00:00
|
|
|
PlaneCycles.Unclock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 19:31:21 +00:00
|
|
|
fixed_t vzp = viewz;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 17:48:06 +00:00
|
|
|
int prevuniq = CurrentPortalUniq;
|
2014-12-16 16:08:48 +00:00
|
|
|
// depth check is in another place right now
|
|
|
|
unsigned int portalsAtEnd = WallPortals.Size ();
|
|
|
|
for (; portalsAtStart < portalsAtEnd; portalsAtStart++)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2014-12-16 16:08:48 +00:00
|
|
|
R_EnterPortal (&WallPortals[portalsAtStart], depth + 1);
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
2014-12-16 19:31:21 +00:00
|
|
|
int prevuniq2 = CurrentPortalUniq;
|
2014-12-16 17:48:06 +00:00
|
|
|
CurrentPortalUniq = prevuniq;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
NetUpdate();
|
|
|
|
|
|
|
|
MaskedCycles.Clock(); // [ZZ] count sprites in portals/mirrors along with normal ones.
|
|
|
|
R_DrawMasked (); // this is required since with portals there often will be cases when more than 80% of the view is inside a portal.
|
|
|
|
MaskedCycles.Unclock();
|
|
|
|
|
|
|
|
NetUpdate();
|
|
|
|
|
2014-12-16 19:31:21 +00:00
|
|
|
R_3D_LeaveSkybox(); // pop 3D floor height map
|
|
|
|
CurrentPortalUniq = prevuniq2;
|
|
|
|
|
2014-12-16 17:48:06 +00:00
|
|
|
// draw a red line around a portal if it's being highlighted
|
|
|
|
if (r_highlight_portals)
|
|
|
|
R_HighlightPortal(pds);
|
|
|
|
|
2014-12-16 16:08:48 +00:00
|
|
|
CurrentPortal = prevpds;
|
|
|
|
MirrorFlags = prevmf;
|
2006-02-24 04:48:15 +00:00
|
|
|
viewangle = startang;
|
|
|
|
viewx = startx;
|
|
|
|
viewy = starty;
|
2014-12-16 19:31:21 +00:00
|
|
|
viewz = startz;
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_SetupBuffer
|
|
|
|
//
|
|
|
|
// Precalculate all row offsets and fuzz table.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
void R_SetupBuffer ()
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
|
|
|
static BYTE *lastbuff = NULL;
|
|
|
|
|
|
|
|
int pitch = RenderTarget->GetPitch();
|
|
|
|
BYTE *lineptr = RenderTarget->GetBuffer() + viewwindowy*pitch + viewwindowx;
|
|
|
|
|
|
|
|
if (dc_pitch != pitch || lineptr != lastbuff)
|
|
|
|
{
|
|
|
|
if (dc_pitch != pitch)
|
|
|
|
{
|
|
|
|
dc_pitch = pitch;
|
|
|
|
R_InitFuzzTable (pitch);
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
#if defined(X86_ASM) || defined(X64_ASM)
|
2006-02-24 04:48:15 +00:00
|
|
|
ASM_PatchPitch ();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
dc_destorg = lineptr;
|
|
|
|
for (int i = 0; i < RenderTarget->GetHeight(); i++)
|
|
|
|
{
|
|
|
|
ylookup[i] = i * pitch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_RenderActorView
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2006-06-18 15:49:00 +00:00
|
|
|
void R_RenderActorView (AActor *actor, bool dontmaplines)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2008-08-10 11:29:19 +00:00
|
|
|
WallCycles.Reset();
|
|
|
|
PlaneCycles.Reset();
|
|
|
|
MaskedCycles.Reset();
|
2008-08-10 03:25:08 +00:00
|
|
|
WallScanCycles.Reset();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2013-02-23 05:15:32 +00:00
|
|
|
fakeActive = 0; // kg3D - reset fake floor indicator
|
2011-01-29 11:09:38 +00:00
|
|
|
R_3D_ResetClip(); // reset clips (floor/ceiling)
|
|
|
|
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
R_SetupBuffer ();
|
2006-02-24 04:48:15 +00:00
|
|
|
R_SetupFrame (actor);
|
|
|
|
|
|
|
|
// Clear buffers.
|
|
|
|
R_ClearClipSegs (0, viewwidth);
|
|
|
|
R_ClearDrawSegs ();
|
|
|
|
R_ClearPlanes (true);
|
|
|
|
R_ClearSprites ();
|
|
|
|
|
|
|
|
NetUpdate ();
|
|
|
|
|
|
|
|
// [RH] Show off segs if r_drawflat is 1
|
|
|
|
if (r_drawflat)
|
|
|
|
{
|
|
|
|
hcolfunc_pre = R_FillColumnHorizP;
|
|
|
|
hcolfunc_post1 = rt_copy1col;
|
|
|
|
hcolfunc_post4 = rt_copy4cols;
|
|
|
|
colfunc = R_FillColumnP;
|
|
|
|
spanfunc = R_FillSpan;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
hcolfunc_pre = R_DrawColumnHoriz;
|
|
|
|
hcolfunc_post1 = rt_map1col;
|
|
|
|
hcolfunc_post4 = rt_map4cols;
|
|
|
|
colfunc = basecolfunc;
|
|
|
|
spanfunc = R_DrawSpan;
|
|
|
|
}
|
|
|
|
|
|
|
|
WindowLeft = 0;
|
2016-01-31 03:19:23 +00:00
|
|
|
WindowRight = viewwidth;
|
2006-02-24 04:48:15 +00:00
|
|
|
MirrorFlags = 0;
|
2014-12-16 16:08:48 +00:00
|
|
|
CurrentPortal = NULL;
|
2014-12-16 19:31:21 +00:00
|
|
|
CurrentPortalUniq = 0;
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2006-06-18 15:49:00 +00:00
|
|
|
r_dontmaplines = dontmaplines;
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
// [RH] Hack to make windows into underwater areas possible
|
|
|
|
r_fakingunderwater = false;
|
|
|
|
|
|
|
|
// [RH] Setup particles for this frame
|
2011-07-06 15:31:05 +00:00
|
|
|
P_FindParticleSubsectors ();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
2008-08-10 03:25:08 +00:00
|
|
|
WallCycles.Clock();
|
2015-04-04 16:40:43 +00:00
|
|
|
ActorRenderFlags savedflags = camera->renderflags;
|
2006-02-24 04:48:15 +00:00
|
|
|
// Never draw the player unless in chasecam mode
|
|
|
|
if (!r_showviewer)
|
|
|
|
{
|
|
|
|
camera->renderflags |= RF_INVISIBLE;
|
|
|
|
}
|
2010-07-23 05:56:25 +00:00
|
|
|
// Link the polyobjects right before drawing the scene to reduce the amounts of calls to this function
|
|
|
|
PO_LinkToSubsectors();
|
2014-08-01 00:43:36 +00:00
|
|
|
R_RenderBSPNode (nodes + numnodes - 1); // The head node is the last node output.
|
|
|
|
R_3D_ResetClip(); // reset clips (floor/ceiling)
|
2006-02-24 04:48:15 +00:00
|
|
|
camera->renderflags = savedflags;
|
2008-08-10 03:25:08 +00:00
|
|
|
WallCycles.Unclock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
NetUpdate ();
|
|
|
|
|
|
|
|
if (viewactive)
|
|
|
|
{
|
2008-08-10 03:25:08 +00:00
|
|
|
PlaneCycles.Clock();
|
2006-02-24 04:48:15 +00:00
|
|
|
R_DrawPlanes ();
|
|
|
|
R_DrawSkyBoxes ();
|
2008-08-10 03:25:08 +00:00
|
|
|
PlaneCycles.Unclock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
// [RH] Walk through mirrors
|
2014-12-16 16:08:48 +00:00
|
|
|
// [ZZ] Merged with portals
|
|
|
|
size_t lastportal = WallPortals.Size();
|
|
|
|
for (unsigned int i = 0; i < lastportal; i++)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
2014-12-16 16:08:48 +00:00
|
|
|
R_EnterPortal(&WallPortals[i], 0);
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
|
2014-12-16 19:31:21 +00:00
|
|
|
CurrentPortal = NULL;
|
|
|
|
CurrentPortalUniq = 0;
|
|
|
|
|
2006-02-24 04:48:15 +00:00
|
|
|
NetUpdate ();
|
|
|
|
|
2008-08-10 03:25:08 +00:00
|
|
|
MaskedCycles.Clock();
|
2006-02-24 04:48:15 +00:00
|
|
|
R_DrawMasked ();
|
2008-08-10 03:25:08 +00:00
|
|
|
MaskedCycles.Unclock();
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
NetUpdate ();
|
|
|
|
}
|
2014-12-16 16:08:48 +00:00
|
|
|
WallPortals.Clear ();
|
2008-06-04 17:53:15 +00:00
|
|
|
interpolator.RestoreInterpolations ();
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
R_SetupBuffer ();
|
2011-05-11 04:16:45 +00:00
|
|
|
|
|
|
|
// If we don't want shadered colormaps, NULL it now so that the
|
|
|
|
// copy to the screen does not use a special colormap shader.
|
|
|
|
if (!r_shadercolormaps)
|
|
|
|
{
|
|
|
|
realfixedcolormap = NULL;
|
|
|
|
}
|
2006-02-24 04:48:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_RenderViewToCanvas
|
|
|
|
//
|
|
|
|
// Pre: Canvas is already locked.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void R_RenderViewToCanvas (AActor *actor, DCanvas *canvas,
|
2006-06-18 15:49:00 +00:00
|
|
|
int x, int y, int width, int height, bool dontmaplines)
|
2006-02-24 04:48:15 +00:00
|
|
|
{
|
|
|
|
const bool savedviewactive = viewactive;
|
|
|
|
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
viewwidth = width;
|
2006-02-24 04:48:15 +00:00
|
|
|
RenderTarget = canvas;
|
|
|
|
bRenderingToCanvas = true;
|
|
|
|
|
|
|
|
R_SetWindow (12, width, height, height);
|
|
|
|
viewwindowx = x;
|
|
|
|
viewwindowy = y;
|
|
|
|
viewactive = true;
|
|
|
|
|
2006-06-18 15:49:00 +00:00
|
|
|
R_RenderActorView (actor, dontmaplines);
|
2006-02-24 04:48:15 +00:00
|
|
|
|
|
|
|
RenderTarget = screen;
|
|
|
|
bRenderingToCanvas = false;
|
|
|
|
R_ExecuteSetViewSize ();
|
|
|
|
screen->Lock (true);
|
- Ported vlinetallasm4 to AMD64 assembly. Even with the increased number of
registers AMD64 provides, this routine still needs to be written as self-
modifying code for maximum performance. The additional registers do allow
for further optimization over the x86 version by allowing all four pixels
to be in flight at the same time. The end result is that AMD64 ASM is about
2.18 times faster than AMD64 C and about 1.06 times faster than x86 ASM.
(For further comparison, AMD64 C and x86 C are practically the same for
this function.) Should I port any more assembly to AMD64, mvlineasm4 is the
most likely candidate, but it's not used enough at this point to bother.
Also, this may or may not work with Linux at the moment, since it doesn't
have the eh_handler metadata. Win64 is easier, since I just need to
structure the function prologue and epilogue properly and use some
assembler directives/macros to automatically generate the metadata. And
that brings up another point: You need YASM to assemble the AMD64 code,
because NASM doesn't support the Win64 metadata directives.
- Added an SSE version of DoBlending. This is strictly C intrinsics.
VC++ still throws around unneccessary register moves. GCC seems to be
pretty close to optimal, requiring only about 2 cycles/color. They're
both faster than my hand-written MMX routine, so I don't need to feel
bad about not hand-optimizing this for x64 builds.
- Removed an extra instruction from DoBlending_MMX, transposed two
instructions, and unrolled it once, shaving off about 80 cycles from the
time required to blend 256 palette entries. Why? Because I tried writing
a C version of the routine using compiler intrinsics and was appalled by
all the extra movq's VC++ added to the code. GCC was better, but still
generated extra instructions. I only wanted a C version because I can't
use inline assembly with VC++'s x64 compiler, and x64 assembly is a bit
of a pain. (It's a pain because Linux and Windows have different calling
conventions, and you need to maintain extra metadata for functions.) So,
the assembly version stays and the C version stays out.
- Removed all the pixel doubling r_detail modes, since the one platform they
were intended to assist (486) actually sees very little benefit from them.
- Rewrote CheckMMX in C and renamed it to CheckCPU.
- Fixed: CPUID function 0x80000005 is specified to return detailed L1 cache
only for AMD processors, so we must not use it on other architectures, or
we end up overwriting the L1 cache line size with 0 or some other number
we don't actually understand.
SVN r1134 (trunk)
2008-08-09 03:13:43 +00:00
|
|
|
R_SetupBuffer ();
|
2006-02-24 04:48:15 +00:00
|
|
|
screen->Unlock ();
|
|
|
|
viewactive = savedviewactive;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// R_MultiresInit
|
|
|
|
//
|
|
|
|
// Called from V_SetResolution()
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void R_MultiresInit ()
|
|
|
|
{
|
|
|
|
R_PlaneInitData ();
|
|
|
|
}
|
|
|
|
|
2011-07-07 19:53:42 +00:00
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// STAT fps
|
|
|
|
//
|
|
|
|
// Displays statistics about rendering times
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
extern cycle_t WallCycles, PlaneCycles, MaskedCycles, WallScanCycles;
|
|
|
|
extern cycle_t FrameCycles;
|
|
|
|
|
|
|
|
ADD_STAT (fps)
|
|
|
|
{
|
|
|
|
FString out;
|
|
|
|
out.Format("frame=%04.1f ms walls=%04.1f ms planes=%04.1f ms masked=%04.1f ms",
|
|
|
|
FrameCycles.TimeMS(), WallCycles.TimeMS(), PlaneCycles.TimeMS(), MaskedCycles.TimeMS());
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static double f_acc, w_acc,p_acc,m_acc;
|
|
|
|
static int acc_c;
|
|
|
|
|
|
|
|
ADD_STAT (fps_accumulated)
|
|
|
|
{
|
|
|
|
f_acc += FrameCycles.TimeMS();
|
|
|
|
w_acc += WallCycles.TimeMS();
|
|
|
|
p_acc += PlaneCycles.TimeMS();
|
|
|
|
m_acc += MaskedCycles.TimeMS();
|
|
|
|
acc_c++;
|
|
|
|
FString out;
|
|
|
|
out.Format("frame=%04.1f ms walls=%04.1f ms planes=%04.1f ms masked=%04.1f ms %d counts",
|
|
|
|
f_acc/acc_c, w_acc/acc_c, p_acc/acc_c, m_acc/acc_c, acc_c);
|
|
|
|
Printf(PRINT_LOG, "%s\n", out.GetChars());
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// STAT wallcycles
|
|
|
|
//
|
|
|
|
// Displays the minimum number of cycles spent drawing walls
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
static double bestwallcycles = HUGE_VAL;
|
|
|
|
|
|
|
|
ADD_STAT (wallcycles)
|
|
|
|
{
|
|
|
|
FString out;
|
|
|
|
double cycles = WallCycles.Time();
|
|
|
|
if (cycles && cycles < bestwallcycles)
|
|
|
|
bestwallcycles = cycles;
|
|
|
|
out.Format ("%g", bestwallcycles);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// CCMD clearwallcycles
|
|
|
|
//
|
|
|
|
// Resets the count of minimum wall drawing cycles
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
CCMD (clearwallcycles)
|
|
|
|
{
|
|
|
|
bestwallcycles = HUGE_VAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 1
|
|
|
|
// To use these, also uncomment the clock/unclock in wallscan
|
|
|
|
static double bestscancycles = HUGE_VAL;
|
|
|
|
|
|
|
|
ADD_STAT (scancycles)
|
|
|
|
{
|
|
|
|
FString out;
|
|
|
|
double scancycles = WallScanCycles.Time();
|
|
|
|
if (scancycles && scancycles < bestscancycles)
|
|
|
|
bestscancycles = scancycles;
|
|
|
|
out.Format ("%g", bestscancycles);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
CCMD (clearscancycles)
|
|
|
|
{
|
|
|
|
bestscancycles = HUGE_VAL;
|
|
|
|
}
|
|
|
|
#endif
|