Example #1
0
/********************************************************************************
Initialise the camera
********************************************************************************/
void TPCamera::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	this->up = defaultUp = right.Cross(view).Normalized();

	// Initialise the camera movement flags
	for (int i = 0; i<255; i++){
		myKeys[i] = false;
	}

	// Initialise the camera type
	sCameraType = LAND_CAM;

	// For Jump use
	m_bJumping = false;
	JumpVel = 0.0f;
	JUMPMAXSPEED = 10.0f;
	JUMPACCEL = 10.0f;
	GRAVITY = -30.0f;

	// Maximum movement speed
	CAMERA_ACCEL = 10.0f;
}
Example #2
0
void Camera3::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	this->up = defaultUp = right.Cross(view).Normalized();
	sCameraType = LAND_CAM;

	pitchMovingUp = pitchMovingDown = yawMovingLeft = yawMovingRight = false;
	walkMovingForward = false;		//is position still changing
	walkMovingBackward = false;
	straftMovingLeft = false;
	straftMovingRight = false;
	pitchVelocity = yawVelocity = 0.f;	//used for x and z (or y if flying)
	movingVelocity = false;	//changing of pos

	straftVelocity = 0.f;
	movingVelocity = 0.f;
	moveAcceleration = 600.f;
	camAcceleration = 10.f;
	camBrakeOffset = 2.5f;
	cameraSpeed = 3.f;
	 yawAngle = 0.f;	//facing X
	 croutching = false;
}
Example #3
0
void World::DoImpulse(std::vector<float>& impulseMag)
{
    for(uint i = 0; i < contacts_.size(); i++)
    {
        Contact& rkContact = contacts_[i];
        RigidBody& rkBodyA = *rkContact.A;
        RigidBody& rkBodyB = *rkContact.B;

        Vector3 kPA = rkBodyA.GetLinearMomentum();
        Vector3 kPB = rkBodyB.GetLinearMomentum();
        Vector3 kLA = rkBodyA.GetAngularMomentum();
        Vector3 kLB = rkBodyB.GetAngularMomentum();

        // update linear/angular momentum/velocity
        Vector3 kImpulse = impulseMag[i]*rkContact.N;
        kPA += kImpulse;
        kPB -= kImpulse;
        Vector3 kRelA = rkContact.PA - rkBodyA.GetPosition();
        kLA += kRelA.Cross(kImpulse);
        Vector3 kRelB = rkContact.PB - rkBodyB.GetPosition();
        kLB -= kRelB.Cross(kImpulse);

        rkBodyA.SetLinearMomentum(kPA);
        rkBodyB.SetLinearMomentum(kPB);
        rkBodyA.SetAngularMomentum(kLA);
        rkBodyB.SetAngularMomentum(kLB);
    }
}
void tyrFreeFormDef::reParamVertices(vector<RectCoord> &param, Vector3 &S,Vector3 &T, Vector3 &U){
	printf("  - Reparameterizing vertices\n");

	int nVtx = _ply.GetNumVertices();
	point3D_t *vtx = _ply.GetVertices();

	Vector3 min = _ply.GetMin();
	Vector3 p0 = min;
	Vector3 max = _ply.GetMax();

	S = Vector3(max.x - min.x,0.0,0.0);
	T = Vector3(0.0,max.y - min.y,0.0);
	U = Vector3(0.0,0.0,max.z - min.z);


	Vector3 TcU = T.Cross(U);
	Vector3 ScU = S.Cross(U);
	Vector3 ScT = S.Cross(T);

	double TcUdS = TcU.Dot(S);
	double ScUdT = ScU.Dot(T);
	double ScTdU = ScT.Dot(U);

	for(int v = 0; v < nVtx; v++){
		Vector3 diff = vtx[v].ToVector3() - p0;

		RectCoord tmp;
		tmp.s = TcU.Dot(diff/TcUdS);
		tmp.t = ScU.Dot(diff/ScUdT);
		tmp.u = ScT.Dot(diff/ScTdU);
		tmp.p = p0 + (tmp.s * S) + (tmp.t * T) + (tmp.u * U);
		tmp.p0 = p0;
		
		{	///Pre-calculate bernstein polynomial expansion.  It only needs to be done once per parameterization
			for(int i = 0; i <= 5; i++){
				for(int j = 0; j <= 5; j++){
					
					for(int k = 0; k <= 5; k++){
						tmp.bernPolyPack[n][k][2] = bern_poly(n,k,tmp.u);
					}
					tmp.bernPolyPack[m][j][1] = bern_poly(m,j,tmp.t);
				}
				tmp.bernPolyPack[l][i][0] = bern_poly(l,i,tmp.s);
			}
		}
		param.push_back(tmp);
		if(tmp.p.Dist(vtx[v].ToVector3()) > Math::EPSILON){
			printf("     - Warning, vtx[%d] does not match it's parameterization.\n",v);
		}
	}
	for(int i = 0; i <= 5; i++){
		for(int j = 0; j <= 5; j++){
			Vector3 tK(0.0f,0.0f,0.0f);
			for(int k = 0; k <= 5; k++){
				controlPoints[i][j][k] = createControlPoint(min,i,j,k,S,T,U);
				
			}
		}
	}
}
Example #5
0
void Triangle::computeForces(Vector3 &airVelocity)
{
	this->airVelocity = airVelocity;
	Vector3 velocity = (p1->velocity + p2->velocity + p3->velocity) / 3;

	Vector3 realVelocity = velocity - airVelocity;

	if (realVelocity.Mag() > 0)
	{
		Vector3 *one = new Vector3();
		Vector3 *two = new Vector3();
		one->Cross(p2->position - p1->position, p3->position - p1->position);
		two->Cross(p2->position - p1->position, p3->position - p1->position);
		one->Normalize();
		normal = *one;

		float a0 = 0.5 * two->Mag();
		float a = a0 * (realVelocity.Dot(normal) / realVelocity.Mag());

		Vector3 fAero = -0.5 * density * realVelocity.Mag2() *a *normal;

		Vector3 fAeroParticle = fAero / 3;

		if (!p1->pinned)
			p1->applyForce(fAeroParticle);
		if (!p2->pinned)
			p2->applyForce(fAeroParticle);
		if (!p3->pinned)
			p3->applyForce(fAeroParticle);

		delete one; 
		delete two; 		
	}
}
void CustomCam1::rotateCamVertical(float degrees)
{
	if (degrees + f_currentPitch > f_pitchLimit && degrees > 0)
	{
		degrees = f_pitchLimit - f_currentPitch;

		if (f_currentPitch >= f_pitchLimit)
		{
			degrees = 0.f;
		}
	}

	else if (degrees + f_currentPitch < -f_pitchLimit && degrees < 0)
	{
		degrees = -f_pitchLimit - f_currentPitch;

		if (f_currentPitch <= -f_pitchLimit)
		{
			degrees = 0.f;
		}
	}

	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	target -= position;
	f_currentPitch += degrees;
	rotation.SetToRotation(static_cast<float>(degrees), right.x, right.y, right.z);
	target = rotation * target;
	target += position;
}
Example #7
0
void Camera2::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
    this->position = defaultPosition = pos;
    this->target = defaultTarget = target;
    Vector3 view = (target - position).Normalized();
    Vector3 right = view.Cross(up);
    right.y = 0;
    right.Normalize();
    this->up = defaultUp = right.Cross(view).Normalized();
}
Example #8
0
bool Collision::Capsule_Capsule(const Capsule& capsule1, const Capsule& capsule2, HitInfo& hitInfo) {
	Vector3 a = capsule1.vector;
	Vector3 b = capsule2.vector;
	Vector3 c = capsule2.p1 - capsule1.p1;

	float distance = capsule1.radius + capsule2.radius;

	Vector3 n = a.Cross(b).GetNormal();
	float L = c.Dot(n);

	Vector3 n1 = a.Cross(n).GetNormal();
	Vector3 n2 = b.Cross(n).GetNormal();

	Vector3 p3Dash = capsule2.p1 - n * L;
	Vector3 p4Dash = capsule2.p2 - n * L;

	Vector3 v1 = capsule1.p1 - p3Dash;
	Vector3 v2 = capsule1.p2 - p3Dash;
	Vector3 v3 = p3Dash - capsule1.p1;
	Vector3 v4 = p4Dash - capsule1.p1;

	float L1 = v1.Dot(n2);
	float L2 = v2.Dot(n2);
	float L3 = v3.Dot(n1);
	float L4 = v4.Dot(n1);

	float t1 = L3 / (L3 - L4);
	float t2 = L1 / (L1 - L2);

	if ((Math::Abs(L) < distance) && (0 < t1 && t1 < 1) && (0 < t2 && t2 < 1)) {
		return true;
	}

	BoundingSphere s = BoundingSphere(capsule1.p1, capsule1.radius);
	if ((t1 < 0) && BoundingSphere_Capsule(s, capsule2, hitInfo)) {
		return true;
	}

	s = BoundingSphere(capsule2.p1, capsule2.radius);
	if ((t1 > 1) && BoundingSphere_Capsule(s, capsule1, hitInfo)) {
		return true;
	}

	s = BoundingSphere(capsule2.p1, capsule2.radius);
	if ((t2 < 0) && BoundingSphere_Capsule(s, capsule1, hitInfo)) {
		return true;
	}

	s = BoundingSphere(capsule2.p2, capsule2.radius);
	if ((t2 > 1) && BoundingSphere_Capsule(s, capsule1, hitInfo)) {
		return true;
	}

	return false;
}
Example #9
0
void Camera3::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
	maxCameraX = 49.99f;
	cameraSpeed = 2.5f;

	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	this->up = defaultUp = right.Cross(view).Normalized();
	directionRotation = Vector3(0, -180, 0);
	gunRecoil = Vector3(0,0,0);
	camerarotation = Vector3(0,0,0);
	speed = 100;
	location = (0,0,0);
	location2 = (0, 0, 0);
	//direction2 = (0, 0, 0);
	//mouseControl = true;
	//delay = 0;
	delay2 = 0;
	//cd = 10;
	cameraStore = 0;
	cRecoilCd = 0;
	stamina = 300;
	staminaDelay = 0;
	glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

	//for hitboxes
	minVectors.push_back(minPos(Vector3(-338, 0, 38), 20, 120, 90));
	minVectors.push_back(minPos(Vector3(-460, 0, 38), 20, 120, 90));
	minVectors.push_back(minPos(Vector3(-400, 0, 73), 120, 120, 20));
	minVectors.push_back(minPos(Vector3(-360, 0, 0), 70, 100, 30));
	minVectors.push_back(minPos(Vector3(-435, 0, 0), 58, 120, 20));

	maxVectors.push_back(maxPos(Vector3(-338, 0, 38), 20, 120, 90));
	maxVectors.push_back(maxPos(Vector3(-460, 0, 38), 20, 120, 90));
	maxVectors.push_back(maxPos(Vector3(-400, 0, 73), 120, 120, 20));
	maxVectors.push_back(maxPos(Vector3(-360, 0, 0), 70, 100, 30));
	maxVectors.push_back(maxPos(Vector3(-435, 0, 0), 52, 120, 20));	

	//Minerals hitbox
	MineralVectors.push_back(Vector3(-113, 5, -66));
	MineralVectors.push_back(Vector3(-126, 5, -394));
	MineralVectors.push_back(Vector3(590, 5, -395));
	MineralVectors.push_back(Vector3(270, 5, 201));
	MineralVectors.push_back(Vector3(223, 5, 934));
	MineralVectors.push_back(Vector3(84, 5, 522));
	MineralVectors.push_back(Vector3(-516, 5, 809));
	MineralVectors.push_back(Vector3(361, 5, 772));
	MineralVectors.push_back(Vector3(-643, 5, 825));
	MineralVectors.push_back(Vector3(-415, 5, 174));

}
Example #10
0
void FirstPersonCamera::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
    this->position = defaultPosition = pos;
    this->target = defaultTarget = target;
    Vector3 view = (target - position).Normalized();
    Vector3 right = view.Cross(up);
    right.y = 0;
    right.Normalize();
    this->up = defaultUp = right.Cross(view).Normalized();
    canMoveBuilding = true;
    canMoveInteractable = true;
}
Example #11
0
void Matrix::SetLookAtRH(const Vector3 &eye, const Vector3 &up, const Vector3 &at)
{
	Vector3 zaxis;
	Vector3 xaxis;
	Vector3 yaxis;

	zaxis = (eye - at).Normalize();
	xaxis = (up.Cross(zaxis)).Normalize();
	yaxis = zaxis.Cross(xaxis);

	*this = Matrix( xaxis, yaxis, zaxis );
    TranslatePreRotation( -eye.x, -eye.y, -eye.z );
}
Example #12
0
void Camera::RenderPath(Scene &scn, int n) {
    RayTrace rayTrace(scn);
    
    for (int y = 0; y < _img.YRes; y++) {
        for (int x = 0; x < _img.XRes; x++) {
            
            // compute the primary ray
            Vector3 cy;
            cy.Cross(_worldMatrix.c, _worldMatrix.b);
            Vector3 cx = cy / pow(cy.Magnitude(), 2);
            cy.Cross(cx, _worldMatrix.c);
            
            float hfov = 2.f * atanf(_aspect * tanf(_verticalFOV / 2.f));
            float cw = 2.f * tanf(hfov/2.f);
            float ch = cw / _aspect;
            
            Ray ray;
            ray.Origin = _worldMatrix.d;
            
            ray.Direction =
            _worldMatrix.c + ((float)(x + 0.5f) / (float)_img.XRes - 0.5f) * cw * cx +
            ((float)(y + 0.5f)/(float)_img.YRes - 0.5f) * ch * cy;
            
            ray.type = Ray::PRIMARY;
            
            // shoot the primary ray
            Intersection hit;
            if (x > 124 && x <= 140 && y == _img.YRes - 495 ) {
//                Color white = Color::WHITE;
//                std::cout << "debug pixel" << std::endl;
//                _img.SetPixel(x, y, white.ToInt());
//                continue;
            }
            
            rayTrace.TraceRay(ray, hit);
            
            if (n != -1) {
                Color c;
                c.FromInt(_img.GetPixel(x, y));
                
                Color avg = Color::BLACK;
                avg.AddScaled(c, n - 1);
                avg.Add(hit.Shade);
                avg.Scale(1.0f / n);
                _img.SetPixel(x, y, avg.ToInt());
            }
            else _img.SetPixel(x, y, hit.Shade.ToInt());
        }
    }
    
}
Example #13
0
bool IntersectTriangle(Vector3& orig, Vector3& dir,
                       Vector3& v0, Vector3& v1, Vector3& v2)
{
    double t,  u,  v;
    // E1
    Vector3 E1 = v1 - v0;

    // E2
    Vector3 E2 = v2 - v0;

    // P
    Vector3 P = dir.Cross(E2);

    // determinant
    double det = E1.Dot(P);

    // keep det > 0, modify T accordingly
    Vector3 T;
    if( det >0 )
    {
        T = orig - v0;
    }
    else
    {
        T = v0 - orig;
        det = -det;
    }

    // If determinant is near zero, ray lies in plane of triangle
    if( det < 0.0001f )
        return false;

    // Calculate u and make sure u <= 1
    u = T.Dot(P);
    if( u < 0.0f || u > det )
        return false;

    // Q
    Vector3 Q = T.Cross(E1);

    // Calculate v and make sure u + v <= 1
    v = dir.Dot(Q);
    if( v < 0.0f || u + v > det )
        return false;

    // Calculate t, scale parameters, ray intersects triangle
    t = E2.Dot(Q);

    if (t < 0.0f) return false;
    return true;
}
Example #14
0
/********************************************************************************
Turn right
********************************************************************************/
void TPCamera::TurnRight(const double dt)
{
	Vector3 view = (target - position).Normalized();
	//	float yaw = (float)(-CAMERA_SPEED * Application::camera_yaw * (float)dt);
	float yaw = (float)(-CAMERA_SPEED * (float)dt);
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	view = rotation * view;
	target = position + view;
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
}
Example #15
0
/********************************************************************************
LookDown
********************************************************************************/
void TPCamera::LookDown(const double dt)
{
	//float pitch = (float)(-CAMERA_SPEED * Application::camera_pitch * (float)dt);
	float pitch = (float)(CAMERA_SPEED * (float)dt);
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(pitch, right.x, right.y, right.z);
	view = rotation * view;
	target = position + view;
}
Example #16
0
void Camera3::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	this->up = defaultUp = right.Cross(view).Normalized();

	// Initialise the camera movement flags
	for (int i = 0; i < 255; i++)
		myKeys[i] = false;
}
Example #17
0
void Camera3::Init(const Vector3& pos, const Vector3& target, const Vector3& up, vector<Rock> *Rocks, Flag *flag, vector<CollisionObject> *Pillars)
{
	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	MouseSensitivity = 0.2;
	this->up = defaultUp = right.Cross(view).Normalized();
	this->Rocks = Rocks;
	this->flag = flag;
	this->Pillars = Pillars;
}
Example #18
0
/********************************************************************************
LookRight
********************************************************************************/
void Camera3::LookRight(const double dt)
{
	float yaw = yawVelocity;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	up = right.Cross(view).Normalized();
	Mtx44 rotation;
	rotation.SetToRotation(yaw, 0, 1, 0);
	view = rotation * view;
	target = position + view;

	up = rotation * up;
}
Example #19
0
const Matrix4& Camera::GetViewMatrix( void )
{
	if (!m_viewMatrixDirty)
	{
		return m_viewMatrix;
	}

	Vector3 viewDir = m_lookAt - m_position;
	viewDir.Normalize();

	Vector3 right = m_up.Cross(viewDir);
	right.Normalize();

	Vector3 yAxis = viewDir.Cross(right);

	float tx = -m_position.Dot(right);
	float ty = -m_position.Dot(yAxis);
	float tz = -m_position.Dot(viewDir);

	m_viewMatrix.m11 = right.x;		m_viewMatrix.m12 = yAxis.x;		m_viewMatrix.m13 = viewDir.x;	m_viewMatrix.m14 = 0.0f;
	m_viewMatrix.m21 = right.y;		m_viewMatrix.m22 = yAxis.y;		m_viewMatrix.m23 = viewDir.y;	m_viewMatrix.m24 = 0.0f;
	m_viewMatrix.m31 = right.z;		m_viewMatrix.m32 = yAxis.z;		m_viewMatrix.m33 = viewDir.z;	m_viewMatrix.m34 = 0.0f;
	m_viewMatrix.m41 = tx;			m_viewMatrix.m42 = ty;			m_viewMatrix.m43 = tz;			m_viewMatrix.m44 = 1.0f;

	m_viewMatrixDirty = false;

	return m_viewMatrix;
}
Example #20
0
void Vector3<Real>::GenerateOrthonormalBasis (Vector3& rkU, Vector3& rkV,
    Vector3& rkW, bool bUnitLengthW)
{
    if ( !bUnitLengthW )
        rkW.Normalize();

    Real fInvLength;

    if ( Math<Real>::FAbs(rkW.m_afTuple[0]) >=
         Math<Real>::FAbs(rkW.m_afTuple[1]) )
    {
        // W.x or W.z is the largest magnitude component, swap them
        fInvLength = Math<Real>::InvSqrt(rkW.m_afTuple[0]*rkW.m_afTuple[0] +
            rkW.m_afTuple[2]*rkW.m_afTuple[2]);
        rkU.m_afTuple[0] = -rkW.m_afTuple[2]*fInvLength;
        rkU.m_afTuple[1] = (Real)0.0;
        rkU.m_afTuple[2] = +rkW.m_afTuple[0]*fInvLength;
    }
    else
    {
        // W.y or W.z is the largest magnitude component, swap them
        fInvLength = Math<Real>::InvSqrt(rkW.m_afTuple[1]*rkW.m_afTuple[1] +
            rkW.m_afTuple[2]*rkW.m_afTuple[2]);
        rkU.m_afTuple[0] = (Real)0.0;
        rkU.m_afTuple[1] = +rkW.m_afTuple[2]*fInvLength;
        rkU.m_afTuple[2] = -rkW.m_afTuple[1]*fInvLength;
    }

    rkV = rkW.Cross(rkU);
}
Example #21
0
Vector3 RigidBodyContact::CalculateFrictionlessImpulse(Matrix3x3* inverseInertiaTensor)
{
    Vector3 impulseContact;
    float deltaVelocity = 0;
    for (int i = 0; i < 2; i ++)
    {
        if (Body[i] != NULL)
        {
            // Calculate a vector that shows the change in velocity in world space for a unit impulse
            // in the direction of the contact normal
            Vector3 deltaVelocityWorldspace = m_relativeContactPosition[i].Cross(ContactNormal);
            deltaVelocityWorldspace = inverseInertiaTensor[i] * deltaVelocityWorldspace;
            deltaVelocityWorldspace = deltaVelocityWorldspace.Cross(m_relativeContactPosition[i]);

            // Calculate the change in velocity in contact coordinates
            deltaVelocity += deltaVelocityWorldspace.Dot(ContactNormal);

            // Add the linear component of velocity change
            deltaVelocity += Body[i]->GetInverseMass();
        }
    }
    impulseContact.SetX(m_desiredDeltaVelocity / deltaVelocity);
    impulseContact.SetY(0.0f);
    impulseContact.SetZ(0.0f);
    return impulseContact;
}
void CustomCam1::Init(const Vector3& pos, const Vector3& target, const Vector3& up, const float mouseSensitivity)
{
	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	Vector3 view = (target - position).Normalized();
	Vector3 right = view.Cross(up);
	right.y = 0;
	right.Normalize();
	this->up = defaultUp = right.Cross(view).Normalized();
	this->mouseSensitivity = mouseSensitivity;
	mouseX = 0.0;
	mouseY = 0.0;

	f_currentPitch = CalAnglefromPosition(target, position, false);
	f_pitchLimit = 80.f;
}
Example #23
0
Object::Object(Vector3 pos, Vector3 view, Vector3 up)
{
	Pos = pos;
	View = view;
	Up = up;
	Right = view.Cross(up);
}
Example #24
0
void FPcamera::Init(const Vector3& pos, const Vector3& target, const Vector3& up)
{
	this->position = defaultPosition = pos;
	this->target = defaultTarget = target;
	view = (target - position).Normalized();
	Vector3 right = view.Cross(up).Normalized();
	right.y = 0;
	right.Normalize();
	this->up = defaultUp = right.Cross(view).Normalized();
	this->sensitivity = defaultSensitivity = 1.0f;

	sCameraType = LAND_CAM;

	for (int i = 0; i < 255; ++i)
	{
		myKeys[i] = false;
	}

	m_bCrouching = false;
	m_bCollideGround = true;
	m_bJumping = false;
	m_bRecoil = false;
	JumpVel = 0.0f;
	JUMPMAXSPEED = 200.f;
	JUMPACCEL = 100.f;
	GRAVITY = -200.f;

	rotationX = 0.f;
	rotationY = 0.f;
	recoil = 0.f;
}
Color Raytracer::CalnReflection( Collider* collider , Vector3 ray_V , int dep , bool refracted , int* hash, int rc, Color weight) {
	Primitive* pri = collider->GetPrimitive();
	ray_V = ray_V.Reflect( collider->N );

	if ( pri->GetMaterial()->drefl < EPS || dep > MAX_DREFL_DEP ) {
		Color alpha = pri->GetMaterial()->color * pri->GetMaterial()->refl;
		return RayTracing( collider->C , ray_V , dep + 1 , refracted , hash, rc, weight * alpha) * alpha;
	}

	Vector3 Dx = ray_V.GetAnVerticalVector();
	Vector3 Dy = ray_V.Cross(Dx);
	Dx = Dx.GetUnitVector() * pri->GetMaterial()->drefl;
	Dy = Dy.GetUnitVector() * pri->GetMaterial()->drefl;
	
	int totalSample = camera->GetDreflQuality();
	Color rcol, alpha = pri->GetMaterial()->color * pri->GetMaterial()->refl / totalSample;
	for ( int k = 0 ; k < totalSample ; k++ ) {
		double x , y;
		do {
			x = ran() * 2 - 1;
			y = ran() * 2 - 1;
		} while ( x * x + y * y > 1 );
		x *= pri->GetMaterial()->drefl;
		y *= pri->GetMaterial()->drefl;

		rcol += RayTracing( collider->C , ray_V + Dx * x + Dy * y , dep + MAX_DREFL_DEP , refracted , NULL, rc, weight * alpha);
	}
	return rcol * alpha;
}
void pTriangle::ComputeForce(Vector3 vair) {
    //find the tirangle velocity
    velocity = (p1->getVelocity() + p2->getVelocity() + p3->getVelocity()) / 3 ;
    //assume no air velocity for now
    Vector3 v = velocity - vair;
    
    Vector3 r1 = p1->getPosition();
    Vector3 r2 = p2->getPosition();
    Vector3 r3 = p3->getPosition();
    //find triangle unnormalized normal, n*
    Vector3 ra = (r2 - r1);
    Vector3 rb = (r3 - r1);
    Vector3 ncross;
    ncross.Cross(ra, rb);
    
    //constants
    float p = 1.225f;
    float cd = 1.225f;
    
    //force = -1/2 * p * |v|^2 * cd * a * n
    Vector3 v2an = ( (v.Mag()*v.Dot(ncross))/(2.0f*ncross.Mag()) ) * ncross;
    Vector3 aeroForce = (-1.0f/2.0f) * p * cd * v2an;
    aeroForce = aeroForce / 3;
    p1->ApplyForce(aeroForce);
    p2->ApplyForce(aeroForce);
    p3->ApplyForce(aeroForce);
    normal = ncross.Normalize();
}
bool IntrSegment3Triangle3<Real>::Test ()
{
    // Compute the offset origin, edges, and normal.
    Vector3<Real> diff = mSegment->Center - mTriangle->V[0];
    Vector3<Real> edge1 = mTriangle->V[1] - mTriangle->V[0];
    Vector3<Real> edge2 = mTriangle->V[2] - mTriangle->V[0];
    Vector3<Real> normal = edge1.Cross(edge2);

    // Solve Q + t*D = b1*E1 + b2*E2 (Q = diff, D = segment direction,
    // E1 = edge1, E2 = edge2, N = Cross(E1,E2)) by
    //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
    //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
    //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
    Real DdN = mSegment->Direction.Dot(normal);
    Real sign;
    if (DdN > Math<Real>::ZERO_TOLERANCE)
    {
        sign = (Real)1;
    }
    else if (DdN < -Math<Real>::ZERO_TOLERANCE)
    {
        sign = (Real)-1;
        DdN = -DdN;
    }
    else
    {
        // Segment and triangle are parallel, call it a "no intersection"
        // even if the segment does intersect.
        mIntersectionType = IT_EMPTY;
        return false;
    }

    Real DdQxE2 = sign*mSegment->Direction.Dot(diff.Cross(edge2));
    if (DdQxE2 >= (Real)0)
    {
        Real DdE1xQ = sign*mSegment->Direction.Dot(edge1.Cross(diff));
        if (DdE1xQ >= (Real)0)
        {
            if (DdQxE2 + DdE1xQ <= DdN)
            {
                // Line intersects triangle, check if segment does.
                Real QdN = -sign*diff.Dot(normal);
                Real extDdN = mSegment->Extent*DdN;
                if (-extDdN <= QdN && QdN <= extDdN)
                {
                    // Segment intersects triangle.
                    mIntersectionType = IT_POINT;
                    return true;
                }
                // else: |t| > extent, no intersection
            }
            // else: b1+b2 > 1, no intersection
        }
        // else: b2 < 0, no intersection
    }
    // else: b1 < 0, no intersection

    mIntersectionType = IT_EMPTY;
    return false;
}
Example #28
0
void rms::ComputeAlignAxisMatrix( const Vector3<Real> & vInitial,
								  const Vector3<Real> & vAlignWith, Matrix3<Real> & matrix )
{
	// compute cosine of angle between vectors
	Real axisDot = vAlignWith.Dot( vInitial );

	// compute rotation axis
	Vector3<Real> axisCross( vInitial.Cross( vAlignWith ) );

	// apply rotation if necessary
	if (axisCross.SquaredLength() > Wml::Math<Real>::EPSILON) {

		// compute normalized axis and angle, then create rotation around axis
		axisCross.Normalize();
		Real fAngle = Math<Real>::ACos( axisDot / vAlignWith.Length() );
		matrix.FromAxisAngle( axisCross, fAngle );

	} else if (axisDot < (Real)0) {

		// find some perpendicular vectors
		Wml::Vector3<Real> vPerp1, vPerp2;
		ComputePerpVectors( vInitial, vPerp1, vPerp2 );

		matrix.FromAxisAngle( vPerp1, (Real)180 * Math<Real>::DEG_TO_RAD );
	} else {
		matrix = Matrix3<Real>::IDENTITY;
	}
}
Example #29
0
Color Shade(const Ray ray, const int depth, const vector<BVHNode>& nodes, const vector<Sphere>& spheres) {
    // id of intersected object
    unsigned int sphereId = 0;

    // cout << "Shade: " << ray.ToString() << endl;
    const float t = ItrIntersect(ray, nodes, spheres, sphereId);
    // cout << endl;
    if (sphereId == -1)
        return Color(0,0,0); // Background color

    const Sphere& sphere = spheres[sphereId];

    const Vector3 hitPos = ray.origin + ray.dir * t;
    const Vector3 norm = (hitPos - sphere.position).Normalize();
    const Vector3 nl = Dot(norm, ray.dir) < 0 ? norm : norm * -1;

    Color f = sphere.color;
    const float maxRefl = f.x>f.y && f.x>f.z ? f.x : f.y>f.z ? f.y : f.z;
    if (depth > 1) // if depth above 5, then terminate
        return sphere.emission;

    // All objects are diffuse
    const float r1 = 2 * M_PI * Rand01();
    const float r2 = Rand01(); 
    const float r2s = sqrtf(r2);
    // Normal space
    const Vector3 w = nl; 
    const Vector3 u = ((fabsf(w.x) > 0.1f ? Vector3(0,1,0) : Vector3(1,0,0)).Cross(w)).Normalize();
    const Vector3 v = w.Cross(u);
    const Vector3 newRayDir = (u * cos(r1) * r2s + v * sin(r1) * r2s + w * sqrtf(1-r2)).Normalize();
    const Vector3 newPos = hitPos + nl * 0.02f;
    return sphere.emission + f * Shade(Ray(newPos, newRayDir), depth+1, nodes, spheres);
}
Example #30
0
vector<Ray> CreateRays() {
    Ray cam(Vector3(50,52,295.6), Vector3(0,-0.042612,-1).Normalize()); // cam pos, dir
    Vector3 cx = Vector3(WIDTH * 0.5135 / HEIGHT, 0, 0);
    Vector3 cy = (cx.Cross(cam.dir)).Normalize() * 0.5135;

    vector<Ray> rays = vector<Ray>(WIDTH * HEIGHT * samples);
    for (int y = 0; y < HEIGHT; y++){
        unsigned short Xi[3] = {0, 0, y*y*y};
        for (unsigned short x = 0; x < WIDTH; x++) {
            
            // subpixel grid
            for (int subY = 0; subY < sqrtSamples; ++subY)
                for (int subX = 0; subX < sqrtSamples; ++subX) {
                    // Samples
                    double r1 = 2 * erand48(Xi);
                    float dx = r1 < 1 ? sqrt(r1) - 1 : 1 - sqrt(2 - r1);
                    double r2 = 2 * erand48(Xi);
                    float dy = r2 < 1 ? sqrt(r2) - 1: 1 - sqrt(2 - r2);
                    
                    Vector3 rayDir = cx * (((subX + 0.5 + dx) / sqrtSamples + x) / WIDTH - 0.5) 
                        + cy * (((subY + 0.5 + dy) / sqrtSamples + y) / HEIGHT - 0.5) + cam.dir;
                    rays[Index(x,y,subX,subY)] = Ray(cam.origin + rayDir * 140, rayDir.Normalize());
                }
        }
    }
    
    return rays;
}