コード例 #1
0
ファイル: Light.cpp プロジェクト: MigrenusMaximus/pixelcity
void CLight::Render ()
{

    int       angle;
    GLvector  pos;
    GLvector  camera;
    GLvector  camera_position;
    GLvector2 offset;

    if (!Visible (_cell_x, _cell_z))
        return;
    camera = CameraAngle ();
    camera_position = CameraPosition ();
    if (fabs (camera_position.x - _position.x) > RenderFogDistance ())
        return;
    if (fabs (camera_position.z - _position.z) > RenderFogDistance ())
        return;
    if (_blink && (GetTickCount () % _blink_interval) > 200)
        return;
    angle = (int)MathAngle (camera.y);
    offset = angles[_size][angle];
    pos = _position;
    glColor4fv (&_color.red);
    glTexCoord2f (0, 0);
    glVertex3f (pos.x + offset.x, pos.y - _vert_size, pos.z + offset.y);
    glTexCoord2f (0, 1);
    glVertex3f (pos.x - offset.x, pos.y - _vert_size, pos.z - offset.y);
    glTexCoord2f (1, 1);
    glVertex3f (pos.x - offset.x, pos.y + _vert_size, pos.z - offset.y);
    glTexCoord2f (1, 0);
    glVertex3f (pos.x + offset.x, pos.y + _vert_size, pos.z + offset.y);

}
コード例 #2
0
ファイル: Car.cpp プロジェクト: elcerdo/pixelcity
void CCar::Render ()
{

  GLvector  pos;
  int       angle;
  int       turn;

  if (!m_ready)
    return;
  if (!Visible (m_drive_position))
    return;
  if (m_front)
    glColor3f (1, 1, 0.8f);
  else
    glColor3f (1, 0.2f, 0);

  glBegin (GL_QUADS);

  angle = dangles[m_direction];
  pos = m_drive_position;// 
  angle = 360 - (int)MathAngle (m_position.x, m_position.z, pos.x, pos.z);
  angle %= 360;
  turn = (int)MathAngleDifference ((float)m_drive_angle, (float)angle);
  m_drive_angle += SIGN (turn);
  pos += glVector (0.5f, 0.0f, 0.5f);
  

  glTexCoord2f (0, 0);   
  glVertex3f (pos.x + angles[angle].x, -CAR_SIZE, pos.z + angles[angle].y);
  glTexCoord2f (1, 0);   
  glVertex3f (pos.x - angles[angle].x, -CAR_SIZE, pos.z - angles[angle].y);
  glTexCoord2f (1, 1);   
  glVertex3f (pos.x - angles[angle].x,  CAR_SIZE, pos.z - angles[angle].y);
  glTexCoord2f (0, 1);   
  glVertex3f (pos.x + angles[angle].x,  CAR_SIZE, pos.z +  angles[angle].y);


  /*
  glVertex3f (m_position.x, m_position.y, m_position.z);
  glVertex3f (m_position.x, m_position.y, m_position.z + 1);
  glVertex3f (m_position.x + 1, m_position.y, m_position.z + 1);
  glVertex3f (m_position.x + 1, m_position.y, m_position.z);
*/
  /*
  glTexCoord2f (0, 0);   
  glVertex3f (m_position.x, m_position.y, m_position.z + 0.2f);
  glTexCoord2f (0, 2);   
  glVertex3f (m_position.x, m_position.y, m_position.z + 1 - 0.2f);
  glTexCoord2f (1, 2);   
  glVertex3f (m_position.x + 1, m_position.y, m_position.z + 1 - 0.2f);
  glTexCoord2f (1, 0);   
  glVertex3f (m_position.x + 1, m_position.y, m_position.z + 0.2f);

*/
  
  glEnd ();

}
コード例 #3
0
ファイル: Camera.cpp プロジェクト: koo5/lemonized-pixel-city
static void do_auto_cam ()
{

    float     dist;
    unsigned  t;
    unsigned  elapsed;
    unsigned  now;
    int       behavior;
    GLvector  target;

    now = GetTickCount ();
    elapsed = now - last_update;
    elapsed = MIN (elapsed, 50); //limit to 1/20th second worth of time
    if (elapsed == 0)
        return;
    last_update = now;
    t = time (NULL) % CAMERA_CYCLE_LENGTH;
#if SCREENSAVER
    behavior = t / CAMERA_CHANGE_INTERVAL;
#else
    behavior = camera_behavior;
#endif
    tracker += (float)elapsed / 300.0f;
    //behavior = CAMERA_FLYCAM1;
    switch (behavior) {
    case CAMERA_ORBIT_INWARD:
        auto_position.x = WORLD_HALF + sinf (tracker * DEGREES_TO_RADIANS) * 150.0f;
        auto_position.y = 60.0f;
        auto_position.z = WORLD_HALF + cosf (tracker * DEGREES_TO_RADIANS) * 150.0f;
        target = glVector (WORLD_HALF, 40.0f, WORLD_HALF);
        break;
    case CAMERA_ORBIT_OUTWARD:
        auto_position.x = WORLD_HALF + sinf (tracker * DEGREES_TO_RADIANS) * 250.0f;
        auto_position.y = 60.0f;
        auto_position.z = WORLD_HALF + cosf (tracker * DEGREES_TO_RADIANS) * 250.0f;
        target = glVector (WORLD_HALF, 30.0f, WORLD_HALF);
        break;
    case CAMERA_ORBIT_ELLIPTICAL:
        dist = 150.0f + sinf (tracker * DEGREES_TO_RADIANS / 1.1f) * 50;
        auto_position.x = WORLD_HALF + sinf (tracker * DEGREES_TO_RADIANS) * dist;
        auto_position.y = 60.0f;
        auto_position.z = WORLD_HALF + cosf (tracker * DEGREES_TO_RADIANS) * dist;
        target = glVector (WORLD_HALF, 50.0f, WORLD_HALF);
        break;
    case CAMERA_FLYCAM1:
    case CAMERA_FLYCAM2:
    case CAMERA_FLYCAM3:
        auto_position = (flycam_position (now) + flycam_position (now + 4000)) / 2.0f;
        target = flycam_position (now + FLYCAM_CIRCUT_HALF - ONE_SECOND * 3);
        break;
    case CAMERA_SPEED:
        auto_position = (flycam_position (now) + flycam_position (now + 500)) / 2.0f;
        target = flycam_position (now + ONE_SECOND * 5);
        auto_position.y /= 2;
        target.y /= 2;
        break;
    case CAMERA_SPIN:
    default:
        target.x = WORLD_HALF + sinf (tracker * DEGREES_TO_RADIANS) * 300.0f;
        target.y = 30.0f;
        target.z = WORLD_HALF + cosf (tracker * DEGREES_TO_RADIANS) * 300.0f;
        auto_position.x = WORLD_HALF + sinf (tracker * DEGREES_TO_RADIANS) * 50.0f;
        auto_position.y = 60.0f;
        auto_position.z = WORLD_HALF + cosf (tracker * DEGREES_TO_RADIANS) * 50.0f;
    }
    dist = MathDistance (auto_position.x, auto_position.z, target.x, target.z);
    auto_angle.y = MathAngle (-MathAngle (auto_position.x, auto_position.z, target.x, target.z));
    auto_angle.x = 90.0f + MathAngle (0, auto_position.y, dist, target.y);

}