Subversion Repositories Games.Descent

/*

 * Portions of this file are copyright Rebirth contributors and licensed as

 * described in COPYING.txt.

 * Portions of this file are copyright Parallax Software and licensed

 * according to the Parallax license below.

 * See COPYING.txt for license details.

THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX

SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO

END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A

ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS

IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS

SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE

FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE

CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS

AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.

COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Rendering Stuff

 *

 */

#include <algorithm>

#include <bitset>

#include <limits>

#include <cstdlib>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include "render_state.h"

#include "inferno.h"

#include "segment.h"

#include "dxxerror.h"

#include "bm.h"

#include "texmap.h"

#include "render.h"

#include "game.h"

#include "object.h"

#include "laser.h"

#include "textures.h"

#include "screens.h"

#include "segpoint.h"

#include "wall.h"

#include "texmerge.h"

#include "physics.h"

#include "3d.h"

#include "gameseg.h"

#include "vclip.h"

#include "lighting.h"

#include "cntrlcen.h"

#include "newdemo.h"

#include "automap.h"

#include "endlevel.h"

#include "key.h"

#include "newmenu.h"

#include "u_mem.h"

#include "piggy.h"

#include "timer.h"

#include "effects.h"

#include "playsave.h"

#if DXX_USE_OGL

#include "ogl_init.h"

#endif

#include "args.h"

#include "compiler-range_for.h"

#include "d_range.h"

#include "partial_range.h"

#include "segiter.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#include "editor/esegment.h"

#endif

#include <utility>

using std::min;

using std::max;

// (former) "detail level" values

#if DXX_USE_OGL

int Render_depth = MAX_RENDER_SEGS; //how many segments deep to render

#else

int Render_depth = 20; //how many segments deep to render

unsigned Max_linear_depth = 50; // Deepest segment at which linear interpolation will be used.

#endif

//used for checking if points have been rotated

int     Clear_window_color=-1;

int     Clear_window=2; // 1 = Clear whole background window, 2 = clear view portals into rest of world, 0 = no clear

static uint16_t s_current_generation;

// When any render function needs to know what's looking at it, it should 

// access Viewer members.

namespace dsx {

const object * Viewer = NULL;

}

#if !DXX_USE_EDITOR && defined(RELEASE)

constexpr

#endif

fix Render_zoom = 0x9000;                                       //the player's zoom factor

#ifndef NDEBUG

static std::bitset<MAX_OBJECTS> object_rendered;

#endif

#if DXX_USE_EDITOR

int     Render_only_bottom=0;

int     Bottom_bitmap_num = 9;

#endif

namespace dcx {

//Global vars for window clip test

int Window_clip_left,Window_clip_top,Window_clip_right,Window_clip_bot;

}

#if DXX_USE_EDITOR

int _search_mode = 0;                   //true if looking for curseg,side,face

short _search_x,_search_y;      //pixel we're looking at

static int found_side,found_face;

static segnum_t found_seg;

static objnum_t found_obj;

#else

constexpr int _search_mode = 0;

#endif

#ifdef NDEBUG           //if no debug code, set these vars to constants

#else

int Outline_mode=0;

int toggle_outline_mode(void)

{

        return Outline_mode = !Outline_mode;

}

#endif

#ifndef NDEBUG

#if DXX_USE_OGL

#define draw_outline(C,a,b)     draw_outline(a,b)

#endif

static void draw_outline(grs_canvas &canvas, const unsigned nverts, cg3s_point *const *const pointlist)

{

        const uint8_t color = BM_XRGB(63, 63, 63);

        const unsigned e = nverts - 1;

        range_for (const unsigned i, xrange(e))

                g3_draw_line(canvas, *pointlist[i], *pointlist[i + 1], color);

        g3_draw_line(canvas, *pointlist[e], *pointlist[0], color);

}

#endif

fix flash_scale;

#define FLASH_CYCLE_RATE f1_0

constexpr std::integral_constant<fix, FLASH_CYCLE_RATE> Flash_rate{};

//cycle the flashing light for when mine destroyed

namespace dsx {

void flash_frame()

{

        auto &LevelUniqueControlCenterState = LevelUniqueObjectState.ControlCenterState;

        static fixang flash_ang=0;

        if (Endlevel_sequence)

                return;

        if (PaletteBlueAdd > 10 )               //whiting out

                return;

//      flash_ang += fixmul(FLASH_CYCLE_RATE,FrameTime);

#if defined(DXX_BUILD_DESCENT_II)

        if (const auto Seismic_tremor_magnitude = LevelUniqueSeismicState.Seismic_tremor_magnitude)

        {

                fix     added_flash;

                added_flash = abs(Seismic_tremor_magnitude);

                if (added_flash < F1_0)

                        added_flash *= 16;

                flash_ang += fixmul(Flash_rate, fixmul(FrameTime, added_flash+F1_0));

                flash_scale = fix_fastsin(flash_ang);

                flash_scale = (flash_scale + F1_0*3)/4; //      gets in range 0.5 to 1.0

        } else

#endif

        if (LevelUniqueControlCenterState.Control_center_destroyed)

        {

                flash_ang += fixmul(Flash_rate,FrameTime);

                flash_scale = fix_fastsin(flash_ang);

                flash_scale = (flash_scale + f1_0)/2;

#if defined(DXX_BUILD_DESCENT_II)

                if (GameUniqueState.Difficulty_level == 0)

                        flash_scale = (flash_scale+F1_0*3)/4;

#endif

        }

}

static inline int is_alphablend_eclip(int eclip_num)

{

#if defined(DXX_BUILD_DESCENT_II)

        if (eclip_num == ECLIP_NUM_FORCE_FIELD || eclip_num == ECLIP_NUM_FORCE_FIELD2)

                return 1;

#endif

        return eclip_num == ECLIP_NUM_FUELCEN;

}

// ----------------------------------------------------------------------------

//      Render a face.

//      It would be nice to not have to pass in segnum and sidenum, but

//      they are used for our hideously hacked in headlight system.

//      vp is a pointer to vertex ids.

//      tmap1, tmap2 are texture map ids.  tmap2 is the pasty one.

static void render_face(grs_canvas &canvas, const shared_segment &segp, const unsigned sidenum, const unsigned nv, const std::array<unsigned, 4> &vp, const unsigned tmap1, const unsigned tmap2, std::array<g3s_uvl, 4> uvl_copy, const WALL_IS_DOORWAY_result_t wid_flags)

{

        auto &LevelUniqueControlCenterState = LevelUniqueObjectState.ControlCenterState;

        auto &TmapInfo = LevelUniqueTmapInfoState.TmapInfo;

        grs_bitmap  *bm;

        std::array<cg3s_point *, 4> pointlist;

        Assert(nv <= pointlist.size());

        range_for (const uint_fast32_t i, xrange(nv))

        {

                pointlist[i] = &Segment_points[vp[i]];

        }

#if defined(DXX_BUILD_DESCENT_I)

        (void)segp;

        (void)wid_flags;

#if !DXX_USE_EDITOR

        (void)sidenum;

#endif

#elif defined(DXX_BUILD_DESCENT_II)

        //handle cloaked walls

        if (wid_flags & WID_CLOAKED_FLAG) {

                const auto wall_num = segp.shared_segment::sides[sidenum].wall_num;

                auto &Walls = LevelUniqueWallSubsystemState.Walls;

                auto &vcwallptr = Walls.vcptr;

                gr_settransblend(canvas, vcwallptr(wall_num)->cloak_value, gr_blend::normal);

                const uint8_t color = BM_XRGB(0, 0, 0);

                // set to black (matters for s3)

                g3_draw_poly(canvas, nv, pointlist, color);    // draw as flat poly

                gr_settransblend(canvas, GR_FADE_OFF, gr_blend::normal);

                return;

        }

#endif

        if (tmap1 >= NumTextures) {

                Int3();

        }

#if DXX_USE_OGL

        grs_bitmap *bm2 = nullptr;

        if (!CGameArg.DbgUseOldTextureMerge)

        {

                PIGGY_PAGE_IN(Textures[tmap1]);

                bm = &GameBitmaps[Textures[tmap1].index];

                if (tmap2){

                        PIGGY_PAGE_IN(Textures[tmap2&0x3FFF]);

                        bm2 = &GameBitmaps[Textures[tmap2&0x3FFF].index];

                        if (bm2->get_flag_mask(BM_FLAG_SUPER_TRANSPARENT))

                        {

                                bm2 = nullptr;

                        bm = &texmerge_get_cached_bitmap( tmap1, tmap2 );

                        }

                }

        }else

#endif

                // New code for overlapping textures...

                if (tmap2 != 0) {

                        bm = &texmerge_get_cached_bitmap( tmap1, tmap2 );

                } else {

                        bm = &GameBitmaps[Textures[tmap1].index];

                        PIGGY_PAGE_IN(Textures[tmap1]);

                }

        assert(!bm->get_flag_mask(BM_FLAG_PAGED_OUT));

        std::array<g3s_lrgb, 4>         dyn_light;

#if defined(DXX_BUILD_DESCENT_I)

        const auto Seismic_tremor_magnitude = 0;

#elif defined(DXX_BUILD_DESCENT_II)

        const auto Seismic_tremor_magnitude = LevelUniqueSeismicState.Seismic_tremor_magnitude;

#endif

        const auto control_center_destroyed = LevelUniqueControlCenterState.Control_center_destroyed;

        const auto need_flashing_lights = (control_center_destroyed | Seismic_tremor_magnitude);        //make lights flash

        auto &Dynamic_light = LevelUniqueLightState.Dynamic_light;

        //set light values for each vertex & build pointlist

        range_for (const uint_fast32_t i, xrange(nv))

        {

                auto &dli = dyn_light[i];

                auto &uvli = uvl_copy[i];

                auto &Dlvpi = Dynamic_light[vp[i]];

                dli.r = dli.g = dli.b = uvli.l;

                //the uvl struct has static light already in it

                //scale static light for destruction effect

                if (need_flashing_lights)       //make lights flash

                        uvli.l = fixmul(flash_scale, uvli.l);

                //add in dynamic light (from explosions, etc.)

                uvli.l += (Dlvpi.r + Dlvpi.g + Dlvpi.b) / 3;

                //saturate at max value

                if (uvli.l > MAX_LIGHT)

                        uvli.l = MAX_LIGHT;

                // And now the same for the ACTUAL (rgb) light we want to use

                //scale static light for destruction effect

                if (need_flashing_lights)       //make lights flash

                {

                        dli.g = dli.b = fixmul(flash_scale, uvli.l);

                        dli.r = (!Seismic_tremor_magnitude && PlayerCfg.DynLightColor)

                                ? fixmul(std::max(static_cast<double>(flash_scale), f0_5 * 1.5), uvli.l) // let the mine glow red a little

                                : dli.g;

                }

                // add light color

                dli.r += Dlvpi.r;

                dli.g += Dlvpi.g;

                dli.b += Dlvpi.b;

                // saturate at max value

                if (dli.r > MAX_LIGHT)

                        dli.r = MAX_LIGHT;

                if (dli.g > MAX_LIGHT)

                        dli.g = MAX_LIGHT;

                if (dli.b > MAX_LIGHT)

                        dli.b = MAX_LIGHT;

                if (PlayerCfg.AlphaEffects) // due to additive blending, transparent sprites will become invivible in font of white surfaces (lamps). Fix that with a little desaturation

                {

                        dli.r *= .93;

                        dli.g *= .93;

                        dli.b *= .93;

                }

        }

        bool alpha = false;

        if (PlayerCfg.AlphaBlendEClips && is_alphablend_eclip(TmapInfo[tmap1].eclip_num)) // set nice transparency/blending for some special effects (if we do more, we should maybe use switch here)

        {

                alpha = true;

                gr_settransblend(canvas, GR_FADE_OFF, gr_blend::additive_c);

        }

#if DXX_USE_EDITOR

        if ((Render_only_bottom) && (sidenum == WBOTTOM))

                g3_draw_tmap(canvas, nv, pointlist, uvl_copy, dyn_light, GameBitmaps[Textures[Bottom_bitmap_num].index]);

        else

#endif

#if DXX_USE_OGL

                if (bm2){

                        g3_draw_tmap_2(canvas, nv, pointlist, uvl_copy, dyn_light, *bm, *bm2, ((tmap2 & 0xC000) >> 14) & 3);

                }else

#endif

                        g3_draw_tmap(canvas, nv, pointlist, uvl_copy, dyn_light, *bm);

        if (alpha)

                gr_settransblend(canvas, GR_FADE_OFF, gr_blend::normal); // revert any transparency / blending setting back to normal

#ifndef NDEBUG

        if (Outline_mode) draw_outline(canvas, nv, &pointlist[0]);

#endif

}

}

// ----------------------------------------------------------------------------

//      Only called if editor active.

//      Used to determine which face was clicked on.

static void check_face(grs_canvas &canvas, const vmsegidx_t segnum, const unsigned sidenum, const unsigned facenum, const unsigned nv, const std::array<unsigned, 4> &vp, const unsigned tmap1, const unsigned tmap2, const std::array<g3s_uvl, 4> &uvl_copy)

{

#if DXX_USE_EDITOR

        if (_search_mode) {

                std::array<g3s_lrgb, 4> dyn_light{};

                std::array<cg3s_point *, 4> pointlist;

#if DXX_USE_OGL

                (void)tmap1;

                (void)tmap2;

#else

                grs_bitmap *bm;

                if (tmap2 > 0 )

                        bm = &texmerge_get_cached_bitmap( tmap1, tmap2 );

                else

                        bm = &GameBitmaps[Textures[tmap1].index];

#endif

                range_for (const uint_fast32_t i, xrange(nv))

                {

                        dyn_light[i].r = dyn_light[i].g = dyn_light[i].b = uvl_copy[i].l;

                        pointlist[i] = &Segment_points[vp[i]];

                }

#if DXX_USE_OGL

                ogl_end_frame();

#endif

                {

                uint8_t color = 0;

                        gr_pixel(canvas.cv_bitmap, _search_x, _search_y, color);        //set our search pixel to color zero

                }

#if DXX_USE_OGL

                ogl_start_frame(canvas);

#endif

                {

#if DXX_USE_OGL

                        const uint8_t color = 1;

                        g3_draw_poly(canvas, nv, pointlist, color);

#else

                        const auto save_lighting = Lighting_on;

                        Lighting_on = 2;

                        g3_draw_tmap(canvas, nv, pointlist, uvl_copy, dyn_light, *bm);

                        Lighting_on = save_lighting;

#endif

                }

                if (gr_ugpixel(canvas.cv_bitmap,_search_x,_search_y) == 1) {

                        found_seg = segnum;

                        found_obj = object_none;

                        found_side = sidenum;

                        found_face = facenum;

                }

        }

#else

        (void)canvas;

        (void)segnum;

        (void)sidenum;

        (void)facenum;

        (void)nv;

        (void)vp;

        (void)tmap1;

        (void)tmap2;

        (void)uvl_copy;

#endif

}

template <std::size_t... N>

static inline void check_render_face(grs_canvas &canvas, std::index_sequence<N...>, const vcsegptridx_t segnum, const unsigned sidenum, const unsigned facenum, const std::array<unsigned, 4> &ovp, const unsigned tmap1, const unsigned tmap2, const std::array<uvl, 4> &uvlp, const WALL_IS_DOORWAY_result_t wid_flags, const std::size_t nv)

{

        const std::array<unsigned, 4> vp{{ovp[N]...}};

        const std::array<g3s_uvl, 4> uvl_copy{{

                {uvlp[N].u, uvlp[N].v, uvlp[N].l}...

        }};

        render_face(canvas, segnum, sidenum, nv, vp, tmap1, tmap2, uvl_copy, wid_flags);

        check_face(canvas, segnum, sidenum, facenum, nv, vp, tmap1, tmap2, uvl_copy);

}

template <std::size_t N0, std::size_t N1, std::size_t N2, std::size_t N3>

static inline void check_render_face(grs_canvas &canvas, std::index_sequence<N0, N1, N2, N3> is, const vcsegptridx_t segnum, const unsigned sidenum, const unsigned facenum, const std::array<unsigned, 4> &vp, const unsigned tmap1, const unsigned tmap2, const std::array<uvl, 4> &uvlp, const WALL_IS_DOORWAY_result_t wid_flags)

{

        check_render_face(canvas, is, segnum, sidenum, facenum, vp, tmap1, tmap2, uvlp, wid_flags, 4);

}

/* Avoid default constructing final element of uvl_copy; if any members

 * are default constructed, gcc zero initializes all members.

 */

template <std::size_t N0, std::size_t N1, std::size_t N2>

static inline void check_render_face(grs_canvas &canvas, std::index_sequence<N0, N1, N2>, const vcsegptridx_t segnum, const unsigned sidenum, const unsigned facenum, const std::array<unsigned, 4> &vp, const unsigned tmap1, const unsigned tmap2, const std::array<uvl, 4> &uvlp, const WALL_IS_DOORWAY_result_t wid_flags)

{

        check_render_face(canvas, std::index_sequence<N0, N1, N2, 3>(), segnum, sidenum, facenum, vp, tmap1, tmap2, uvlp, wid_flags, 3);

}

constexpr std::integral_constant<fix, (F1_0/4)> Tulate_min_dot{};

//--unused-- fix        Tulate_min_ratio = (2*F1_0);

constexpr std::integral_constant<fix, (F1_0*15/16)> Min_n0_n1_dot{};

// -----------------------------------------------------------------------------------

//      Render a side.

//      Check for normal facing.  If so, render faces on side dictated by sidep->type.

namespace dsx {

static void render_side(fvcvertptr &vcvertptr, grs_canvas &canvas, const vcsegptridx_t segp, const unsigned sidenum, const WALL_IS_DOORWAY_result_t wid_flags, const vms_vector &Viewer_eye)

{

        fix             min_dot, max_dot;

        if (!(wid_flags & WID_RENDER_FLAG))             //if (WALL_IS_DOORWAY(segp, sidenum) == WID_NO_WALL)

                return;

        const auto vertnum_list = get_side_verts(segp,sidenum);

        //      Regardless of whether this side is comprised of a single quad, or two triangles, we need to know one normal, so

        //      deal with it, get the dot product.

        const auto &sside = segp->shared_segment::sides[sidenum];

        const unsigned which_vertnum =

                (sside.get_type() == side_type::tri_13)

                        ? 1

                        : 0;

        const auto tvec = vm_vec_normalized_quick(vm_vec_sub(Viewer_eye, vcvertptr(vertnum_list[which_vertnum])));

        auto &normals = sside.normals;

        const auto v_dot_n0 = vm_vec_dot(tvec, normals[0]);

        //      ========== Mark: Here is the change...beginning here: ==========

        std::index_sequence<0, 1, 2, 3> is_quad;

        const auto &uside = segp->unique_segment::sides[sidenum];

        if (sside.get_type() == side_type::quad)

        {

                if (v_dot_n0 >= 0) {

                        check_render_face(canvas, is_quad, segp, sidenum, 0, vertnum_list, uside.tmap_num, uside.tmap_num2, uside.uvls, wid_flags);

                }

        } else {

                //      ========== Mark: The change ends here. ==========

                //      Although this side has been triangulated, because it is not planar, see if it is acceptable

                //      to render it as a single quadrilateral.  This is a function of how far away the viewer is, how non-planar

                //      the face is, how normal to the surfaces the view is.

                //      Now, if both dot products are close to 1.0, then render two triangles as a single quad.

                const auto v_dot_n1 = vm_vec_dot(tvec, normals[1]);

                if (v_dot_n0 < v_dot_n1) {

                        min_dot = v_dot_n0;

                        max_dot = v_dot_n1;

                } else {

                        min_dot = v_dot_n1;

                        max_dot = v_dot_n0;

                }

                //      Determine whether to detriangulate side: (speed hack, assumes Tulate_min_ratio == F1_0*2, should fixmul(min_dot, Tulate_min_ratio))

                if (DETRIANGULATION && ((min_dot+F1_0/256 > max_dot) || ((Viewer->segnum != segp) &&  (min_dot > Tulate_min_dot) && (max_dot < min_dot*2)))) {

                        fix     n0_dot_n1;

                        //      The other detriangulation code doesn't deal well with badly non-planar sides.

                        n0_dot_n1 = vm_vec_dot(normals[0], normals[1]);

                        if (n0_dot_n1 < Min_n0_n1_dot)

                                goto im_so_ashamed;

                        check_render_face(canvas, is_quad, segp, sidenum, 0, vertnum_list, uside.tmap_num, uside.tmap_num2, uside.uvls, wid_flags);

                } else {

im_so_ashamed: ;

                        if (sside.get_type() == side_type::tri_02)

                        {

                                if (v_dot_n0 >= 0) {

                                        check_render_face(canvas, std::index_sequence<0, 1, 2>(), segp, sidenum, 0, vertnum_list, uside.tmap_num, uside.tmap_num2, uside.uvls, wid_flags);

                                }

                                if (v_dot_n1 >= 0) {

                                        // want to render from vertices 0, 2, 3 on side

                                        check_render_face(canvas, std::index_sequence<0, 2, 3>(), segp, sidenum, 1, vertnum_list, uside.tmap_num, uside.tmap_num2, uside.uvls, wid_flags);

                                }

                        }

                        else if (sside.get_type() == side_type::tri_13)

                        {

                                if (v_dot_n1 >= 0) {

                                        // rendering 1,2,3, so just skip 0

                                        check_render_face(canvas, std::index_sequence<1, 2, 3>(), segp, sidenum, 1, vertnum_list, uside.tmap_num, uside.tmap_num2, uside.uvls, wid_flags);

                                }

                                if (v_dot_n0 >= 0) {

                                        // want to render from vertices 0,1,3

                                        check_render_face(canvas, std::index_sequence<0, 1, 3>(), segp, sidenum, 0, vertnum_list, uside.tmap_num, uside.tmap_num2, uside.uvls, wid_flags);

                                }

                        } else

                                throw shared_side::illegal_type(segp, sside);

                }

        }

}

#if DXX_USE_EDITOR

static void render_object_search(grs_canvas &canvas, const d_level_unique_light_state &LevelUniqueLightState, const vmobjptridx_t obj)

{

        int changed=0;

        //note that we draw each pixel object twice, since we cannot control

        //what color the object draws in, so we try color 0, then color 1,

        //in case the object itself is rendering color 0

        {

        const uint8_t color = 0;

        //set our search pixel to color zero

#if DXX_USE_OGL

        ogl_end_frame();

        // For OpenGL we use gr_rect instead of gr_pixel,

        // because in some implementations (like my Macbook Pro 5,1)

        // point smoothing can't be turned off.

        // Point smoothing would change the pixel to dark grey, but it MUST be black.

        // Making a 3x3 rectangle wouldn't matter

        // (but it only seems to draw a single pixel anyway)

        gr_rect(canvas, _search_x - 1, _search_y - 1, _search_x + 1, _search_y + 1, color);

        ogl_start_frame(canvas);

#else

        gr_pixel(canvas.cv_bitmap, _search_x, _search_y, color);

#endif

        }

        render_object(canvas, LevelUniqueLightState, obj);

        if (gr_ugpixel(canvas.cv_bitmap,_search_x,_search_y) != 0)

                changed=1;

        {

                const uint8_t color = 1;

#if DXX_USE_OGL

        ogl_end_frame();

        gr_rect(canvas, _search_x - 1, _search_y - 1, _search_x + 1, _search_y + 1, color);

        ogl_start_frame(canvas);

#else

        gr_pixel(canvas.cv_bitmap, _search_x, _search_y, color);

#endif

        }

        render_object(canvas, LevelUniqueLightState, obj);

        if (gr_ugpixel(canvas.cv_bitmap,_search_x,_search_y) != 1)

                changed=1;

        if (changed) {

                if (obj->segnum != segment_none)

                        Cursegp = imsegptridx(obj->segnum);

                found_seg = segment_none;

                found_obj = obj;

        }

}

#endif

static void do_render_object(grs_canvas &canvas, const d_level_unique_light_state &LevelUniqueLightState, const vmobjptridx_t obj, window_rendered_data &window)

{

#if DXX_USE_EDITOR

        int save_3d_outline=0;

        #endif

        int count = 0;

        #ifndef NDEBUG

        if (object_rendered[obj]) {             //already rendered this...

                Int3();         //get Matt!!!

                return;

        }

        object_rendered[obj] = true;

        #endif

#if defined(DXX_BUILD_DESCENT_II)

   if (Newdemo_state==ND_STATE_PLAYBACK)  

         {

          if ((DemoDoingLeft==6 || DemoDoingRight==6) && obj->type==OBJ_PLAYER)

                {

                        // A nice fat hack: keeps the player ship from showing up in the

                        // small extra view when guiding a missile in the big window

                        return;

                }

         }

#endif

        //      Added by MK on 09/07/94 (at about 5:28 pm, CDT, on a beautiful, sunny late summer day!) so

        //      that the guided missile system will know what objects to look at.

        //      I didn't know we had guided missiles before the release of D1. --MK

        if (obj->type == OBJ_ROBOT)

                window.rendered_robots.emplace_back(obj);

        if ((count++ > MAX_OBJECTS) || (obj->next == obj)) {

                Int3();                                 // infinite loop detected

                obj->next = object_none;                // won't this clean things up?

                return;                                 // get out of this infinite loop!

        }

                //g3_draw_object(obj->class_id,&obj->pos,&obj->orient,obj->size);

        //check for editor object

#if DXX_USE_EDITOR

        if (EditorWindow && obj==Cur_object_index) {

                save_3d_outline = g3d_interp_outline;

                g3d_interp_outline=1;

        }

        #endif

#if DXX_USE_EDITOR

        if (_search_mode)

                render_object_search(canvas, LevelUniqueLightState, obj);

        else

        #endif

                //NOTE LINK TO ABOVE

                render_object(canvas, LevelUniqueLightState, obj);

        for (auto n = obj->attached_obj; n != object_none;)

        {

                const auto &&o = obj.absolute_sibling(n);

                Assert(o->type == OBJ_FIREBALL);

                Assert(o->control_type == CT_EXPLOSION);

                Assert(o->flags & OF_ATTACHED);

                n = o->ctype.expl_info.next_attach;

                render_object(canvas, LevelUniqueLightState, o);

        }

#if DXX_USE_EDITOR

        if (EditorWindow && obj==Cur_object_index)

                g3d_interp_outline = save_3d_outline;

        #endif

}

}

//increment counter for checking if points rotated

//This must be called at the start of the frame if rotate_list() will be used

void render_start_frame()

{

        if (s_current_generation == std::numeric_limits<decltype(s_current_generation)>::max())

        {

                Segment_points = {};

                s_current_generation = 0;

        }

        ++ s_current_generation;

}

//Given a lit of point numbers, rotate any that haven't been rotated this frame

g3s_codes rotate_list(fvcvertptr &vcvertptr, const std::size_t nv, const unsigned *const pointnumlist)

{

        g3s_codes cc;

        const auto current_generation = s_current_generation;

        const auto cheats_acid = cheats.acid;

        const float f = likely(!cheats_acid)

                ? 0.0f /* unused */

                : 2.0f * (static_cast<float>(timer_query()) / F1_0);

        range_for (const auto pnum, unchecked_partial_range(pointnumlist, nv))

        {

                auto &pnt = Segment_points[pnum];

                if (pnt.p3_last_generation != current_generation)

                {

                        pnt.p3_last_generation = current_generation;

                        auto &v = *vcvertptr(pnum);

                        vertex tmpv;

                        g3_rotate_point(pnt, likely(!cheats_acid) ? v : (

                                tmpv = v,

                                tmpv.x += fl2f(sinf(f + f2fl(tmpv.x))),

                                tmpv.y += fl2f(sinf(f * 1.5f + f2fl(tmpv.y))),

                                tmpv.z += fl2f(sinf(f * 2.5f + f2fl(tmpv.z))),

                                tmpv

                        ));

                }

                cc.uand &= pnt.p3_codes;

                cc.uor  |= pnt.p3_codes;

        }

        return cc;

}

//Given a lit of point numbers, project any that haven't been projected

static void project_list(const std::array<unsigned, 8> &pointnumlist)

{

        range_for (const auto pnum, pointnumlist)

        {

                auto &p = Segment_points[pnum];

                if (!(p.p3_flags & PF_PROJECTED))

                        g3_project_point(p);

        }

}

// -----------------------------------------------------------------------------------

#if !DXX_USE_OGL

namespace dsx {

static void render_segment(fvcvertptr &vcvertptr, fvcwallptr &vcwallptr, const vms_vector &Viewer_eye, grs_canvas &canvas, const vcsegptridx_t seg)

{

        if (!rotate_list(vcvertptr, seg->verts).uand)

        {               //all off screen?

#if defined(DXX_BUILD_DESCENT_II)

                if (Viewer->type != OBJ_ROBOT)

#endif

                {

                        LevelUniqueAutomapState.Automap_visited[seg] = 1;

                }

                range_for (const uint_fast32_t sn, xrange(MAX_SIDES_PER_SEGMENT))

                        render_side(vcvertptr, canvas, seg, sn, WALL_IS_DOORWAY(GameBitmaps, Textures, vcwallptr, seg, sn), Viewer_eye);

        }

        //draw any objects that happen to be in this segment

        //sort objects!

        //object_sort_segment_objects( seg );

}

}

#endif

#if DXX_USE_EDITOR