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.

*/

/*

 *

 * Include file for functions which need to access segment data structure.

 *

 */

#pragma once

#include <physfs.h>

#include <type_traits>

#include "pstypes.h"

#include "maths.h"

#include "vecmat.h"

#include "dxxsconf.h"

#include "dsx-ns.h"

#ifdef __cplusplus

#include <cassert>

#include <cstdint>

#include <stdexcept>

#include "fwd-segment.h"

#include "countarray.h"

#include "valptridx.h"

#include "objnum.h"

#include "pack.h"

#ifdef dsx

namespace dsx {

// Returns true if segnum references a child, else returns false.

// Note that -1 means no connection, -2 means a connection to the outside world.

static inline bool IS_CHILD(segnum_t s)

{

        return s != segment_none && s != segment_exit;

}

}

#endif

namespace dcx {

//Structure for storing u,v,light values.

//NOTE: this structure should be the same as the one in 3d.h

struct uvl

{

        fix u, v, l;

};

enum class side_type : uint8_t

{

        quad = 1,       // render side as quadrilateral

        tri_02 = 2,     // render side as two triangles, triangulated along edge from 0 to 2

        tri_13 = 3,     // render side as two triangles, triangulated along edge from 1 to 3

};

#if 0

struct wallnum_t : prohibit_void_ptr<wallnum_t>

{

        typedef int16_t integral_type;

        integral_type value;

        wallnum_t() = default;

        wallnum_t(const integral_type &v) : value(v)

        {

#ifdef DXX_HAVE_BUILTIN_CONSTANT_P

                if (__builtin_constant_p(v))

                        DXX_ALWAYS_ERROR_FUNCTION(dxx_trap_constant_wall, "constant wall number constructed");

#endif

        }

        wallnum_t &operator=(integral_type v)

        {

#ifdef DXX_HAVE_BUILTIN_CONSTANT_P

                if (__builtin_constant_p(v))

                        DXX_ALWAYS_ERROR_FUNCTION(dxx_trap_constant_wall, "constant wall number assigned");

#endif

                value = v;

                return *this;

        }

        template <integral_type I>

                wallnum_t &operator=(const wall_magic_constant_t<I> &)

                {

                        value = I;

                        return *this;

                }

        bool operator==(const wallnum_t &v) const { return value == v.value; }

        bool operator==(const int &v) const

        {

#ifdef DXX_HAVE_BUILTIN_CONSTANT_P

                if (__builtin_constant_p(v))

                        DXX_ALWAYS_ERROR_FUNCTION(dxx_trap_constant_wall, "constant wall number compared");

#endif

                return value == v;

        }

        template <integral_type I>

                bool operator==(const wall_magic_constant_t<I> &) const { return value == I; }

        template <typename T>

                bool operator!=(const T &v) const { return !(*this == v); }

        template <typename T>

                bool operator==(const T &v) const = delete;

        template <typename T>

                bool operator<(const T &v) const

                {

                        static_assert(std::is_integral<T>::value, "non-integral wall number compared");

#ifdef DXX_HAVE_BUILTIN_CONSTANT_P

                        if (__builtin_constant_p(v))

                                DXX_ALWAYS_ERROR_FUNCTION(dxx_trap_constant_wall, "constant wall number compared");

#endif

                        return value < v;

                }

        template <typename T>

                bool operator>(const T &v) const

                {

                        return v < *this;

                }

        template <typename T>

                bool operator<=(const T &) const = delete;

        template <typename T>

                bool operator>=(const T &) const = delete;

        constexpr operator integral_type() const { return value; }

        operator integral_type &() { return value; }

};

#endif

struct shared_side

{

        struct illegal_type;

        side_type m_type;           // replaces num_faces and tri_edge, 1 = quad, 2 = 0:2 triangulation, 3 = 1:3 triangulation

        const side_type &get_type() const { return m_type; }

        void set_type(side_type t) { m_type = t; }

        wallnum_t wall_num;

        std::array<vms_vector, 2> normals;  // 2 normals, if quadrilateral, both the same.

};

struct unique_side

{

        int16_t tmap_num;

        int16_t tmap_num2;

        std::array<uvl, 4>     uvls;

};

#ifdef dsx

struct shared_segment

{

#if DXX_USE_EDITOR

        segnum_t   segnum;     // segment number, not sure what it means

        short   group;      // group number to which the segment belongs.

#endif

        std::array<segnum_t, MAX_SIDES_PER_SEGMENT>   children;    // indices of 6 children segments, front, left, top, right, bottom, back

        std::array<unsigned, MAX_VERTICES_PER_SEGMENT> verts;    // vertex ids of 4 front and 4 back vertices

        uint8_t special;    // what type of center this is

        int8_t matcen_num; // which center segment is associated with.

        uint8_t station_idx;

        /* if DXX_BUILD_DESCENT_II */

        uint8_t s2_flags;

        /* endif */

        std::array<shared_side, MAX_SIDES_PER_SEGMENT> sides;

};

struct unique_segment

{

        objnum_t objects;    // pointer to objects in this segment

        //      If bit n (1 << n) is set, then side #n in segment has had light subtracted from original (editor-computed) value.

        uint8_t light_subtracted;

        /* if DXX_BUILD_DESCENT_II */

        uint8_t slide_textures;

        /* endif */

        fix     static_light;

        std::array<unique_side, MAX_SIDES_PER_SEGMENT> sides;

};

struct segment : unique_segment, shared_segment

{

};

template <typename S, typename U>

struct susegment

{

        using qualified_segment = typename std::conditional<std::is_const<S>::value && std::is_const<U>::value, const segment, segment>::type;

        S &s;

        U &u;

        constexpr susegment(qualified_segment &b) :

                s(b), u(b)

        {

        }

        constexpr susegment(const susegment &) = default;

        constexpr susegment(susegment &&) = default;

        template <typename S2, typename U2, typename std::enable_if<std::is_convertible<S2 &, S &>::value && std::is_convertible<U2 &, U &>::value, int>::type = 0>

                constexpr susegment(const susegment<S2, U2> &r) :

                        s(r.s), u(r.u)

        {

        }

        template <typename T, typename std::enable_if<std::is_convertible<T &&, qualified_segment &>::value, int>::type = 0>

                constexpr susegment(T &&t) :

                        susegment(static_cast<qualified_segment &>(t))

        {

        }

        operator S &() const

        {

                return s;

        }

        operator U &() const

        {

                return u;

        }

};

#endif

struct count_segment_array_t : public count_array_t<segnum_t, MAX_SEGMENTS> {};

struct group

{

        struct segment_array_type_t : public count_segment_array_t {};

        struct vertex_array_type_t : public count_array_t<unsigned, MAX_VERTICES> {};

        segment_array_type_t segments;

        vertex_array_type_t vertices;

        void clear()

        {

                segments.clear();

                vertices.clear();

        }

};

#ifdef dsx

#define Highest_segment_index (Segments.get_count() - 1)

DXX_VALPTRIDX_DEFINE_GLOBAL_FACTORIES(segment, seg, Segments);

#endif

// Globals from mglobal.c

struct vertex : vms_vector

{

        vertex() = default;

        vertex(const fix &a, const fix &b, const fix &c) :

                vms_vector{a, b, c}

        {

        }

        explicit vertex(const vms_vector &v) :

                vms_vector(v)

        {

        }

};

}

#ifdef dsx

struct shared_side::illegal_type : std::runtime_error

{

        const shared_segment *const m_segment;

        const shared_side *const m_side;

        illegal_type(const shared_segment &seg, const shared_side &s) :

                runtime_error("illegal side type"),

                m_segment(&seg), m_side(&s)

        {

        }

        illegal_type(const shared_side &s) :

                runtime_error("illegal side type"),

                m_segment(nullptr), m_side(&s)

        {

        }

};

namespace dsx {

#if defined(DXX_BUILD_DESCENT_II)

// New stuff, 10/14/95: For shooting out lights and monitors.

// Light cast upon vert_light vertices in segnum:sidenum by some light

struct delta_light : prohibit_void_ptr<delta_light>

{

        segnum_t   segnum;

        uint8_t   sidenum;

        std::array<ubyte, 4>   vert_light;

};

// Light at segnum:sidenum casts light on count sides beginning at index (in array Delta_lights)

struct dl_index {

        segnum_t   segnum;

        uint8_t   sidenum;

        uint8_t count;

        uint16_t index;

        bool operator<(const dl_index &rhs) const

        {

                if (segnum < rhs.segnum)

                        return true;

                if (segnum > rhs.segnum)

                        return false;

                return sidenum < rhs.sidenum;

        }

};

struct d_level_shared_destructible_light_state

{

        valptridx<dl_index>::array_managed_type Dl_indices;

        d_delta_light_array Delta_lights;

};

#endif

}

#endif

namespace dcx {

#ifdef dsx

struct d_level_shared_vertex_state

{

        unsigned Num_vertices;

private:

        vertex_array Vertices;

#if DXX_USE_EDITOR

        std::array<uint8_t, MAX_VERTICES> Vertex_active; // !0 means vertex is in use, 0 means not in use.

#endif

public:

        auto &get_vertices()

        {

                return Vertices;

        }

        const auto &get_vertices() const

        {

                return Vertices;

        }

#if DXX_USE_EDITOR

        auto &get_vertex_active()

        {

                return Vertex_active;

        }

        const auto &get_vertex_active() const

        {

                return Vertex_active;

        }

#endif

};

struct d_level_shared_segment_state

{

        unsigned Num_segments;

        d_level_shared_vertex_state LevelSharedVertexState;

        auto &get_segments()

        {

                return Segments;

        }

        const auto &get_segments() const

        {

                return Segments;

        }

        auto &get_vertex_state()

        {

                return LevelSharedVertexState;

        }

        const auto &get_vertex_state() const

        {

                return LevelSharedVertexState;

        }

};

struct d_level_unique_automap_state

{

        std::array<uint8_t, MAX_SEGMENTS> Automap_visited;

};

struct d_level_unique_segment_state

{

        auto &get_segments()

        {

                return Segments;

        }

        const auto &get_segments() const

        {

                return Segments;

        }

};

extern d_level_unique_automap_state LevelUniqueAutomapState;

extern d_level_unique_segment_state LevelUniqueSegmentState;

#endif

template <unsigned bits>

class visited_segment_mask_base

{

        static_assert(bits == 1 || bits == 2 || bits == 4, "bits must align in bytes");

protected:

        enum

        {

                divisor = 8 / bits,

        };

        using array_t = std::array<uint8_t, (MAX_SEGMENTS + (divisor - 1)) / divisor>;

        typedef typename array_t::size_type size_type;

        array_t a;

        struct maskproxy_shift_count_type

        {

                using bitmask_low_aligned = std::integral_constant<unsigned, (1 << bits) - 1>;

                const unsigned m_shift;

                unsigned shift() const

                {

                        return m_shift;

                }

                typename array_t::value_type mask() const

                {

                        return bitmask_low_aligned() << shift();

                }

                maskproxy_shift_count_type(const unsigned s) :

                        m_shift(s * bits)

                {

                }

        };

        template <typename R>

        struct maskproxy_byte_reference : public maskproxy_shift_count_type

        {

                R m_byte;

                maskproxy_byte_reference(R byte, const unsigned s) :

                        maskproxy_shift_count_type(s), m_byte(byte)

                {

                }

                operator uint8_t() const

                {

                        return (this->m_byte >> this->shift()) & typename maskproxy_shift_count_type::bitmask_low_aligned();

                }

        };

        template <typename R>

        struct maskproxy_assignable_type : maskproxy_byte_reference<R>

        {

                DXX_INHERIT_CONSTRUCTORS(maskproxy_assignable_type, maskproxy_byte_reference<R>);

                using typename maskproxy_shift_count_type::bitmask_low_aligned;

                maskproxy_assignable_type &operator=(const uint8_t u)

                {

                        assert(!(u & ~bitmask_low_aligned()));

                        auto &byte = this->m_byte;

                        byte = (byte & ~this->mask()) | (u << this->shift());

                        return *this;

                }

                maskproxy_assignable_type &operator|=(const uint8_t u)

                {

                        assert(!(u & ~bitmask_low_aligned()));

                        this->m_byte |= (u << this->shift());

                        return *this;

                }

        };

        template <typename R, typename A>

        static R make_maskproxy(A &a, const size_type segnum)

        {

                const size_type idx = segnum / divisor;

                if (idx >= a.size())

                        throw std::out_of_range("index exceeds segment range");

                const size_type bit = segnum % divisor;

                return R(a[idx], bit);

        }

public:

        /* Explicitly invoke the default constructor for `a` so that the

         * storage is cleared.

         */

        visited_segment_mask_base() :

                a()

        {

        }

        void clear()

        {

                a = {};

        }

};

template <>

template <typename R>

struct visited_segment_mask_base<1>::maskproxy_assignable_type : maskproxy_byte_reference<R>

{

        DXX_INHERIT_CONSTRUCTORS(maskproxy_assignable_type, maskproxy_byte_reference<R>);

        maskproxy_assignable_type &operator=(const bool b)

        {

                const auto m = this->mask();

                auto &byte = this->m_byte;

                if (b)

                        byte |= m;

                else

                        byte &= ~m;

                return *this;

        }

};

/* This type must be separate so that its members are defined after the

 * specialization of maskproxy_assignable_type.  If these are defined

 * inline in visited_segment_mask_base, gcc crashes.

 * Known bad:

 *      gcc-4.9.4

 *      gcc-5.4.0

 *      gcc-6.4.0

 *      gcc-7.2.0

 */

template <unsigned bits>

class visited_segment_mask_t : visited_segment_mask_base<bits>

{

        using base_type = visited_segment_mask_base<bits>;

public:

        auto operator[](const typename base_type::size_type segnum)

        {

                return this->template make_maskproxy<typename base_type::template maskproxy_assignable_type<typename base_type::array_t::reference>>(this->a, segnum);

        }

        auto operator[](const typename base_type::size_type segnum) const

        {

                return this->template make_maskproxy<typename base_type::template maskproxy_assignable_type<typename base_type::array_t::const_reference>>(this->a, segnum);

        }

};

}

#ifdef dsx

namespace dsx {

#if defined(DXX_BUILD_DESCENT_II)

struct d_level_shared_segment_state : ::dcx::d_level_shared_segment_state

{

        d_level_shared_destructible_light_state DestructibleLights;

        segnum_t Secret_return_segment;

        vms_matrix Secret_return_orient;

};

#endif

extern d_level_shared_segment_state LevelSharedSegmentState;

}

#endif

#endif