示例#1
0
Game::Game() ://mapGraph(NULL), mapPath(NULL), selected(NULL), selectedNode(NULL), delauny(NULL), 
drawDebug(true), objectMap(AABBf(V2f(-50,-50),V2f(50,50)), V2i(7,7)) {
	gameLoopRunning = true;
	paused = false;

	V2f min(-10, -10), max(10, 10);
}
示例#2
0
Box2f scale( const Box2f& b, float sx, float sy, float xcenter, float ycenter)
{
    Box2f box = offsetBy( b, V2f( -xcenter, -ycenter));
    box = scale( box, sx, sy);
    box = offsetBy( box, V2f( xcenter, ycenter));
    return box;
}
示例#3
0
DogThing::DogThing(V2i _position, float start_difficulty) :
Thing(_position, "dog"),
// don't center animation horizontally
graphic(this, V2f(0,0), V2f(0, 0), GraphicIncarnation::CENTER_Y),
unleash_timer(this, STR_UNLEASH_TIMER),
state(OFFSCREEN)
{
}
示例#4
0
void Widget::draw()
{
    Gl_Widget::draw();

    //DJV_DEBUG("Widget::draw");

    const Box2i & geom = this->geom();

    //DJV_DEBUG_PRINT("geom = " << geom);

    Gl_Util::ortho(V2i(geom.w, geom.h));
    DJV_DEBUG_GL(glViewport(0, 0, geom.w, geom.h));

    //DJV_DEBUG_GL(glClearColor(0.0, 0.0, 1.0, 0.0));
    DJV_DEBUG_GL(glClear(GL_COLOR_BUFFER_BIT));

    if (_image)
    {
        const Pixel_Data_Info & info = _image->info();

        //DJV_DEBUG_PRINT("info = " << info);

        try
        {
            _image->bind();
        }
        catch (Error error)
        {
            DJV_APP->error(error);
        }

        DJV_DEBUG_GL(glPushMatrix());

        double u [] = { 0, 0 }, v [] = { 0, 0 };

        u[! info.mirror.x] = info.size.x / static_cast<double>(info.size.x);
        v[! info.mirror.y] = info.size.y / static_cast<double>(info.size.y);

        const V2f uv [] =
        {
            V2f(u[0], v[0]),
            V2f(u[0], v[1]),
            V2f(u[1], v[1]),
            V2f(u[1], v[0])
        };

        DJV_DEBUG_GL(glBegin(GL_QUADS));

        Gl_Util::draw_box(info.size, uv);

        DJV_DEBUG_GL(glEnd());

        DJV_DEBUG_GL(glPopMatrix());
    }
}
示例#5
0
const Chromaticities &
acesChromaticities ()
{
    static const Chromaticities acesChr 
	    (V2f (0.73470,  0.26530),	// red
	     V2f (0.00000,  1.00000),	// green
	     V2f (0.00010, -0.07700),	// blue
	     V2f (0.32168,  0.33767));	// white

    return acesChr;
}
示例#6
0
int Application::startSDL()
{
  // Initialise SDL
	ASSERT_SDL(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) >= 0,
		"Initialising SDL video and audio");

  // Initialise timing
  prev_tick = this_tick = SDL_GetTicks();

	// Open the window where we will draw. NB: Android will override the
	// specified height and width no matter what they are!
	window = SDL_CreateWindow(APP_NAME, SDL_WINDOWPOS_CENTERED,
                           SDL_WINDOWPOS_CENTERED, WINDOW_DEFAULT_W,
                           WINDOW_DEFAULT_H, WINDOW_FLAGS);
  ASSERT_SDL(window, "Opening SDL application window");

  // Since the window size can be overriden, check what it is actually
  SDL_GetWindowSize(window, &global::viewport.w, &global::viewport.h);
  global::scale = V2f(global::viewport.w / (float)WINDOW_DEFAULT_W,
                        global::viewport.h / (float)WINDOW_DEFAULT_H);

  // Create the OpenGL context for the window we just opened
  context = SDL_GL_CreateContext(window);
  SDL_GL_MakeCurrent(window, context);

  // Configure SDL/OpenGL interface
  ASSERT_SDL(SDL_GL_SetSwapInterval(1) != -1, "Activating SDL V-sync");
  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, GL_V_MAJOR);
  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, GL_V_MINOR);
  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

  // No problems, return success code!
  return EXIT_SUCCESS;
}
示例#7
0
V2f
latLong (const Box2i &dataWindow, const V2f &pixelPosition)
{
    float latitude, longitude;

    if (dataWindow.max.y > dataWindow.min.y)
    {
	latitude = -M_PI *
		  ((pixelPosition.y  - dataWindow.min.y) /
		   (dataWindow.max.y - dataWindow.min.y) - 0.5f);
    }
    else
    {
	latitude = 0;
    }

    if (dataWindow.max.x > dataWindow.min.x)
    {
	longitude = -2 * M_PI *
		   ((pixelPosition.x  - dataWindow.min.x) /
		    (dataWindow.max.x - dataWindow.min.x) - 0.5f);
    }
    else
    {
	longitude = 0;
    }

    return V2f (latitude, longitude);
}
示例#8
0
void Util::quad(const Pixel_Data_Info & in)
{
    double u [] = { 0, 0 }, v [] = { 0, 0 };
    u[! in.mirror.x] = in.size.x;
    v[! in.mirror.y] = in.size.y;
    const V2f uv [] =
    {
        V2f(u[0], v[0]),
        V2f(u[0], v[1]),
        V2f(u[1], v[1]),
        V2f(u[1], v[0])
    };

    glBegin(GL_QUADS);
    Gl_Util::draw_box(Box2i(in.size), uv);
    glEnd();
}
示例#9
0
V2f
pixelPosition (const Box2i &dataWindow, const V2f &latLong)
{
    float x = latLong.y / (-2 * M_PI) + 0.5f;
    float y = latLong.x / -M_PI + 0.5f;

    return V2f (x * (dataWindow.max.x - dataWindow.min.x) + dataWindow.min.x,
		y * (dataWindow.max.y - dataWindow.min.y) + dataWindow.min.y);
}
示例#10
0
FallingThing::FallingThing(V2i _position, const char* name, Animation* loop,
                          float loop_speed, float gravity, float max_speed) :
Thing(_position, name),
graphic(this),
movement(this, max_speed)
{
  graphic.setSprite(loop, loop_speed);
  graphic.setRandFrame();
  movement.setSpeed(V2f(-X_SPEED, gravity));
  body = new ColliderElement(this, V2d(V2d(32, 32))); // freed by ~Thing
}
示例#11
0
void
faceAndPixelPosition (const V3f &direction,
		      const Box2i &dataWindow,
		      CubeMapFace &face,
		      V2f &pif)
{
    int sof = sizeOfFace (dataWindow);
    float absx = abs (direction.x);
    float absy = abs (direction.y);
    float absz = abs (direction.z);

    if (absx >= absy && absx >= absz)
    {
	if (absx == 0)
	{
	    //
	    // Special case - direction is (0, 0, 0)
	    //

	    face = CUBEFACE_POS_X;
	    pif = V2f (0, 0);
	    return;
	}

	pif.x = (direction.y / absx + 1) / 2 * (sof - 1);
	pif.y = (direction.z / absx + 1) / 2 * (sof - 1);

	if (direction.x > 0)
	    face = CUBEFACE_POS_X;
	else
	    face = CUBEFACE_NEG_X;
    }
    else if (absy >= absz)
    {
	pif.x = (direction.x / absy + 1) / 2 * (sof - 1);
	pif.y = (direction.z / absy + 1) / 2 * (sof - 1);

	if (direction.y > 0)
	    face = CUBEFACE_POS_Y;
	else
	    face = CUBEFACE_NEG_Y;
    }
    else
    {
	pif.x = (direction.x / absz + 1) / 2 * (sof - 1);
	pif.y = (direction.y / absz + 1) / 2 * (sof - 1);

	if (direction.z > 0)
	    face = CUBEFACE_POS_Z;
	else
	    face = CUBEFACE_NEG_Z;
    }
}
示例#12
0
V2f	
latLong (const V3f &dir)
{
    float r = sqrt (dir.z * dir.z + dir.x * dir.x);

    float latitude = (r < abs (dir.y))?
			 acos (r / dir.length()) * sign (dir.y):
			 asin (dir.y / dir.length());

    float longitude = (dir.z == 0 && dir.x == 0)? 0: atan2 (dir.x, dir.z);

    return V2f (latitude, longitude);
}
示例#13
0
MeshPlane::MeshPlane(GLfloat x, GLfloat y, GLfloat z, GLfloat x_len, GLfloat y_len, int x_tiles, int y_tiles, GLuint texid){
	MeshPlane::texid=texid;
	textured=true;
	t.push_back(V2f(0,0));
	t.push_back(V2f(0,1));
	t.push_back(V2f(1,1));
	t.push_back(V2f(1,0));
	for(int i = 0; i<=x_tiles; i++)
		for(int j = 0; j<=y_tiles; j++)
			v.push_back(V3f(i*x_len+x,y, j*y_len+z));

	for(int i = 1; i<v.size()-y_tiles-1; i++){
		if(i%(y_tiles+1)!=0){
		vi.push_back(V3i(i-1,i,i+y_tiles+1));
		ti.push_back(V3i(0,1,2));
		vi.push_back(V3i( i-1,i+y_tiles+1, i+y_tiles));
		ti.push_back(V3i(0,2,3));
		}
	}
	calcFaceNormals();
	calcVertexNormalsAverage();
	calcVertexNormalsWeight();
}
//-*****************************************************************************
// much like lib/Alembic/Abc/OTypedProperty.cpp, this is just a compile test,
// due to the implementation being in the .h file, due to templates.
void __testOGeomParamCompile( Abc::OCompoundProperty &iParent )
{
    OV2fGeomParam uvs( iParent, "uv", false, kVertexScope, 1 );

    std::vector<V2f> vec;

    vec.push_back( V2f( 1.0f, 2.0f ) );

    V2fArraySample val( vec );

    OV2fGeomParam::Sample samp( val, kUnknownScope );

    uvs.set( samp );
}
示例#15
0
//------------------------------------------------------------------------------
// DofMbTileSet implementation.
DofMbTileSet::DofMbTileSet(int tileWidth, float timeStratQuality,
                           float shutterMin, float shutterMax)
    : m_tileWidth(tileWidth)
{
    // Generate time and lens samples, and copy them into a convenient
    // format.
    std::vector<float> tuv;
    canonicalTimeLensSamps(tuv, tileWidth*tileWidth);
    m_tuv.resize(tileWidth*tileWidth);
    for(int i = 0, iend=m_tuv.size(); i < iend; ++i)
    {
        m_tuv[i].time = lerp(shutterMin, shutterMax, tuv[3*i]);
        m_tuv[i].lens = V2f(tuv[3*i+1], tuv[3*i+2]);
    }
    makeTileSet(m_tileIndices, tileWidth, tuv, timeStratQuality);
}
示例#16
0
void Magnify_Dialog::widget_update()
{
    if (! _view)
    {
        return;
    }

    //DJV_DEBUG("Magnify_Dialog::widget_update");

    callbacks(false);

    const double zoom = Math::pow(2, _zoom);

    //DJV_DEBUG_PRINT("zoom = " << zoom);

    _widget->set(
        _view,
        Vector_Util::floor<double, int>(V2f(_pick) * zoom),
        _view->zoom() * zoom);

    _zoom_widget->set(_zoom);

    callbacks(true);
}
示例#17
0
/// Draw the 3D cursor
void View3D::drawCursor(const TransformState& transStateIn, const V3d& cursorPos, float centerPointRadius) const
{
    V3d offset = transStateIn.cameraPos();
    TransformState transState = transStateIn.translate(offset);
    V3d relCursor = cursorPos - offset;

    // Cull if behind camera
    if((relCursor * transState.modelViewMatrix).z > 0)
        return;

    // Find position of cursor in screen space
    V3d screenP3 = relCursor * transState.modelViewMatrix * transState.projMatrix;
    // Position in ortho coord system
    V2f p2 = 0.5f * V2f(width(), height()) * (V2f(screenP3.x, screenP3.y) + V2f(1.0f));

    // Draw cursor
    if (m_cursorShader->isValid())
    {
        QGLShaderProgram& cursorShader = m_cursorShader->shaderProgram();
        // shader
        cursorShader.bind();
        // vertex array
        glBindVertexArray(m_cursorVertexArray);

        transState.projMatrix.makeIdentity();
        transState.setOrthoProjection(0, width(), 0, height(), 0, 1);
        transState.modelViewMatrix.makeIdentity();

        if (centerPointRadius > 0)
        {
            // fake drawing of white point through scaling ...
            //
            TransformState pointState = transState.translate( V3d(p2.x, p2.y, 0) );
            pointState = pointState.scale( V3d(0.0,0.0,0.0) );
            glLineWidth(centerPointRadius);
            cursorShader.setUniformValue("color", 1.0f, 1.0f, 1.0f, 1.0f);
            pointState.setUniforms(cursorShader.programId());
            glDrawArrays( GL_POINTS, 0, 1 );
        }

        // Now draw a 2D overlay over the 3D scene to allow user to pinpoint the
        // cursor, even when when it's behind something.
        glDisable(GL_DEPTH_TEST);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_LINE_SMOOTH);

        glLineWidth(1); // this won't work anymore for values larger than 1 (2.0f);

        // draw white lines
        transState = transState.translate( V3d(p2.x, p2.y, 0) );
        cursorShader.setUniformValue("color", 1.0f, 1.0f, 1.0f, 1.0f);
        transState.setUniforms(cursorShader.programId());
        glDrawArrays( GL_LINES, 0, 8 );

        // draw black lines
        transState = transState.rotate( V4d(0,0,1,0.785398) ); //45 deg
        cursorShader.setUniformValue("color", 0.0f, 0.0f, 0.0f, 1.0f);
        transState.setUniforms(cursorShader.programId());
        glDrawArrays( GL_LINES, 0, 8 );
    }
}
示例#18
0
V2f V2f::operator-(const V2f& b) {
  return V2f(x() - b.x(), y() - b.y());
}
示例#19
0
// deal with input messages, return BACK, EXIT or CONTINUE
int Application::treatEvents()
{
  // local variables
  static V2i cursor(0,0);
  static bool clicking(false);

  // static to avoid reallocating it ever time we run the function
  static SDL_Event event;


  // write each event to our static variable
  while (SDL_PollEvent(&event))
  {
    switch (event.type)
    {
      // exit if the window is closed (ex: pressing the cross)
      case SDL_QUIT:
        return Application::EXIT;
        break;

      // check for keypresses
      case SDL_KEYDOWN:
        switch (event.key.keysym.sym)
        {
          case KEY_BACK:
            return Application::BACK;
          case KEY_EXIT:
            return Application::EXIT;
          case KEY_VOLUME_UP:
            AudioManager::getInstance()->volume_up();
            break;
          case KEY_VOLUME_DOWN:
            AudioManager::getInstance()->volume_down();
            break;
          default:
            // here we DO want a default break, as not all keys are needed
            break;
        }
        break;

      #if USE_TOUCH
      // touch events
      case SDL_FINGERDOWN:
        cursor = normaliseTouch(event.tfinger.touchId,
                                   V2i(event.tfinger.x, event.tfinger.y));
        clicking = true;
        break;

      case SDL_FINGERUP:
        clicking = false;
        break;

      case SDL_FINGERMOTION:
        cursor = normaliseTouch(event.tfinger.touchId,
                                V2i(event.tfinger.x, event.tfinger.y));
        break;
      #endif  // USE_TOUCH

      #if USE_MOUSE
      // mouse events
      case SDL_MOUSEBUTTONDOWN:
        if(event.button.button == SDL_BUTTON_RIGHT)
          return Application::BACK;
        clicking = true;
        break;

      case SDL_MOUSEBUTTONUP:
        if(event.button.button == SDL_BUTTON_LEFT)
          clicking = false;
        break;

      case SDL_MOUSEMOTION:
        cursor = V2f(event.motion.x, event.motion.y) / global::scale;
        break;
      #endif  // USE_MOUSE

      default:
        // not all possible inputs are needed, so we DO want a default break
        break;
    }
  }

  // Update the scene with the new input
  scene->getState()->setCursor(cursor, clicking);

  // No exit events encountered, we can continue
  return Application::CONTINUE;
}
示例#20
0
V2f V2f::operator+(float b) {
  return V2f(x() + b, y() + b);
}
示例#21
0
V2f V2f::operator+(const V2f& b) {
  return V2f(x() + b.x(), y() + b.y());
}
示例#22
0
Box2f scale( const Box2f& b, float sx, float sy)
{
    return Box2f( V2f( b.min.x * sx, b.min.y * sy), V2f( b.max.x * sx, b.max.y * sy));
}
示例#23
0
V2f V2f::operator/(float b) {
  return V2f(x() / b, y() / b);
}
示例#24
0
V2f V2f::operator*(float b) {
  return V2f(x() * b, y() * b);
}
示例#25
0
V3f
direction (CubeMapFace face, const Box2i &dataWindow, const V2f &positionInFace)
{
    int sof = sizeOfFace (dataWindow);

    V2f pos;
    
    if (sof > 1)
    {
	pos = V2f (positionInFace.x / (sof - 1) * 2 - 1,
		   positionInFace.y / (sof - 1) * 2 - 1);
    }
    else
    {
	pos = V2f (0, 0);
    }

    V3f dir (1, 0, 0);

    switch (face)
    {
      case CUBEFACE_POS_X:

	dir.x = 1;
	dir.y = pos.x;
	dir.z = pos.y;
	break;

      case CUBEFACE_NEG_X:

	dir.x = -1;
	dir.y = pos.x;
	dir.z = pos.y;
	break;

      case CUBEFACE_POS_Y:

	dir.x = pos.x;
	dir.y = 1;
	dir.z = pos.y;
	break;

      case CUBEFACE_NEG_Y:

	dir.x = pos.x;
	dir.y = -1;
	dir.z = pos.y;
	break;

      case CUBEFACE_POS_Z:

	dir.x = pos.x;
	dir.y = pos.y;
	dir.z = 1;
	break;

      case CUBEFACE_NEG_Z:

	dir.x = pos.x;
	dir.y = pos.y;
	dir.z = -1;
	break;
    }

    return dir;
}
示例#26
0
void Game::init() {
	objectMap.addLayer(Obstacle::STATIC, AABBf(V2f(-60, -60), V2f(60, 60)), V2i(16, 16));
	addObstacle(new CircleObject(Circf(V2f(-4, -4), 2), Obstacle::STATIC));
	addObstacle(new AABBObject(AABBf(V2f(-4, 1), V2f(-2, 5)), Obstacle::STATIC));
	addObstacle(new BoxObject(Boxf(V2f(4, 0), V2f(2, 5), V2f(1)), Obstacle::STATIC));
	addObstacle(new ConeObject(Conef(V2f(0, 1), 1.5f, (float)V_2PI * 1 / 8, (float)V_2PI * 3 / 8), Obstacle::STATIC)); // make the radius of the cone correct based on the calculated center
	V2f trapezoid[] = { V2f(-.5f, .5f), V2f(.5f, 1.2f), V2f(.5f, -1.5f), V2f(-.5f, -.8f) };
	int trapezoidCount = sizeof(trapezoid) / sizeof(trapezoid[0]);
	addObstacle(new PolygonObject(Polygon2f(V2f(5, -7), V2f((float)V_2PI*0.0f/6), trapezoid, trapezoidCount), Obstacle::STATIC)); // TODO raycast does not always hit the shape correctly from all sides
	V2f a(-2, -2), b(5, -4);
	addObstacle(new LineObject(Linef(&a, &b), Obstacle::STATIC));
	addObstacle(new PointObject(V2f(7, 7), Obstacle::STATIC));

	delaunyBoundary = new CircleObject(Circf(V2f::ZERO(), 100), Obstacle::EVERYTHING);
	delauny = new DelaunySet(delaunyBoundary);
	//delauny->addNode(V2f(3, 4));
	//delauny->addNode(V2f(-3, 4));
	//delauny->addNode(V2f(-3, -4));
	//delauny->addNode(V2f(0, -1));
//	for (int i = 0; i < 10; ++i) {
//		delauny->addNode(V2f::randomUnitVector() * Random::PRNGf() * 100);
//	}
	delauny->makeRandom(6);
	delauny->calculateAllTriangles();
}