C++ DEG_TO_RAD函数代码示例

static gfloat
left_end (gfloat   from,
          gfloat   to,
          gboolean cl)
{
  gfloat alpha  = DEG_TO_RAD (from);
  gfloat beta   = DEG_TO_RAD (to);
  gint   cw_ccw = cl ? -1 : 1;

  switch (cw_ccw)
    {
    case -1:
      if (alpha < beta)
        return alpha + TWO_PI;

    default:
      return alpha; /* 1 */
    }
}

void CCamera::ProcessVectorTrackLinear(float time)
{
    m_processedVectorTrackLinear = true;
    float weight = time;
    if (m_vectorTrackLinearConstSpeed)
    {
        weight = (sin(DEG_TO_RAD(270.0f - time * 180.0f)) + 1.0f) / 2.0f;
    }
    m_vectorTrackLinearCurrent = Lerp(m_vectorTrackLinearStart, weight, m_vectorTrackLinearEnd);
}

void
sg_camera_rotate_hat(int buttonVal, void *data)
{
  //log_info("hat pushed %d", buttonVal);
  sg_scene_t *sc = sim_get_scene();
  sg_camera_t *cam = sg_scene_get_cam(sc);

  ASSERT_CAM(cam);

  // Note that the camera control will rotate the camera based on WCT.
  // This differ from the normal rotation of objects which is based on SRT.
  // The interpolation doesn't really care, it just expresses time as a
  // normalized value where 0 is the time of the last physics system sync
  // and 1.0 is the expected time of the next sync.
  // We thus need to take the frequency (not the SRT period) here.
  float wct_freq;
  config_get_float_def("openorbit/sim/freq", &wct_freq, 20.0); // Hz

  if ((cam->src == cam->tgt) && cam->src) {
    // We are targeting our follow object this means orbiting it
    if (buttonVal == -1) {
      cam->dq = QD_IDENT;
    } else {
      cam->dq = qd_rot(0.0,
                       cosf(DEG_TO_RAD(buttonVal)),
                       sinf(DEG_TO_RAD(buttonVal)),
                       M_PI_2 / wct_freq);
    }
    cam->q1 = qd_mul(cam->q0, cam->dq);
  } else {
    if (buttonVal == -1) {
      cam->dq = QD_IDENT;
    } else {
      cam->dq = qd_rot(0.0,
                       cosf(DEG_TO_RAD(buttonVal)),
                       sinf(DEG_TO_RAD(buttonVal)),
                       M_PI_2 / wct_freq);
    }
    cam->q1 = qd_mul(cam->q0, cam->dq);
  }

  ASSERT_CAM(cam);
}

OOellipse* ooGeoEllipseAreaSeg(size_t segs, float semiMajor, float semiMinor)
{
    OOellipse *e = smalloc(sizeof(OOellipse));
    ooVecArrayInit(&e->vec);
    //uint64_t totalIterations = 0;
    e->semiMajor = semiMajor;
    e->semiMinor = semiMinor;
    e->ecc = ooGeoEllipseEcc(e);

    double area = ooGeoEllipseArea(e);

    double sweep = area / (double)segs;

    ooVecArrayPushC(&e->vec,
                    semiMajor * cos(0.0) - e->ecc * semiMajor, semiMinor * sin(0.0), 0.0f, 0.0f);
    double segArea, tol;
    double prevAngle = 0.0f;
    double newAngle = prevAngle + 1.0*DEG_TO_RAD(360.0/(double)segs);
    double delta;

    for (size_t i = 1 ; i < segs ; i ++) {
        int count = 0;
        segArea = ooGeoEllipseSegmentArea(e, prevAngle, newAngle);
        delta = (newAngle-prevAngle);
        do {
            if (segArea > sweep) {
                delta -= delta/STEPSIZE;
            } else {
                delta += delta/STEPSIZE;
            }
            newAngle = prevAngle + delta;
            segArea = ooGeoEllipseSegmentArea(e, prevAngle, newAngle);
            tol = fabs(1.0 - segArea/sweep);
            count ++;
        } while (tol > 0.00001 && count < ITERSTOP);

        if (count >= ITERSTOP) {
            log_warn("ellipse segment did not converge in %d iterations", ITERSTOP);
        }
        //segArea = segmentArea(prevAngle, newAngle, semimajor, ecc);

        // Insert vec in array, note that center is in foci
        ooVecArrayPushC(&e->vec,
                        semiMajor * cos(newAngle) - e->ecc * semiMajor,
                        semiMinor * sin(newAngle),
                        0.0f, 0.0f);


        double nextNewAngle = newAngle + (newAngle-prevAngle);
        prevAngle = newAngle;
        newAngle = nextNewAngle;
    }

    return e;
}

static void entityWait()
{
	self->thinkTime += 2;

	if (self->thinkTime >= 360)
	{
		self->thinkTime = 0;
	}

	self->y = self->startY + sin(DEG_TO_RAD(self->thinkTime)) * 16;
}

static void swing()
{
	self->thinkTime += 2;

	if (self->thinkTime >= 360)
	{
		self->thinkTime = 0;
	}

	self->x = self->endX + sin(DEG_TO_RAD(self->thinkTime)) * 8;
}

static void shudder()
{
	self->startY += 90;

	self->x = self->startX + sin(DEG_TO_RAD(self->startY)) * 4;

	if (self->startY >= 360)
	{
		self->startY = 0;
	}
}

// Returns the distance (in meters) to the current waypoint
static float calc_dist_to_waypoint(float lat_1, float long_1, float lat_2, float long_2) {
  float lat_1_rad = DEG_TO_RAD(lat_1);
  float long_1_rad = DEG_TO_RAD(long_1);
  float lat_2_rad = DEG_TO_RAD(lat_2);
  float long_2_rad = DEG_TO_RAD(long_2);

  float diff_lat = lat_2_rad - lat_1_rad;
  float diff_long = long_2_rad - long_1_rad;

  float a = ( pow(sin(diff_lat / 2), 2) ) +
    cos(lat_1_rad) *
    cos(lat_2_rad) *
    ( pow(sin(diff_long / 2), 2) );

  float c = 2 * asin(sqrt(a));

  float distance_m = EARTH_RADIUS_M * c;

  return distance_m;
}

static void hover()
{
	self->endX++;

	if (self->endX >= 360)
	{
		self->endX = 0;
	}

	self->y = self->endY + sin(DEG_TO_RAD(self->endX)) * 8;
}

static void hover()
{
	self->endX += 4;

	if (self->endX >= 360)
	{
		self->endX = 0;
	}

	self->y = self->startY + sin(DEG_TO_RAD(self->endX)) * 4;
}

static void hover()
{
	self->startX++;

	if (self->startX >= 360)
	{
		self->startX = 0;
	}

	self->y = self->startY + sin(DEG_TO_RAD(self->startX)) * 8;
}

/**
 * snaps a vector to the nearest angle that is a multiple of snapAngle
 *
 * @param vector the Vector to be modified
 */
Vector3& angle( Vector3& vector, float snapAngle )
{
    float pitch;
	float yaw;

    bool flipYaw;

    if (vector.x != 0.f)
    {
        yaw = atanf( vector.z / vector.x );
        flipYaw = ( vector.x < 0 );
    }
    else
    {
        yaw = MATH_PI / 2;
        flipYaw = ( vector.z < 0 );
    }

    pitch = acosf( Math::clamp(-1.0f, vector.y, +1.0f) );

    //snap the angles
    yaw	    = value( yaw, DEG_TO_RAD( snapAngle ) );
    //snap the angle
    pitch	= value( pitch, DEG_TO_RAD( snapAngle ) );

    //mirror octants
   	if ( flipYaw )
    	yaw = yaw - MATH_PI;

    //recalc the orientation
    float cosYaw = cosf( yaw );
    float sinYaw = sinf( yaw );
    float cosPitch = cosf( pitch );
    float sinPitch = sinf( pitch );

    vector.set( cosYaw * sinPitch, cosPitch, sinYaw * sinPitch );

    vector.normalise();

	return vector;
}

Quaternion Quaternion::rotationQuaternion(GLfloat angle, vec3_t<GLfloat> axis)
{
    Quaternion q;
    GLfloat radians = DEG_TO_RAD(angle);
    GLfloat angBy2 = radians / 2.f;
    q.w = cosf(angBy2);
    q.x = axis.x * sinf(angBy2);
    q.y = axis.y * sinf(angBy2);
    q.z = axis.z * sinf(angBy2);

    return q;
}

// --[  Method  ]---------------------------------------------------------------
//
//  - Class     : CMatrix
//
//  - prototype : BuildRotation(float fAngle, float fAxisX, float fAxisY, float fAxisZ)
//
//  - Purpose   : Builds a rotation matrix of fAngle degrees around the axis
//                given by (fAxisX, fAxisY, fAxisZ).
//
// -----------------------------------------------------------------------------
void CMatrix::BuildRotation(float fAngle, float fAxisX, float fAxisY, float fAxisZ)
{
	CVector3 axis(fAxisX, fAxisY, fAxisZ);
	axis.Normalize();

	float fRad  = DEG_TO_RAD(fAngle * 0.5f);
	float fSine = sinf(fRad);

	CQuaternion quat(cosf(fRad), fSine * fAxisX, fSine * fAxisY, fSine * fAxisZ);

	*this = quat.Matrix();
}

Rect_V polar_to_rect(Polar_V pv)
{
   #define PI (4.0*atan(1))
   #define DEG_TO_RAD(X) ((X)*(PI/180.0))
   Rect_V rv;
   register double A = DEG_TO_RAD(pv.angle);
   
   rv.x = pv.magnitude*cos(A);
   rv.y = pv.magnitude*sin(A);

   return rv;   
}