示例#1
0
void CPlayerCamera::SetRotation ( CVector & vecRotation )
{
    // Rotate a 1000,0,0 vector with the given rotation vector
    CVector vecRotationCopy = vecRotation;
    vecRotationCopy.fX = 0.0f;
    CVector vecNormal = CVector ( 1000.0f, 0.0f, 0.0f );
    RotateVector ( vecNormal, vecRotationCopy );

    // Add it with our current position
    vecNormal += m_vecPosition;

    // Set the calculated vector as the target
    m_vecLookAt = vecNormal;
}
示例#2
0
bool	CRigidBody::Contains(const PAVECTOR* pPoint)
{
	D3DXVECTOR3 localPoint = (*pPoint) - m_position;
	
	localPoint = RotateVector(localPoint, true);
	
	for (std::list<Ptr<IHitbox>>::iterator it = m_lHitbox.begin();
		it != m_lHitbox.end();
		it++)
	{
		if ((*it)->Contains(&PAVector(localPoint))) return true;
	}

	return false;
}
示例#3
0
BOOL CGeometry::TransformLights(D3DVECTOR *CameraRotation,D3DVECTOR *CameraPosition)
{
	HRESULT	ddrval;

	for(int i=0; i<MAXLIGHTS; i++) {
		if(m_Lights[i].InUse) {
				D3DVECTOR RelVec = m_Lights[i].Position;
				RelVec.x -= CameraPosition->x;
				RelVec.y -= CameraPosition->y;
				RelVec.z -= CameraPosition->z;
				SetWorldMatrix(CameraRotation);
				RotateVector(&RelVec,&m_Lights[i].LightDesc.dvPosition);

				if(m_Lights[i].Transform) {
					RelVec = m_Lights[i].Direction;
					RotateVector(&RelVec,&m_Lights[i].LightDesc.dvDirection);
				}

				DXCALL(m_Lights[i].Light->SetLight(&m_Lights[i].LightDesc));
		}
	}

	return TRUE;
}
示例#4
0
void CClientCamera::SetRotation ( const CVector& vecRotation )
{
    // Rotate a 1000,0,0 vector with the given rotation vector
    CVector vecRotationCopy = vecRotation;
    vecRotationCopy.fX = 0.0f;
    CVector vecNormal = CVector ( 1000.0f, 0.0f, 0.0f );
    RotateVector ( vecNormal, vecRotationCopy );

    // Add it with our current position
    CVector vecPosition;
    GetPosition ( vecPosition );
    vecPosition += vecNormal;

    // Set the calculated vector as the target
    SetTarget ( vecPosition );
}
示例#5
0
void TMercury::Reflect(value_type x1, state_type y1, value_type &x2, state_type &y2, int &polarisation,
			const double normal[3], solid *leaving, solid *entering, bool &trajectoryaltered, bool &traversed){
	
	value_type vnormal = y1[3]*normal[0] + y1[4]*normal[1] + y1[5]*normal[2]; // velocity normal to reflection plane
	//particle was neither transmitted nor absorbed, so it has to be reflected
	double prob = mc->UniformDist(0,1);
	material *mat = vnormal < 0 ? &entering->mat : &leaving->mat;
	double diffprob = mat->DiffProb;
//	cout << "prob: " << diffprob << '\n';
	
	if (prob >= diffprob){
		//************** specular reflection **************
//				printf("Specular reflection! Erefl=%LG neV\n",Enormal*1e9);
		x2 = x1;
		for (int i = 0; i < 6; i++)
			y2[i] = y1[i];
		y2[3] -= 2*vnormal*normal[0]; // reflect velocity
		y2[4] -= 2*vnormal*normal[1];
		y2[5] -= 2*vnormal*normal[2];
	}
	else{
		//************** diffuse reflection no MR model ************
		double phi_r, theta_r;	
		
		phi_r = mc->UniformDist(0, 2*pi); // generate random reflection angles (Lambert's law)
		theta_r = mc->SinCosDist(0, 0.5*pi);
		
		if (vnormal > 0) theta_r = pi - theta_r; // if velocity points out of volume invert polar angle
		x2 = x1;
		for (int i = 0; i < 3; i++)
			y2[i] = y1[i];
		value_type vabs = sqrt(y1[3]*y1[3] + y1[4]*y1[4] + y1[5]*y1[5]);
		y2[3] = vabs*cos(phi_r)*sin(theta_r);	// new velocity with respect to z-axis
		y2[4] = vabs*sin(phi_r)*sin(theta_r);
		y2[5] = vabs*cos(theta_r);
		RotateVector(&y2[3], normal, &y1[3]); // rotate velocity into coordinate system defined by incoming velocity and plane normal
//				printf("Diffuse reflection! Erefl=%LG neV w_e=%LG w_s=%LG\n",Enormal*1e9,phi_r/conv,theta_r/conv);
	}

	if (mc->UniformDist(0,1) < entering->mat.SpinflipProb){
		polarisation *= -1;
		Nspinflip++;
	}

	traversed = false;
	trajectoryaltered = true;
} // end reflect method
示例#6
0
文件: decal.c 项目: mbait/avpmp
void ScanHModelForDecals(DISPLAYBLOCK *objectPtr, SECTION_DATA *sectionDataPtr)
{
    SECTION *sectionPtr = sectionDataPtr->sempai;

    /* Unreal things aren't drawn... */
    if (!(sectionDataPtr->flags&section_data_notreal) && (sectionPtr->Shape!=NULL))
    {
        /* does the object have decals? */
        extern MODULE *playerPherModule;
        if(sectionDataPtr->NumberOfDecals && playerPherModule)
        {
            int d;
            for(d=0; d<sectionDataPtr->NumberOfDecals; d++)
            {
                int i;
                DECAL decal;
                decal.DecalID = sectionDataPtr->Decals[d].DecalID;
                decal.ModuleIndex = playerPherModule->m_index;
                decal.UOffset = 0;

                for(i=0; i<5; i++)
                {
                    decal.Vertices[i] = sectionDataPtr->Decals[d].Vertices[i];
                    RotateVector(&(decal.Vertices[i]),&(sectionDataPtr->SecMat));
                    decal.Vertices[i].vx += sectionDataPtr->World_Offset.vx;
                    decal.Vertices[i].vy += sectionDataPtr->World_Offset.vy;
                    decal.Vertices[i].vz += sectionDataPtr->World_Offset.vz;
                }
                RenderDecal(&decal);
            }
        }
    }

    /* Now call recursion... */
    if (sectionDataPtr->First_Child!=NULL)
    {
        SECTION_DATA *childrenListPtr = sectionDataPtr->First_Child;

        while (childrenListPtr!=NULL)
        {
            ScanHModelForDecals(objectPtr,childrenListPtr);
            childrenListPtr=childrenListPtr->Next_Sibling;
        }
    }

}
示例#7
0
void NtlGetDestination_Keyboard_TURN_R(float fCurrentHeadingVectorX, float fCurrentHeadingVectorZ, float fSpeedInSecs,
										float fCurrentPositionX, float fCurrentPositionY, float fCurrentPositionZ,
										DWORD dwDeltaTimeInMillisecs, float fTurningSpeedRatio,
										CNtlVector* pNewHeadingVector, CNtlVector* pDestination)
{
	UNREFERENCED_PARAMETER( fSpeedInSecs );

	pNewHeadingVector->x = fCurrentHeadingVectorX;
	pNewHeadingVector->y = 0.0f;
	pNewHeadingVector->z = fCurrentHeadingVectorZ;

	pDestination->x = fCurrentPositionX;
	pDestination->y = fCurrentPositionY;
	pDestination->z = fCurrentPositionZ;

	float fRadian = 2 * NTL_PI * ((float)dwDeltaTimeInMillisecs / (float)NTL_REQUIRED_TIME_FOR_COMPLETE_CIRCULAR_MOVEMENT_IN_MILLISECS);
	fRadian *= fTurningSpeedRatio;

	*pNewHeadingVector = RotateVector(pNewHeadingVector, -fRadian);
}
示例#8
0
/**
 * Drive method for Mecanum wheeled robots.
 *
 * A method for driving with Mecanum wheeled robots. There are 4 wheels
 * on the robot, arranged so that the front and back wheels are toed in 45 degrees.
 * When looking at the wheels from the top, the roller axles should form an X across the robot.
 * 
 * This is designed to be directly driven by joystick axes.
 *
 * @param x The speed that the robot should drive in the X direction. [-1.0..1.0]
 * @param y The speed that the robot should drive in the Y direction.
 * This input is inverted to match the forward == -1.0 that joysticks produce. [-1.0..1.0]
 * @param rotation The rate of rotation for the robot that is completely independent of
 * the translation. [-1.0..1.0]
 * @param gyroAngle The current angle reading from the gyro.  Use this to implement field-oriented controls.
 */
void RobotDrive::MecanumDrive_Cartesian(float x, float y, float rotation, float gyroAngle)
{
	double xIn = x;
	double yIn = y;
	// Negate y for the joystick.
	yIn = -yIn;
	// Compenstate for gyro angle.
	RotateVector(xIn, yIn, gyroAngle);

	double wheelSpeeds[kMaxNumberOfMotors];
	wheelSpeeds[kFrontLeftMotor] = xIn + yIn + rotation;
	wheelSpeeds[kFrontRightMotor] = -xIn + yIn - rotation;
	wheelSpeeds[kRearLeftMotor] = -xIn + yIn + rotation;
	wheelSpeeds[kRearRightMotor] = xIn + yIn - rotation;

	Normalize(wheelSpeeds);

	m_frontLeftMotor->Set(wheelSpeeds[kFrontLeftMotor] * m_invertedMotors[kFrontLeftMotor]);
	m_frontRightMotor->Set(wheelSpeeds[kFrontRightMotor] * m_invertedMotors[kFrontRightMotor]);
	m_rearLeftMotor->Set(wheelSpeeds[kRearLeftMotor] * m_invertedMotors[kRearLeftMotor]);
	m_rearRightMotor->Set(wheelSpeeds[kRearRightMotor] * m_invertedMotors[kRearRightMotor]);
}
示例#9
0
/**
 * Drive method for Mecanum wheeled robots.
 *
 * A method for driving with Mecanum wheeled robots. There are 4 wheels
 * on the robot, arranged so that the front and back wheels are toed in 45
 * degrees.
 * When looking at the wheels from the top, the roller axles should form an X
 * across the robot.
 *
 * This is designed to be directly driven by joystick axes.
 *
 * @param x The speed that the robot should drive in the X direction.
 * [-1.0..1.0]
 * @param y The speed that the robot should drive in the Y direction.
 * This input is inverted to match the forward == -1.0 that joysticks produce.
 * [-1.0..1.0]
 * @param rotation The rate of rotation for the robot that is completely
 * independent of
 * the translation. [-1.0..1.0]
 * @param gyroAngle The current angle reading from the gyro.  Use this to
 * implement field-oriented controls.
 */
void RobotDrive::MecanumDrive_Cartesian(float x, float y, float rotation,
                                        float gyroAngle) {
  static bool reported = false;
  if (!reported) {
    HALReport(HALUsageReporting::kResourceType_RobotDrive, GetNumMotors(),
              HALUsageReporting::kRobotDrive_MecanumCartesian);
    reported = true;
  }

  double xIn = x;
  double yIn = y;
  // Negate y for the joystick.
  yIn = -yIn;
  // Compenstate for gyro angle.
  RotateVector(xIn, yIn, gyroAngle);

  double wheelSpeeds[kMaxNumberOfMotors];
  wheelSpeeds[kFrontLeftMotor] = xIn + yIn + rotation;
  wheelSpeeds[kFrontRightMotor] = -xIn + yIn - rotation;
  wheelSpeeds[kRearLeftMotor] = -xIn + yIn + rotation;
  wheelSpeeds[kRearRightMotor] = xIn + yIn - rotation;

  Normalize(wheelSpeeds);

  m_frontLeftMotor->Set(wheelSpeeds[kFrontLeftMotor] * m_maxOutput,
                        m_syncGroup);
  m_frontRightMotor->Set(wheelSpeeds[kFrontRightMotor] * m_maxOutput,
                         m_syncGroup);
  m_rearLeftMotor->Set(wheelSpeeds[kRearLeftMotor] * m_maxOutput, m_syncGroup);
  m_rearRightMotor->Set(wheelSpeeds[kRearRightMotor] * m_maxOutput,
                        m_syncGroup);

  if (m_syncGroup != 0) {
    CANJaguar::UpdateSyncGroup(m_syncGroup);
  }

  m_safetyHelper->Feed();
}
示例#10
0
TParticle* TSurfaceSource::CreateParticle(){
	double t = fmc->UniformDist(0, fActiveTime);
	double RandA = fmc->UniformDist(0,sourcearea);
	double SumA = 0;
	vector<TTriangle>::iterator i;
	for (i = sourcetris.begin(); i != sourcetris.end(); i++){
		SumA += i->area();
		if (RandA <= SumA) break;
	}
	double a = fmc->UniformDist(0,1); // generate random point on triangle (see Numerical Recipes 3rd ed., p. 1114)
	double b = fmc->UniformDist(0,1);
	if (a+b > 1){
		a = 1 - a;
		b = 1 - b;
	}
	CVector nv = i->normal();
	CPoint p = i->tri[0] + a*(i->tri[1] - i->tri[0]) + b*(i->tri[2] - i->tri[0]) + nv*REFLECT_TOLERANCE;

	double Ekin = fmc->Spectrum(fParticleName);
	double phi_v = fmc->UniformDist(0, 2*pi); // generate random velocity angles in upper hemisphere
	double theta_v = fmc->SinCosDist(0, 0.5*pi); // Lambert's law!
	if (Enormal > 0){
		double vnormal = sqrt(Ekin*cos(theta_v)*cos(theta_v) + Enormal); // add E_normal to component normal to surface
		double vtangential = sqrt(Ekin)*sin(theta_v);
		theta_v = atan2(vtangential, vnormal); // update angle
		Ekin = vnormal*vnormal + vtangential*vtangential; // update energy
	}

	double v[3] = {cos(phi_v)*sin(theta_v), sin(phi_v)*sin(theta_v), cos(theta_v)};
	double n[3] = {nv[0], nv[1], nv[2]};
	RotateVector(v, n);
	phi_v = atan2(v[1],v[0]);
	theta_v = acos(v[2]);
	int polarisation = fmc->DicePolarisation(fParticleName);

	return TParticleSource::CreateParticle(t, p[0], p[1], p[2], Ekin, phi_v, theta_v, polarisation);
}
示例#11
0
void NtlGetDestination_Keyboard_B_TURN_R(float fCurrentHeadingVectorX, float fCurrentHeadingVectorZ, float fSpeedInSecs,
											float fCurrentPositionX, float fCurrentPositionY, float fCurrentPositionZ,
											DWORD dwDeltaTimeInMillisecs, float fTurningSpeedRatio,
											CNtlVector* pNewHeadingVector, CNtlVector* pDestination)
{
	pNewHeadingVector->x = fCurrentHeadingVectorX;
	pNewHeadingVector->y = 0.0f;
	pNewHeadingVector->z = fCurrentHeadingVectorZ;

	float fRadian = 2 * NTL_PI * ((float)dwDeltaTimeInMillisecs / (float)NTL_REQUIRED_TIME_FOR_COMPLETE_CIRCULAR_MOVEMENT_IN_MILLISECS);
	fRadian *= fTurningSpeedRatio;

	*pNewHeadingVector = RotateVector(pNewHeadingVector, -fRadian);

	float fRadius = 0.0f;
	fRadius = (fSpeedInSecs * NTL_BACKWARD_MOVEMENT_SPEED_RATE) * ((float)NTL_REQUIRED_TIME_FOR_COMPLETE_CIRCULAR_MOVEMENT_IN_MILLISECS / (float)1000) / (2 * NTL_PI);

	float fTempX = fCurrentHeadingVectorX * fRadius / sqrt(fCurrentHeadingVectorX * fCurrentHeadingVectorX + fCurrentHeadingVectorZ * fCurrentHeadingVectorZ);
	float fTempZ = fCurrentHeadingVectorZ * fRadius / sqrt(fCurrentHeadingVectorX * fCurrentHeadingVectorX + fCurrentHeadingVectorZ * fCurrentHeadingVectorZ);

	pDestination->x = fCurrentPositionX - fTempX * sin(fRadian) + fTempZ * (1 - cos(fRadian));
	pDestination->y = fCurrentPositionY;
	pDestination->z = fCurrentPositionZ - fTempZ * sin(fRadian) - fTempX * (1 - cos(fRadian));
}
void TeleportPreservedSBsToNewEnvModule(MODULE *new_pos, MODULE* old_pos, int orient_change)
{
	int i;
	VECTORCH mod_offset;

	mod_offset.vx = new_pos->m_world.vx - old_pos->m_world.vx;
	mod_offset.vy = new_pos->m_world.vy - old_pos->m_world.vy;
	mod_offset.vz = new_pos->m_world.vz - old_pos->m_world.vz;
 
	for(i = 0; i < Num_SB_Preserved; i++)
		{
			VECTORCH obj_world;
			VECTORCH pos_rel; 
			STRATEGYBLOCK	*sbptr;
			DYNAMICSBLOCK	*dynptr;			

			sbptr = &SB_Preserved[i];
			
			dynptr = sbptr->DynPtr;
			GLOBALASSERT(dynptr);

			obj_world = sbptr->DynPtr->Position;
			
			
			{
			  // okay we need to find our relative position to the moduke
		  	int cos;
 	  		int sin;
				int angle;
				MATRIXCH mat;


				pos_rel.vx = dynptr->Position.vx - old_pos->m_world.vx; 
				pos_rel.vy = dynptr->Position.vy - old_pos->m_world.vy; 
				pos_rel.vz = dynptr->Position.vz - old_pos->m_world.vz; 

				if(orient_change == 1 || orient_change == -3)
					angle = 1024;
				else if(orient_change == 2 || orient_change == -2)
					angle = 2048;
				else if(orient_change == 3 || orient_change == -1)
					angle = 3072;
				else
					angle = 0;

		  	cos = GetCos(angle);
 	  		sin = GetSin(angle);

				mat.mat11 = cos;		 
	 	  	mat.mat12 = 0;
		  	mat.mat13 = -sin;
 		  	mat.mat21 = 0;	  	
 	  		mat.mat22 = 65536;	  	
 	  		mat.mat23 = 0;	  	
 	  		mat.mat31 = sin;	  	
 	  		mat.mat32 = 0;	  	
 	  		mat.mat33 = cos;	
			
				// rotate the relative object about the center of the
				// module and rotate the abject about its own y-axis
				
				RotateVector(&pos_rel, &mat);
		  	MatrixMultiply(&dynptr->OrientMat,&mat,&dynptr->OrientMat);
			 	MatrixToEuler(&dynptr->OrientMat, &dynptr->OrientEuler);
			}

#if 0 
			dynptr->Position.vx = mod_offset.vx; 
			dynptr->Position.vy = mod_offset.vy; 
			dynptr->Position.vz = mod_offset.vz; 

			dynptr->PrevPosition.vx = mod_offset.vx; 
			dynptr->PrevPosition.vy = mod_offset.vy; 
			dynptr->PrevPosition.vz = mod_offset.vz; 
#endif

			dynptr->Position.vx = pos_rel.vx + new_pos->m_world.vx; 
			dynptr->Position.vy = pos_rel.vy + new_pos->m_world.vy; 
			dynptr->Position.vz = pos_rel.vz + new_pos->m_world.vz; 

			dynptr->PrevPosition.vx = -pos_rel.vx + old_pos->m_world.vx; 
			dynptr->PrevPosition.vy = -pos_rel.vy + old_pos->m_world.vy; 
			dynptr->PrevPosition.vz = -pos_rel.vz + old_pos->m_world.vz; 
	
		}
 }
示例#13
0
bool DexMouseTracker::GetCurrentMarkerFrame( CodaFrame &frame ) {


	POINT mouse_position;
	GetCursorPos( &mouse_position );
	RECT rect;
	GetWindowRect( GetDesktopWindow(), &rect );

	Vector3		position, rotated;
	Vector3	x_dir, y_span, z_span;
	Vector3		x_displacement, y_displacement, z_displacement;

	double		x, y, z;

	Quaternion	Ry, Rz, Q, nominalQ, midQ;
	Matrix3x3	xform = {{-1.0, 0.0, 0.0},{0.0, 0.0, 1.0},{0.0, 1.0, 0.0}};

	int mrk, id;
	
	// Just set the target frame markers at their nominal fixed positions.
	for ( mrk = 0; mrk < nFrameMarkers; mrk++ ) {
		id = FrameMarkerID[mrk];
		CopyVector( frame.marker[id].position, TargetFrameBody[mrk] );
	}

	// Shift the vertical bar markers to simulate being in the left position.
	if ( IsDlgButtonChecked( dlg, IDC_LEFT ) ) {
		frame.marker[DEX_NEGATIVE_BAR_MARKER].position[X] += 300.0;
		frame.marker[DEX_POSITIVE_BAR_MARKER].position[X] += 300.0;
	}

	// Transform the marker positions of the target box and frame according 
	//  to whether the system was upright or supine when it was aligned and
	//  according to whether the system is currently installed in the upright
	//  or supine configuration.
	if ( ( IsDlgButtonChecked( dlg, IDC_SUPINE ) && TRACKER_ALIGNED_SUPINE  != SendDlgItemMessage( dlg, IDC_ALIGNMENT, CB_GETCURSEL, 0, 0 ) ) ||
		 ( IsDlgButtonChecked( dlg, IDC_SEATED ) && TRACKER_ALIGNED_UPRIGHT != SendDlgItemMessage( dlg, IDC_ALIGNMENT, CB_GETCURSEL, 0, 0 ) ) )	{	
		 for ( mrk = 0; mrk < nFrameMarkers; mrk++ ) {

			id = FrameMarkerID[mrk];
			position[X] = - frame.marker[id].position[X];
			position[Z] =   frame.marker[id].position[Y];
			position[Y] =   frame.marker[id].position[Z];

			CopyVector( frame.marker[id].position, position );
		}
		MatrixToQuaternion( nominalQ, xform );
	}
	else CopyQuaternion( nominalQ, nullQuaternion );

	// Now set the visibility flag as a funciton of the GUI.
	if ( IsDlgButtonChecked( dlg, IDC_BAR_OCCLUDED ) ) {
		frame.marker[DEX_NEGATIVE_BAR_MARKER].visibility = false;
		frame.marker[DEX_POSITIVE_BAR_MARKER].visibility = false;
	}
	else {
		frame.marker[DEX_NEGATIVE_BAR_MARKER].visibility = true;
		frame.marker[DEX_POSITIVE_BAR_MARKER].visibility = true;
	}
	if ( IsDlgButtonChecked( dlg, IDC_BOX_OCCLUDED ) ) {
		frame.marker[DEX_NEGATIVE_BOX_MARKER].visibility = false;
		frame.marker[DEX_POSITIVE_BOX_MARKER].visibility = false;
	}
	else {
		frame.marker[DEX_NEGATIVE_BOX_MARKER].visibility = true;
		frame.marker[DEX_POSITIVE_BOX_MARKER].visibility = true;
	}

	// Map mouse coordinates to world coordinates. The factors used here are empirical.
	
	y =  (double) ( mouse_position.y - rect.top ) / (double) ( rect.bottom - rect.top );
	z =  (double) (mouse_position.x - rect.right) / (double) ( rect.left - rect.right );
	x = 0.0;

	// By default, the orientation of the manipulandum is the nominal orientation.

	CopyQuaternion( Q, nominalQ );

	// Simulate wobbly movements of the manipulandum. This has not really been tested.

	if ( IsDlgButtonChecked( dlg, IDC_CODA_WOBBLY ) ) {
		// We will make the manipulandum rotate in a strange way as a function of the distance from 0.
		// This is just so that we can test the routines that compute the manipulandum position and orientation.
		double theta = y * 45.0;
		double gamma = - z * 45.0;
		SetQuaterniond( Ry, theta, iVector );
		SetQuaterniond( Rz, gamma, jVector );
		MultiplyQuaternions( midQ, Rz, nominalQ );
		MultiplyQuaternions( Q, Ry, midQ );
		// Make the movement a little bit in X as well so that we test the routines in 3D.
		x = 0.0 + 5.0 * sin( y / 80.0);
	}

	// Map screen position of the mouse pointer to 3D position of the wrist and manipulandum.
	// Top of the screen corresponds to the bottom of the bar and vice versa. It's inverted to protect the right hand rule.
	// Right of the screen correponds to the nearest horizontal target and left corresponds to the farthest.
	// The X position is set to be just to the right of the box.

	SubtractVectors( y_span, frame.marker[DEX_POSITIVE_BAR_MARKER].position, frame.marker[DEX_NEGATIVE_BAR_MARKER].position );
	SubtractVectors( x_dir, frame.marker[DEX_POSITIVE_BOX_MARKER].position, frame.marker[DEX_NEGATIVE_BOX_MARKER].position );
	NormalizeVector( x_dir );
	ComputeCrossProduct( z_span, x_dir, y_span );
	 
	ScaleVector( y_displacement, y_span, y );
	ScaleVector( z_displacement, z_span, z );
	ScaleVector( x_displacement, x_dir, x );

	// Reference position is the bottom target on the vertical target bar.
	CopyVector( position, frame.marker[DEX_NEGATIVE_BAR_MARKER].position );
	// Place the manipulandum to the right of the box, even if the target bar is in the left position.
	position[X] = frame.marker[DEX_NEGATIVE_BOX_MARKER].position[X];
	// Shift the position in X if the is any wobble to it.
	AddVectors( position, position, x_displacement );
	// Shift the position in Y and Z according to the displacements computed from the mouse position.
	AddVectors( position, position, y_displacement );
	AddVectors( position, position, z_displacement );

	frame.time = DexTimerElapsedTime( acquisitionTimer );

	// Displace the manipulandum with the mouse and make it rotate.
	for ( mrk = 0; mrk < nManipulandumMarkers; mrk++ ) {
		id = ManipulandumMarkerID[mrk];
		RotateVector( rotated, Q, ManipulandumBody[mrk] );
		AddVectors( frame.marker[id].position, position, rotated );
		frame.marker[id].visibility = true;
	}

	// Displace the wrist with the mouse, but don't rotate it.
	for ( mrk = 0; mrk < nWristMarkers; mrk++ ) {
		id = WristMarkerID[mrk];
		AddVectors( frame.marker[id].position, position, WristBody[mrk] );
		frame.marker[id].visibility = true;
	}

	// Output the position and orientation used to compute the simulated
	// marker positions. This is for testing only.
	fprintf( fp, "%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n",
		frame.time, 
		position[X], position[Y], position[Z],
		Q[X], Q[Y], Q[Z], Q[M] );

	return( true );

}
示例#14
0
文件: main.c 项目: c14006078/opengl
void drawGLScene(void)
{
	int i, j;

	float TmpShade;

	MATRIX TmpMatrix;
	VECTOR TmpVector, TmpNormal;

	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity ();

	if (True == outlineSmooth)
	{
		glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
		glEnable (GL_LINE_SMOOTH);
	}
	else
		glDisable (GL_LINE_SMOOTH);

	glTranslatef (0.0f, 0.0f, -2.0f);
	glRotatef (modelAngle, 0.0f, 1.0f, 0.0f);

	glGetFloatv (GL_MODELVIEW_MATRIX, TmpMatrix.Data);

	glEnable (GL_TEXTURE_1D);
	glBindTexture (GL_TEXTURE_1D, shaderTexture[0]);

	glColor3f (1.0f, 1.0f, 1.0f);

	glBegin (GL_TRIANGLES);

	for (i = 0; i < polyNum; i++)
	{
		for (j = 0; j < 3; j++)
		{
			TmpNormal.X = polyData[i].Verts[j].Nor.X;
			TmpNormal.Y = polyData[i].Verts[j].Nor.Y;
			TmpNormal.Z = polyData[i].Verts[j].Nor.Z;

			RotateVector (&TmpMatrix, &TmpNormal, &TmpVector);

			Normalize (&TmpVector);

			TmpShade = DotProduct (&TmpVector,&lightAngle);

			if (TmpShade < 0.0f)
				TmpShade = 0.0f;

			glTexCoord1f (TmpShade);
			glVertex3fv (&polyData[i].Verts[j].Pos.X);
		}
	}

	glEnd ();

	glDisable (GL_TEXTURE_1D);

	if (True == outlineDraw)
	{
		glEnable (GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

		glPolygonMode (GL_BACK, GL_LINE);
		glLineWidth (outlineWidth);

		glCullFace (GL_FRONT);

		glDepthFunc (GL_LEQUAL);

		glColor3fv (&outlineColor[0]);

		glBegin (GL_TRIANGLES);

		for (i = 0; i < polyNum; i++)
		{
			for (j = 0; j < 3; j++)
			{
				glVertex3fv (&polyData[i].Verts[j].Pos.X);
			}
		}

		glEnd ();

		glDepthFunc (GL_LESS);

		glCullFace (GL_BACK);

		glPolygonMode (GL_BACK, GL_FILL);

		glDisable (GL_BLEND);
	}
}
示例#15
0
dVector dMatrix::TransformPlane (const dVector & localPlane) const
{
   dVector tmp (RotateVector (localPlane));
   tmp.m_w = localPlane.m_w - (localPlane % UnrotateVector (m_posit));
   return tmp;
}
HRESULT CRotate2DTool::RotateSelectedObjects( float flDeltaX )
{
	HRESULT hr = S_OK;
	CRotateObject * pCTrans = NULL;
	BOOL bHandled = FALSE;
	static DWORD dwTime = - 1;
	DWORD dwTimeNow;
	CComBSTR bstr1, bstr2, bstr3;
	CString tmpStr;
	D3DVECTOR vec;
	int i;

	if (IsPressed('S'))
	{
		flDeltaX *= SLOWKEY_SLOWFACTOR;
	}

	m_fDeltaTotal += flDeltaX;

	for( POSITION pos = m_TransformList.GetHeadPosition(); pos != NULL; )
	{
		bHandled = TRUE;
		pCTrans = m_TransformList.GetNext( pos );
		if(NULL != pCTrans)
		{
			for (i = 0; i < pCTrans->m_nPoints; i++)
			{
				vec.x = pCTrans->m_pPoints[i].x;
				vec.y = 0.0f;
				vec.z = pCTrans->m_pPoints[i].y;

				RotateVector(m_fDeltaTotal, &vec);

				vec.x += pCTrans->m_fCenter.x;
				vec.z += pCTrans->m_fCenter.y;

				hr = pCTrans->m_pVWFrame->InverseTransform(AXIS_Y, &vec.x, &vec.y, &vec.z, vec.x, vec.y, vec.z);
				if(FAILED( hr )) goto EXIT_FAIL;

				hr = pCTrans->m_pBoundary->SetVertexXY(i, vec.x, vec.z);
				if(FAILED( hr )) goto EXIT_FAIL;
			}

			InvokeToolEvent(TOOLEVENT_BOUNDARYUPDATE, pCTrans->m_pBoundary, bstrNULL, bstrNULL, bstrNULL, VARIANT_FALSE);

			dwTimeNow = GetTickCount();

			if (dwTimeNow - dwTime > 200)
			{
				tmpStr.Format("%0.3f", m_fDeltaTotal / PI * 180.0f);
				bstr1 = tmpStr;
				tmpStr = "";
				bstr2 = tmpStr;
				bstr3 = tmpStr;

				InvokeToolEvent(TOOLEVENT_2DOBJECTROTATED, pCTrans->m_pPickData, bstr1, bstr2, bstr3, VARIANT_TRUE); 

				dwTime = dwTimeNow;
			}
		}
	}

EXIT_FAIL:
	return hr;
}
示例#17
0
bool NtlGetDestination(float fCurrentHeadingVectorX, float fCurrentHeadingVectorZ, float fSpeedInSecs,
						float fCurrentPositionX, float fCurrentPositionY, float fCurrentPositionZ,
						float fDestinationX, float fDestinationY, float fDestinationZ,
						BYTE byMoveDirection, DWORD dwDeltaTimeInMillisecs,
						float fAttackDistance,
						float* pfNewHeadingVectorX, float* pfNewHeadingVectorZ,
						float* pfDestinationX, float* pfDestinationY, float* pfDestinationZ,
						float fTurningSpeedRatio)
{
	if (0 == fCurrentHeadingVectorX && 0 == fCurrentHeadingVectorZ)
		return false;

	*pfNewHeadingVectorX = fCurrentHeadingVectorX;
	*pfNewHeadingVectorZ = fCurrentHeadingVectorZ;
	*pfDestinationX = fCurrentPositionX;
	*pfDestinationY = fCurrentPositionY;
	*pfDestinationZ = fCurrentPositionZ;

	float fDistanceInTick = fSpeedInSecs * (float)dwDeltaTimeInMillisecs / 1000.0f;

	switch (byMoveDirection)
	{
	case NTL_MOVE_NONE :
		break;

	case NTL_MOVE_F :
	case NTL_MOVE_B :
	// DON'T delete these lines permanently!
	// 완전히 삭제하지 마시오!
	// by YOSHIKI(2006-09-22)
//	case NTL_MOVE_L :
//	case NTL_MOVE_R :
//	case NTL_MOVE_F_L :
//	case NTL_MOVE_F_R :
//	case NTL_MOVE_B_L :
//	case NTL_MOVE_B_R :
		{
			float fMovementVectorX = 0.0f;
			float fMovementVectorZ = 0.0f;

			if (NTL_MOVE_F == byMoveDirection)
			{
				fMovementVectorX = fCurrentHeadingVectorX;
				fMovementVectorZ = fCurrentHeadingVectorZ;
			}
			else if (NTL_MOVE_B == byMoveDirection)
			{
				RotateVector180Degree(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}
			// DON'T delete these lines permanently!
			// 완전히 삭제하지 마시오!
			// by YOSHIKI(2006-09-22)
/*			else if (NTL_MOVE_L == byMoveDirection)
			{
				RotateVector90DegreeToLeft(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}
			else if (NTL_MOVE_R == byMoveDirection)
			{
				RotateVector90DegreeToRight(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}
			else if (NTL_MOVE_F_L == byMoveDirection)
			{
				RotateVector45DegreeToLeft(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}
			else if (NTL_MOVE_F_R == byMoveDirection)
			{
				RotateVector45DegreeToRight(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}
			else if (NTL_MOVE_B_L == byMoveDirection)
			{
				RotateVector135DegreeToLeft(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}
			else if (NTL_MOVE_B_R == byMoveDirection)
			{
				RotateVector135DegreeToRight(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, &fMovementVectorX, &fMovementVectorZ);
			}*/

			float fSin = 0.0f;
			float fCos = 0.0f;

			if (false == NtlSin(fMovementVectorX, fMovementVectorZ, &fSin))
				return true;
			if (false == NtlCos(fMovementVectorX, fMovementVectorZ, &fCos))
				return true;

			float fDeltaX = fDistanceInTick * fCos;
			float fDeltaZ = fDistanceInTick * fSin;
			*pfDestinationX = fCurrentPositionX + fDeltaX;
			*pfDestinationZ = fCurrentPositionZ + fDeltaZ;
		}
		break;

	case NTL_MOVE_TURN_L :
	case NTL_MOVE_TURN_R :
	case NTL_MOVE_F_TURN_L :
	case NTL_MOVE_F_TURN_R :
	case NTL_MOVE_B_TURN_L :
	case NTL_MOVE_B_TURN_R :
		{
			float fRadian = 2 * NTL_PI * ((float)dwDeltaTimeInMillisecs / (float)NTL_REQUIRED_TIME_FOR_COMPLETE_CIRCULAR_MOVEMENT_IN_MILLISECS);
			fRadian *= fTurningSpeedRatio;

			if (NTL_MOVE_TURN_L == byMoveDirection ||
				NTL_MOVE_F_TURN_L == byMoveDirection ||
				NTL_MOVE_B_TURN_L == byMoveDirection)
			{
				RotateVector(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, fRadian, pfNewHeadingVectorX, pfNewHeadingVectorZ);
			}
			else if (NTL_MOVE_TURN_R == byMoveDirection ||
						NTL_MOVE_F_TURN_R == byMoveDirection ||
						NTL_MOVE_B_TURN_R == byMoveDirection)
			{
				RotateVector(fCurrentHeadingVectorX, fCurrentHeadingVectorZ, -fRadian, pfNewHeadingVectorX, pfNewHeadingVectorZ);
			}

			if (NTL_MOVE_TURN_L == byMoveDirection || NTL_MOVE_TURN_R == byMoveDirection)
			{
				// The position doesn't change.
			}
			else if (NTL_MOVE_F_TURN_L == byMoveDirection || NTL_MOVE_F_TURN_R == byMoveDirection ||
						NTL_MOVE_B_TURN_L == byMoveDirection || NTL_MOVE_B_TURN_R == byMoveDirection)
			{
				float fRadius = 0.0f;
				fRadius = fSpeedInSecs * ((float)NTL_REQUIRED_TIME_FOR_COMPLETE_CIRCULAR_MOVEMENT_IN_MILLISECS / (float)1000) / (2 * NTL_PI);

				float fTempX = fCurrentHeadingVectorX * fRadius / sqrt(fCurrentHeadingVectorX * fCurrentHeadingVectorX + fCurrentHeadingVectorZ * fCurrentHeadingVectorZ);
				float fTempZ = fCurrentHeadingVectorZ * fRadius / sqrt(fCurrentHeadingVectorX * fCurrentHeadingVectorX + fCurrentHeadingVectorZ * fCurrentHeadingVectorZ);

				if (NTL_MOVE_F_TURN_L == byMoveDirection)
				{
					*pfDestinationX = fCurrentPositionX + fTempX * sin(fRadian) + fTempZ * (1 - cos(fRadian));
					*pfDestinationZ = fCurrentPositionZ + fTempZ * sin(fRadian) - fTempX * (1 - cos(fRadian));
				}
				else if (NTL_MOVE_F_TURN_R == byMoveDirection)
				{
					*pfDestinationX = fCurrentPositionX + fTempX * sin(fRadian) - fTempZ * (1 - cos(fRadian));
					*pfDestinationZ = fCurrentPositionZ + fTempZ * sin(fRadian) - fTempX * (1 - cos(fRadian));
				}
				else if (NTL_MOVE_B_TURN_L == byMoveDirection)
				{
					*pfDestinationX = fCurrentPositionX - fTempX * sin(fRadian) - fTempZ * (1 - cos(fRadian));
					*pfDestinationZ = fCurrentPositionZ - fTempZ * sin(fRadian) - fTempX * (1 - cos(fRadian));
				}
				else if (NTL_MOVE_B_TURN_R == byMoveDirection)
				{
					*pfDestinationX = fCurrentPositionX - fTempX * sin(fRadian) + fTempZ * (1 - cos(fRadian));
					*pfDestinationZ = fCurrentPositionZ - fTempZ * sin(fRadian) - fTempX * (1 - cos(fRadian));
				}
			}
		}
		break;

	case NTL_MOVE_MOUSE_MOVEMENT :
		{
			float fDeltaX = fDestinationX - fCurrentPositionX;
			float fDeltaZ = fDestinationZ - fCurrentPositionZ;

			//  [6/21/2006 zeroera] : 수정 : float 비교 오차 범위
			if ( ( fabs( fDeltaX ) < 0.001f ) && ( fabs( fDeltaZ ) < 0.001f ) )
			{
				*pfNewHeadingVectorX = fCurrentHeadingVectorX;
				*pfNewHeadingVectorZ = fCurrentHeadingVectorZ;
				*pfDestinationX = fDestinationX;
				*pfDestinationY = fDestinationY;
				*pfDestinationZ = fDestinationZ;

				return true;
			}

			CNtlVector vDelta(fDeltaX, 0, fDeltaZ);
			float fDeltaLength = vDelta.Length();

			vDelta.Normalize(fDeltaLength);

			*pfNewHeadingVectorX = vDelta.x;
			*pfNewHeadingVectorZ = vDelta.z;

			if (fDeltaLength <= fDistanceInTick)
			{
				*pfDestinationX = fDestinationX;
				*pfDestinationY = fDestinationY;
				*pfDestinationZ = fDestinationZ;
			}
			else
			{
				vDelta *= fDistanceInTick;

				*pfDestinationX = fCurrentPositionX + vDelta.x;
				*pfDestinationY = fCurrentPositionY + (fDestinationY - fCurrentPositionY) * fDistanceInTick / fDeltaLength;
				*pfDestinationZ = fCurrentPositionZ + vDelta.z;
			}
		}
		break;

	case NTL_MOVE_FOLLOW_MOVEMENT :
		{
			float fDeltaX = fDestinationX - fCurrentPositionX;
			float fDeltaZ = fDestinationZ - fCurrentPositionZ;

			//  [6/21/2006 zeroera] : 수정 : float 비교 오차 범위
			if ( ( fabs( fDeltaX ) < 0.001f ) && ( fabs( fDeltaZ ) < 0.001f ) )
			{
				*pfNewHeadingVectorX = fCurrentHeadingVectorX;
				*pfNewHeadingVectorZ = fCurrentHeadingVectorZ;
				*pfDestinationX = fCurrentPositionX;
				*pfDestinationY = fCurrentPositionY;
				*pfDestinationZ = fCurrentPositionZ;

				return true;
			}

			CNtlVector vDelta(fDeltaX, 0, fDeltaZ);
			float fDeltaLength = vDelta.Length();

			vDelta.Normalize(fDeltaLength);

			*pfNewHeadingVectorX = vDelta.x;
			*pfNewHeadingVectorZ = vDelta.z;

			if ( fDeltaLength <= fAttackDistance )
			{
				*pfDestinationX = fCurrentPositionX;
				*pfDestinationY = fCurrentPositionY;
				*pfDestinationZ = fCurrentPositionZ;
			}
			else if ( fDeltaLength > fAttackDistance && fDeltaLength < fAttackDistance + fDistanceInTick)
			{
				vDelta *= ( fDeltaLength - fAttackDistance * 0.99f );

				*pfDestinationX = fCurrentPositionX + vDelta.x;
				*pfDestinationY = fCurrentPositionY + (fDestinationY - fCurrentPositionY) * (fDeltaLength - fAttackDistance * 0.99f) / fDeltaLength;
				*pfDestinationY = fDestinationY;
				*pfDestinationZ = fCurrentPositionZ + vDelta.z;
			}
			else
			{
				vDelta *= fDistanceInTick;

				*pfDestinationX = fCurrentPositionX + vDelta.x;
				*pfDestinationY = fCurrentPositionY + (fDestinationY - fCurrentPositionY) * fDistanceInTick / fDeltaLength;
				*pfDestinationZ = fCurrentPositionZ + vDelta.z;
			}
		}
		break;

	default :
		return false;
		break;
	}

	return true;
}
void	Renderer::ProtoRender(int flags)
{


  ///

  // std::vector<unsigned int>	tmp_Indices;

  // for (unsigned int i = 0; i < m_Indices.size(); i += 6)
  //   {
  //     tmp_Indices.push_back( m_Indices[ i + 0 ] );
  //     tmp_Indices.push_back( m_Indices[ i + 1 ] );
  //     tmp_Indices.push_back( m_Indices[ i + 2 ] );
  //   }

  // m_Indices = tmp_Indices;

  ///

  if ( flags & eCellShading_texture1D || flags & eCellShading_color )
    {
      sf::Vector3f	lightAngle(0,0,1);
      // Normalize( lightAngle );

      float	tmp_matrix[16];
      glGetFloatv( GL_MODELVIEW_MATRIX, tmp_matrix );


      m_sec_Vertices.clear();
      m_sec_Normales.clear();
      m_sec_TexCoords.clear();
      m_sec_Colors.clear();
      m_sec_TexCoords1D.clear();

      for (unsigned int i = 0; i < m_Indices.size(); ++i)
      // for (unsigned int i = 0; i < m_Indices2.size(); ++i)
	{

#define	D_IDX	m_Indices[i]
// #define	D_IDX	m_Indices2[i]

	  m_sec_Vertices.push_back( m_Vertices[ D_IDX ] );

	  if ( flags & eNormal )
	    m_sec_Normales.push_back( m_Normales[ D_IDX ] );

	  if ( flags & eTexture )
	    m_sec_TexCoords.push_back( m_TexCoords[ D_IDX ] );


	  {
	    sf::Vector3f	tmp_vector;

	    RotateVector( tmp_matrix, m_Normales[ D_IDX ], tmp_vector );
	    Normalize( tmp_vector );

	    float	tmp_shade = DotProduct( tmp_vector, lightAngle );

	    if (tmp_shade < 0.0f)
	      tmp_shade = 0.0f;

	    if ( flags & eCellShading_texture1D )
	      m_sec_TexCoords1D.push_back( tmp_shade );

	    if ( flags & eCellShading_color )
	      m_sec_Colors.push_back( sf::Vector3f(tmp_shade, tmp_shade, tmp_shade) );

	  }

#undef	D_IDX

	} // for (unsigned int i = 0; i < m_Indices.size(); ++i)

    }






  {

    {
      glEnableClientState( GL_VERTEX_ARRAY );

      if ( flags & eCellShading_texture1D || flags & eCellShading_color )
	glVertexPointer( 3, GL_FLOAT, 0, &(m_sec_Vertices[0].x) );
      else
	glVertexPointer( 3, GL_FLOAT, 0, &(m_Vertices[0].x) );
    }


    if ( flags & eNormal )
      {
	glEnableClientState( GL_NORMAL_ARRAY );


	glEnable(GL_LIGHTING);


	if ( flags & eCellShading_texture1D || flags & eCellShading_color )
	  glNormalPointer( GL_FLOAT, 0, &(m_sec_Normales[0].x) );
	else
	  glNormalPointer( GL_FLOAT, 0, &(m_Normales[0].x) );
      }
    else
      glDisable(GL_LIGHTING);


    if ( flags & eCellShading_color )
      {
	glEnableClientState( GL_COLOR_ARRAY );
	glColorPointer( 3, GL_FLOAT, 0, &(m_sec_Colors[0].x) );
      }


    if ( flags & eCellShading_texture1D )
      {
	glClientActiveTexture(GL_TEXTURE1);
	glActiveTextureARB(GL_TEXTURE1_ARB);

	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	glEnable(GL_TEXTURE_1D);
	m_Tex1D.Bind();

	glTexCoordPointer( 1, GL_FLOAT, 0, &(m_sec_TexCoords1D[0]) );
      }


    if ( flags & eTexture )
      {
	glClientActiveTexture(GL_TEXTURE0);
	glActiveTextureARB(GL_TEXTURE0_ARB);

	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	glEnable(GL_TEXTURE_2D);
	sf::Texture::bind( m_pTexture );
	m_pTexture->setSmooth(false);

	if ( flags & eCellShading_texture1D || flags & eCellShading_color )
	  glTexCoordPointer( 2, GL_FLOAT, 0, &(m_sec_TexCoords[0].x) );
	else
	  glTexCoordPointer( 2, GL_FLOAT, 0, &(m_TexCoords[0].x) );
      }


    if ( flags & eCellShading_texture1D || flags & eCellShading_color )
      glDrawArrays( GL_TRIANGLES, 0, m_sec_Vertices.size() );
    else
      glDrawElements( GL_TRIANGLES, m_Indices.size(), GL_UNSIGNED_INT, &(m_Indices[0]) );
      // glDrawElements( GL_TRIANGLES, m_Indices2.size(), GL_UNSIGNED_INT, &(m_Indices2[0]) );

    {
      glDisableClientState( GL_VERTEX_ARRAY );

      if ( flags & eNormal )
	glDisableClientState( GL_NORMAL_ARRAY );

      if ( flags & eCellShading_color )
	glDisableClientState( GL_COLOR_ARRAY );

      if ( flags & eCellShading_texture1D )
	{
	  glClientActiveTexture(GL_TEXTURE1);
	  glActiveTexture(GL_TEXTURE1);
	  glDisable(GL_TEXTURE_1D);
	  glDisableClientState( GL_TEXTURE_COORD_ARRAY );
	}


      glClientActiveTexture( GL_TEXTURE0 );
      glActiveTexture(GL_TEXTURE0);

      if ( flags & eTexture )
	{
	  glDisable(GL_TEXTURE_2D);
	  glDisableClientState( GL_TEXTURE_COORD_ARRAY );
	}
    }

  }


  if ( flags & eCellShading_bound )
    {

      {
	glDisable(GL_LIGHTING);

	glEnable(GL_CULL_FACE);

	glColor3ub(0,0,0);

	{
	  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	  // glCullFace(GL_BACK);
	  glCullFace(GL_FRONT);
	}

	glDepthFunc (GL_LEQUAL);


	glLineWidth(3.0f);
      }


      glEnableClientState( GL_VERTEX_ARRAY );
      glVertexPointer( 3, GL_FLOAT, 0, &(m_Vertices[0].x) );

      glDrawElements( GL_TRIANGLES, m_Indices.size(),
      		      GL_UNSIGNED_INT, &(m_Indices[0]) );
      // glDrawElements( GL_TRIANGLES, m_Indices2.size(),
      // 		      GL_UNSIGNED_INT, &(m_Indices2[0]) );

      glDisableClientState( GL_VERTEX_ARRAY );


      {
	glLineWidth(1.0f);

	glDepthFunc(GL_LESS);
	glCullFace(GL_BACK);

	{
	  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	}

	glDisable(GL_CULL_FACE);
      }

    } // if ( flags & eCellShading_bound )


  /**
  {
    glColor3f(1,0,1);
    glPointSize(10);

    glEnableClientState( GL_VERTEX_ARRAY );
    glVertexPointer( 3, GL_FLOAT, 0, &(m_Vertices[0].x) );

    glDrawArrays( GL_POINTS, 0, m_Vertices.size() );

    glDisableClientState( GL_VERTEX_ARRAY );
  }
  //*/

  /**
  {
    m_sec_Vertices.clear();

    for (unsigned int i = 0; i < m_Vertices.size(); ++i)
      {
	m_sec_Vertices.push_back( m_Vertices[ i ] );
	m_sec_Vertices.push_back( m_Vertices[ i ] + m_Normales[ i ] );
      }

    glColor3f(1,0,1);
    // glPointSize(10);

    glEnableClientState( GL_VERTEX_ARRAY );
    glVertexPointer( 3, GL_FLOAT, 0, &(m_sec_Vertices[0].x) );

    glDrawArrays( GL_LINES, 0, m_sec_Vertices.size() );

    glDisableClientState( GL_VERTEX_ARRAY );

  }
  //*/

}
示例#19
0
文件: decal.c 项目: mbait/avpmp
void AddDecalToHModel(VECTORCH *normalPtr, VECTORCH *positionPtr, SECTION_DATA *sectionDataPtr)
{
    enum DECAL_ID decalID;
    OBJECT_DECAL *decalPtr;
    MATRIXCH orientation;
    VECTORCH v;

    int decalSize;
    int theta,sin,cos;

    if (!LocalDetailLevels.DrawHierarchicalDecals) return;

    theta = FastRandom()&4095;
    sin = GetSin(theta);
    cos = GetCos(theta);


    LOCALASSERT(sectionDataPtr->NumberOfDecals <= MAX_NO_OF_DECALS_PER_HIERARCHICAL_SECTION);
    {
        MATRIXCH mat = sectionDataPtr->SecMat;
        VECTORCH n = *normalPtr;

        TransposeMatrixCH(&mat);

        RotateVector(&n,&mat);
        MakeMatrixFromDirection(&n,&orientation);

        v = *positionPtr;
        v.vx -= sectionDataPtr->World_Offset.vx;
        v.vy -= sectionDataPtr->World_Offset.vy;
        v.vz -= sectionDataPtr->World_Offset.vz;
        RotateVector(&v,&mat);
    }


    {
        SECTION	*sectionPtr = sectionDataPtr->sempai;

        if(sectionPtr->flags&section_sprays_blood)
        {
            decalID = DECAL_HUMAN_BLOOD;
        }
        else if(sectionPtr->flags&section_sprays_predoblood)
        {
            decalID = DECAL_PREDATOR_BLOOD;
        }
        else if(sectionPtr->flags&section_sprays_acid)
        {
            decalID = DECAL_ALIEN_BLOOD;
        }
        else
        {
            decalID = DECAL_BULLETHOLE;
        }

    }

    decalPtr = &sectionDataPtr->Decals[sectionDataPtr->NextDecalToUse];

    if (sectionDataPtr->NextDecalToUse >= MAX_NO_OF_DECALS_PER_HIERARCHICAL_SECTION-1)
    {
        sectionDataPtr->NextDecalToUse = 0;
    }
    else
    {
        sectionDataPtr->NextDecalToUse++;
    }

    if (sectionDataPtr->NumberOfDecals < MAX_NO_OF_DECALS_PER_HIERARCHICAL_SECTION)
    {
        sectionDataPtr->NumberOfDecals++;
    }


    decalPtr->DecalID = decalID;
    decalSize = 40;//DecalDescription[decalID].MaxSize;

    decalPtr->Centre = v;

    decalPtr->Vertices[0].vx = MUL_FIXED(-decalSize,cos) - MUL_FIXED(-decalSize,sin);
    decalPtr->Vertices[0].vy = MUL_FIXED(-decalSize,sin) + MUL_FIXED(-decalSize,cos);
    decalPtr->Vertices[0].vz = DECAL_Z_OFFSET;
    RotateVector(&(decalPtr->Vertices[0]),&orientation);
    decalPtr->Vertices[0].vx += v.vx;
    decalPtr->Vertices[0].vy += v.vy;
    decalPtr->Vertices[0].vz += v.vz;

    decalPtr->Vertices[1].vx = MUL_FIXED(decalSize,cos) - MUL_FIXED(-decalSize,sin);
    decalPtr->Vertices[1].vy = MUL_FIXED(decalSize,sin) + MUL_FIXED(-decalSize,cos);
    decalPtr->Vertices[1].vz = DECAL_Z_OFFSET;
    RotateVector(&(decalPtr->Vertices[1]),&orientation);
    decalPtr->Vertices[1].vx += v.vx;
    decalPtr->Vertices[1].vy += v.vy;
    decalPtr->Vertices[1].vz += v.vz;

    decalPtr->Vertices[2].vx = MUL_FIXED(decalSize,cos) - MUL_FIXED(decalSize,sin);
    decalPtr->Vertices[2].vy = MUL_FIXED(decalSize,sin) + MUL_FIXED(decalSize,cos);
    decalPtr->Vertices[2].vz = DECAL_Z_OFFSET;
    RotateVector(&(decalPtr->Vertices[2]),&orientation);
    decalPtr->Vertices[2].vx += v.vx;
    decalPtr->Vertices[2].vy += v.vy;
    decalPtr->Vertices[2].vz += v.vz;

    decalPtr->Vertices[3].vx = MUL_FIXED(-decalSize,cos) - MUL_FIXED(decalSize,sin);
    decalPtr->Vertices[3].vy = MUL_FIXED(-decalSize,sin) + MUL_FIXED(decalSize,cos);
    decalPtr->Vertices[3].vz = DECAL_Z_OFFSET;
    RotateVector(&(decalPtr->Vertices[3]),&orientation);
    decalPtr->Vertices[3].vx += v.vx;
    decalPtr->Vertices[3].vy += v.vy;
    decalPtr->Vertices[3].vz += v.vz;
}
示例#20
0
文件: decal.c 项目: mbait/avpmp
void AddDecal(enum DECAL_ID decalID, VECTORCH *normalPtr, VECTORCH *positionPtr, int moduleIndex)
{
    DECAL *decalPtr;
    MATRIXCH orientation;
    int decalSize;
    int theta = FastRandom()&4095;
    int sin = GetSin(theta);
    int cos = GetCos(theta);


    MakeMatrixFromDirection(normalPtr,&orientation);

    if (decalID == DECAL_BULLETHOLE)
    {
        MakeImpactSmoke(&orientation,positionPtr);
    }

    decalPtr = AllocateDecal();

    decalPtr->DecalID = decalID;

    decalPtr->Centre = *positionPtr;

    if(DecalDescription[decalID].GrowthRate)
    {
        decalSize = ONE_FIXED;
        decalPtr->Direction[0].vx = MUL_FIXED(-decalSize,cos) - MUL_FIXED(-decalSize,sin);
        decalPtr->Direction[0].vy = MUL_FIXED(-decalSize,sin) + MUL_FIXED(-decalSize,cos);
        decalPtr->Direction[0].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Direction[0]),&orientation);
        Normalise(&(decalPtr->Direction[0]));

        decalPtr->Direction[1].vx = MUL_FIXED(decalSize,cos) - MUL_FIXED(-decalSize,sin);
        decalPtr->Direction[1].vy = MUL_FIXED(decalSize,sin) + MUL_FIXED(-decalSize,cos);
        decalPtr->Direction[1].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Direction[1]),&orientation);
        Normalise(&(decalPtr->Direction[1]));

        decalPtr->Direction[2].vx = MUL_FIXED(decalSize,cos) - MUL_FIXED(decalSize,sin);
        decalPtr->Direction[2].vy = MUL_FIXED(decalSize,sin) + MUL_FIXED(decalSize,cos);
        decalPtr->Direction[2].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Direction[2]),&orientation);
        Normalise(&(decalPtr->Direction[2]));

        decalPtr->Direction[3].vx = MUL_FIXED(-decalSize,cos) - MUL_FIXED(decalSize,sin);
        decalPtr->Direction[3].vy = MUL_FIXED(-decalSize,sin) + MUL_FIXED(decalSize,cos);
        decalPtr->Direction[3].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Direction[3]),&orientation);
        Normalise(&(decalPtr->Direction[3]));
        decalPtr->CurrentSize = DecalDescription[decalID].MinSize;
        decalPtr->TargetSize = DecalDescription[decalID].MaxSize;
        if (DecalDescription[decalID].CanCombine) decalPtr->TargetSize/=4;
    }
    else
    {
        decalSize = DecalDescription[decalID].MinSize;
        decalPtr->Vertices[0].vx = MUL_FIXED(-decalSize,cos) - MUL_FIXED(-decalSize,sin);
        decalPtr->Vertices[0].vy = MUL_FIXED(-decalSize,sin) + MUL_FIXED(-decalSize,cos);
        decalPtr->Vertices[0].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Vertices[0]),&orientation);
        decalPtr->Vertices[0].vx += positionPtr->vx;
        decalPtr->Vertices[0].vy += positionPtr->vy;
        decalPtr->Vertices[0].vz += positionPtr->vz;


        decalPtr->Vertices[1].vx = MUL_FIXED(decalSize,cos) - MUL_FIXED(-decalSize,sin);
        decalPtr->Vertices[1].vy = MUL_FIXED(decalSize,sin) + MUL_FIXED(-decalSize,cos);
        decalPtr->Vertices[1].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Vertices[1]),&orientation);
        decalPtr->Vertices[1].vx += positionPtr->vx;
        decalPtr->Vertices[1].vy += positionPtr->vy;
        decalPtr->Vertices[1].vz += positionPtr->vz;

        decalPtr->Vertices[2].vx = MUL_FIXED(decalSize,cos) - MUL_FIXED(decalSize,sin);
        decalPtr->Vertices[2].vy = MUL_FIXED(decalSize,sin) + MUL_FIXED(decalSize,cos);
        decalPtr->Vertices[2].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Vertices[2]),&orientation);
        decalPtr->Vertices[2].vx += positionPtr->vx;
        decalPtr->Vertices[2].vy += positionPtr->vy;
        decalPtr->Vertices[2].vz += positionPtr->vz;

        decalPtr->Vertices[3].vx = MUL_FIXED(-decalSize,cos) - MUL_FIXED(decalSize,sin);
        decalPtr->Vertices[3].vy = MUL_FIXED(-decalSize,sin) + MUL_FIXED(decalSize,cos);
        decalPtr->Vertices[3].vz = DECAL_Z_OFFSET;
        RotateVector(&(decalPtr->Vertices[3]),&orientation);
        decalPtr->Vertices[3].vx += positionPtr->vx;
        decalPtr->Vertices[3].vy += positionPtr->vy;
        decalPtr->Vertices[3].vz += positionPtr->vz;

    }

    decalPtr->ModuleIndex = moduleIndex;

    switch (decalID)
    {
    case DECAL_HUMAN_BLOOD:
    case DECAL_PREDATOR_BLOOD:
    case DECAL_ANDROID_BLOOD:
    {
        decalPtr->UOffset = (FastRandom()&1)*(32<<16);
        if (normalPtr->vy<-32768)
        {
            decalPtr->UOffset+=64<<16;
        }
        else
        {
            decalPtr->TargetSize = DecalDescription[decalID].MaxSize;
            decalPtr->CurrentSize = decalPtr->TargetSize-1;
        }
        break;
    }
    default:
    {
        decalPtr->UOffset = 0;
        break;
    }

    }

}
示例#21
0
//Baking
//using all rotations scales positions etc, generates the list of triangles that
//is represented by the rendered shapes.
//similar to instance baking.
//remember that this function needed to always reflect what render() does but inverted.
void B9SupportStructure::BakeToInstanceGeometry()
{
    unsigned int t;
    unsigned short int v;
    Triangle3D* pNewTri;
    QVector3D topScale;
    QVector3D topPos;
    QVector3D midScale;
    QVector3D midPos;
    QVector3D bottomScale;
    QVector3D bottomPos;


    //first bake the top
    topScale = QVector3D(topRadius*2.0,topRadius*2.0,topLength + topPenetration);
    topPos = QVector3D((topPenetrationPoint.x() + topPivot.x())*0.5
                          ,(topPenetrationPoint.y() + topPivot.y())*0.5
                          ,(topPenetrationPoint.z() + topPivot.z())*0.5);
    if(topAttachShape != NULL)
    for(t = 0; t < topAttachShape->GetTriangles()->size(); t++)
    {
        pNewTri = new Triangle3D(topAttachShape->GetTriangles()->at(t));


        for(v=0;v<3;v++)
        {
            //scale triangle vertices 1st
            pNewTri->vertex[v] *= topScale;

            //Rotate 2nd
            //dont deal with y - not needed in rendering or baking
            RotateVector(pNewTri->vertex[v], topThetaX, QVector3D(1,0,0));//x
            RotateVector(pNewTri->vertex[v], topThetaZ, QVector3D(0,0,1));//z

            //Translate 3rd into global space
            pNewTri->vertex[v] += topPos;
            pNewTri->vertex[v] += instanceParent->GetPos();
        }

        //Update the triangle bounds and normal
        pNewTri->UpdateBounds();
        pNewTri->UpdateNormalFromGeom();

        //Add To List
        instanceParent->triList.push_back(pNewTri);
    }

    //second bake the middle
    midScale = QVector3D(midRadius*2.0,midRadius*2.0,midLength);
    midPos = QVector3D((topMidExtensionPoint.x() + bottomMidExtensionPoint.x())*0.5
                      ,(topMidExtensionPoint.y() + bottomMidExtensionPoint.y())*0.5
                      ,(topMidExtensionPoint.z() + bottomMidExtensionPoint.z())*0.5);

    if(midAttachShape != NULL)
    for(t = 0; t < midAttachShape->GetTriangles()->size(); t++)
    {
        pNewTri = new Triangle3D(midAttachShape->GetTriangles()->at(t));



        for(v=0;v<3;v++)
        {
            //scale triangle vertices 1st
            pNewTri->vertex[v] *= midScale;

            //Rotate 2nd
            //dont deal with y - not needed in rendering or baking
            RotateVector(pNewTri->vertex[v], midThetaX, QVector3D(1,0,0));//x
            RotateVector(pNewTri->vertex[v], midThetaZ, QVector3D(0,0,1));//z

            //Translate 3rd into global space
            pNewTri->vertex[v] += midPos;
            pNewTri->vertex[v] += instanceParent->GetPos();
        }

        //Update the triangle bounds and normal
        pNewTri->UpdateBounds();
        pNewTri->UpdateNormalFromGeom();

        //Add To List
        instanceParent->triList.push_back(pNewTri);
    }

    //third bake the bottom
    bottomScale = QVector3D(bottomRadius*2.0,bottomRadius*2.0,bottomLength + bottomPenetration);
    bottomPos = QVector3D((bottomPenetrationPoint.x() + bottomPivot.x())*0.5
                          ,(bottomPenetrationPoint.y() + bottomPivot.y())*0.5
                          ,(bottomPenetrationPoint.z() + bottomPivot.z())*0.5);

    if(bottomAttachShape != NULL)
    for(t = 0; t < bottomAttachShape->GetTriangles()->size(); t++)
    {
        pNewTri = new Triangle3D(bottomAttachShape->GetTriangles()->at(t));



        for(v=0;v<3;v++)
        {
            //scale triangle vertices 1st
            pNewTri->vertex[v] *= bottomScale;

            //Rotate 2nd
            //dont deal with y - not needed in rendering or baking
            RotateVector(pNewTri->vertex[v], bottomThetaX+180, QVector3D(1,0,0));//x
            RotateVector(pNewTri->vertex[v], bottomThetaZ, QVector3D(0,0,1));//z

            //Translate 3rd into global space
            pNewTri->vertex[v] += bottomPos;
            pNewTri->vertex[v] += instanceParent->GetPos();
        }

        //Update the triangle bounds and normal
        pNewTri->UpdateBounds();
        pNewTri->UpdateNormalFromGeom();

        //Add To List
        instanceParent->triList.push_back(pNewTri);
    }

}
VOID CDrawingObject::Translate(FLOAT fdx, FLOAT fdy, BOOL bInertia)
{
    m_fdX = fdx;
    m_fdY = fdy;

    FLOAT fOffset[2];
    fOffset[0] = m_fOX - m_fdX;
    fOffset[1] = m_fOY - m_fdY;

    // Translate based on the offset caused by rotating 
    // and scaling in order to vary rotational behavior depending 
    // on where the manipulation started
    
    if(m_fAngleApplied != 0.0f)
    {
        FLOAT v1[2];
        v1[0] = GetCenterX() - fOffset[0];
        v1[1] = GetCenterY() - fOffset[1];

        FLOAT v2[2];
        RotateVector(v1, v2, m_fAngleApplied);

        m_fdX += v2[0] - v1[0];
        m_fdY += v2[1] - v1[1];
    }

    if(m_fFactor != 1.0f)
    {
        FLOAT v1[2];
        v1[0] = GetCenterX() - fOffset[0];
        v1[1] = GetCenterY() - fOffset[1];

        FLOAT v2[2];
        v2[0] = v1[0] * m_fFactor;
        v2[1] = v1[1] * m_fFactor;
        
        m_fdX += v2[0] - v1[0];
        m_fdY += v2[1] - v1[1];
    }

    m_fXI += m_fdX;
    m_fYI += m_fdY;

    // The following code handles the effect for 
    // bouncing off the edge of the screen.  It takes
    // the x,y coordinates computed by the inertia processor
    // and calculates the appropriate render coordinates
    // in order to achieve the effect.

    if (bInertia)
    {
        ComputeElasticPoint(m_fXI, &m_fXR, m_iBorderX);
        ComputeElasticPoint(m_fYI, &m_fYR, m_iBorderY);
    }
    else
    {
        m_fXR = m_fXI;
        m_fYR = m_fYI;

        // Make sure it stays on screen
        EnsureVisible();
    }
}
示例#23
0
BOOL CShockWaveEffect::Process(FLOAT time)
{
	FLOAT fDeltaTime, fProcessedTime;
	BOOL bRet, bRender;
	if(!PreProcess(time, bRet, bRender, fDeltaTime, fProcessedTime))
	{
		if(!bRender) SetNotRenderAtThisFrame();
		return bRet;
	}

	//color 정보
	FLOAT fadeVal = this->GetFadeValue(fProcessedTime);
	if(fadeVal == 1.0f && m_bColorWhite)
	{
		//nothing
	}
	else
	{
		m_vectorGFXColor.clear();
		m_vectorGFXColor.reserve(m_iSplitCount*2);
		UBYTE ubColElement = UBYTE(255.0f * fadeVal);
		GFXColor col;
		if( m_eBlendType == PBT_BLEND || m_eBlendType == PBT_ADDALPHA )
		{
			col = 0xFFFFFF00 | ubColElement; //fade by alpha
		}
		else if( m_eBlendType == PBT_ADD )
		{
			col = (ubColElement << 24) | (ubColElement << 16) | (ubColElement << 8) | 0x000000FF; //fade by color
		}
		else col = 0xFFFFFFFF;	//fade 의미 없음.
		for(INDEX i=0; i<m_iSplitCount; ++i)
		{
			m_vectorGFXColor.push_back(col);
			m_vectorGFXColor.push_back(col);
		}
	}

	//wave 정보
	m_ssHeight.Prepare();
	FLOAT3D height(0, m_ssHeight.Value(fProcessedTime), 0);
	FLOAT radiusInner = 0, radiusOuter = 0;
	m_ssRadius.Prepare();
	m_ssWidth.Prepare();
	if(m_bInnerBasis)
	{
		radiusInner = m_ssRadius.Value(fProcessedTime);
		radiusOuter = radiusInner + m_ssWidth.Value(fProcessedTime);
	}
	else
	{
		radiusOuter = m_ssRadius.Value(fProcessedTime);
		radiusInner = radiusOuter - m_ssWidth.Value(fProcessedTime);
	}

	//tag의 정보
	if(m_ePosition == EOTT_ALWAYS) m_vTagPos = m_ptrAttachTag->CurrentTagInfo().m_vPos;
	if(m_eRotation == EOTT_ALWAYS) m_qTagRot = m_ptrAttachTag->CurrentTagInfo().m_qRot;

	//gfx vertex fill, every frame
	GFXVertex vtx;
	FLOAT3D pos;
	const FLOAT angleUnit = 2 * PI / m_iSplitCount;
	FLOAT angle = 0;
	INDEX index = 0;
	m_vectorGFXVertex.clear();
	m_vectorGFXColor.reserve(m_iSplitCount*2);
	for(INDEX i=0; i<m_iSplitCount; ++i)
	{
		index = 2*i+0;
		pos = m_vectorMoveVector[index] * radiusOuter + height;
		RotateVector(pos, m_qTagRot);
		pos += m_vTagPos;
		vtx.x = pos(1);	vtx.y = pos(2);	vtx.z = pos(3);
		m_vectorGFXVertex.push_back(vtx);

		++index;
		pos = m_vectorMoveVector[index] * radiusInner;
		RotateVector(pos, m_qTagRot);
		pos += m_vTagPos;
		vtx.x = pos(1);	vtx.y = pos(2);	vtx.z = pos(3);
		m_vectorGFXVertex.push_back(vtx);
		angle += angleUnit;
	}

	PostProcess();
	return TRUE;
}
示例#24
0
/* The main drawing function. */
void DrawGLScene()
{
  int i, j;                         // Looping Variables
  float TmpShade;                       // Temporary Shader Value
  MATRIX TmpMatrix;                     // Temporary MATRIX Structure
  VECTOR TmpVector, TmpNormal;                // Temporary VECTOR Structures

  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // Clear The Buffers
  glLoadIdentity ();                      // Reset The Matrix

  // Check To See If We Want Anti-Aliased Lines
  if (outlineSmooth) {
    glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);        // Use The Good Calculations
    glEnable (GL_LINE_SMOOTH);                // Enable Anti-Aliasing
  } else {
    // We Don't Want Smooth Lines
    // Disable Anti-Aliasing
    glDisable (GL_LINE_SMOOTH);
  }

  // Move 2 Units Away From The Screen
  glTranslatef (0.0f, 0.0f, -2.0f);

  // Rotate The Model On It's Y-Axis
  glRotatef (modelAngle, 0.0f, 1.0f, 0.0f);

  InitGL(800, 600);

  // Get The Generated Matrix
  glGetFloatv(GL_MODELVIEW_MATRIX, TmpMatrix.Data);

  // Cel-Shading Code //
  // Enable 1D Texturing
  glDisable (GL_TEXTURE_3D);
  glDisable (GL_TEXTURE_2D);
  glEnable (GL_TEXTURE_1D);

  // Bind to current texture
  glBindTexture (GL_TEXTURE_1D, shaderTexture[0]);

  // Set colour of model
  glColor3f (0.0, 0.0, 0.0);

  glBegin (GL_TRIANGLES);
    for (i = 0; i < polyNum; i++) {
      for (j = 0; j < 3; j++) {
        TmpNormal.X = polyData[i].Verts[j].Nor.X;   // Fill Up The TmpNormal Structure With
        TmpNormal.Y = polyData[i].Verts[j].Nor.Y;   // The Current Vertices' Normal Values
        TmpNormal.Z = polyData[i].Verts[j].Nor.Z;

        RotateVector (TmpMatrix, TmpNormal, TmpVector); // Rotate This By The Matrix
        Normalize (TmpVector);              // Normalize The New Normal
        TmpShade = DotProduct (TmpVector, lightAngle);  // Calculate The Shade Value

        if (TmpShade < 0.0f)
          TmpShade = 0.0f;              // Clamp The Value to 0 If Negative

        glTexCoord1f (TmpShade);            // Set The Texture Co-ordinate As The Shade Value
        glVertex3fv(&polyData[i].Verts[j].Pos.X);    // Send The Vertex Position
      }
    }
  glEnd();

  glDisable (GL_TEXTURE_1D);                  // Disable 1D Textures

  // Outline Code //
  // Check To See If We Want To Draw The Outline
  if (outlineDraw) {
    glEnable (GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glPolygonMode (GL_BACK, GL_LINE);           // Draw Backfacing Polygons As Wireframes
    glLineWidth (outlineWidth);               // Set The Line Width
    glCullFace (GL_FRONT);                  // Don't Draw Any Front-Facing Polygons
    glDepthFunc (GL_LEQUAL);                // Change The Depth Mode
    glColor3fv (&outlineColor[0]);              // Set The Outline Color

    glBegin (GL_TRIANGLES);
      for (i = 0; i < polyNum; i++) {
        for (j = 0; j < 3; j++) {
          glVertex3fv (&polyData[i].Verts[j].Pos.X);  // Send The Vertex Position
        }
      }
    glEnd();

    glDepthFunc (GL_LESS);                  // Reset The Depth-Testing Mode
    glCullFace (GL_BACK);                 // Reset The Face To Be Culled
    glPolygonMode (GL_BACK, GL_FILL);           // Reset Back-Facing Polygon Drawing Mode
    glDisable (GL_BLEND);                 // Disable Blending
  }

  // since this is double buffered, swap the buffers to display what just got drawn.
  //glutSwapBuffers();

  // Check To See If Rotation Is Enabled
  if (modelRotate) {
    modelAngle += 2.0f;
  }
}
示例#25
0
文件: Body.cpp 项目: TurkeyXIII/PA
void	CBody::AdjustPitch(float radianAngle)
{
	D3DXVECTOR3 right = RotateVector(D3DXVECTOR3(1.0f, 0.0f, 0.0f));
	AdjustAxisAngle(right, radianAngle);
}
示例#26
0
dVector dMatrix::TransformVector (const dVector & v) const
{
   return m_posit + RotateVector (v);
}
示例#27
0
GLvoid NEHE37::DrawGLScene(){
	
	float TmpShade;
	MATRIX37 TmpMatrix;
	VECTOR37 TmpVector, TmpNormal;
	
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	
	// Check To See If We Want Anti-Aliased Lines
	if(outlineSmooth){
		glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
		glEnable (GL_LINE_SMOOTH);
	}
	else{
		glDisable (GL_LINE_SMOOTH);
	}
	
	glTranslatef (0.0f, 0.0f, -2.0f);
	glRotatef (modelAngle, 0.0f, 1.0f, 0.0f);
	
	glGetFloatv (GL_MODELVIEW_MATRIX, TmpMatrix.Data);
	
	// Cel-Shading Code
	glEnable (GL_TEXTURE_1D);
	glBindTexture (GL_TEXTURE_1D, shaderTexture[0]);
	
	glColor3f (1.0f, 1.0f, 1.0f);
	
	glBegin (GL_TRIANGLES);
	
    for (int i = 0; i < polyNum; i++){
        for (int j = 0; j < 3; j++){
            TmpNormal.X = polyData[i].Verts[j].Nor.X;
            TmpNormal.Y = polyData[i].Verts[j].Nor.Y;
            TmpNormal.Z = polyData[i].Verts[j].Nor.Z;
			RotateVector (TmpMatrix, TmpNormal, TmpVector);
			Normalize (TmpVector);
			TmpShade = DotProduct (TmpVector, lightAngle);
			if (TmpShade < 0.0f)
				TmpShade = 0.0f;
			glTexCoord1f (TmpShade);
            glVertex3fv (&polyData[i].Verts[j].Pos.X);
        }
    }
	
	glEnd ();
	glDisable (GL_TEXTURE_1D);
	
	
	// Outline Code
	if (outlineDraw){
		glEnable (GL_BLEND);
		glBlendFunc (GL_SRC_ALPHA ,GL_ONE_MINUS_SRC_ALPHA);
		
		glPolygonMode (GL_BACK, GL_LINE);
		glLineWidth (outlineWidth);
		
		glCullFace (GL_FRONT);
		
		glDepthFunc (GL_LEQUAL);
		
		glColor3fv (&outlineColor[0]);
		
		glBegin (GL_TRIANGLES);
		
        for (int i = 0; i < polyNum; i++){
            for (int j = 0; j < 3; j++){
                glVertex3fv (&polyData[i].Verts[j].Pos.X);
            }
        }
		
		glEnd ();
		glDepthFunc (GL_LESS);
        glCullFace (GL_BACK);
        glPolygonMode (GL_BACK, GL_FILL);
		
        glDisable (GL_BLEND);
    }
	
	/*
	//draw FPS text
	glDisable(GL_TEXTURE_2D);
	glLoadIdentity ();
	glTranslatef(0.0f,0.0f,-1.0f);
	glColor3f(0.8f,0.8f,0.8f);//set text color
	computeFPS();
	Utils::drawText(-0.54f,-0.4f, GLUT_BITMAP_HELVETICA_12, FPSstr);
	glEnable(GL_TEXTURE_2D);
	*/
	 
	glutSwapBuffers();
	
	//handle key input
    if(specialKeys[GLUT_KEY_DOWN]){
		outlineWidth--;
        specialKeys[GLUT_KEY_DOWN] = FALSE;
	}
    if(specialKeys[GLUT_KEY_UP]){
		outlineWidth++;
        specialKeys[GLUT_KEY_UP] = FALSE;
	}
	
    if(keys[' ']){
		modelRotate = !modelRotate;	// Toggle Model Rotation On/Off
        keys[' '] = false;
	}
    if(keys['1']){
		outlineDraw = !outlineDraw;	// Toggle Outline Drawing On/Off
        keys['1'] = false;
	}
	
	if(keys['2']){
		outlineSmooth = !outlineSmooth;	// Toggle Anti-Aliasing On/Off
        keys['2'] = false;
	}
	
	if (modelRotate)
        modelAngle += 1.0f;
	
}
示例#28
0
/* cambia angolo di ROLL (rollio) */
void Camera::roll(GLfloat angle) 
{  
	up = Normalize(RotateVector(angle,view,up));

}
示例#29
0
void RubiksCube::Grab(VECTOR touchVector)
{
	tvf32[0]+=floattof32(touchVector.X);
	tvf32[1]+=floattof32(touchVector.Y);
	tvf32[2]=0;
	if(f32toint(sqrtf32(mulf32(tvf32[0],tvf32[0])+mulf32(tvf32[1],tvf32[1])+mulf32(tvf32[2],tvf32[2])))>5)
	{
		VECTOR upv, rightv, rotduv, rotdrv;
		int32 uvf32[3];//up vector as f32
		int32 rvf32[3];//right vector
		int32 magup, magright;
		m4x4 grabMatrix;//container for the Position Matrix

		vectorFromSide(upv, rightv, clicked[0]);
		//printf ("Initial Vector:\n %f, ", tmpv.X);
		//printf("%f, ", tmpv.Y);
		//printf("%f\n", tmpv.Z);
		glGetFixed(GL_GET_MATRIX_POSITION, (int32*)&grabMatrix);
		glMatrixMode(GL_MODELVIEW);
		//rotate the up vector thru the projection matrix
		//and cast it to f32
		RotateVector(grabMatrix, upv, rotduv);
		uvf32[0]=floattof32(rotduv.X);
		uvf32[1]=floattof32(rotduv.Y);
		uvf32[2]=floattof32(rotduv.Z);
		//rinse and repeat with the right vector
		RotateVector(grabMatrix, rightv, rotdrv);
		rvf32[0]=floattof32(rotdrv.X);
		rvf32[1]=floattof32(rotdrv.Y);
		rvf32[2]=floattof32(rotdrv.Z);

		if(controlStyle)
		{
			int32 suvf32[3];
			int32 srvf32[3];
			suvf32[0]=0;
			suvf32[1]=inttof32(1);
			suvf32[2]=0;
			srvf32[0]=inttof32(1);
			srvf32[1]=0;
			srvf32[2]=0;

			magup=dotf32(uvf32, suvf32);
			magright=dotf32(uvf32, srvf32);
			if(abs(magup)>abs(magright))
			{
				for(int i=0; i<3; i++)
				{
					if(magup>0)
					{
						rvf32[i]=srvf32[i];
						uvf32[i]=suvf32[i];
					}
					else
					{
						rvf32[i]=-srvf32[i];
						uvf32[i]=-suvf32[i];
					}
				}
			} else {
				for(int i=0; i<3; i++)
				{
					if(magright>0)
					{
						uvf32[i]=srvf32[i];
						rvf32[i]=-suvf32[i];
					}
					else
					{
						uvf32[i]=-srvf32[i];
						rvf32[i]=suvf32[i];
					}
				}
			}

		}
		
		magup=dotf32(uvf32, tvf32);
		magright=dotf32(rvf32, tvf32);
		
		if(magup || magright)
		{
			int32 tmp[2];
			if(abs(magup)>abs(magright))
			{
				tmp[0]=uvf32[0];
				tmp[1]=uvf32[1];
				unitVector((int32*)tmp);
				InitTwist(true, tmp);
			}else{
				tmp[0]=rvf32[0];
				tmp[1]=rvf32[1];
				unitVector((int32*)tmp);
				InitTwist(false, tmp);
			}
			Twisting=true;
			Grabbing=false;
			tvf32[0]=0;
			tvf32[1]=0;
		}
	}
}
double * IntegratorMulti1D::Getqaccel()
{
  RotateVector(Q, zaccel, qaccel);
  return qaccel;
}