.Map :: MoHAA Mapping

Code: Select all

/*
===============
RotatePointAroundVector

This is not implemented very well...
===============
*/
void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point,
							 float degrees ) {
	float	m[3][3];
	float	im[3][3];
	float	zrot[3][3];
	float	tmpmat[3][3];
	float	rot[3][3];
	int	i;
	vec3_t vr, vup, vf;
	float	rad;

	vf[0] = dir[0];
	vf[1] = dir[1];
	vf[2] = dir[2];

	PerpendicularVector( vr, dir );
	CrossProduct( vr, vf, vup );

	m[0][0] = vr[0];
	m[1][0] = vr[1];
	m[2][0] = vr[2];

	m[0][1] = vup[0];
	m[1][1] = vup[1];
	m[2][1] = vup[2];

	m[0][2] = vf[0];
	m[1][2] = vf[1];
	m[2][2] = vf[2];

	memcpy( im, m, sizeof( im ) );

	im[0][1] = m[1][0];
	im[0][2] = m[2][0];
	im[1][0] = m[0][1];
	im[1][2] = m[2][1];
	im[2][0] = m[0][2];
	im[2][1] = m[1][2];

	memset( zrot, 0, sizeof( zrot ) );
	zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;

	rad = DEG2RAD( degrees );
	zrot[0][0] = cos( rad );
	zrot[0][1] = sin( rad );
	zrot[1][0] = -sin( rad );
	zrot[1][1] = cos( rad );

	MatrixMultiply( m, zrot, tmpmat );
	MatrixMultiply( tmpmat, im, rot );

	for ( i = 0; i < 3; i++ ) {
		dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];
	}
}

Code: Select all

public Transform(float x, float y, float z)
{
      this.cosX = Math.cos(x);
      this.cosY = Math.cos(y); // Math.cos gets the cosine of the var.
      this.cosZ = Math.cos(z);

      //... same for Sine values
}

Code: Select all

    
    // where it all starts
    public void addRotation(Transform t)
    {
        rotateX(t.getCosX(), t.getSinX());
        rotateZ(t.getCosZ(), t.getSinZ());
        rotateY(t.getCosY(), t.getSinY());
    }

    // GET ANGLES
    public float getAngleX()
    {return ((float)Math.atan2(sinX, cosX));}
    
    public float getAngleY()
    {return ((float)Math.atan2(sinY, cosY));}
    
    public float getAngleZ()
    {return ((float)Math.atan2(sinZ, cosZ));}
    

    // SET ANGLES
    public void setAngleX(float angleX)
    {
        cosX = (float)Math.cos(angleX);
        sinX = (float)Math.sin(angleX);
    }
    
    public void setAngleY(float angleY)
    {
        cosY = (float)Math.cos(angleY);
        sinY = (float)Math.sin(angleY);
    }
    
    public void setAngleZ(float angleZ)
    {
        cosZ = (float)Math.cos(angleZ);
        sinZ = (float)Math.sin(angleZ);
    }

    
    // ROTATE AXIS    
    public void rotateX(float cos, float sin)
    {// rotate this vector around the X AXIS
           
        y = y*cos - z*sin;
        z = y*sin + z*cos;
    }
    
    public void rotateY(float cos, float sin)
    {
        x = z*sin + x*cos;
        z = z*cos - x*sin;
    }
    
    public void rotateZ(float cos, float sin)
    {
        x = x*cos - y*sin;
        y = x*sin + y*cos;
    }
    
    

    public void rotateAngle(float angleX, float angleY, float angleZ)
    {
        rotateX(angleX);
        rotateY(angleY);
        rotateZ(angleZ);
    }

Code: Select all

void RotatePointAroundVectorByAngles(vec3_t dst, vec3_t point, vec3_t angles, vec3_t centre) {
	vec3_t axis;
	// absolute -> relative
	if (centre)
		VectorSubtract(point, centre, dst);
	// pitch
	axis[0] = 1.f;
	axis[1] = axis[2] = 0.f;
	RotatePointAroundVector(dst, axis, dst, angles[0]);
	// yaw
	axis[0] = axis[1] = 0.f;
	axis[2] = 1.f;
	RotatePointAroundVector(dst, axis, dst, angles[1]);
	// roll
	axis[0] = axis[2] = 0.f;
	axis[1] = 1.f;
	RotatePointAroundVector(dst, axis, dst, angles[2]);
	// relative -> absolute
	if (centre)
		VectorAdd(dst, centre, dst);
}