void AnimCtrlPlayerCharacter::updateAimRotation(Ogre::Radian angleHorizontal, Ogre::Radian angleVertical, unsigned long timeSinceLastFrame)
{
// This is freaking important! Must be in seconds and an Ogre::Real
Ogre::Real secSinceLastFrame = (Ogre::Real) timeSinceLastFrame / 1000.f;
// Set manual frame position
// ---------------------------------------
float prevValue = animPipeline->getAnimManualTimePos( "aim" );
float maxValue = animPipeline->getAnimLength( "aim" );
float aimFrame = interpolateAiming( angleHorizontal.valueDegrees(), 360.f, prevValue, maxValue, 3500.f, secSinceLastFrame );
animPipeline->setAnimManualTimePos( "aim", aimFrame );
animPipeline->setAnimManualTimePos( "aimUp", aimFrame );
animPipeline->setAnimManualTimePos( "aimDown", aimFrame );
// Set blend value
// ---------------------------------------
// Modify Angle; animated only from 45° (up) to -45° (down)
float aimBlend = angleVertical.valueDegrees() - 45.f;
aimBlend = std::max( 0.f, aimBlend );
aimBlend = std::min( 90.f, aimBlend );
prevValue = getFlagValue( "aim_vertical2", 0 ) +
getFlagValue( "aim_vertical3", 0 );
aimBlend = interpolateAiming( aimBlend, 90.f, prevValue, 2.f, 2000.f, secSinceLastFrame );
// Split up blend value from 0 to 1 into three blend values for the LERP tree
float aimBlendTrees = (aimBlend > 1.f) ? 1.f : 0.f; setFlagValue( "aim_vertical1", aimBlendTrees );
float aimBlend2 = std::min( 1.f, aimBlend ); setFlagValue( "aim_vertical2", aimBlend2 );
float aimBlend3 = std::max( 1.f, aimBlend ) - 1.f; setFlagValue( "aim_vertical3", aimBlend3 );
}
void _jle (tCommandWithOperands cmd)
{
if (getFlagValue(ZeroFlag) == 1 || getFlagValue(NegativeFlag) == 1) {
regValue[IP] = getOperandValue(cmd.left);
command_did_jump = 1;
}
}
void _jne (tCommandWithOperands cmd)
{
if (getFlagValue(ZeroFlag) == 0) {
regValue[IP] = getOperandValue(cmd.left);
command_did_jump = 1;
}
}
int setLogFormat(int argc, char** argv)
{
const char* value = getOption(FLAG_NAME[FLAG_LOG_FORMAT], argc, argv);
if (NULL == value) {
value = getFlagValue(FLAG_NAME[FLAG_LOG_FORMAT], argc, argv);
}
if (NULL != value) {
if (0 == strcmp(value, "xml")) {
setStreamPrintXML(1);
} else if (0 == strcmp(value, "xmltcp")) {
setStreamPrintXML(2);
} else if (0 == strcmp(value, "text")) {
setStreamPrintXML(0);
} else {
warningStreamPrint(LOG_STDOUT, 0, "invalid command line option: -logFormat=%s, expected text, xml, or xmltcp", value);
return 1;
}
}
return 0;
}
jboolean followArgs(CallTempStruct* call, DCArgs* args, int nTypes, ValueType* pTypes, jboolean toJava, jboolean isVarArgs)
{
JNIEnv* env = call->env;
int iParam;
//printf("ARGS : %d args\n", (int)nTypes);
for (iParam = 0; iParam < nTypes; iParam++) {
ValueType type = pTypes[iParam];
switch (type) {
case eIntFlagSet:
{
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
if (toJava) {
int flags = dcbArgInt(args);
jobject obj = createPointerFromIO(env, JLONG_TO_PTR ((jlong)flags), callIO);
dcArgPointer(call->vm, obj);
} else {
int arg = (jint)getFlagValue(env, (jobject)dcbArgPointer(args));
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgInt(call->vm, arg);
}
}
break;
case eIntValue:
{
int arg = dcbArgInt(args);
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgInt(call->vm, arg);
}
break;
#define ARG_BOXED_INTEGRAL(type, capitalized) \
{ \
if (toJava) { \
type arg = (sizeof(type) == 4) ? (type)dcbArgInt(args) : (type)dcbArgLongLong(args); \
dcArgPointer(call->vm, Box ## capitalized(env, arg)); \
} else { \
jobject parg = dcbArgPointer(args); \
jlong arg = Unbox ## capitalized(env, parg); \
if (isVarArgs) \
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg); \
else if (sizeof(type) == 4) \
dcArgInt(call->vm, (jint)arg); \
else \
dcArgLongLong(call->vm, (jlong)arg); \
} \
}
#define ARG_UNBOXED_INTEGRAL(type, capitalized) \
{ \
if (toJava) { \
type arg = (sizeof(type) == 4) ? (type)dcbArgInt(args) : (type)dcbArgLongLong(args); \
dcArgLongLong(call->vm, (jlong)arg); \
} else { \
jlong arg = dcbArgLongLong(args); \
if (isVarArgs) \
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg); \
else if (sizeof(type) == 4) \
dcArgInt(call->vm, (jint)arg); \
else \
dcArgLongLong(call->vm, (jlong)arg); \
} \
}
case eCLongValue:
ARG_UNBOXED_INTEGRAL(long, CLong);
break;
case eSizeTValue:
ARG_UNBOXED_INTEGRAL(size_t, SizeT);
break;
case eCLongObjectValue:
ARG_BOXED_INTEGRAL(long, CLong);
break;
case eSizeTObjectValue:
ARG_BOXED_INTEGRAL(size_t, SizeT);
break;
case eTimeTObjectValue:
ARG_BOXED_INTEGRAL(time_t, TimeT);
break;
case eLongValue:
dcArgLongLong(call->vm, dcbArgLongLong(args));
break;
case eShortValue:
{
short arg = dcbArgShort(args);
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgShort(call->vm, arg);
}
break;
case eBooleanValue:
case eByteValue:
{
char arg = dcbArgChar(args);
if (isVarArgs)
dcArgPointer(call->vm, (void*)(ptrdiff_t)arg);
else
dcArgChar(call->vm, arg);
}
break;
case eFloatValue:
{
float arg = dcbArgFloat(args);
if (isVarArgs)
dcArgDouble(call->vm, arg);
else
dcArgFloat(call->vm, arg);
}
break;
case eDoubleValue:
dcArgDouble(call->vm, dcbArgDouble(args));
break;
case ePointerValue:
{
void* ptr = dcbArgPointer(args);
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
if (toJava)
{
ptr = createPointerFromIO(env, ptr, callIO);
} else {
ptr = ptr ? getPointerPeer(env, ptr) : NULL;
// printf("ARG POINTER = %d\n", ptr);
}
dcArgPointer(call->vm, ptr);
}
break;
case eWCharValue:
switch (sizeof(wchar_t)) {
case 1:
dcArgChar(call->vm, dcbArgChar(args));
break;
case 2:
dcArgShort(call->vm, dcbArgShort(args));
break;
case 4:
dcArgInt(call->vm, dcbArgInt(args));
break;
default:
throwException(env, "Invalid wchar_t size for argument !");
return JNI_FALSE;
}
break;
case eEllipsis: {
if (toJava) {
throwException(env, "Calling Java ellipsis is not supported yet !");
return JNI_FALSE;
} else {
jobjectArray arr = (jobjectArray)dcbArgPointer(args);
jsize n = (*env)->GetArrayLength(env, arr), i;
for (i = 0; i < n; i++) {
jobject arg = (*env)->GetObjectArrayElement(env, arr, i);
#define TEST_INSTANCEOF(cl, st) \
if ((*env)->IsInstanceOf(env, arg, cl)) st;
if (arg == NULL)
dcArgPointer(call->vm, getPointerPeer(env, (void*)NULL));
else
// As per the C standard for varargs, all ints are promoted to ptrdiff_t and float is promoted to double :
TEST_INSTANCEOF(gIntClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxInt(env, arg)))
else
TEST_INSTANCEOF(gLongClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxLong(env, arg)))
else
TEST_INSTANCEOF(gShortClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxShort(env, arg)))
else
TEST_INSTANCEOF(gByteClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxByte(env, arg)))
else
TEST_INSTANCEOF(gBooleanClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)(char)UnboxBoolean(env, arg)))
else
TEST_INSTANCEOF(gCharClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)(short)UnboxChar(env, arg)))
else
TEST_INSTANCEOF(gDoubleClass, dcArgDouble(call->vm, UnboxDouble(env, arg)))
else
TEST_INSTANCEOF(gFloatClass, dcArgDouble(call->vm, UnboxFloat(env, arg)))
else
TEST_INSTANCEOF(gCLongClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)(long)UnboxCLong(env, arg)))
else
TEST_INSTANCEOF(gSizeTClass, dcArgPointer(call->vm, (void*)(ptrdiff_t)UnboxSizeT(env, arg)))
else
TEST_INSTANCEOF(gPointerClass, dcArgPointer(call->vm, getPointerPeer(env, (void*)arg)))
else {
throwException(env, "Invalid value type in ellipsis");
return JNI_FALSE;
}
}
}
break;
}
default:
throwException(env, "Invalid argument value type !");
return JNI_FALSE;
}
}
if ((*env)->ExceptionCheck(env))
return JNI_FALSE;
return JNI_TRUE;
}
int checkCommandLineArguments(int argc, char **argv)
{
int i,j;
/* This works not that well - but is probably better than no check */
assertStreamPrint(NULL, !strcmp(FLAG_NAME[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_NAME");
assertStreamPrint(NULL, !strcmp(FLAG_DESC[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_DESC");
assertStreamPrint(NULL, !strcmp(FLAG_DETAILED_DESC[FLAG_MAX], "FLAG_MAX"), "unbalanced command line flag structure: FLAG_DETAILED_DESC");
for(i=0; i<FLAG_MAX; ++i)
{
omc_flag[i] = 0;
omc_flagValue[i] = NULL;
}
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 1, "used command line options");
for(i=1; i<argc; ++i)
debugStreamPrint(LOG_STDOUT, 0, "%s", argv[i]);
messageClose(LOG_STDOUT);
debugStreamPrint(LOG_STDOUT, 1, "interpreted command line options");
#endif
for(i=1; i<argc; ++i)
{
int found=0;
for(j=1; j<FLAG_MAX; ++j)
{
if((FLAG_TYPE[j] == FLAG_TYPE_FLAG) && flagSet(FLAG_NAME[j], 1, argv+i))
{
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s", FLAG_NAME[j]);
#endif
break;
} else if((FLAG_TYPE[j] == FLAG_TYPE_OPTION) && flagSet(FLAG_NAME[j], 1, argv+i) && (i+1 < argc)) {
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
omc_flagValue[j] = (char*)getFlagValue(FLAG_NAME[j], 1, argv+i);
i++;
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s %s", FLAG_NAME[j], omc_flagValue[j]);
#endif
break;
} else if((FLAG_TYPE[j] == FLAG_TYPE_OPTION) && optionSet(FLAG_NAME[j], 1, argv+i)) {
if(omc_flag[j]) {
warningStreamPrint(LOG_STDOUT, 0, "each command line option can only be used once: %s", argv[i]);
return 1;
}
omc_flag[j] = 1;
omc_flagValue[j] = (char*)getOption(FLAG_NAME[j], 1, argv+i);
found=1;
#ifdef USE_DEBUG_OUTPUT
debugStreamPrint(LOG_STDOUT, 0, "-%s=%s", FLAG_NAME[j], omc_flagValue[j]);
#endif
break;
}
}
if(!found)
{
#ifdef USE_DEBUG_OUTPUT
messageClose(LOG_STDOUT);
#endif
warningStreamPrint(LOG_STDOUT, 0, "invalid command line option: %s", argv[i]);
return 1;
}
}
#ifdef USE_DEBUG_OUTPUT
messageClose(LOG_STDOUT);
#endif
return 0;
}
jboolean followCallGenericJavaCallback(CallTempStruct* call, ValueType returnType, DCValue* result, void* callback)
{
JNIEnv* env = call->env;
jobject ret = dcCallPointer(call->vm, callback);
if ((*env)->ExceptionCheck(env))
return JNI_FALSE;
switch (returnType) {
case eIntValue:
result->i = UnboxInt(env, ret);
break;
case eLongValue:
result->l = UnboxLong(env, ret);
break;
case eShortValue:
result->s = UnboxShort(env, ret);
break;
case eByteValue:
result->c = UnboxByte(env, ret);
break;
case eFloatValue:
result->f = UnboxFloat(env, ret);
break;
case eDoubleValue:
result->d = UnboxDouble(env, ret);
break;
case eBooleanValue:
result->c = UnboxBoolean(env, ret);
break;
case eCLongValue: {
jlong v;
if ((*env)->IsInstanceOf(env, ret, gCLongClass))
v = UnboxCLong(env, ret);
else
v = UnboxLong(env, ret);
if (sizeof(long) == 4)
result->i = (int)v;
else
result->l = v;
break;
}
case eSizeTValue: {
jlong v;
if ((*env)->IsInstanceOf(env, ret, gCLongClass))
v = UnboxSizeT(env, ret);
else
v = UnboxLong(env, ret);
if (sizeof(size_t) == 4)
result->i = (int)v;
else
result->L = v;
break;
}
case eVoidValue:
assert(ret == NULL);
break;
case eIntFlagSet:
result->i = (jint)getFlagValue(env, ret);
break;
case ePointerValue:
result->p = ret ? getPointerPeer(env, (void*)ret) : NULL;
call->pCallIOs++;
break;
case eWCharValue:
switch (sizeof(wchar_t)) {
case 1:
result->c = (char)UnboxChar(env, ret);
break;
case 2:
result->s = (short)UnboxChar(env, ret);
break;
case 4:
result->i = UnboxInt(env, ret);
break;
default:
throwException(env, "Invalid wchar_t size !");
return JNI_FALSE;
}
break;
default:
throwException(env, "Invalid return value type !");
return JNI_FALSE;
}
return JNI_TRUE;
}
jboolean followArgsGenericJavaCallback(CallTempStruct* call, DCArgs* args, int nTypes, ValueType* pTypes)
{
JNIEnv* env = call->env;
int iParam;
jobjectArray arr = (*env)->NewObjectArray(env, nTypes, gObjectClass, NULL);
for (iParam = 0; iParam < nTypes; iParam++) {
ValueType type = pTypes[iParam];
jobject arg = NULL;
switch (type) {
case eIntFlagSet:
arg = BoxInt(env, (jint)getFlagValue(env, (jobject)dcbArgPointer(args)));
break;
case eIntValue:
arg = BoxInt(env, dcbArgInt(args));
break;
case eCLongValue: {
jlong v;
if (sizeof(long) == 4)
v = dcbArgLong(args);
else
v = dcbArgLongLong(args);
arg = BoxCLong(env, v);
break;
}
case eSizeTValue: {
jlong v;
if (sizeof(size_t) == 4)
v = dcbArgInt(args);
else
v = dcbArgLongLong(args);
arg = BoxSizeT(env, v);
break;
}
case eLongValue:
arg = BoxLong(env, dcbArgLongLong(args));
break;
case eShortValue:
arg = BoxShort(env, dcbArgShort(args));
break;
case eBooleanValue:
case eByteValue:
arg = BoxByte(env, dcbArgChar(args));
break;
case eFloatValue:
arg = BoxFloat(env, dcbArgFloat(args));
break;
case eDoubleValue:
arg = BoxDouble(env, dcbArgDouble(args));
break;
case ePointerValue:
{
jobject callIO = call && call->pCallIOs ? *(call->pCallIOs++) : NULL;
void* ptr = dcbArgPointer(args);
arg = createPointerFromIO(env, ptr, callIO);
}
break;
case eWCharValue:
switch (sizeof(wchar_t)) {
case 1:
arg = BoxChar(env, dcbArgChar(args));
break;
case 2:
arg = BoxChar(env, dcbArgShort(args));
break;
case 4:
arg = BoxInt(env, dcbArgInt(args));
break;
default:
throwException(env, "Invalid wchar_t size for argument !");
return JNI_FALSE;
}
break;
default:
throwException(env, "Invalid argument value type !");
return JNI_FALSE;
}
(*env)->SetObjectArrayElement(env, arr, iParam, arg);
}
dcArgPointer(call->vm, arr);
if ((*env)->ExceptionCheck(env))
return JNI_FALSE;
return JNI_TRUE;
}
jboolean followCallGenericJavaCallback(CallTempStruct* call, ValueType returnType, DCValue* result, void* callback)
{
JNIEnv* env = call->env;
jobject ret = dcCallPointer(call->vm, callback);
HACK_REFETCH_ENV();
if ((*env)->ExceptionCheck(env))
return JNI_FALSE;
switch (returnType) {
case eIntValue:
result->i = UnboxInt(env, ret);
break;
case eLongValue:
result->l = UnboxLong(env, ret);
break;
case eShortValue:
result->s = UnboxShort(env, ret);
break;
case eByteValue:
result->c = UnboxByte(env, ret);
break;
case eFloatValue:
result->f = UnboxFloat(env, ret);
break;
case eDoubleValue:
result->d = UnboxDouble(env, ret);
break;
case eBooleanValue:
result->c = UnboxBoolean(env, ret);
break;
#define RETURN_UNBOXED_INTEGRAL(type, capitalized) \
{ \
jlong v; \
if ((*env)->IsInstanceOf(env, ret, g ## capitalized ## Class)) \
v = Unbox ## capitalized(env, ret); \
else \
v = UnboxLong(env, ret); \
if (sizeof(type) == 4) \
result->i = (jint)v; \
else \
result->L = (jlong)v; \
}
#define RETURN_BOXED_INTEGRAL(type, capitalized) \
{ \
if ((*env)->IsInstanceOf(env, ret, g ## capitalized ##Class)) \
result->p = ret; \
else \
result->p = Box ## capitalized(env, (type)UnboxLong(env, ret)); \
}
case eCLongValue:
RETURN_UNBOXED_INTEGRAL(long, CLong)
break;
case eCLongObjectValue:
RETURN_BOXED_INTEGRAL(long, CLong);
break;
case eSizeTValue:
RETURN_UNBOXED_INTEGRAL(size_t, SizeT);
break;
case eSizeTObjectValue:
RETURN_BOXED_INTEGRAL(size_t, SizeT);
break;
case eTimeTObjectValue:
RETURN_BOXED_INTEGRAL(time_t, TimeT);
break;
case eVoidValue:
assert(ret == NULL);
break;
case eIntFlagSet:
result->i = (jint)getFlagValue(env, ret);
break;
case ePointerValue:
result->p = ret ? getPointerPeer(env, (void*)ret) : NULL;
call->pCallIOs++;
break;
case eWCharValue:
switch (sizeof(wchar_t)) {
case 1:
result->c = (char)UnboxChar(env, ret);
break;
case 2:
result->s = (short)UnboxChar(env, ret);
break;
case 4:
result->i = UnboxInt(env, ret);
break;
default:
throwException(env, "Invalid wchar_t size !");
return JNI_FALSE;
}
break;
default:
throwException(env, "Invalid return value type !");
return JNI_FALSE;
}
return JNI_TRUE;
}
