void CCamera::ProcessVectorTrackLinear(float time)
{
m_processedVectorTrackLinear = true;
float weight = time;
if (m_vectorTrackLinearConstSpeed)
{
weight = (sin(DEG_TO_RAD(270.0f - time * 180.0f)) + 1.0f) / 2.0f;
}
m_vectorTrackLinearCurrent = Lerp(m_vectorTrackLinearStart, weight, m_vectorTrackLinearEnd);
}
void
sg_camera_rotate_hat(int buttonVal, void *data)
{
//log_info("hat pushed %d", buttonVal);
sg_scene_t *sc = sim_get_scene();
sg_camera_t *cam = sg_scene_get_cam(sc);
ASSERT_CAM(cam);
// Note that the camera control will rotate the camera based on WCT.
// This differ from the normal rotation of objects which is based on SRT.
// The interpolation doesn't really care, it just expresses time as a
// normalized value where 0 is the time of the last physics system sync
// and 1.0 is the expected time of the next sync.
// We thus need to take the frequency (not the SRT period) here.
float wct_freq;
config_get_float_def("openorbit/sim/freq", &wct_freq, 20.0); // Hz
if ((cam->src == cam->tgt) && cam->src) {
// We are targeting our follow object this means orbiting it
if (buttonVal == -1) {
cam->dq = QD_IDENT;
} else {
cam->dq = qd_rot(0.0,
cosf(DEG_TO_RAD(buttonVal)),
sinf(DEG_TO_RAD(buttonVal)),
M_PI_2 / wct_freq);
}
cam->q1 = qd_mul(cam->q0, cam->dq);
} else {
if (buttonVal == -1) {
cam->dq = QD_IDENT;
} else {
cam->dq = qd_rot(0.0,
cosf(DEG_TO_RAD(buttonVal)),
sinf(DEG_TO_RAD(buttonVal)),
M_PI_2 / wct_freq);
}
cam->q1 = qd_mul(cam->q0, cam->dq);
}
ASSERT_CAM(cam);
}
OOellipse* ooGeoEllipseAreaSeg(size_t segs, float semiMajor, float semiMinor)
{
OOellipse *e = smalloc(sizeof(OOellipse));
ooVecArrayInit(&e->vec);
//uint64_t totalIterations = 0;
e->semiMajor = semiMajor;
e->semiMinor = semiMinor;
e->ecc = ooGeoEllipseEcc(e);
double area = ooGeoEllipseArea(e);
double sweep = area / (double)segs;
ooVecArrayPushC(&e->vec,
semiMajor * cos(0.0) - e->ecc * semiMajor, semiMinor * sin(0.0), 0.0f, 0.0f);
double segArea, tol;
double prevAngle = 0.0f;
double newAngle = prevAngle + 1.0*DEG_TO_RAD(360.0/(double)segs);
double delta;
for (size_t i = 1 ; i < segs ; i ++) {
int count = 0;
segArea = ooGeoEllipseSegmentArea(e, prevAngle, newAngle);
delta = (newAngle-prevAngle);
do {
if (segArea > sweep) {
delta -= delta/STEPSIZE;
} else {
delta += delta/STEPSIZE;
}
newAngle = prevAngle + delta;
segArea = ooGeoEllipseSegmentArea(e, prevAngle, newAngle);
tol = fabs(1.0 - segArea/sweep);
count ++;
} while (tol > 0.00001 && count < ITERSTOP);
if (count >= ITERSTOP) {
log_warn("ellipse segment did not converge in %d iterations", ITERSTOP);
}
//segArea = segmentArea(prevAngle, newAngle, semimajor, ecc);
// Insert vec in array, note that center is in foci
ooVecArrayPushC(&e->vec,
semiMajor * cos(newAngle) - e->ecc * semiMajor,
semiMinor * sin(newAngle),
0.0f, 0.0f);
double nextNewAngle = newAngle + (newAngle-prevAngle);
prevAngle = newAngle;
newAngle = nextNewAngle;
}
return e;
}
static void swing()
{
self->thinkTime += 2;
if (self->thinkTime >= 360)
{
self->thinkTime = 0;
}
self->x = self->endX + sin(DEG_TO_RAD(self->thinkTime)) * 8;
}
static void shudder()
{
self->startY += 90;
self->x = self->startX + sin(DEG_TO_RAD(self->startY)) * 4;
if (self->startY >= 360)
{
self->startY = 0;
}
}
// Returns the distance (in meters) to the current waypoint
static float calc_dist_to_waypoint(float lat_1, float long_1, float lat_2, float long_2) {
float lat_1_rad = DEG_TO_RAD(lat_1);
float long_1_rad = DEG_TO_RAD(long_1);
float lat_2_rad = DEG_TO_RAD(lat_2);
float long_2_rad = DEG_TO_RAD(long_2);
float diff_lat = lat_2_rad - lat_1_rad;
float diff_long = long_2_rad - long_1_rad;
float a = ( pow(sin(diff_lat / 2), 2) ) +
cos(lat_1_rad) *
cos(lat_2_rad) *
( pow(sin(diff_long / 2), 2) );
float c = 2 * asin(sqrt(a));
float distance_m = EARTH_RADIUS_M * c;
return distance_m;
}
static void hover()
{
self->endX++;
if (self->endX >= 360)
{
self->endX = 0;
}
self->y = self->endY + sin(DEG_TO_RAD(self->endX)) * 8;
}
static void hover()
{
self->endX += 4;
if (self->endX >= 360)
{
self->endX = 0;
}
self->y = self->startY + sin(DEG_TO_RAD(self->endX)) * 4;
}
static void hover()
{
self->startX++;
if (self->startX >= 360)
{
self->startX = 0;
}
self->y = self->startY + sin(DEG_TO_RAD(self->startX)) * 8;
}
static void entityWait()
{
self->thinkTime += 2;
if (self->thinkTime >= 360)
{
self->thinkTime = 0;
}
self->y = self->startY + sin(DEG_TO_RAD(self->thinkTime)) * 16;
}
/**
* snaps a vector to the nearest angle that is a multiple of snapAngle
*
* @param vector the Vector to be modified
*/
Vector3& angle( Vector3& vector, float snapAngle )
{
float pitch;
float yaw;
bool flipYaw;
if (vector.x != 0.f)
{
yaw = atanf( vector.z / vector.x );
flipYaw = ( vector.x < 0 );
}
else
{
yaw = MATH_PI / 2;
flipYaw = ( vector.z < 0 );
}
pitch = acosf( Math::clamp(-1.0f, vector.y, +1.0f) );
//snap the angles
yaw = value( yaw, DEG_TO_RAD( snapAngle ) );
//snap the angle
pitch = value( pitch, DEG_TO_RAD( snapAngle ) );
//mirror octants
if ( flipYaw )
yaw = yaw - MATH_PI;
//recalc the orientation
float cosYaw = cosf( yaw );
float sinYaw = sinf( yaw );
float cosPitch = cosf( pitch );
float sinPitch = sinf( pitch );
vector.set( cosYaw * sinPitch, cosPitch, sinYaw * sinPitch );
vector.normalise();
return vector;
}
Quaternion Quaternion::rotationQuaternion(GLfloat angle, vec3_t<GLfloat> axis)
{
Quaternion q;
GLfloat radians = DEG_TO_RAD(angle);
GLfloat angBy2 = radians / 2.f;
q.w = cosf(angBy2);
q.x = axis.x * sinf(angBy2);
q.y = axis.y * sinf(angBy2);
q.z = axis.z * sinf(angBy2);
return q;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CMatrix
//
// - prototype : BuildRotation(float fAngle, float fAxisX, float fAxisY, float fAxisZ)
//
// - Purpose : Builds a rotation matrix of fAngle degrees around the axis
// given by (fAxisX, fAxisY, fAxisZ).
//
// -----------------------------------------------------------------------------
void CMatrix::BuildRotation(float fAngle, float fAxisX, float fAxisY, float fAxisZ)
{
CVector3 axis(fAxisX, fAxisY, fAxisZ);
axis.Normalize();
float fRad = DEG_TO_RAD(fAngle * 0.5f);
float fSine = sinf(fRad);
CQuaternion quat(cosf(fRad), fSine * fAxisX, fSine * fAxisY, fSine * fAxisZ);
*this = quat.Matrix();
}
Rect_V polar_to_rect(Polar_V pv)
{
#define PI (4.0*atan(1))
#define DEG_TO_RAD(X) ((X)*(PI/180.0))
Rect_V rv;
register double A = DEG_TO_RAD(pv.angle);
rv.x = pv.magnitude*cos(A);
rv.y = pv.magnitude*sin(A);
return rv;
}
void updateFrustum()
{
// build view frustum from projection and view matrix
frustum.SetFromMatrix(
Gs::ProjectionMatrix4::Perspective(
static_cast<Gs::Real>(resolution.x) / resolution.y,
0.1f,
100.0f,
DEG_TO_RAD(fov)
).ToMatrix4()// * viewMatrix.ToMatrix4()
);
}
static void calc_derived_values(rift_priv *priv)
{
priv->base.properties.hsize = priv->display_info.h_screen_size;
priv->base.properties.vsize = priv->display_info.v_screen_size;
priv->base.properties.hres = priv->display_info.h_resolution;
priv->base.properties.vres = priv->display_info.v_resolution;
priv->base.properties.lens_sep = priv->display_info.lens_separation;
priv->base.properties.lens_vpos = priv->display_info.v_center;
priv->base.properties.fov = DEG_TO_RAD(125.5144f); // TODO calculate.
// Calculate the screen ratio of each subscreen.
float full_ratio = (float)priv->display_info.h_resolution /
(float)priv->display_info.v_resolution;
float ratio = full_ratio / 2.0f;
priv->base.properties.ratio = ratio;
// Calculate where the lens is on each screen,
// and with the given value offset the projection matrix.
float screen_center = priv->display_info.h_screen_size / 4.0f;
float lens_shift = screen_center - priv->display_info.lens_separation / 2.0f;
float proj_offset = 4.0f * lens_shift / priv->display_info.h_screen_size;
priv->calc_values.proj_offset = proj_offset;
// Setup the base projection matrix. Each eye mostly have the
// same projection matrix with the exception of the offset.
omat4x4f_init_perspective(&priv->calc_values.proj_base,
priv->base.properties.fov,
priv->base.properties.ratio,
priv->base.properties.znear,
priv->base.properties.zfar);
// Setup the two adjusted projection matricies. Each is setup to deal
// with the fact that the lens is not in the center of the screen.
// These matrices only change of the hardware changes, so static.
mat4x4f translate;
omat4x4f_init_translate(&translate, proj_offset, 0, 0);
omat4x4f_mult(&translate,
&priv->calc_values.proj_base,
&priv->base.properties.proj_left);
omat4x4f_init_translate(&translate, -proj_offset, 0, 0);
omat4x4f_mult(&translate,
&priv->calc_values.proj_base,
&priv->base.properties.proj_right);
}
Quaternion::Quaternion(const Vector3f &axis, float angleInDegrees)
{
float a = DEG_TO_RAD(angleInDegrees) * 0.5f;
float s = sin(a);
float norm = axis.Length();
if (norm < 0.00001f) norm = 0.00001f;
x = s * axis.x / norm;
y = s * axis.y / norm;
z = s * axis.z / norm;
w = cos(a);
}
bool CBlock::CheckCollision (sf::Sprite *p_pSprite, sf::Vector2f p_fPos)
{
bool bCollided = false;
int iNbSteps = 0;
float fDirection = p_pSprite->getRotation ();
if (p_pSprite->getOrigin () != sf::Vector2f (0.f, 0.f))
{
fDirection -= 90.f;
p_fPos.x += p_pSprite->getOrigin ().x * cos (DEG_TO_RAD(fDirection));
p_fPos.y += p_pSprite->getOrigin ().y * sin (DEG_TO_RAD(fDirection));
fDirection += 90.f;
p_fPos.x += p_pSprite->getOrigin ().x * cos (DEG_TO_RAD(fDirection));
p_fPos.y += p_pSprite->getOrigin ().y * sin (DEG_TO_RAD(fDirection));
}
for (int i = 0; i < 4; i++)
{
fDirection += 90.f;
if (i % 2 == 1)
iNbSteps = p_pSprite->getTextureRect ().height;
else
iNbSteps = p_pSprite->getTextureRect ().width;
for (int j = 0; j < iNbSteps; j++)
{
p_fPos.x += 1.f * cos (DEG_TO_RAD(fDirection));
p_fPos.y += 1.f * sin (DEG_TO_RAD(fDirection));
if ((p_fPos.x >= m_fPos.x - static_cast<float> (m_iSize.x) / 2) && (p_fPos.x <= m_fPos.x + static_cast<float> (m_iSize.x) / 2) &&
(p_fPos.y >= m_fPos.y - static_cast<float> (m_iSize.y) / 2) && (p_fPos.y <= m_fPos.y + static_cast<float> (m_iSize.y) / 2))
bCollided = true;
}
}
return bCollided;
}
static void headWait()
{
int x;
/* Sway back and forth */
self->dirX += 0.5;
if (self->dirX >= 360)
{
self->dirX = 0;
}
x = 24;
self->x = self->targetX + (sin(DEG_TO_RAD(self->dirX)) * x);
alignBodyToHead();
self->thinkTime--;
if (self->thinkTime <= 0 && player.health > 0)
{
self->thinkTime = 0;
x = prand() % 4;
switch (x)
{
case 0:
self->action = &biteAttackInit;
break;
case 1:
self->action = &changeSidesInit;
break;
case 2:
self->action = &shotAttackInit;
break;
default:
self->action = &crushAttackInit;
break;
}
}
if (prand() % 180 == 0)
{
playSoundToMap("sound/boss/snake_boss/hiss", BOSS_CHANNEL, self->x, self->y, 0);
}
}
Matrix Camera::GetProjectionMatrix() {
double c = -Near / Far;
double a = -1.0/(c+1.0);
double b = c/(c+1.0);
Matrix M = Matrix(1, 0, 0, 0,
0, 1, 0, 0,
0, 0, a, b,
0, 0, -1, 0);
double sx = 1.0/(tan(DEG_TO_RAD(view*width/height/2))*Far);
double sy = 1.0/(tan(DEG_TO_RAD(view/2))*Far);
double sz = 1.0/Far;
Matrix S = Matrix(sx, 0, 0, 0,
0, sy, 0, 0,
0, 0, sz, 0,
0, 0, 0, 1);
return M * S;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CMatrix
//
// - prototype : void BuildRotationZ(float fDegrees)
//
// - Purpose : Builds a rotation matrix around z axis. Angle in degrees.
//
// -----------------------------------------------------------------------------
void CMatrix::BuildRotationZ(float fDegrees)
{
float fRad = DEG_TO_RAD(fDegrees);
float fSine = sinf(fRad);
float fCosine = cosf(fRad);
SetIdentity();
m_fM[0][0] = fCosine;
m_fM[0][1] = -fSine;
m_fM[1][0] = fSine;
m_fM[1][1] = fCosine;
}
static void createVehicle( Vector2 pos, Color clr )
{
SteeringVehicle v;
v.pos = pos;
v.vel = vec2( 0.0f, 0.0f );
v.maxSpeed = 200.0f;
v.rotRad = 0.0f;
v.rotSpdRad = DEG_TO_RAD( 0.0f );
v.maxRotSpeedRad = DEG_TO_RAD( 720.0f );
v.linearAccel = VEC2_ZERO;
v.angularAccelRad = 0.0f;
v.radius = 10.0f;
v.clr = clr;
v.wanderTarget = pos;
sb_Push( sbVehicles, v );
}
void TaskCubeMap::update( void )
{
glClearColor( 0.2f, 0.2f, 0.2f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
const horizon::input::PadState& pad = horizon::input::getPadState( 0 );
if( pad.stick.right.y != 0.0f ) {
mCamera.rotation().x -= DEG_TO_RAD( pad.stick.right.y );
}
if( pad.stick.right.x != 0.0f ) {
mCamera.rotation().y -= DEG_TO_RAD( pad.stick.right.x );
}
glm::vec4 direction( -pad.stick.left.x, 0.0f, - pad.stick.left.y, 0.0f );
glm::mat4 identityMtx( 1.0f );
direction = glm::rotate( identityMtx, mCamera.rotation().x, GLM_X_AXIS ) * direction;
direction = glm::rotate( identityMtx, mCamera.rotation().y, GLM_Y_AXIS ) * direction;
mCamera.position().x += direction.x;
mCamera.position().y += direction.y;
mCamera.position().z += direction.z;
mCamera.apply();
mCubeMap.useProgram();
mCubeMap.bindTexture( 0, mTextureCubeChapel );
mCubeMap.getProgram().setUniform( "SkyBox", 1 );
mSkyBox.draw();
glClear( GL_DEPTH_BUFFER_BIT );
mCubeMap.getProgram().setUniform( "SkyBox", 0 );
mSphere.draw();
mShader_PresentNormal.useProgram();
mSphere.draw();
}
//==============================================================================
// Brief : プレイヤーの移動処理
//==============================================================================
void SceneGame::MovePlayer()
{
// wiiボードを利用した、プレイヤーの移動処理1
//---------------------------------------------------------------------------------------------------------
//#ifdef _WIIBOARD
float totalCalibKg = wiiContoroller->getCalibKg().Total * 0.7f;
float totalKgR = wiiContoroller->getKg().BottomR + wiiContoroller->getKg().TopR;
float totalKgL = wiiContoroller->getKg().BottomL + wiiContoroller->getKg().TopL;
if(totalKgL
>=
totalCalibKg)
{
player->addSpeed((-((totalKgL - totalCalibKg) / wiiContoroller->getCalibKg().Total)) * 2.0f);
}
if(totalKgR
>=
totalCalibKg)
{
player->addSpeed((((totalKgR - totalCalibKg) / wiiContoroller->getCalibKg().Total)) * 2.0f);
}
//#endif
if(pArgument_->pKeyboard_->IsPress(DIK_LEFT) == true)
{
player->AddPositionX(-1.0f);
}
if(pArgument_->pKeyboard_->IsPress(DIK_RIGHT) == true)
{
player->AddPositionX(1.0f);
}
D3DXVECTOR3 buff = player->getPosition();
//PrintDebug( _T( "\nplayerPos.x = %f\n"), buff.x );
//---------------------------------------------------------------------------------------------------------
// プレイヤー腕オブジェクトに回転量をセット
D3DXVECTOR3 buffRot = wiiContoroller->getRot();
player->setRotationArm(DEG_TO_RAD(buffRot.x), DEG_TO_RAD(-buffRot.y), DEG_TO_RAD(buffRot.z));
}
static void floatUpAndDown()
{
self->endX++;
if (self->endX >= 360)
{
self->endX = 0;
}
self->y = self->endY + sin(DEG_TO_RAD(self->endX)) * 5;
self->dirY = 3;
}
//===========================================
// Box2dPhysics::updatePos
//===========================================
void Box2dPhysics::updatePos(const EEvent* ev) {
static long entityRotationStr = internString("entityRotation");
static long entityShapeStr = internString("entityShape");
static long entityTranslationStr = internString("entityTranslation");
if (!m_init)
throw PhysicsException("Instance of Box2dPhysics is not initialised", __FILE__, __LINE__);
if (ev->getType() == entityTranslationStr) {
const EEntityTranslation* event = static_cast<const EEntityTranslation*>(ev);
b2Vec2 p = m_body->GetPosition();
// Update position
float32_t x = event->newTransl_abs.x - event->oldTransl_abs.x;
float32_t y = event->newTransl_abs.y - event->oldTransl_abs.y;
m_body->SetTransform(b2Vec2(p.x + x / m_worldUnitsPerMetre, p.y + y / m_worldUnitsPerMetre), m_body->GetAngle());
}
else if (ev->getType() == entityRotationStr) {
const EEntityRotation* event = static_cast<const EEntityRotation*>(ev);
float32_t a = m_body->GetAngle();
float32_t r = DEG_TO_RAD(event->newRotation_abs - event->oldRotation_abs);
m_body->SetTransform(m_body->GetPosition(), a + r);
}
else if (ev->getType() == entityShapeStr) {
const EEntityShape* event = static_cast<const EEntityShape*>(ev);
unique_ptr<Shape> oldShape(dynamic_cast<Shape*>(event->oldShape.get()->clone()));
unique_ptr<Shape> newShape(dynamic_cast<Shape*>(event->newShape.get()->clone()));
oldShape->rotate(-event->oldRotation_abs);
newShape->rotate(-event->newRotation_abs);
// Update shape
if (oldShape == NULL || *oldShape != *newShape) {
for (unsigned int i = 0; i < m_numFixtures; ++i)
m_body->DestroyFixture(m_body->GetFixtureList());
shapeToBox2dBody(*newShape, m_opts, m_body, &m_numFixtures);
}
}
// Wake bodies
/* b2Body* body = m_world.GetBodyList();
while (body != NULL) {
body->SetAwake(true);
body = body->GetNext();
}*/
}
/*-----------------------------------------------------------------------------
Name : svStartup()
Description :
Inputs :
Outputs :
Return :
----------------------------------------------------------------------------*/
void svStartup(void)
{
cameraInit(&svCamera, SV_InitialCameraDistance);
svCamera.angle = DEG_TO_RAD(svAngle);
svCamera.declination = DEG_TO_RAD(svDeclination);
feDrawCallbackAdd(SV_ShipViewName, svShipViewRender); //add render callbacks
feDrawCallbackAdd(SV_FirepowerName, svFirepowerRender);
feDrawCallbackAdd(SV_CoverageName, svCoverageRender);
feDrawCallbackAdd(SV_ManeuverName, svManeuverRender);
feDrawCallbackAdd(SV_ArmorName, svArmorRender);
feDrawCallbackAdd(SV_TopSpeedName, svTopSpeedRender);
feDrawCallbackAdd(SV_MassName, svMassRender);
svMouseInside = FALSE;
svMousePressLeft = FALSE;
svMousePressRight = FALSE;
svShipViewFont = frFontRegister(svShipViewFontName);
svShipStatFont = frFontRegister(svShipStatFontName);
}
//--------------------------------------------------------------
// Name: CCAMERA::ComputeViewMatrix - public
// Description: Compute the information for the camera
// Arguments: -fTimeDelta: amount to interpolate from last frame
// (defaults to 1.0f)
// Return Value: None
//--------------------------------------------------------------
void CCAMERA::ComputeViewMatrix( float fTimeDelta )
{
if( ( m_fYaw>=360.0f) || ( m_fYaw<=-360.0f ) )
m_fYaw= 0.0f;
if( m_fPitch>60.0f )
m_fPitch= 60.0f;
if( m_fPitch<-60.0f )
m_fPitch= -60.0f;
float cosYaw = cosf( DEG_TO_RAD( m_fYaw ) );
float sinYaw = sinf( DEG_TO_RAD( m_fYaw ) );
float sinPitch= sinf( DEG_TO_RAD( m_fPitch ) );
float cosPitch= cosf( DEG_TO_RAD( m_fPitch ) );
m_vecForward[0]= sinYaw * cosPitch;
m_vecForward[1]= sinPitch;
m_vecForward[2]= cosPitch * -cosYaw;
m_vecLookAt= m_vecEyePos + m_vecForward;
m_vecSide= m_vecForward.CrossProduct( m_vecUp );
}
static void entityWait()
{
if (self->targetY > 0)
{
self->targetY -= 20;
if (self->targetY < 0)
{
self->targetY = 0;
}
self->x = self->startX + sin(DEG_TO_RAD(self->targetY)) * 10;
}
}
static gfloat
left_end (gfloat from,
gfloat to,
gboolean cl)
{
gfloat alpha = DEG_TO_RAD (from);
gfloat beta = DEG_TO_RAD (to);
gint cw_ccw = cl ? -1 : 1;
switch (cw_ccw)
{
case -1:
if (alpha < beta)
return alpha + TWO_PI;
default:
return alpha; /* 1 */
}
}
