mirror of
https://github.com/Cesarus85/ringfall-mjolnir-vr.git
synced 2026-10-17 17:00:35 +02:00
308 lines
7.1 KiB
C
308 lines
7.1 KiB
C
/*
|
|
RANDOM_MATH.C
|
|
|
|
symbols in this file:
|
|
000FA8B0 0010:
|
|
_lock_global_random_seed (0000)
|
|
000FA8C0 0030:
|
|
_unlock_global_random_seed (0000)
|
|
000FA8F0 0040:
|
|
_get_global_random_seed_address (0000)
|
|
000FA930 0010:
|
|
_get_random_seed (0000)
|
|
000FA940 0010:
|
|
_get_global_local_random_seed_address (0000)
|
|
000FA950 0010:
|
|
_random_seed_debug_log (0000)
|
|
000FA960 0020:
|
|
_get_number_suitable_for_initializing_random_seed (0000)
|
|
000FA980 00c0:
|
|
_random_math_initialize (0000)
|
|
000FAA40 0020:
|
|
_random_math_dispose (0000)
|
|
000FAA60 0030:
|
|
_real_seed_random (0000)
|
|
000FAA90 0040:
|
|
_real_seed_random_range (0000)
|
|
000FAAD0 0020:
|
|
_seed_random (0000)
|
|
000FAAF0 0030:
|
|
_seed_random_range (0000)
|
|
000FAB20 0080:
|
|
_direction3d_from_table (0000)
|
|
000FABA0 0040:
|
|
_seed_random_direction3d (0000)
|
|
000FABE0 0100:
|
|
_seed_random_orientation (0000)
|
|
000FACE0 0100:
|
|
_seed_random_vector_in_cone3d (0000)
|
|
0027AE88 0031:
|
|
??_C@_0DB@GOKAHAFJ@unmatched?5call?5to?5unlock_random_@ (0000)
|
|
0027AEBC 0022:
|
|
??_C@_0CC@CGOEMOHM@c?3?2halo?2SOURCE?2math?2random_math?4@ (0000)
|
|
0027AEE0 0044:
|
|
??_C@_0EE@KKMKHIJL@you?5should?5not?5be?5using?5global?5r@ (0000)
|
|
0027AF24 001b:
|
|
??_C@_0BL@CJPMPDBB@random_direction_geosphere?$AA@ (0000)
|
|
0027AF40 0042:
|
|
??_C@_0EC@LPLKDAPN@index?$DO?$DN0?5?$CG?$CG?5index?$DMrandom_math_gl@ (0000)
|
|
0027AF84 002b:
|
|
??_C@_0CL@KJMLMACI@random_math_globals?4random_direc@ (0000)
|
|
00456208 0014:
|
|
_random_math_globals (0000)
|
|
*/
|
|
|
|
/* ---------- headers */
|
|
|
|
#include "cseries.h"
|
|
#include "cseries_windows.h"
|
|
#include "real_math.h"
|
|
#include "geometry.h"
|
|
#include "random_math.h"
|
|
#include "game_engine.h"
|
|
|
|
/* ---------- constants */
|
|
|
|
enum
|
|
{
|
|
RANDOM_DIRECTION_TABLE_GEOSPHERE_SEGMENT_COUNT= 16,
|
|
RANDOM_A= 1664525L,
|
|
RANDOM_C= 1013904223L
|
|
};
|
|
|
|
/* ---------- macros */
|
|
|
|
/* ---------- structures */
|
|
|
|
struct random_math_globals
|
|
{
|
|
real_vector3d *random_direction_table;
|
|
short random_direction_table_size;
|
|
short pad;
|
|
long global_random_seed_lock;
|
|
unsigned long global_random_seed;
|
|
unsigned long global_local_random_seed;
|
|
};
|
|
|
|
/* ---------- prototypes */
|
|
|
|
static real_vector3d *
|
|
direction3d_from_table(
|
|
real_vector3d *result,
|
|
short index);
|
|
|
|
/* ---------- globals */
|
|
|
|
#ifndef HALO_ANDROID /* Mach-O section names differ; the default is .bss anyway */
|
|
#pragma bss_seg(".bss")
|
|
#endif
|
|
struct random_math_globals random_math_globals;
|
|
#ifndef HALO_ANDROID
|
|
#pragma bss_seg()
|
|
#endif
|
|
|
|
/* ---------- public code */
|
|
|
|
void
|
|
lock_global_random_seed(
|
|
void)
|
|
{
|
|
random_math_globals.global_random_seed_lock++;
|
|
return;
|
|
}
|
|
|
|
void
|
|
unlock_global_random_seed(
|
|
void)
|
|
{
|
|
match_dassert(
|
|
"c:\\halo\\SOURCE\\math\\random_math.c",
|
|
41,
|
|
random_math_globals.global_random_seed_lock>0,
|
|
"unmatched call to unlock_random_seed() somewhere");
|
|
random_math_globals.global_random_seed_lock--;
|
|
return;
|
|
}
|
|
|
|
unsigned long get_random_seed(
|
|
void)
|
|
{
|
|
return random_math_globals.global_random_seed;
|
|
}
|
|
|
|
unsigned long *get_global_random_seed_address(
|
|
void)
|
|
{
|
|
match_dassert(
|
|
"c:\\halo\\SOURCE\\math\\random_math.c",
|
|
56,
|
|
!game_engine_running() || !random_math_globals.global_random_seed_lock,
|
|
"you should not be using global random(); use local random() instead");
|
|
return &random_math_globals.global_random_seed;
|
|
}
|
|
|
|
unsigned long *get_global_local_random_seed_address(
|
|
void)
|
|
{
|
|
return &random_math_globals.global_local_random_seed;
|
|
}
|
|
|
|
void
|
|
random_seed_debug_log(
|
|
boolean log)
|
|
{
|
|
return;
|
|
}
|
|
|
|
unsigned long get_number_suitable_for_initializing_random_seed(
|
|
void)
|
|
{
|
|
return system_seconds()^system_milliseconds()^rand();
|
|
}
|
|
|
|
void
|
|
random_math_initialize(
|
|
void)
|
|
{
|
|
struct geosphere *random_direction_geosphere;
|
|
short index;
|
|
|
|
random_math_globals.global_local_random_seed= get_number_suitable_for_initializing_random_seed();
|
|
random_direction_geosphere= geosphere_new(RANDOM_DIRECTION_TABLE_GEOSPHERE_SEGMENT_COUNT);
|
|
match_assert("c:\\halo\\SOURCE\\math\\random_math.c", 174, random_direction_geosphere);
|
|
random_math_globals.random_direction_table= match_malloc(
|
|
"c:\\halo\\SOURCE\\math\\random_math.c",
|
|
176,
|
|
random_direction_geosphere->vertex_count*sizeof(real_vector3d));
|
|
random_math_globals.random_direction_table_size= random_direction_geosphere->vertex_count;
|
|
for (index= 0; index<random_direction_geosphere->vertex_count; index++)
|
|
random_math_globals.random_direction_table[index]=
|
|
*((real_vector3d *)random_direction_geosphere->vertices + index);
|
|
geosphere_dispose(random_direction_geosphere);
|
|
return;
|
|
}
|
|
|
|
void
|
|
random_math_dispose(
|
|
void)
|
|
{
|
|
debug_free(
|
|
random_math_globals.random_direction_table,
|
|
"c:\\halo\\SOURCE\\math\\random_math.c",
|
|
200);
|
|
return;
|
|
}
|
|
|
|
unsigned short seed_random(
|
|
unsigned long *seed)
|
|
{
|
|
*seed = *seed*RANDOM_A+RANDOM_C;
|
|
return *seed>>16;
|
|
}
|
|
|
|
short seed_random_range(
|
|
unsigned long *seed,
|
|
short lower_bound,
|
|
short upper_bound)
|
|
{
|
|
return lower_bound+((unsigned long)(upper_bound-lower_bound)*seed_random(seed)>>16);
|
|
}
|
|
|
|
real real_seed_random(
|
|
unsigned long *seed)
|
|
{
|
|
*seed = *seed*RANDOM_A+RANDOM_C;
|
|
return (real)(*seed>>16)/65535.0f;
|
|
}
|
|
|
|
real real_seed_random_range(
|
|
unsigned long *seed,
|
|
real lower_bound,
|
|
real upper_bound)
|
|
{
|
|
real random= real_seed_random(seed);
|
|
return lower_bound+(upper_bound-lower_bound)*random;
|
|
}
|
|
|
|
real_vector3d *seed_random_direction3d(
|
|
unsigned long *seed,
|
|
real_vector3d *direction)
|
|
{
|
|
return direction3d_from_table(
|
|
direction,
|
|
seed_random_range(seed, 0, random_math_globals.random_direction_table_size));
|
|
}
|
|
|
|
void
|
|
seed_random_orientation(
|
|
unsigned long *seed,
|
|
real_vector3d *facing,
|
|
real_vector3d *up)
|
|
{
|
|
real azimuth= real_seed_random_range(seed, 0.f, 2.f*_pi);
|
|
real elevation= real_seed_random_range(seed, -_pi/2.f, _pi/2.f);
|
|
real roll= real_seed_random_range(seed, 0.f, 2.f*_pi);
|
|
real azimuth_cosine= cosine(azimuth);
|
|
real azimuth_sine= sine(azimuth);
|
|
real elevation_cosine= cosine(elevation);
|
|
real elevation_sine= sine(elevation);
|
|
|
|
facing->i= elevation_cosine*azimuth_cosine;
|
|
facing->j= elevation_cosine*azimuth_sine;
|
|
facing->k= elevation_sine;
|
|
|
|
up->i= -azimuth_cosine*elevation_sine;
|
|
up->j= -azimuth_sine*elevation_sine;
|
|
up->k= elevation_cosine;
|
|
|
|
yaw_vectors(up, facing, sine(roll), cosine(roll));
|
|
return;
|
|
}
|
|
|
|
real_vector3d *
|
|
seed_random_vector_in_cone3d(
|
|
unsigned long *seed,
|
|
real_vector3d const *axis,
|
|
real inner_cone_angle,
|
|
real outer_cone_angle,
|
|
real_vector3d *result)
|
|
{
|
|
real_vector3d random_direction;
|
|
real_vector3d rotation_axis;
|
|
real angle;
|
|
|
|
*result= *axis;
|
|
direction3d_from_table(
|
|
&random_direction,
|
|
seed_random_range(seed, 0, random_math_globals.random_direction_table_size));
|
|
cross_product3d(axis, &random_direction, &rotation_axis);
|
|
if (normalize3d(&rotation_axis)>0.f)
|
|
{
|
|
angle= real_seed_random_range(seed, inner_cone_angle, outer_cone_angle);
|
|
rotate_vector_about_axis(result, &rotation_axis, sine(angle), cosine(angle));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* ---------- private code */
|
|
|
|
static real_vector3d *
|
|
direction3d_from_table(
|
|
real_vector3d *result,
|
|
short index)
|
|
{
|
|
real_vector3d *random_direction=
|
|
&random_math_globals.random_direction_table[index];
|
|
match_assert(
|
|
"c:\\halo\\SOURCE\\math\\random_math.c",
|
|
250,
|
|
random_math_globals.random_direction_table);
|
|
match_assert(
|
|
"c:\\halo\\SOURCE\\math\\random_math.c",
|
|
251,
|
|
index>=0 && index<random_math_globals.random_direction_table_size);
|
|
*result= *random_direction;
|
|
return result;
|
|
}
|