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-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Morphing code

 *

 */

#include <algorithm>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "texmap.h"

#include "dxxerror.h"

#include "inferno.h"

#include "polyobj.h"

#include "game.h"

#include "lighting.h"

#include "newdemo.h"

#include "piggy.h"

#include "bm.h"

#include "interp.h"

#include "render.h"

#include "object.h"

#include "compiler-poison.h"

#include "compiler-range_for.h"

#include "d_enumerate.h"

#include "d_range.h"

#include "d_zip.h"

#include "partial_range.h"

using std::max;

namespace dcx {

namespace {

class invalid_morph_model_type : public std::runtime_error

{

        __attribute_cold

        static std::string prepare_message(const unsigned type)

        {

                char buf[32 + sizeof("4294967295")];

                const auto len = std::snprintf(buf, sizeof buf, "invalid morph model type: %u", type);

                return std::string(buf, len);

        }

public:

        invalid_morph_model_type(const unsigned type) :

                runtime_error(prepare_message(type))

        {

        }

};

class invalid_morph_model_vertex_count : public std::runtime_error

{

        __attribute_cold

        static std::string prepare_message(const unsigned count, const morph_data::polymodel_idx idx, const unsigned submodel_num)

        {

                char buf[68 + 3 * sizeof("4294967295")];

                const unsigned uidx = idx.idx;

                const auto len = std::snprintf(buf, sizeof buf, "too many vertices in morph model: found %u in model %u, submodel %u", count, uidx, submodel_num);

                return std::string(buf, len);

        }

public:

        invalid_morph_model_vertex_count(const unsigned count, const morph_data::polymodel_idx idx, const unsigned submodel_num) :

                runtime_error(prepare_message(count, idx, submodel_num))

        {

        }

};

struct submodel_data

{

        const uint16_t *body;

        const unsigned type;

        const unsigned nverts;

        const unsigned startpoint;

};

submodel_data parse_model_data_header(const polymodel &pm, const unsigned submodel_num)

{

        auto data = reinterpret_cast<const uint16_t *>(&pm.model_data[pm.submodel_ptrs[submodel_num]]);

        const auto ptype = data++;

        const uint16_t type = *ptype;

        const auto pnverts = data++;

        const uint16_t startpoint = (type == 7)

                ? *std::exchange(data, data + 2)                //get start point number, skip pad

                : (type == 1)

                ? 0                             //start at zero

                : throw invalid_morph_model_type(type);

        const uint16_t nverts = *pnverts;

        return {data, type, nverts, startpoint};

}

std::size_t count_submodel_points(const polymodel &pm, const morph_data::polymodel_idx model_idx, const unsigned submodel_num)

{

        /* Return the minimum array size that will not cause this submodel

         * to index past the end of the array.

         */

        const auto &&sd = parse_model_data_header(pm, submodel_num);

        const std::size_t count = sd.startpoint + sd.nverts;

        if (count > morph_data::MAX_VECS)

                throw invalid_morph_model_vertex_count(count, model_idx, submodel_num);

        return count;

}

std::size_t count_model_points(const polymodel &pm, const morph_data::polymodel_idx model_idx)

{

        /* Return the minimum array size that will not cause any used

         * submodel of this model to index past the end of the array.

         *

         * Unused submodels are not considered.  A submodel is used if:

         * - its index is not above pm.n_models

         * - its parent index is valid

         * - its parent index is a used submodel

         *

         * Submodel 0 is always used.

         */

        auto count = count_submodel_points(pm, model_idx, 0);

        unsigned visited_submodels = 1;

        const unsigned mask_all_enabled_models = (1 << pm.n_models) - 1;

        const auto &&submodel_parents = enumerate(partial_range(pm.submodel_parents, pm.n_models));

        for (;;)

        {

                if (visited_submodels == mask_all_enabled_models)

                        /* Every submodel has been checked, so the next pass through

                         * the loop will ignore every element.  Break out early to

                         * avoid the extra iteration.

                         */

                        break;

                const auto previous_visited_submodels = visited_submodels;

                range_for (auto &&e, submodel_parents)

                {

                        const unsigned mask_this_submodel = 1 << e.idx;

                        if (mask_this_submodel & visited_submodels)

                                /* Already tested on a prior iteration */

                                continue;

                        if (e.value >= pm.submodel_parents.size())

                                /* Ignore submodels with out-of-range parents.  This

                                 * avoids undefined behavior in the shift, since some

                                 * submodels have a parent of 0xff.

                                 */

                                continue;

                        const unsigned mask_parent_submodel = 1 << e.value;

                        if (mask_parent_submodel & visited_submodels)

                        {

                                visited_submodels |= mask_this_submodel;

                                /* Parent is in use, so this submodel is also in use. */

                                const auto subcount = count_submodel_points(pm, model_idx, e.idx);

                                count = std::max(count, subcount);

                        }

                }

                if (previous_visited_submodels == visited_submodels)

                        /* No changes on the most recent pass, so no changes will

                         * occur on any subsequent pass.  Break out.

                         */

                        break;

        }

        return count;

}

}

void *morph_data::operator new(std::size_t, const max_vectors max_vecs)

{

        return ::operator new(sizeof(morph_data) + (max_vecs.count * (sizeof(fix) + sizeof(vms_vector) + sizeof(vms_vector))));

}

morph_data::ptr morph_data::create(object_base &o, const polymodel &pm, const polymodel_idx model_idx)

{

        const max_vectors m{count_model_points(pm, model_idx)};

        /* This is an unusual form of `new` overload.  Although arguments to

         * `new` are typically considered a use of `placement new`, this is

         * not used to place the object.  Instead, it is used to pass extra

         * information to `operator new` so that the count of allocated

         * bytes can be adjusted.

         */

        return ptr(new(m) morph_data(o, m));

}

morph_data::morph_data(object_base &o, const max_vectors m) :

        obj(&o), Morph_sig(o.signature), max_vecs(m)

{

        DXX_POISON_VAR(submodel_active, 0xcc);

        const auto morph_times = get_morph_times();

        DXX_POISON_MEMORY(morph_times.begin(), morph_times.end(), 0xcc);

        const auto morph_vecs = get_morph_times();

        DXX_POISON_MEMORY(morph_vecs.begin(), morph_vecs.end(), 0xcc);

        const auto morph_deltas = get_morph_times();

        DXX_POISON_MEMORY(morph_deltas.begin(), morph_deltas.end(), 0xcc);

        DXX_POISON_VAR(n_morphing_points, 0xcc);

        DXX_POISON_VAR(submodel_startpoints, 0xcc);

}

span<fix> morph_data::get_morph_times()

{

        return {reinterpret_cast<fix *>(this + 1), max_vecs.count};

}

span<vms_vector> morph_data::get_morph_vecs()

{

        return {reinterpret_cast<vms_vector *>(get_morph_times().end()), max_vecs.count};

}

span<vms_vector> morph_data::get_morph_deltas()

{

        return {get_morph_vecs().end(), max_vecs.count};

}

d_level_unique_morph_object_state::~d_level_unique_morph_object_state() = default;

//returns ptr to data for this object, or NULL if none

morph_data::ptr *find_morph_data(d_level_unique_morph_object_state &LevelUniqueMorphObjectState, object_base &obj)

{

        auto &morph_objects = LevelUniqueMorphObjectState.morph_objects;

        if (Newdemo_state == ND_STATE_PLAYBACK) {

                return nullptr;

        }

        range_for (auto &i, morph_objects)

                if (i && i->obj == &obj)

                        return &i;

        return nullptr;

}

}

static void assign_max(fix &a, const fix &b)

{

        a = std::max(a, b);

}

static void assign_min(fix &a, const fix &b)

{

        a = std::min(a, b);

}

static void update_bounds(vms_vector &minv, vms_vector &maxv, const vms_vector &v, fix vms_vector::*const p)

{

        auto &mx = maxv.*p;

        assign_max(mx, v.*p);

        auto &mn = minv.*p;

        assign_min(mn, v.*p);

}

//takes pm, fills in min & max

static void find_min_max(const polymodel &pm, const unsigned submodel_num, vms_vector &minv, vms_vector &maxv)

{

        const auto &&sd = parse_model_data_header(pm, submodel_num);

        const unsigned nverts = sd.nverts;

        if (!nverts)

        {

                minv = maxv = {};

                return;

        }

        const auto vp = reinterpret_cast<const vms_vector *>(sd.body);

        minv = maxv = *vp;

        range_for (auto &v, unchecked_partial_range(vp + 1, nverts - 1))

        {

                update_bounds(minv, maxv, v, &vms_vector::x);

                update_bounds(minv, maxv, v, &vms_vector::y);

                update_bounds(minv, maxv, v, &vms_vector::z);

        }

}

#define MORPH_RATE (f1_0*3)

constexpr fix morph_rate = MORPH_RATE;

static fix update_bounding_box_extent(const vms_vector &vp, const vms_vector &box_size, fix vms_vector::*const p, const fix entry_extent)

{

        if (!(vp.*p))

                return entry_extent;

        const auto box_size_p = box_size.*p;

        const auto abs_vp_p = abs(vp.*p);

        if (f2i(box_size_p) >= abs_vp_p / 2)

                return entry_extent;

        const fix t = fixdiv(box_size_p, abs_vp_p);

        return std::min(entry_extent, t);

}

static fix compute_bounding_box_extents(const vms_vector &vp, const vms_vector &box_size)

{

        fix k = INT32_MAX;

        k = update_bounding_box_extent(vp, box_size, &vms_vector::x, k);

        k = update_bounding_box_extent(vp, box_size, &vms_vector::y, k);

        k = update_bounding_box_extent(vp, box_size, &vms_vector::z, k);

        return k;

}

static void init_points(const polymodel &pm, const vms_vector *const box_size, const unsigned submodel_num, morph_data *const md)

{

        const auto &&sd = parse_model_data_header(pm, submodel_num);

        const unsigned startpoint = sd.startpoint;

        const unsigned endpoint = sd.startpoint + sd.nverts;

        md->submodel_active[submodel_num] = morph_data::submodel_state::animating;

        md->n_morphing_points[submodel_num] = 0;

        md->submodel_startpoints[submodel_num] = startpoint;

        const auto morph_times = md->get_morph_times();

        const auto morph_vecs = md->get_morph_vecs();

        const auto morph_deltas = md->get_morph_deltas();

        auto &&zr = zip(

                unchecked_partial_range(reinterpret_cast<const vms_vector *>(sd.body), sd.nverts),

                partial_range(morph_vecs, startpoint, endpoint),

                partial_range(morph_deltas, startpoint, endpoint),

                partial_range(morph_times, startpoint, endpoint)

        );

        range_for (auto &&z, zr)

        {

                const auto vp = &std::get<0>(z);

                auto &morph_vec = std::get<1>(z);

                auto &morph_delta = std::get<2>(z);

                auto &morph_time = std::get<3>(z);

                fix k;

                if (box_size && (k = compute_bounding_box_extents(*vp, *box_size) != INT32_MAX))

                        vm_vec_copy_scale(morph_vec, *vp, k);

                else

                        morph_vec = {};

                const fix dist = vm_vec_normalized_dir_quick(morph_delta, *vp, morph_vec);

                morph_time = fixdiv(dist, morph_rate);

                if (morph_time != 0)

                        md->n_morphing_points[submodel_num]++;

                vm_vec_scale(morph_delta, morph_rate);

        }

}

static void update_points(const polymodel &pm, const unsigned submodel_num, morph_data *const md)

{

        const auto &&sd = parse_model_data_header(pm, submodel_num);

        const unsigned startpoint = sd.startpoint;

        const unsigned endpoint = startpoint + sd.nverts;

        const auto morph_times = md->get_morph_times();

        const auto morph_vecs = md->get_morph_vecs();

        const auto morph_deltas = md->get_morph_deltas();

        auto &&zr = zip(

                unchecked_partial_range(reinterpret_cast<const vms_vector *>(sd.body), sd.nverts),

                partial_range(morph_vecs, startpoint, endpoint),

                partial_range(morph_deltas, startpoint, endpoint),

                partial_range(morph_times, startpoint, endpoint)

        );

        range_for (auto &&z, zr)

        {

                const auto vp = &std::get<0>(z);

                auto &morph_vec = std::get<1>(z);

                auto &morph_delta = std::get<2>(z);

                auto &morph_time = std::get<3>(z);

                if (morph_time)         //not done yet

                {

                        if ((morph_time -= FrameTime) <= 0) {

                                morph_vec = *vp;

                                morph_time = 0;

                                md->n_morphing_points[submodel_num]--;

                        }

                        else

                                vm_vec_scale_add2(morph_vec, morph_delta, FrameTime);

                }

        }

}

//process the morphing object for one frame

void do_morph_frame(object &obj)

{

        auto &LevelUniqueMorphObjectState = LevelUniqueObjectState.MorphObjectState;

        const auto umd = find_morph_data(LevelUniqueMorphObjectState, obj);

        if (!umd) {                                     //maybe loaded half-morphed from disk

                obj.flags |= OF_SHOULD_BE_DEAD;         //..so kill it

                return;

        }

        const auto md = umd->get();

        assert(md->obj == &obj);

        auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

        const polymodel &pm = Polygon_models[obj.rtype.pobj_info.model_num];

        const auto n_models = pm.n_models;

        range_for (const auto &&zi, zip(xrange(n_models), md->submodel_active, md->n_morphing_points))

        {

                const unsigned i = std::get<0>(zi);

                auto &submodel_active = std::get<1>(zi);

                if (submodel_active == morph_data::submodel_state::animating)

                {

                        update_points(pm,i,md);

                        const auto &n_morphing_points = std::get<2>(zi);

                        if (n_morphing_points == 0) {           //maybe start submodel

                                submodel_active = morph_data::submodel_state::visible;          //not animating, just visible

                                md->n_submodels_active--;               //this one done animating

                                range_for (const auto &&zt, zip(xrange(n_models), pm.submodel_parents))

                                {

                                        auto &submodel_parents = std::get<1>(zt);

                                        if (submodel_parents == i)

                                        {               //start this one

                                                const auto t = std::get<0>(zt);

                                                init_points(pm,nullptr,t,md);

                                                md->n_submodels_active++;

                                        }

                                }

                        }

                }

        }

        if (!md->n_submodels_active) {                  //done morphing!

                obj.control_type = md->morph_save_control_type;

                set_object_movement_type(obj, md->morph_save_movement_type);

                obj.render_type = RT_POLYOBJ;

                obj.mtype.phys_info = md->morph_save_phys_info;

                umd->reset();

        }

}

constexpr vms_vector morph_rotvel{0x4000,0x2000,0x1000};

void init_morphs()

{

        auto &LevelUniqueMorphObjectState = LevelUniqueObjectState.MorphObjectState;

        auto &morph_objects = LevelUniqueMorphObjectState.morph_objects;

        morph_objects = {};

}

//make the object morph

void morph_start(d_level_unique_morph_object_state &LevelUniqueMorphObjectState, d_level_shared_polygon_model_state &LevelSharedPolygonModelState, object_base &obj)

{

        vms_vector pmmin,pmmax;

        vms_vector box_size;

        auto &morph_objects = LevelUniqueMorphObjectState.morph_objects;

        const auto mob = morph_objects.begin();

        const auto moe = morph_objects.end();

        const auto mop = [](const morph_data::ptr &pmo) {

                if (!pmo)

                        return true;

                auto &mo = *pmo.get();

                return mo.obj->type == OBJ_NONE || mo.obj->signature != mo.Morph_sig;

        };

        const auto moi = std::find_if(mob, moe, mop);

        if (moi == moe)         //no free slots

                return;

        auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

        const morph_data::polymodel_idx pmi(obj.rtype.pobj_info.model_num);

        auto &pm = Polygon_models[pmi.idx];

        *moi = morph_data::create(obj, pm, pmi);

        morph_data *const md = moi->get();

        assert(obj.render_type == RT_POLYOBJ);

        md->morph_save_control_type = obj.control_type;

        md->morph_save_movement_type = obj.movement_type;

        md->morph_save_phys_info = obj.mtype.phys_info;

        assert(obj.control_type == CT_AI);              //morph objects are also AI objects

        obj.control_type = CT_MORPH;

        obj.render_type = RT_MORPH;

        obj.movement_type = MT_PHYSICS;         //RT_NONE;

        obj.mtype.phys_info.rotvel = morph_rotvel;

        find_min_max(pm,0,pmmin,pmmax);

        box_size.x = max(-pmmin.x,pmmax.x) / 2;

        box_size.y = max(-pmmin.y,pmmax.y) / 2;

        box_size.z = max(-pmmin.z,pmmax.z) / 2;

        //clear all points

        const auto morph_times = md->get_morph_times();

        std::fill(morph_times.begin(), morph_times.end(), fix());

        //clear all parts

        md->submodel_active = {};

        md->n_submodels_active = 1;

        //now, project points onto surface of box

        init_points(pm,&box_size,0,md);

}

static void draw_model(grs_canvas &canvas, polygon_model_points &robot_points, polymodel *const pm, const unsigned submodel_num, const submodel_angles anim_angles, g3s_lrgb light, morph_data *const md)

{

        std::array<unsigned, MAX_SUBMODELS> sort_list;

        unsigned sort_n;

        //first, sort the submodels

        sort_list[0] = submodel_num;

        sort_n = 1;

        const uint_fast32_t n_models = pm->n_models;

        range_for (const uint_fast32_t i, xrange(n_models))

                if (md->submodel_active[i] != morph_data::submodel_state::invisible && pm->submodel_parents[i] == submodel_num)

                {

                        const auto facing = g3_check_normal_facing(pm->submodel_pnts[i],pm->submodel_norms[i]);

                        if (!facing)

                                sort_list[sort_n] = i;

                        else {          //put at start

                                const auto b = sort_list.begin();

                                const auto e = std::next(b, sort_n);

                                std::move_backward(b, e, std::next(e));

                                sort_list[0] = i;

                        }

                        ++sort_n;

                }

        //now draw everything

        range_for (const auto mn, partial_const_range(sort_list, sort_n))

        {

                if (mn == submodel_num) {

                        std::array<bitmap_index, MAX_POLYOBJ_TEXTURES> texture_list_index;

                        std::array<grs_bitmap *, MAX_POLYOBJ_TEXTURES> texture_list;

                        for (unsigned i = 0; i < pm->n_textures; ++i)

                        {

                                const auto ptr = ObjBitmapPtrs[pm->first_texture + i];

                                const auto &bmp = ObjBitmaps[ptr];

                                texture_list_index[i] = bmp;

                                texture_list[i] = &GameBitmaps[bmp.index];

                        }

                        // Make sure the textures for this object are paged in...

                        range_for (auto &j, partial_const_range(texture_list_index, pm->n_textures))

                                PIGGY_PAGE_IN(j);

                        // Hmmm... cache got flushed in the middle of paging all these in,

                        // so we need to reread them all in.

                        // Make sure that they can all fit in memory.

                        const auto morph_vecs = md->get_morph_vecs();

                        g3_draw_morphing_model(canvas, &pm->model_data[pm->submodel_ptrs[submodel_num]], &texture_list[0], anim_angles, light, &morph_vecs[md->submodel_startpoints[submodel_num]], robot_points);

                }

                else {

                        const auto &&orient = vm_angles_2_matrix(anim_angles[mn]);

                        g3_start_instance_matrix(pm->submodel_offsets[mn], orient);

                        draw_model(canvas, robot_points,pm,mn,anim_angles,light,md);

                        g3_done_instance();

                }

        }

}

namespace dsx {

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

{

        if (Newdemo_state == ND_STATE_PLAYBACK)

                return;

        polymodel *po;

        auto &LevelUniqueMorphObjectState = LevelUniqueObjectState.MorphObjectState;

        const auto umd = find_morph_data(LevelUniqueMorphObjectState, obj);

        if (!umd)

                throw std::runtime_error("missing morph data");

        const auto md = umd->get();

        auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

        po=&Polygon_models[obj->rtype.pobj_info.model_num];

        const auto light = compute_object_light(LevelUniqueLightState, obj);

        g3_start_instance_matrix(obj->pos, obj->orient);

        polygon_model_points robot_points;

        draw_model(canvas, robot_points, po, 0, obj->rtype.pobj_info.anim_angles, light, md);

        g3_done_instance();

        if (Newdemo_state == ND_STATE_RECORDING)

                newdemo_record_morph_frame(obj);

}

}