void hal::os::Clock::ReadCounters(s64 & tsc, s64 & pc)
{
u64 rdtsc_a, rdtsc_b;
LARGE_INTEGER pca;
int count = 0;
again:
rdtsc_a = __rdtsc();
::NtQueryPerformanceCounter(&pca, 0);
rdtsc_b = __rdtsc();
if (rdtsc_b - rdtsc_a > 100000 && count++ < 5 ) goto again;
tsc = s64((rdtsc_a + rdtsc_b)/2ULL);
pc = s64(pca.QuadPart);
}
XRCORE_API BOOL is_stack_ptr ( void* _ptr)
{
int local_value = 0;
void* ptr_refsound = _ptr;
void* ptr_local = &local_value;
ptrdiff_t difference = (ptrdiff_t)_abs(s64(ptrdiff_t(ptr_local) - ptrdiff_t(ptr_refsound)));
return (difference < (512*1024));
}
void ForceExceptionCheck(s64 cycles)
{
if (s64(DowncountToCycles(PowerPC::ppcState.downcount)) > cycles)
{
// downcount is always (much) smaller than MAX_INT so we can safely cast cycles to an int here.
g_slicelength -= (DowncountToCycles(PowerPC::ppcState.downcount) - (int)cycles); // Account for cycles already executed by adjusting the g_slicelength
PowerPC::ppcState.downcount = CyclesToDowncount((int)cycles);
}
}
hal::os::Clock::Clock(int)
{
ULONG dummy;
s64 pca, pcb, pcf, tsca, tscb;
f64 interval;
int const times = 16;
int const retries = 5;
::NtQueryTimerResolution(&dummy, &m_max_resolution, &m_old_resolution);
::NtSetTimerResolution(m_max_resolution, TRUE, &dummy);
::NtQueryPerformanceCounter((PLARGE_INTEGER)&pca, (PLARGE_INTEGER)&pcf);
m_qpc_frequency = f64(pcf);
m_qpc_factor = 1000000.0 / m_qpc_frequency;
m_qpc_resolution = f64(m_max_resolution) / 10.0;
m_tsc_frequency = 0;
f64 frequency = 0.0;
__ThreadPriority(THREAD_PRIORITY_TIME_CRITICAL)
{
for (int j = 0; j < times; ++j)
{
for (int i = 0; i < retries; ++i)
{
ReadCounters(tsca, pca);
do
{
ReadCounters(tscb, pcb);
interval = f64(pcb - pca) * m_qpc_factor;
}
while (interval < 1000.0);
if (interval < 1001.0)
{
frequency += f64(tscb - tsca) / interval;
break;
}
}
}
}
m_tsc_frequency = s64(frequency / f64(times));
}
int Database_SQLite3::busyHandler(void *data, int count)
{
s64 &first_time = reinterpret_cast<s64 *>(data)[0];
s64 &prev_time = reinterpret_cast<s64 *>(data)[1];
s64 cur_time = getTimeMs();
if (count == 0) {
first_time = cur_time;
prev_time = first_time;
} else {
while (cur_time < prev_time)
cur_time += s64(1)<<32;
}
if (cur_time - first_time < BUSY_INFO_TRESHOLD) {
; // do nothing
} else if (cur_time - first_time >= BUSY_INFO_TRESHOLD &&
prev_time - first_time < BUSY_INFO_TRESHOLD) {
infostream << "SQLite3 database has been locked for "
<< cur_time - first_time << " ms." << std::endl;
} else if (cur_time - first_time >= BUSY_WARNING_TRESHOLD &&
prev_time - first_time < BUSY_WARNING_TRESHOLD) {
warningstream << "SQLite3 database has been locked for "
<< cur_time - first_time << " ms." << std::endl;
} else if (cur_time - first_time >= BUSY_ERROR_TRESHOLD &&
prev_time - first_time < BUSY_ERROR_TRESHOLD) {
errorstream << "SQLite3 database has been locked for "
<< cur_time - first_time << " ms; this causes lag." << std::endl;
} else if (cur_time - first_time >= BUSY_FATAL_TRESHOLD &&
prev_time - first_time < BUSY_FATAL_TRESHOLD) {
errorstream << "SQLite3 database has been locked for "
<< cur_time - first_time << " ms - giving up!" << std::endl;
} else if ((cur_time - first_time) / BUSY_ERROR_INTERVAL !=
(prev_time - first_time) / BUSY_ERROR_INTERVAL) {
// Safety net: keep reporting every BUSY_ERROR_INTERVAL
errorstream << "SQLite3 database has been locked for "
<< (cur_time - first_time) / 1000 << " seconds!" << std::endl;
}
prev_time = cur_time;
// Make sqlite transaction fail if delay exceeds BUSY_FATAL_TRESHOLD
return cur_time - first_time < BUSY_FATAL_TRESHOLD;
}
float CLevel::GetEnvironmentGameDayTimeSec()
{
return (float(s64(GetEnvironmentGameTime() % (24*60*60*1000)))/1000.f);
}
u32 CLevel::GetGameDayTimeMS()
{
return (u32(s64(GetGameTime() % (24*60*60*1000))));
}
constexpr int64_t SX64(int64_t x) { return (x & s64(0x0000800000000000U)) ? x | s64(0xffff000000000000U) : x & s64(0x0000ffffffffffffU); }
***************************************************************************************/
#include "emu.h"
#include "es5510.h"
#include "es5510d.h"
#include "cpu/m68000/m68000.h"
#include "debugger.h"
#include <cstdio>
#include <algorithm>
static constexpr int32_t MIN_24 = -(1 << 23);
static constexpr int32_t MAX_24 = (1 << 23) - 1;
static constexpr int64_t MIN_48 = -(s64(1) << 47);
static constexpr int64_t MAX_48 = (s64(1) << 47) - 1;
#define SIGN_BIT_24 (0x00800000)
#define GET_SIGN_BIT_24(x) ((x) & SIGN_BIT_24)
#define IS_NEGATIVE(x) (((x) & SIGN_BIT_24) != 0)
#define CARRY_OUT_24 (0x01000000)
constexpr int32_t SX(int32_t x) { return IS_NEGATIVE(x) ? x | 0xff000000 : x & 0x00ffffff; }
constexpr int32_t SC(int32_t x) { return x & 0x00ffffff; }
constexpr int64_t SX64(int64_t x) { return (x & s64(0x0000800000000000U)) ? x | s64(0xffff000000000000U) : x & s64(0x0000ffffffffffffU); }
//constexpr int64_t SC64(int64_t x) { return x & s64(0x0000ffffffffffffU); }
#define VERBOSE 0
#define VERBOSE_EXEC 0
bool test(bool is_kernel_exact = true)
{
// types
typedef typename K::FT FT;
typedef typename K::Line_3 Line;
typedef typename K::Point_3 Point;
typedef typename K::Segment_3 Segment;
typedef typename K::Ray_3 Ray;
typedef typename K::Line_3 Line;
typedef typename K::Triangle_3 Triangle;
/* -------------------------------------
// Test data is something like that (in t supporting plane)
// Triangle is (p1,p2,p3)
//
// +E +1
// / \
// +C 6+ +8 +4 +B
// / 9++7 \
// 3+-------+5--+2
//
// +F +A
------------------------------------- */
Point p1(FT(1.), FT(0.), FT(0.));
Point p2(FT(0.), FT(1.), FT(0.));
Point p3(FT(0.), FT(0.), FT(1.));
Triangle t(p1,p2,p3);
// Edges of t
Segment s12(p1,p2);
Segment s21(p2,p1);
Segment s13(p1,p3);
Segment s23(p2,p3);
Segment s32(p3,p2);
Segment s31(p3,p1);
bool b = test_aux(is_kernel_exact,t,s12,"t-s12",s12);
b &= test_aux(is_kernel_exact,t,s21,"t-s21",s21);
b &= test_aux(is_kernel_exact,t,s13,"t-s13",s13);
b &= test_aux(is_kernel_exact,t,s23,"t-s23",s23);
// Inside points
Point p4(FT(0.5), FT(0.5), FT(0.));
Point p5(FT(0.), FT(0.75), FT(0.25));
Point p6(FT(0.5), FT(0.), FT(0.5));
Point p7(FT(0.25), FT(0.625), FT(0.125));
Point p8(FT(0.5), FT(0.25), FT(0.25));
Segment s14(p1,p4);
Segment s41(p4,p1);
Segment s24(p2,p4);
Segment s42(p4,p2);
Segment s15(p1,p5);
Segment s25(p2,p5);
Segment s34(p3,p4);
Segment s35(p3,p5);
Segment s36(p3,p6);
Segment s45(p4,p5);
Segment s16(p1,p6);
Segment s26(p2,p6);
Segment s62(p6,p2);
Segment s46(p4,p6);
Segment s48(p4,p8);
Segment s56(p5,p6);
Segment s65(p6,p5);
Segment s64(p6,p4);
Segment s17(p1,p7);
Segment s67(p6,p7);
Segment s68(p6,p8);
Segment s86(p8,p6);
Segment s78(p7,p8);
Segment s87(p8,p7);
b &= test_aux(is_kernel_exact,t,s14,"t-s14",s14);
b &= test_aux(is_kernel_exact,t,s41,"t-s41",s41);
b &= test_aux(is_kernel_exact,t,s24,"t-s24",s24);
b &= test_aux(is_kernel_exact,t,s42,"t-s42",s42);
b &= test_aux(is_kernel_exact,t,s15,"t-s15",s15);
b &= test_aux(is_kernel_exact,t,s25,"t-s25",s25);
b &= test_aux(is_kernel_exact,t,s34,"t-s34",s34);
b &= test_aux(is_kernel_exact,t,s35,"t-s35",s35);
b &= test_aux(is_kernel_exact,t,s36,"t-s36",s36);
b &= test_aux(is_kernel_exact,t,s45,"t-s45",s45);
b &= test_aux(is_kernel_exact,t,s16,"t-s16",s16);
b &= test_aux(is_kernel_exact,t,s26,"t-s26",s26);
b &= test_aux(is_kernel_exact,t,s62,"t-s62",s62);
b &= test_aux(is_kernel_exact,t,s46,"t-s46",s46);
b &= test_aux(is_kernel_exact,t,s65,"t-s65",s65);
b &= test_aux(is_kernel_exact,t,s64,"t-s64",s64);
b &= test_aux(is_kernel_exact,t,s48,"t-s48",s48);
b &= test_aux(is_kernel_exact,t,s56,"t-s56",s56);
b &= test_aux(is_kernel_exact,t,s17,"t-t17",s17);
b &= test_aux(is_kernel_exact,t,s67,"t-t67",s67);
b &= test_aux(is_kernel_exact,t,s68,"t-s68",s68);
b &= test_aux(is_kernel_exact,t,s86,"t-s86",s86);
b &= test_aux(is_kernel_exact,t,s78,"t-t78",s78);
b &= test_aux(is_kernel_exact,t,s87,"t-t87",s87);
// Outside points (in triangle plane)
Point pA(FT(-0.5), FT(1.), FT(0.5));
Point pB(FT(0.5), FT(1.), FT(-0.5));
Point pC(FT(0.5), FT(-0.5), FT(1.));
Point pE(FT(1.), FT(-1.), FT(1.));
Point pF(FT(-1.), FT(0.), FT(2.));
Segment sAB(pA,pB);
Segment sBC(pB,pC);
Segment s2E(p2,pE);
Segment sE2(pE,p2);
Segment s2A(p2,pA);
Segment s6E(p6,pE);
Segment sB8(pB,p8);
Segment sC8(pC,p8);
Segment s8C(p8,pC);
Segment s1F(p1,pF);
Segment sF6(pF,p6);
b &= test_aux(is_kernel_exact,t,sAB,"t-sAB",p2);
b &= test_aux(is_kernel_exact,t,sBC,"t-sBC",s46);
b &= test_aux(is_kernel_exact,t,s2E,"t-s2E",s26);
b &= test_aux(is_kernel_exact,t,sE2,"t-sE2",s62);
b &= test_aux(is_kernel_exact,t,s2A,"t-s2A",p2);
b &= test_aux(is_kernel_exact,t,s6E,"t-s6E",p6);
b &= test_aux(is_kernel_exact,t,sB8,"t-sB8",s48);
b &= test_aux(is_kernel_exact,t,sC8,"t-sC8",s68);
b &= test_aux(is_kernel_exact,t,s8C,"t-s8C",s86);
b &= test_aux(is_kernel_exact,t,s1F,"t-s1F",s13);
b &= test_aux(is_kernel_exact,t,sF6,"t-sF6",s36);
// Outside triangle plane
Point pa(FT(0.), FT(0.), FT(0.));
Point pb(FT(2.), FT(0.), FT(0.));
Point pc(FT(1.), FT(0.), FT(1.));
Point pe(FT(1.), FT(0.5), FT(0.5));
Segment sab(pa,pb);
Segment sac(pa,pc);
Segment sae(pa,pe);
Segment sa8(pa,p8);
Segment sb2(pb,p2);
b &= test_aux(is_kernel_exact,t,sab,"t-sab",p1);
b &= test_aux(is_kernel_exact,t,sac,"t-sac",p6);
b &= test_aux(is_kernel_exact,t,sae,"t-sae",p8);
b &= test_aux(is_kernel_exact,t,sa8,"t-sa8",p8);
b &= test_aux(is_kernel_exact,t,sb2,"t-sb2",p2);
// -----------------------------------
// ray queries
// -----------------------------------
// Edges of t
Ray r12(p1,p2);
Ray r21(p2,p1);
Ray r13(p1,p3);
Ray r23(p2,p3);
b &= test_aux(is_kernel_exact,t,r12,"t-r12",s12);
b &= test_aux(is_kernel_exact,t,r21,"t-r21",s21);
b &= test_aux(is_kernel_exact,t,r13,"t-r13",s13);
b &= test_aux(is_kernel_exact,t,r23,"t-r23",s23);
// In triangle
Point p9_(FT(0.), FT(0.5), FT(0.5));
Point p9(FT(0.25), FT(0.375), FT(0.375));
Ray r14(p1,p4);
Ray r41(p4,p1);
Ray r24(p2,p4);
Ray r42(p4,p2);
Ray r15(p1,p5);
Ray r25(p2,p5);
Ray r34(p3,p4);
Ray r35(p3,p5);
Ray r36(p3,p6);
Ray r45(p4,p5);
Ray r16(p1,p6);
Ray r26(p2,p6);
Ray r62(p6,p2);
Ray r46(p4,p6);
Ray r48(p4,p8);
Ray r56(p5,p6);
Ray r47(p4,p7);
Ray r89(p8,p9);
Ray r86(p8,p6);
Ray r68(p6,p8);
Segment r89_res(p8,p9_);
b &= test_aux(is_kernel_exact,t,r14,"t-r14",s12);
b &= test_aux(is_kernel_exact,t,r41,"t-r41",s41);
b &= test_aux(is_kernel_exact,t,r24,"t-r24",s21);
b &= test_aux(is_kernel_exact,t,r42,"t-r42",s42);
b &= test_aux(is_kernel_exact,t,r15,"t-r15",s15);
b &= test_aux(is_kernel_exact,t,r25,"t-r25",s23);
b &= test_aux(is_kernel_exact,t,r34,"t-r34",s34);
b &= test_aux(is_kernel_exact,t,r35,"t-r35",s32);
b &= test_aux(is_kernel_exact,t,r36,"t-r36",s31);
b &= test_aux(is_kernel_exact,t,r45,"t-r45",s45);
b &= test_aux(is_kernel_exact,t,r16,"t-r16",s13);
b &= test_aux(is_kernel_exact,t,r26,"t-r26",s26);
b &= test_aux(is_kernel_exact,t,r62,"t-r62",s62);
b &= test_aux(is_kernel_exact,t,r46,"t-r46",s46);
b &= test_aux(is_kernel_exact,t,r48,"t-r48",s46);
b &= test_aux(is_kernel_exact,t,r56,"t-r56",s56);
b &= test_aux(is_kernel_exact,t,r47,"t-r47",s45);
b &= test_aux(is_kernel_exact,t,r89,"t-t89",r89_res);
b &= test_aux(is_kernel_exact,t,r68,"t-r68",s64);
b &= test_aux(is_kernel_exact,t,r86,"t-r86",s86);
// Outside points (in triangre prane)
Ray rAB(pA,pB);
Ray rBC(pB,pC);
Ray r2E(p2,pE);
Ray rE2(pE,p2);
Ray r2A(p2,pA);
Ray r6E(p6,pE);
Ray rB8(pB,p8);
Ray rC8(pC,p8);
Ray r8C(p8,pC);
Ray r1F(p1,pF);
Ray rF6(pF,p6);
b &= test_aux(is_kernel_exact,t,rAB,"t-rAB",p2);
b &= test_aux(is_kernel_exact,t,rBC,"t-rBC",s46);
b &= test_aux(is_kernel_exact,t,r2E,"t-r2E",s26);
b &= test_aux(is_kernel_exact,t,rE2,"t-rE2",s62);
b &= test_aux(is_kernel_exact,t,r2A,"t-r2A",p2);
b &= test_aux(is_kernel_exact,t,r6E,"t-r6E",p6);
b &= test_aux(is_kernel_exact,t,rB8,"t-rB8",s46);
b &= test_aux(is_kernel_exact,t,rC8,"t-rC8",s64);
b &= test_aux(is_kernel_exact,t,r8C,"t-r8C",s86);
b &= test_aux(is_kernel_exact,t,r1F,"t-r1F",s13);
b &= test_aux(is_kernel_exact,t,rF6,"t-rF6",s31);
// Outside triangle plane
Ray rab(pa,pb);
Ray rac(pa,pc);
Ray rae(pa,pe);
Ray ra8(pa,p8);
Ray rb2(pb,p2);
b &= test_aux(is_kernel_exact,t,rab,"t-rab",p1);
b &= test_aux(is_kernel_exact,t,rac,"t-rac",p6);
b &= test_aux(is_kernel_exact,t,rae,"t-rae",p8);
b &= test_aux(is_kernel_exact,t,ra8,"t-ra8",p8);
b &= test_aux(is_kernel_exact,t,rb2,"t-rb2",p2);
// -----------------------------------
// Line queries
// -----------------------------------
// Edges of t
Line l12(p1,p2);
Line l21(p2,p1);
Line l13(p1,p3);
Line l23(p2,p3);
b &= test_aux(is_kernel_exact,t,l12,"t-l12",s12);
b &= test_aux(is_kernel_exact,t,l21,"t-l21",s21);
b &= test_aux(is_kernel_exact,t,l13,"t-l13",s13);
b &= test_aux(is_kernel_exact,t,l23,"t-l23",s23);
// In triangle
Line l14(p1,p4);
Line l41(p4,p1);
Line l24(p2,p4);
Line l42(p4,p2);
Line l15(p1,p5);
Line l25(p2,p5);
Line l34(p3,p4);
Line l35(p3,p5);
Line l36(p3,p6);
Line l45(p4,p5);
Line l16(p1,p6);
Line l26(p2,p6);
Line l62(p6,p2);
Line l46(p4,p6);
Line l48(p4,p8);
Line l56(p5,p6);
Line l47(p4,p7);
Line l89(p8,p9);
Line l86(p8,p6);
Line l68(p6,p8);
Segment l89_res(p1,p9_);
b &= test_aux(is_kernel_exact,t,l14,"t-l14",s12);
b &= test_aux(is_kernel_exact,t,l41,"t-l41",s21);
b &= test_aux(is_kernel_exact,t,l24,"t-l24",s21);
b &= test_aux(is_kernel_exact,t,l42,"t-l42",s12);
b &= test_aux(is_kernel_exact,t,l15,"t-l15",s15);
b &= test_aux(is_kernel_exact,t,l25,"t-l25",s23);
b &= test_aux(is_kernel_exact,t,l34,"t-l34",s34);
b &= test_aux(is_kernel_exact,t,l35,"t-l35",s32);
b &= test_aux(is_kernel_exact,t,l36,"t-l36",s31);
b &= test_aux(is_kernel_exact,t,l45,"t-l45",s45);
b &= test_aux(is_kernel_exact,t,l16,"t-l16",s13);
b &= test_aux(is_kernel_exact,t,l26,"t-l26",s26);
b &= test_aux(is_kernel_exact,t,l62,"t-l62",s62);
b &= test_aux(is_kernel_exact,t,l46,"t-l46",s46);
b &= test_aux(is_kernel_exact,t,l48,"t-l48",s46);
b &= test_aux(is_kernel_exact,t,l56,"t-l56",s56);
b &= test_aux(is_kernel_exact,t,l47,"t-l47",s45);
b &= test_aux(is_kernel_exact,t,l89,"t-t89",l89_res);
b &= test_aux(is_kernel_exact,t,l68,"t-l68",s64);
b &= test_aux(is_kernel_exact,t,l86,"t-l86",s46);
// Outside points (in triangle plane)
Line lAB(pA,pB);
Line lBC(pB,pC);
Line l2E(p2,pE);
Line lE2(pE,p2);
Line l2A(p2,pA);
Line l6E(p6,pE);
Line lB8(pB,p8);
Line lC8(pC,p8);
Line l8C(p8,pC);
Line l1F(p1,pF);
Line lF6(pF,p6);
b &= test_aux(is_kernel_exact,t,lAB,"t-lAB",p2);
b &= test_aux(is_kernel_exact,t,lBC,"t-lBC",s46);
b &= test_aux(is_kernel_exact,t,l2E,"t-l2E",s26);
b &= test_aux(is_kernel_exact,t,lE2,"t-lE2",s62);
b &= test_aux(is_kernel_exact,t,l2A,"t-l2A",p2);
b &= test_aux(is_kernel_exact,t,l6E,"t-l6E",s26);
b &= test_aux(is_kernel_exact,t,lB8,"t-lB8",s46);
b &= test_aux(is_kernel_exact,t,lC8,"t-lC8",s64);
b &= test_aux(is_kernel_exact,t,l8C,"t-l8C",s46);
b &= test_aux(is_kernel_exact,t,l1F,"t-l1F",s13);
b &= test_aux(is_kernel_exact,t,lF6,"t-lF6",s31);
// Outside triangle plane
Line lab(pa,pb);
Line lac(pa,pc);
Line lae(pa,pe);
Line la8(pa,p8);
Line lb2(pb,p2);
b &= test_aux(is_kernel_exact,t,lab,"t-lab",p1);
b &= test_aux(is_kernel_exact,t,lac,"t-lac",p6);
b &= test_aux(is_kernel_exact,t,lae,"t-lae",p8);
b &= test_aux(is_kernel_exact,t,la8,"t-la8",p8);
b &= test_aux(is_kernel_exact,t,lb2,"t-lb2",p2);
return b;
}
static EERIE_ANIM * TheaToEerie(const char * adr, size_t size, const res::path & file) {
(void)size; // TODO use size
LogDebug("Loading animation file " << file);
size_t pos = 0;
const THEA_HEADER * th = reinterpret_cast<const THEA_HEADER *>(adr + pos);
if(th->version < 2014) {
LogError << "Invalid TEA Version " << th->version << " in " << file;
return NULL;
}
pos += sizeof(THEA_HEADER);
EERIE_ANIM * eerie = new EERIE_ANIM();
LogDebug("TEA header size: " << sizeof(THEA_HEADER));
LogDebug("Identity " << th->identity);
LogDebug("Version - " << th->version << " Frames " << th->nb_frames
<< " Groups " << th->nb_groups << " KeyFrames " << th->nb_key_frames);
eerie->nb_groups = th->nb_groups;
eerie->nb_key_frames = th->nb_key_frames;
eerie->frames = allocStructZero<EERIE_FRAME>(th->nb_key_frames);
eerie->groups = allocStructZero<EERIE_GROUP>(th->nb_key_frames * th->nb_groups);
eerie->voidgroups = allocStructZero<unsigned char>(th->nb_groups);
eerie->anim_time = AnimationDuration_ZERO;
// Go For Keyframes read
for(long i = 0; i < th->nb_key_frames; i++) {
LogDebug("Loading keyframe " << i);
THEA_KEYFRAME_2015 kf2015;
const THEA_KEYFRAME_2015 * tkf2015;
if(th->version >= 2015) {
LogDebug(" New keyframe version THEA_KEYFRAME_2015:" << sizeof(THEA_KEYFRAME_2015));
tkf2015 = reinterpret_cast<const THEA_KEYFRAME_2015 *>(adr + pos);
pos += sizeof(THEA_KEYFRAME_2015);
} else {
LogDebug(" Old keyframe version THEA_KEYFRAME_2014:" << sizeof(THEA_KEYFRAME_2014));
const THEA_KEYFRAME_2014 * tkf = reinterpret_cast<const THEA_KEYFRAME_2014 *>(adr + pos);
pos += sizeof(THEA_KEYFRAME_2014);
memset(&kf2015, 0, sizeof(THEA_KEYFRAME_2015));
kf2015.num_frame = tkf->num_frame;
kf2015.flag_frame = tkf->flag_frame;
kf2015.master_key_frame = tkf->master_key_frame;
kf2015.key_frame = tkf->key_frame;
kf2015.key_move = tkf->key_move;
kf2015.key_orient = tkf->key_orient;
kf2015.key_morph = tkf->key_morph;
kf2015.time_frame = tkf->time_frame;
tkf2015 = &kf2015;
}
eerie->frames[i].num_frame = tkf2015->num_frame;
eerie->frames[i].f_rotate = (tkf2015->key_orient != 0);
eerie->frames[i].f_translate = (tkf2015->key_move != 0);
eerie->frames[i].time = AnimationDurationUs(s64(tkf2015->num_frame) * 1000 * 1000 / 24);
arx_assert(tkf2015->flag_frame == -1 || tkf2015->flag_frame == 9);
eerie->frames[i].stepSound = (tkf2015->flag_frame == 9);
LogDebug(" pos " << pos << " - NumFr " << eerie->frames[i].num_frame
<< " MKF " << tkf2015->master_key_frame << " THEA_KEYFRAME " << sizeof(THEA_KEYFRAME_2014)
<< " TIME " << toS(eerie->frames[i].time) << "s -Move " << tkf2015->key_move
<< " Orient " << tkf2015->key_orient << " Morph " << tkf2015->key_morph);
// Is There a Global translation ?
if(tkf2015->key_move != 0) {
const THEA_KEYMOVE * tkm = reinterpret_cast<const THEA_KEYMOVE *>(adr + pos);
pos += sizeof(THEA_KEYMOVE);
LogDebug(" -> move x " << tkm->x << " y " << tkm->y << " z " << tkm->z
<< " THEA_KEYMOVE:" << sizeof(THEA_KEYMOVE));
eerie->frames[i].translate = tkm->toVec3();
}
// Is There a Global Rotation ?
if(tkf2015->key_orient != 0) {
pos += 8; // THEO_ANGLE
const ArxQuat * quat = reinterpret_cast<const ArxQuat *>(adr + pos);
pos += sizeof(ArxQuat);
LogDebug(" -> rotate x " << quat->x << " y " << quat->y << " z " << quat->z
<< " w " << quat->w << " ArxQuat:" << sizeof(ArxQuat));
eerie->frames[i].quat = *quat;
}
// Is There a Global Morph ? (IGNORED!)
if(tkf2015->key_morph != 0) {
pos += 16; // THEA_MORPH
}
// Now go for Group Rotations/Translations/scaling for each GROUP
for(long j = 0; j < th->nb_groups; j++) {
const THEO_GROUPANIM * tga = reinterpret_cast<const THEO_GROUPANIM *>(adr + pos);
pos += sizeof(THEO_GROUPANIM);
EERIE_GROUP * eg = &eerie->groups[j + i * th->nb_groups];
eg->key = tga->key_group;
eg->quat = tga->Quaternion;
eg->translate = tga->translate.toVec3();
eg->zoom = tga->zoom.toVec3();
}
// Now Read Sound Data included in this frame
s32 num_sample = *reinterpret_cast<const s32 *>(adr + pos);
pos += sizeof(s32);
LogDebug(" -> num_sample " << num_sample << " s32:" << sizeof(s32));
eerie->frames[i].sample = -1;
if(num_sample != -1) {
const THEA_SAMPLE * ts = reinterpret_cast<const THEA_SAMPLE *>(adr + pos);
pos += sizeof(THEA_SAMPLE);
pos += ts->sample_size;
LogDebug(" -> sample " << ts->sample_name << " size " << ts->sample_size
<< " THEA_SAMPLE:" << sizeof(THEA_SAMPLE));
eerie->frames[i].sample = ARX_SOUND_Load(res::path::load(util::loadString(ts->sample_name)));
}
pos += 4; // num_sfx
}
for(long i = 0; i < th->nb_key_frames; i++) {
if(!eerie->frames[i].f_translate) {
long k = i;
while((k >= 0) && (!eerie->frames[k].f_translate)) {
k--;
}
long j = i;
while((j < th->nb_key_frames) && (!eerie->frames[j].f_translate)) {
j++;
}
if((j < th->nb_key_frames) && (k >= 0)) {
float r1 = GetTimeBetweenKeyFrames(eerie, k, i);
float r2 = GetTimeBetweenKeyFrames(eerie, i, j);
float tot = 1.f / (r1 + r2);
r1 *= tot;
r2 *= tot;
eerie->frames[i].translate = eerie->frames[j].translate * r1 + eerie->frames[k].translate * r2;
}
}
if(!eerie->frames[i].f_rotate) {
long k = i;
while((k >= 0) && (!eerie->frames[k].f_rotate)) {
k--;
}
long j = i;
while ((j < th->nb_key_frames) && (!eerie->frames[j].f_rotate)) {
j++;
}
if ((j < th->nb_key_frames) && (k >= 0)) {
float r1 = GetTimeBetweenKeyFrames(eerie, k, i);
float r2 = GetTimeBetweenKeyFrames(eerie, i, j);
float tot = 1.f / (r1 + r2);
r1 *= tot;
r2 *= tot;
// TODO use overloaded operators
eerie->frames[i].quat.w = eerie->frames[j].quat.w * r1 + eerie->frames[k].quat.w * r2;
eerie->frames[i].quat.x = eerie->frames[j].quat.x * r1 + eerie->frames[k].quat.x * r2;
eerie->frames[i].quat.y = eerie->frames[j].quat.y * r1 + eerie->frames[k].quat.y * r2;
eerie->frames[i].quat.z = eerie->frames[j].quat.z * r1 + eerie->frames[k].quat.z * r2;
}
}
}
for(long i = 0; i < th->nb_key_frames; i++) {
eerie->frames[i].f_translate = true;
eerie->frames[i].f_rotate = true;
}
// Sets Flag for voidgroups (unmodified groups for whole animation)
for(long i = 0; i < eerie->nb_groups; i++) {
bool voidd = true;
for(long j = 0; j < eerie->nb_key_frames; j++) {
long pos = i + (j * eerie->nb_groups);
if( eerie->groups[pos].quat != glm::quat()
|| eerie->groups[pos].translate != Vec3f_ZERO
|| eerie->groups[pos].zoom != Vec3f_ZERO) {
voidd = false;
break;
}
}
if(voidd) {
eerie->voidgroups[i] = 1;
}
}
eerie->anim_time = AnimationDurationUs(s64(th->nb_frames) * 1000 * 1000 / 24);
if(eerie->anim_time < AnimationDurationMs(1)) {
eerie->anim_time = AnimationDurationMs(1);
}
LogDebug("Finished Conversion TEA -> EERIE - " << toS(eerie->anim_time) << " seconds");
return eerie;
}
inline s64 random_i64() { return s64(random_u64()); }
void ConfuseSpell::Update() {
Vec3f pos = entities[m_target]->pos;
if(m_target != EntityHandle_Player) {
pos.y += entities[m_target]->physics.cyl.height - 30.f;
}
ObjVertHandle idx = entities[m_target]->obj->fastaccess.head_group_origin;
if(idx != ObjVertHandle()) {
pos = entities[m_target]->obj->vertexlist3[idx.handleData()].v;
pos.y -= 50.f;
}
eCurPos = pos;
RenderMaterial mat;
mat.setDepthTest(false);
mat.setBlendType(RenderMaterial::Additive);
mat.setTexture(tex_trail);
Anglef stiteangle = Anglef(0.f, -glm::degrees(arxtime.now_f() * ( 1.0f / 500 )), 0.f);
{
AnimationDuration delta = AnimationDurationUs(s64(g_framedelay * 1000.f));
EERIEDrawAnimQuatUpdate(spapi, animlayer, stiteangle, eCurPos, delta, NULL, false);
EERIEDrawAnimQuatRender(spapi, eCurPos, NULL, 0.f);
}
for(int i = 0; i < 6; i++) {
PARTICLE_DEF * pd = createParticle();
if(!pd) {
break;
}
Vec2f p = glm::diskRand(15.f);
pd->ov = eCurPos + Vec3f(p.x, 0.f, p.y);
pd->move = Vec3f(0.f, Random::getf(1.f, 4.f), 0.f);
pd->siz = 0.25f;
pd->tolive = Random::getu(2300, 3300);
pd->tc = tex_p1;
pd->m_flags = PARTICLE_GOLDRAIN | FADE_IN_AND_OUT | ROTATING | DISSIPATING;
pd->m_rotation = 0.0000001f;
Color3f baseColor = Color3f(0.4f, 0.2f, 0.4f);
Color3f randomFactor = Color3f(0.4f, 0.6f, 0.4f);
Color3f c = baseColor + randomColor3f() * randomFactor;
while(glm::abs(c.r - c.g) > 0.3f && glm::abs(c.g - c.b) > 0.3f) {
c = baseColor + randomColor3f() * randomFactor;
}
pd->rgb = c * Color3f(0.8f, 0.8f, 0.8f);
}
EERIE_LIGHT * light = dynLightCreate(m_light);
if(light) {
light->intensity = 1.3f;
light->fallstart = 180.f;
light->fallend = 420.f;
light->rgb = Color3f(0.3f, 0.3f, 0.5f) + Color3f(0.2f, 0.f, 0.2f) * randomColor3f();
light->pos = eCurPos;
light->duration = ArxDurationMs(200);
light->extras = 0;
}
}
int fromS64(char* in, int length, char* out, int outMaxLength, char* pass){
s64(in, length, out, outMaxLength, pass, false);
}
int toS64(char* in, int length, char* out, int outMaxLength, char* pass){
s64(in, length, out, outMaxLength, pass, true);
}
/*==============================================================================
* FUNCTION: DfaTest::testMeetInt
* OVERVIEW: Test meeting IntegerTypes with various other types
*============================================================================*/
void DfaTest::testMeetInt()
{
IntegerType i32(32, 1);
IntegerType j32(32, 0);
IntegerType u32(32, -1);
IntegerType xint(0);
IntegerType j16(16, 0);
SizeType s32(32);
SizeType s64(64);
FloatType flt(32);
PointerType pt(&flt);
VoidType v;
bool ch = false;
i32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost1;
ost1 << &i32;
std::string actual(ost1.str());
std::string expected("i32");
CPPUNIT_ASSERT_EQUAL(expected, actual);
i32.meetWith(&j32, ch, false);
CPPUNIT_ASSERT(ch == false);
j32.meetWith(&i32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost2;
ost2 << &i32;
actual = ost2.str();
expected = "i32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
j32.setSigned(0);
j32.meetWith(&v, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost2a;
ost2a << &j32;
actual = ost2a.str();
expected = "j32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
j32.meetWith(&u32, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost3;
ost3 << &j32;
actual = ost3.str();
expected = "u32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
u32.meetWith(&s32, ch, false);
CPPUNIT_ASSERT(ch == false);
std::ostringstream ost4;
ost4 << &u32;
actual = ost4.str();
expected = "u32";
CPPUNIT_ASSERT_EQUAL(expected, actual);
u32.meetWith(&s64, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost5;
ost5 << &u32;
actual = ost5.str();
expected = "u64";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
Type *res = i32.meetWith(&flt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost6;
ost6 << res;
actual = ost6.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
ch = false;
res = i32.meetWith(&pt, ch, false);
CPPUNIT_ASSERT(ch == true);
std::ostringstream ost7;
ost7 << res;
actual = ost7.str();
expected = "union";
CPPUNIT_ASSERT_EQUAL(expected, actual);
}
