void updateFlyBy () {
std::list<CameraSettings> flyBy = flyBys[selectedFlyBy];
CameraSettings from = flyBy.front();
CameraSettings to = flyBy.back();
for (flyByIterator = flyBy.begin(); flyByIterator != flyBy.end(); flyByIterator++) {
if ((*flyByIterator).time <= flyByElapsed) {
from = (*flyByIterator);
}
if ((*flyByIterator).time > flyByElapsed) {
to = (*flyByIterator);
break;
}
}
int duration = to.time - from.time;
if (duration == 0) {
flyBySettings = to;
flyByElapsed = 0;
} else {
int relativeTime = flyByElapsed - from.time;
EaseFunc ease;
ease = getEase(from.positionXEase);
flyBySettings.position.x = ease(relativeTime, from.position.x, to.position.x - from.position.x, duration);
ease = getEase(from.positionYEase);
flyBySettings.position.y = ease(relativeTime, from.position.y, to.position.y - from.position.y, duration);
ease = getEase(from.positionZEase);
flyBySettings.position.z = ease(relativeTime, from.position.z, to.position.z - from.position.z, duration);
ease = getEase(from.lookAtXEase);
flyBySettings.lookAt.x = ease(relativeTime, from.lookAt.x, to.lookAt.x - from.lookAt.x, duration);
ease = getEase(from.lookAtYEase);
flyBySettings.lookAt.y = ease(relativeTime, from.lookAt.y, to.lookAt.y - from.lookAt.y, duration);
ease = getEase(from.lookAtZEase);
flyBySettings.lookAt.z = ease(relativeTime, from.lookAt.z, to.lookAt.z - from.lookAt.z, duration);
ease = getEase(from.upXEase);
flyBySettings.up.x = ease(relativeTime, from.up.x, to.up.x - from.up.x, duration);
ease = getEase(from.upYEase);
flyBySettings.up.y = ease(relativeTime, from.up.y, to.up.y - from.up.y, duration);
ease = getEase(from.upZEase);
flyBySettings.up.z = ease(relativeTime, from.up.z, to.up.z - from.up.z, duration);
flyBySettings.time = flyByElapsed;
flyByElapsed += 1;
}
}
static int getEaseInt( int i_value, int i_maxvalue )
{
int i;
HSPREAL value;
if ( i_maxvalue > 0 ) {
value = (HSPREAL)i_value / (HSPREAL)i_maxvalue;
} else {
value = ease_4096 * i_value;
}
i = (int)getEase(value);
return i;
}
static HSPREAL getEase( HSPREAL value, HSPREAL maxvalue )
{
if ( maxvalue == 0 ) return (HSPREAL)0;
return getEase( value / maxvalue );
}
static void *reffunc_intfunc( int *type_res, int arg )
{
// reffunc : TYPE_INTFUNC
// (内蔵関数)
//
void *ptr;
int chk;
HSPREAL dval;
HSPREAL dval2;
int ival;
char *sval;
int p1,p2,p3;
// '('で始まるかを調べる
//
if ( *type != TYPE_MARK ) throw HSPERR_INVALID_FUNCPARAM;
if ( *val != '(' ) throw HSPERR_INVALID_FUNCPARAM;
code_next();
// 返値のタイプをargをもとに設定する
// 0～255 : int
// 256～383 : string
// 384～511 : double(HSPREAL)
//
switch( arg>>7 ) {
case 2: // 返値がstr
*type_res = HSPVAR_FLAG_STR; // 返値のタイプを指定する
ptr = NULL; // 返値のポインタ
break;
case 3: // 返値がdouble
*type_res = HSPVAR_FLAG_DOUBLE; // 返値のタイプを指定する
ptr = &reffunc_intfunc_value; // 返値のポインタ
break;
default: // 返値がint
*type_res = HSPVAR_FLAG_INT; // 返値のタイプを指定する
ptr = &reffunc_intfunc_ivalue; // 返値のポインタ
break;
}
switch( arg ) {
// int function
case 0x000: // int
{
int *ip;
chk = code_get();
if ( chk <= PARAM_END ) { throw HSPERR_INVALID_FUNCPARAM; }
ip = (int *)HspVarCoreCnvPtr( mpval, HSPVAR_FLAG_INT );
reffunc_intfunc_ivalue = *ip;
break;
}
case 0x001: // rnd
ival = code_geti();
if ( ival == 0 ) throw HSPERR_DIVIDED_BY_ZERO;
#ifdef HSPRANDMT
{
std::uniform_int_distribution<int> dist( 0, ival - 1 );
reffunc_intfunc_ivalue = dist( mt );
}
#else
reffunc_intfunc_ivalue = rand()%ival;
#endif
break;
case 0x002: // strlen
sval = code_gets();
reffunc_intfunc_ivalue = (int) strlen( sval );
break;
case 0x003: // length(3.0)
case 0x004: // length2(3.0)
case 0x005: // length3(3.0)
case 0x006: // length4(3.0)
{
PVal *pv;
pv = code_getpval();
reffunc_intfunc_ivalue = pv->len[ arg - 0x002 ];
break;
}
case 0x007: // vartype(3.0)
{
PVal *pv;
HspVarProc *proc;
if ( *type == TYPE_STRING ) {
sval = code_gets();
proc = HspVarCoreSeekProc( sval );
if ( proc == NULL ) throw HSPERR_ILLEGAL_FUNCTION;
reffunc_intfunc_ivalue = proc->flag;
} else {
code_getva( &pv );
reffunc_intfunc_ivalue = pv->flag;
}
break;
}
case 0x008: // gettime
ival = code_geti();
reffunc_intfunc_ivalue = gettime( ival );
break;
case 0x009: // peek
case 0x00a: // wpeek
case 0x00b: // lpeek
{
PVal *pval;
char *ptr;
int size;
ptr = code_getvptr( &pval, &size );
p1 = code_getdi( 0 );
if ( p1<0 ) throw HSPERR_ILLEGAL_FUNCTION;
ptr += p1;
if ( arg == 0x09 ) {
if ( (p1+1)>size ) throw HSPERR_ILLEGAL_FUNCTION;
reffunc_intfunc_ivalue = ((int)(*ptr)) & 0xff;
} else if ( arg == 0x0a ) {
if ( (p1+2)>size ) throw HSPERR_ILLEGAL_FUNCTION;
reffunc_intfunc_ivalue = ((int)(*(short *)ptr)) & 0xffff;
} else {
if ( (p1+4)>size ) throw HSPERR_ILLEGAL_FUNCTION;
reffunc_intfunc_ivalue = *(int *)ptr;
}
break;
}
case 0x00c: // varptr
{
PVal *pval;
APTR aptr;
PDAT *pdat;
STRUCTDAT *st;
if ( *type == TYPE_DLLFUNC ) {
st = &(ctx->mem_finfo[ *val ]);
reffunc_intfunc_ivalue = (int)(size_t)(st->proc);
code_next();
break;
}
aptr = code_getva( &pval );
pdat = HspVarCorePtrAPTR( pval, aptr );
reffunc_intfunc_ivalue = (int)(size_t)(pdat);
break;
}
case 0x00d: // varuse
{
PVal *pval;
APTR aptr;
PDAT *pdat;
aptr = code_getva( &pval );
if ( pval->support & HSPVAR_SUPPORT_VARUSE ) {
pdat = HspVarCorePtrAPTR( pval, aptr );
reffunc_intfunc_ivalue = HspVarCoreGetUsing( pval, pdat );
} else throw HSPERR_TYPE_MISMATCH;
break;
}
case 0x00e: // noteinfo
ival = code_getdi(0);
note_update();
switch( ival ) {
case 0:
reffunc_intfunc_ivalue = note.GetMaxLine();
break;
case 1:
reffunc_intfunc_ivalue = note.GetSize();
break;
default:
throw HSPERR_ILLEGAL_FUNCTION;
}
break;
case 0x00f: // instr
{
PVal *pval;
char *ptr;
char *ps;
char *ps2;
int size;
int p1;
ptr = code_getvptr( &pval, &size );
if ( pval->flag != HSPVAR_FLAG_STR ) throw HSPERR_TYPE_MISMATCH;
p1 = code_getdi(0);
if ( p1 >= size ) throw HSPERR_BUFFER_OVERFLOW;
ps = code_gets();
if ( p1 >= 0 ) {
ptr += p1;
ps2 = strstr2( ptr, ps );
} else {
ps2 = NULL;
}
if ( ps2 == NULL ) {
reffunc_intfunc_ivalue = -1;
} else {
reffunc_intfunc_ivalue = (int)(ps2 - ptr);
}
break;
}
case 0x010: // abs
reffunc_intfunc_ivalue = code_geti();
if ( reffunc_intfunc_ivalue < 0 ) reffunc_intfunc_ivalue = -reffunc_intfunc_ivalue;
break;
case 0x011: // limit
p1 = code_geti();
p2 = code_geti();
p3 = code_geti();
reffunc_intfunc_ivalue = GetLimit( p1, p2, p3 );
break;
case 0x012: // getease
p1 = code_geti();
p2 = code_getdi(-1);
reffunc_intfunc_ivalue = getEaseInt( p1, p2 );
break;
case 0x013: // notefind
{
char *ps;
char *p;
int findopt;
ps = code_gets();
p = code_stmpstr( ps );
findopt = code_getdi(0);
note_update();
reffunc_intfunc_ivalue = note.FindLine( p, findopt );
break;
}
// str function
case 0x100: // str
{
char *sp;
chk = code_get();
if ( chk <= PARAM_END ) { throw HSPERR_INVALID_FUNCPARAM; }
sp = (char *)HspVarCoreCnvPtr( mpval, HSPVAR_FLAG_STR );
ptr = (void *)sp;
break;
}
case 0x101: // strmid
{
PVal *pval;
char *sptr;
char *p;
char chrtmp;
int size;
int i;
int slen;
sptr = code_getvptr( &pval, &size );
if ( pval->flag != HSPVAR_FLAG_STR ) throw HSPERR_TYPE_MISMATCH;
p1 = code_geti();
p2 = code_geti();
slen=(int)strlen( sptr );
if ( p1 < 0 ) {
p1=slen - p2;
if ( p1 < 0 ) p1 = 0;
}
if ( p1 >= slen )
p2 = 0;
if ( p2 > slen ) p2 = slen;
sptr += p1;
ptr = p = code_stmp( p2 + 1 );
for(i=0;i<p2;i++) {
chrtmp = *sptr++;
*p++ = chrtmp;
if (chrtmp==0) break;
}
*p = 0;
break;
}
case 0x103: // strf
ptr = cnvformat();
break;
case 0x104: // getpath
{
char *p;
char pathname[HSP_MAX_PATH];
p = ctx->stmp;
strncpy( pathname, code_gets(), HSP_MAX_PATH-1 );
p1=code_geti();
getpath( pathname, p, p1 );
ptr = p;
break;
}
case 0x105: // strtrim
{
PVal *pval;
char *sptr;
char *p;
int size;
sptr = code_getvptr( &pval, &size );
if ( pval->flag != HSPVAR_FLAG_STR ) throw HSPERR_TYPE_MISMATCH;
p1 = code_getdi(0);
p2 = code_getdi(32);
ptr = p = code_stmp( size + 1 );
strcpy( p, sptr );
switch( p1 ) {
case 0:
TrimCodeL( p, p2 );
TrimCodeR( p, p2 );
break;
case 1:
TrimCodeL( p, p2 );
break;
case 2:
TrimCodeR( p, p2 );
break;
case 3:
TrimCode( p, p2 );
break;
}
break;
}
// double function
case 0x180: // sin
dval = code_getd();
reffunc_intfunc_value = sin( dval );
break;
case 0x181: // cos
dval = code_getd();
reffunc_intfunc_value = cos( dval );
break;
case 0x182: // tan
dval = code_getd();
reffunc_intfunc_value = tan( dval );
break;
case 0x183: // atan
dval = code_getd();
dval2 = code_getdd( 1.0 );
reffunc_intfunc_value = atan2( dval, dval2 );
break;
case 0x184: // sqrt
dval = code_getd();
reffunc_intfunc_value = sqrt( dval );
break;
case 0x185: // double
{
HSPREAL *dp;
chk = code_get();
if ( chk <= PARAM_END ) { throw HSPERR_INVALID_FUNCPARAM; }
dp = (HSPREAL *)HspVarCoreCnvPtr( mpval, HSPVAR_FLAG_DOUBLE );
reffunc_intfunc_value = *dp;
break;
}
case 0x186: // absf
reffunc_intfunc_value = code_getd();
if ( reffunc_intfunc_value < 0 ) reffunc_intfunc_value = -reffunc_intfunc_value;
break;
case 0x187: // expf
dval = code_getd();
reffunc_intfunc_value = exp( dval );
break;
case 0x188: // logf
dval = code_getd();
reffunc_intfunc_value = log( dval );
break;
case 0x189: // limitf
{
HSPREAL d1,d2,d3;
d1 = code_getd();
d2 = code_getd();
d3 = code_getd();
if ( d1 < d2 ) d1 = d2;
if ( d1 > d3 ) d1 = d3;
reffunc_intfunc_value = d1;
break;
}
case 0x18a: // powf
dval = code_getd();
dval2 = code_getd();
reffunc_intfunc_value = pow( dval, dval2 );
break;
case 0x18b: // geteasef
dval = code_getd();
dval2 = code_getdd(1.0);
if ( dval2 == 1.0 ) {
reffunc_intfunc_value = getEase( dval );
} else {
reffunc_intfunc_value = getEase( dval, dval2 );
}
break;
default:
throw HSPERR_UNSUPPORTED_FUNCTION;
}
// ')'で終わるかを調べる
//
if ( *type != TYPE_MARK ) throw HSPERR_INVALID_FUNCPARAM;
if ( *val != ')' ) throw HSPERR_INVALID_FUNCPARAM;
code_next();
return ptr;
}
