bool CMinotaur::RayCastForward(float& fHitTime)
{
XMFLOAT3 start = *GetPosition();
start.y = 75.0f;
TRay tRay;
tRay.f3Start = start;
XMFLOAT3 f3ZAxis = *GetZAxis();
tRay.f3Direction.x = f3ZAxis.x;
tRay.f3Direction.y = f3ZAxis.y;
tRay.f3Direction.z = f3ZAxis.z;
tRay.fDistance = 25000.0f;
std::vector<IObject*> vColliders = m_cpObjectManager->GetList(CObjectManager::Static);
for (unsigned int i = 0; i < m_vDoors.size(); i++)
{
vColliders.push_back(m_vDoors[i]);
}
bool bOutput = true;
if (LineSegmentIntersection(tRay, vColliders, fHitTime) == false)
{
bOutput = false;
}
return bOutput;
}
void Camera::Update()
{
UpdateBasis();
MathLib::vector4& camera_xAxis = GetXAxis();
MathLib::vector4& camera_yAxis = GetYAxis();
MathLib::vector4& camera_zAxis = GetZAxis();
MathLib::vector4& camera_position = GetPosition();
// Create world to camera space transform.
{
MathLib::matrix4x4 worldToCameraTransform_basisComponent
(
camera_xAxis.extractX(), camera_xAxis.extractY(), camera_xAxis.extractZ(), 0.0f,
camera_yAxis.extractX(), camera_yAxis.extractY(), camera_yAxis.extractZ(), 0.0f,
camera_zAxis.extractX(), camera_zAxis.extractY(), camera_zAxis.extractZ(), 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
);
MathLib::matrix4x4 worldToCameraTransform_translationComponent
(
1.0f, 0.0f, 0.0f, -camera_position.extractX(),
0.0f, 1.0f, 0.0f, -camera_position.extractY(),
0.0f, 0.0f, 1.0f, -camera_position.extractZ(),
0.0f, 0.0f, 0.0f, 1.0f
);
MathLib::matrix4x4 worldToCameraTransform;
MathLib::matrix4x4_mul(worldToCameraTransform_basisComponent, worldToCameraTransform_translationComponent, worldToCameraTransform);
MathLib::matrix4x4_copy(worldToCameraSpaceMatrix, worldToCameraTransform);
}
// Create camera to world space transform.
{
MathLib::matrix4x4 orientation
(
camera_xAxis.extractX(), camera_yAxis.extractX(), camera_zAxis.extractX(), 0.0f,
camera_xAxis.extractY(), camera_yAxis.extractY(), camera_zAxis.extractY(), 0.0f,
camera_xAxis.extractZ(), camera_yAxis.extractZ(), camera_zAxis.extractZ(), 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
);
MathLib::matrix4x4 translation
(
1.0f, 0.0f, 0.0f, camera_position.extractX(),
0.0f, 1.0f, 0.0f, camera_position.extractY(),
0.0f, 0.0f, 1.0f, camera_position.extractZ(),
0.0f, 0.0f, 0.0f, 1.0f
);
MathLib::matrix4x4_mul(translation, orientation, cameraToWorldSpaceMatrix);
}
}
void CSkeleton::ResetManuverVector(int chance, XMFLOAT3& mVector)
{
XMVECTOR zAxis = XMLoadFloat3(GetZAxis());
XMVECTOR yAxis = XMLoadFloat3(GetYAxis());
zAxis = XMVector3Normalize(zAxis);
yAxis = XMVector3Normalize(yAxis);
XMVECTOR translateVector;
if (chance == 0)
translateVector = XMVector3Cross(zAxis, yAxis);
else
translateVector = XMVector3Cross(yAxis, zAxis);
translateVector = XMVector3Normalize(translateVector);
translateVector *= 150.0f;
XMStoreFloat3(&mVector, translateVector);
}
//************************************************
//*测试任务初始化
//************************************************
VOID t1::TestInit()
{
if (m_TrialType == TRIAL_PRACTICE)
{
m_TrialTime = m_Setting.m_PracTime;
m_TrialTimes = m_Setting.m_PracTimes;
}
else
{
m_TrialTime = m_Setting.m_ExperTime;
m_TrialTimes = m_Setting.m_ExperTimes;
}
a = x_resolution / 2;
b = y_resolution / 2;
r1 = 300;
r2 = 200;
Rx = 400;
Ry = 200;
acce = m_Setting.m_AccelerationMin;
// inc_v = m_Setting.m_IncreaseValue;
if (m_Setting.m_SpeedMode == 0)
{
v = m_Setting.m_Speed;
}
else
{
v = m_Setting.m_InitSpeed;
}
InitRotateAngle = 0.0;
if (m_Setting.m_MoveMode)
{
RandValueFloat(m_Setting.m_AngleSpeedMin, m_Setting.m_AngleSpeedMax, AngleSpeed);
RandValueFloat(-90.0, 90.0, RotateAngle);
if (RotateAngle<0)
{
AngleSpeed = -AngleSpeed;
}
}
else
{
RotateAngle = 0.0;
AngleSpeed = 0.0;
}
fai = 0.0;
post_fai = 0.0;
m_PointNum = 0;
m_MemNum = 1000;
m_ObjPoint = (SPOINT*)malloc(m_MemNum*sizeof(POINT));
m_PostPoint = (SPOINT*)malloc(m_MemNum*sizeof(POINT));
m_ObjRotate = (float*)malloc(m_MemNum*sizeof(float));
m_PostRotate = (float*)malloc(m_MemNum*sizeof(float));
m_Distance = (float*)malloc(m_MemNum*sizeof(float));
m_RotateError = (float*)malloc(m_MemNum*sizeof(float));
m_PointTime = (unsigned long*)malloc(m_MemNum*sizeof(unsigned long));
m_bHit = (BOOL*)malloc(m_MemNum*sizeof(BOOL));
m_ObjSpeedX = (float*)malloc(m_MemNum*sizeof(float));
m_ObjSpeedY = (float*)malloc(m_MemNum*sizeof(float));
m_PostSpeedX = (float*)malloc(m_MemNum*sizeof(float));
m_PostSpeedY = (float*)malloc(m_MemNum*sizeof(float));
m_ObjRotateSpeed = (float*)malloc(m_MemNum*sizeof(float));
m_PostRotateSpeed = (float*)malloc(m_MemNum*sizeof(float));
if (m_Setting.m_Pause == 1)
{
m_PauseTimeStart = (int*)malloc(m_Setting.m_PauseNum*sizeof(int));
m_PauseTimeEnd = (int*)malloc(m_Setting.m_PauseNum*sizeof(int));
}
m_ObjRotateSpeed[m_PointNum] = AngleSpeed;
m_PostPointX = x_resolution / 2;
m_PostPointY = y_resolution / 2;
m_PostPoint[m_PointNum].x = m_PostPointX;
m_PostPoint[m_PointNum].y = m_PostPointY;
m_PostRotate[m_PointNum] = post_fai;
m_ObjRotate[m_PointNum] = fai;
m_RotateError[m_PointNum] = 0.0;
switch (m_Setting.m_Track)
{
case TRACK_CIRCLE:
alpha = m_Setting.m_InitAngle*PI / 180.0;
m_ObjPoint[m_PointNum].x = a + r1 * cos(alpha);
m_ObjPoint[m_PointNum].y = b - r1 * sin(alpha);
r = r1;
break;
case TRACK_ELLIPSE:
alpha = m_Setting.m_InitAngle*PI / 180.0;
m_ObjPoint[m_PointNum].x = a + Rx * cos(alpha);
m_ObjPoint[m_PointNum].y = b - Ry * sin(alpha);
r = pow(pow((m_ObjPoint[m_PointNum].y - b), (float)2.0) + pow((m_ObjPoint[m_PointNum].x - a), (float)2.0), (float)0.5);
break;
case TRACK_EIGHT:
alpha = 0;
m_ObjPoint[m_PointNum].x = a + r2 + r2 * cos(2 * alpha);
m_ObjPoint[m_PointNum].y = b - r2 * sin(2 * alpha);
r = r2;
break;
}
m_Distance[m_PointNum] = pow(pow((m_ObjPoint[m_PointNum].y - m_PostPoint[m_PointNum].y), 2.0) + pow((m_ObjPoint[m_PointNum].x - m_PostPoint[m_PointNum].x), 2.0), 0.5);
if (m_Setting.m_Track == TRACK_ELLIPSE)
{
omiga = pow(v*v / (pow(Rx*sin(alpha), (float)2.0) + pow(Ry*cos(alpha), (float)2.0)), (float)0.5);
}
else
{
omiga = v / r;
}
m_ObjSpeedX[m_PointNum] = -v * sin(alpha);
m_ObjSpeedY[m_PointNum] = -v * cos(alpha);
JoyX = 0;
JoyY = 0;
m_bHit[m_PointNum] = FALSE;
m_bObjPause = FALSE;
m_PauseNo = 0;
if (m_Setting.m_Pause == 1)
{
RandPausePoint(60, m_Setting.m_PauseNum, m_PauseTimeStart, m_PauseTimeEnd);
}
if (JoystickUpdate())
{
post_fai0 = GetZAxis();//GetXAxis();
}
if (m_Setting.m_Direction == 0)
{
m_Direction = 1;
}
else
{
m_Direction = -1;
}
}
//************************************************
//*操纵杆输入线程
//************************************************
DWORD WINAPI t1::InputThreadProcedure(LPVOID lpStartupParam)
{
// get the data we passed to the thread. Note that we don't have to use this
// at all if we don't want
MYDATA* pMyData = (MYDATA*)lpStartupParam;
// access some imaginary members of MYDATA, which you can define on
// your own later
pMyData->nTime = GetCurrentTime(); // imaginary function I created
pMyData->nNumber = 5;
// here's the thread's main loop ?kind of like the main loop in WinMain
MSG msg;
int i;
for (;;)
{
//处理外部消息
if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
{
GetMessage(&msg, NULL, 0, 0);
if (msg.message == WM_THREADSTOP)
break; // only way out of the for( ;; ) loop
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
switch (m_TestState)
{
case STATE_DISPLAYINSTURCTION:
case STATE_DISPLAYNEXT:
case STATE_DISPLAYOPTION:
//呈现开始选项，等待按任意键开始测试
if (JoystickUpdate())
{
for (i = 0; i<8; i++)
{
if (IsButtonDown(KEY_YES))
{
m_TrialNo++;
TestInit();
m_TestState = STATE_DISPLAYOBJ;
break;
}
}
}
break;
case STATE_DISPLAYOBJ:
case STATE_MOVINGOBJ:
//测试过程中获得操纵杆输入
if (JoystickUpdate())
{
JoyX = GetXAxis();//GetYAxis();//
JoyY = GetYAxis();//-GetZAxis();//
if (m_Setting.m_MoveMode == MODE_MOVEROATE)
{
JoyZ = GetZAxis();//GetXAxis();//
post_fai = (float)(JoyZ - post_fai0)*(3600.0 / 1024.0) / m_HardSetting.m_KnobSensitive;//GetZAxis()*PI/400.0;
while (post_fai<-180)
{
post_fai = post_fai + 360;
}
while (post_fai>180)
{
post_fai = post_fai - 360;
}
}
}
break;
case STATE_OVER:
//测试结束，等待按任意键退出
if (JoystickUpdate())
{
for (i = 0; i<12; i++)
{
if (IsButtonDown(i))
{
PostThreadMessage(dwInputThreadID, WM_THREADSTOP, 0, 0);
m_TestState = STATE_NEXT;// STATE_EXIT --> STATE_NEXT
}
}
}
break;
default:
break;
}
// do the task ?add in your own stuff here
// yield to other threads, because we almost never get messages
// (note that we may be yielding to WinMain too)
//以键盘代替操纵杆
if (JOY == 0)
{
if (IsButtonDown(DIK_ESCAPE))
{
PostThreadMessage(dwInputThreadID, WM_THREADSTOP, 0, 0);
m_TestState = STATE_EXIT;
}
}
}
Sleep(1);
}
g_nThreadExitCount++;
return 0;
}
