Ejemplo n.º 1
0
void resizeGL(unsigned int width, unsigned int height)
{
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	setPerspective(45, (float)width/height, 0.1, 100.0);
}
Ejemplo n.º 2
0
// Creates a default camera resembling Maya Persp
CameraPersp::CameraPersp()
	: Camera(), mLensShift( Vec2f::zero() )
{
	lookAt( Vec3f( 28.0f, 21.0f, 28.0f ), Vec3f::zero(), Vec3f::yAxis() );
	setCenterOfInterest( 44.822f );
	setPerspective( 35.0f, 1.0f, 0.1f, 1000.0f );
}
Ejemplo n.º 3
0
Camera::Camera()
    : _pitch(0), _yaw(0), _position(0,0,0),
    _moveSpeed(1.0f), _movementFlags(0)
{
    updateViewMatrix();
    setPerspective(60.0f, 16.0f/9.0f, 0.01f, 100.0f);
}
Ejemplo n.º 4
0
// Creates a default camera resembling Maya Persp
CameraPersp::CameraPersp()
	: Camera()
{
	lookAt( vec3( 28, 21, 28 ), vec3(), vec3( 0, 1, 0 ) );
	setCenterOfInterest( 44.822f );
	setPerspective( 35, 1, 0.1f, 1000 );
}
Ejemplo n.º 5
0
void AbstractContent::slotSetPerspective(const QPointF & sceneRelPoint, Qt::KeyboardModifiers modifiers)
{
    if (modifiers & Qt::ControlModifier)
        return slotClearPerspective();
    qreal k = modifiers == Qt::NoModifier ? 0.2 : 0.5;
    setPerspective(QPointF(qBound((qreal)-70.0, (qreal)sceneRelPoint.x()*k, (qreal)70.0), qBound((qreal)-70.0, (qreal)sceneRelPoint.y()*k, (qreal)70.0)));
}
Ejemplo n.º 6
0
   void ElevatorSimRenderWindow::setViewport() {
      glViewport(0, 0, w(), h());

      float ratio = (float)w() / (float)h();

      setPerspective(45.0, 1.0*ratio, 1.0, 200.0);
   }
Ejemplo n.º 7
0
Camera::Camera(float fovY, float aspectRatio, float near, float far)
	: m_speed(10),
	m_up(0,1,0),
	m_transform(1),
	m_view(1)
{
	setPerspective(fovY, aspectRatio, near, far);
}
Ejemplo n.º 8
0
void Camera::setViewport(float x0, float y0, float xn, float yn)
{
	m_viewport[0] = x0;
	m_viewport[1] = y0;
	m_viewport[2] = xn;
	m_viewport[3] = yn;
	setPerspective(m_near, m_far, m_fov, xn/yn);
}
Ejemplo n.º 9
0
void GlWindow::resizeGL( int w, int h )
{
    glViewport( 0, 0, w, h );

    float a = w / static_cast<GLfloat>(h);
//	printf( "Size: (%d,%d) - AspectRatio: %f\n", w, h, a );

    setPerspective( 45.0f, a, 0.1f, 100.0f );
}
Ejemplo n.º 10
0
void OGLViewer::resetCamera()
{
	Transform cam2w = lookAt(Point3D(30, 10, 30), Point3D(0.0, 0.0, 0.0), Point3D(0, 1, 0));
	Transform pers = Transform(setPerspective(67,
		width() / static_cast<double>(height()), 0.1, 500));
	view_cam = new perspCamera(cam2w, pers);
	view_cam->exportVBO(view_mat, proj_mat, nullptr);
	//update();
}
Camera::Camera(void)
{
	p_position = D3DXVECTOR3(0.0f,0.0f,10.0f);
	p_updir = D3DXVECTOR3(0.0f,1.0f,0.0f);

	//hard coded to 1.3333 by default
	float ratio = 640 / 480;
	setPerspective(3.14159f / 4, ratio, 1.0f, 2000.0f);

}
Ejemplo n.º 12
0
MainWindow::MainWindow(QWidget *parent) :
  QMainWindow(parent),
  ui(new Ui::MainWindow)
{
  ui->setupUi(this);
  connect(ui->action,SIGNAL(changed()),ui->SceneWidget,SLOT(setOrthogonal()));
  connect(ui->action_2,SIGNAL(changed()),ui->SceneWidget,SLOT(setPerspective()));
  connect(ui->SceneWidget,SIGNAL(setPerspectiveInfo(QString)),ui->label,SLOT(setText(QString)));
  connect(ui->SceneWidget,SIGNAL(setFiguresInfo(QString)),ui->label_2,SLOT(setText(QString)));
}
Ejemplo n.º 13
0
static void myReshape(int w, int h)
{
    /* Callback function to handle window dimensions and size changes */
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);	/* specifies the current matrix */
	glLoadIdentity();			/* Sets the currant matrix to identity */
//	gluPerspective(30,1.0,0.1,20.0);	//ankle, aspect ratio x/y, near, far
//	gluLookAt(0,0,10,0.5,0.5,0.5,0,1,0); //Eye:XYZ, Center XYZ, Up XYZ 
	setPerspective();
}
Ejemplo n.º 14
0
void Camera::centerOn(float center[4], float halfDists[4])
{
	vec4fCopy(m_o, center); 
	m_radius = vec3fNorm(halfDists) * 2.f;
	if (m_far < m_radius)
	{
		m_far = 1.5 *  m_radius;
		setPerspective(m_near, m_far, m_fov, m_ratio);
	}
}
Ejemplo n.º 15
0
///// resizeGL ////////////////////////////////////////////////////////////////
void GLView::resizeGL(int w, int h)
/// Overridden from QGlWidget::resizeGL().
/// Resizes the OpenGL viewport according to the size of the widget.
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  //aspectRatio = static_cast<float>(w) / static_cast<float>(h);
  setPerspective(); // calls gluPerspective or glOrtho depending on the prespective setting
  glMatrixMode(GL_MODELVIEW);
}
Ejemplo n.º 16
0
void GLWidget::resizeGL(int width, int height)
{
    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    setPerspective();

    glMatrixMode(GL_MODELVIEW);
    updateGL();
}
Ejemplo n.º 17
0
Camera::Camera() {
	rotX = 0.0f;
	rotY = 0.0f;
	rotZ = 0.0f;
	setPos(0.0f, 0.0f, 70.0f);
	setPerspective(45.0f, 1.0f, 0.1f, 200.0f);

	recalcRotateView();
	Model = glm::scale(glm::mat4(1.0f), glm::vec3(1.0f));

	MVP = Projection * View * Model;
}
void GLES2Lesson::render() {
    clearBuffers();
    prepareShaderProgram();
    setPerspective();
    resetTransformMatrices();

    drawGeometry(vboCubeVertexDataIndex,
                 vboCubeVertexIndicesIndex,
                 36,
                 cubeTransformMatrix
    );
}
Ejemplo n.º 19
0
void CCCameraBase::setupViewport(float x, float y, float width, float height, const int frameBufferID)
{
    this->frameBufferID = frameBufferID;
    
    viewportX = x;
    viewportY = y;
    viewportX2 = x+width;
    viewportY2 = y+height;
    viewportWidth = width;
    viewportHeight = height;
    invViewportWidth = 1.0f / viewportWidth;
    invViewportHeight = 1.0f / viewportHeight;
    
    if( frameBufferID == -1 )
    {
        const CCTarget<float> &orientation = CCAppManager::GetOrientation();
        if( orientation.target == 270.0f )
        {
            CCSwapFloat( x, y );
            CCSwapFloat( width, height );
            x = 1.0f - width - x;
        }
        else if( orientation.target == 90.0f )
        {
            CCSwapFloat( x, y );
            CCSwapFloat( width, height );
            y = 1.0f - height - y;
        }
        else if( orientation.target == 180.0f )
        {
            x = 1.0f - width - x;
            y = 1.0f - height - y;
        }
        else
        {
        }
    }
    
    const float invY = ( 1.0f-height ) - y;
    
    const float frameBufferWidth = gEngine->renderer->frameBufferManager.getWidth( frameBufferID );
    const float frameBufferHeight = gEngine->renderer->frameBufferManager.getHeight( frameBufferID );
    const float definedWidth = width * frameBufferWidth;
    const float definedHeight = height * frameBufferHeight;
    viewport[0] = x * frameBufferWidth;
    viewport[1] = invY * frameBufferHeight;
    viewport[2] = definedWidth;
    viewport[3] = definedHeight;
    
    aspectRatio = definedWidth / definedHeight;
    
    setPerspective( perspective );
}
Ejemplo n.º 20
0
void zoom_in(){
	if(!ortho){
	if(view_angle>20)view_angle-=1;
	else if(view_angle>1)view_angle-=.1;
	else return;
	}
	else{
		 if(view_angle>-8) view_angle-=1;
			
	 }
	setPerspective(GL_RENDER,0,0);
	}
Ejemplo n.º 21
0
void zoom_out(){
	if(!ortho){
	if(view_angle<150)view_angle+=1;
	else if(view_angle<170)view_angle+=.1;
	else return;
	}
	else {
		
		view_angle+=1;
	}
	setPerspective(GL_RENDER,0,0);	
	}
Ejemplo n.º 22
0
void MyWorld::Update()
{
    // Adjust perspective based on dimensions of screen to keep board in view
    int max = IwGxGetScreenHeight() > IwGxGetScreenWidth() ? IwGxGetScreenHeight() : IwGxGetScreenWidth();
    setPerspective(480.0f - (1024 - max) / 2);

    // Update camera swing
    if (CamSwing)
    {
        float d = CamSwingTime / CAM_SWING_TIME;
        LookFrom.x = StartCamSwingPos.x + (FinalCamSwingPos.x - StartCamSwingPos.x) * d;
        LookFrom.y = StartCamSwingPos.y + (FinalCamSwingPos.y - StartCamSwingPos.y) * d;
        LookFrom.z = StartCamSwingPos.z + (FinalCamSwingPos.z - StartCamSwingPos.z) * d;
        TransformDirty = true;
        CamSwingTime++;
        if (CamSwingTime > CAM_SWING_TIME)
        {
            CamSwing = false;
            CamSwingTime = 0;
        }
    }

    // TODO: Add world logic here
    World::Update();

    switch (GameState)
    {
    case eGameState_GameOver:
        if (GameOverTimer.HasTimedOut())
        {
            RestartGame();
        }
        break;
    case eGameState_Running:
        if (TurnsLeftChanged)
        {
            char str[64];
            snprintf(str, 64, "%u", TurnsLeft);
            TurnsLeftLabel->setText(str);
            TurnsLeftChanged = false;
        }
        if (RoundChanged)
        {
            char str[64];
            snprintf(str, 64, "%u", Round);
            RoundLabel->setText(str);
            RoundChanged = false;
        }
        break;
    }

}
Ejemplo n.º 23
0
void Camera::reset( GLfloat width, GLfloat height )
{
	setPos(m_InitialPos);
	setDir(m_InitialDir);
	setUp(m_InitialUp);

	setPerspective(m_InitialFOV, width, height, m_InitialNear, m_InitialFar);

	m_Pitch = 0.0f;
	m_Yaw = 0.0f;
	m_Speed = m_InitialSpeed;
	m_PosDelta = vec3(0.0f);
}
Ejemplo n.º 24
0
    //--------------------------------------------------------------------------
    Camera::Camera() :
            mAnimationComponent(mTransformComponent),
            mCurrentTranslationAnimation(nullptr),
            mCurrentSlerpAnimation(nullptr)
    {
        mView = glm::lookAt(glm::vec3(0.0f, 0.0, 7.0f),
                            glm::vec3(0.0f, 0.0f, 0.0f),
                            glm::vec3(0.0f, 1.0f, 0.0f));
        mZoom = 1.0f;

        //Perspective values
        mBaseFov = DEFAULT_FOVY;
        setPerspective(mBaseFov, DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_PLANE, DEFAULT_FAR_PLANE);
    }
Ejemplo n.º 25
0
void onReshape (int width, int height)
/* pre:  glut window has been resized
   post: resets cameras location and aspect to match window */
{
  glViewport(0, 0, width, height);
  if (! isFullScreen)
    {
      theWindowWidth = width;
      theWindowHeight = height;
    }

  /* set camera to view resized area */
  setPerspective(GL_RENDER,0,0);
}
Ejemplo n.º 26
0
static void RenderScene(void)
{
    /* Creating the Scene */ 
    //  Clear screen and Z-buffer
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(0,0,0.5);		  /* Farbe festlegen */
   glMatrixMode( GL_MODELVIEW ); 		// Modell-Matrixstack wählen
		glLoadIdentity();             	// Die Matrix zurücksetzen
		glCallList(CUBE);
	glMatrixMode( GL_PROJECTION );		// World-Matrixstack wählen
		glLoadIdentity();             	// Die Matrix zurücksetzen
	setPerspective();
	glutSwapBuffers();
}
Ejemplo n.º 27
0
CameraPersp::CameraPersp( int pixelWidth, int pixelHeight, float fovDegrees, float nearPlane, float farPlane )
	: Camera(), mLensShift( Vec2f::zero() )
{
	float halfFov, theTan, aspect;

	float eyeX 		= pixelWidth / 2.0f;
	float eyeY 		= pixelHeight / 2.0f;
	halfFov 		= 3.14159f * fovDegrees / 360.0f;
	theTan 			= cinder::math<float>::tan( halfFov );
	float dist 		= eyeY / theTan;
	aspect 			= pixelWidth / (float)pixelHeight;

	setPerspective( fovDegrees, aspect, nearPlane, farPlane );
	lookAt( Vec3f( eyeX, eyeY, dist ), Vec3f( eyeX, eyeY, 0.0f ) );
}
Ejemplo n.º 28
0
CameraPersp::CameraPersp( int pixelWidth, int pixelHeight, float fovDegrees )
	: Camera()
{
	float eyeX 		= pixelWidth / 2.0f;
	float eyeY 		= pixelHeight / 2.0f;
	float halfFov 	= 3.14159f * fovDegrees / 360.0f;
	float theTan 	= cinder::math<float>::tan( halfFov );
	float dist 		= eyeY / theTan;
	float nearDist 	= dist / 10.0f;	// near / far clip plane
	float farDist 	= dist * 10.0f;
	float aspect 	= pixelWidth / (float)pixelHeight;

	setPerspective( fovDegrees, aspect, nearDist, farDist );
	lookAt( vec3( eyeX, eyeY, dist ), vec3( eyeX, eyeY, 0.0f ) );
}
Ejemplo n.º 29
0
void renderFn()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);



	g_program.use();
	setPerspective();
	glActiveTexture(GL_TEXTURE9);
	glBindTexture(GL_TEXTURE_2D, omap2);

	g_program.setUniform("MaxTessLevel", max_tess);
	g_program.setUniform("ModelView", g_modelview);
	g_program.setUniform("Projection", g_projection);
	g_program.setUniform("MVP", g_projection * g_modelview);
	g_program.setUniform("NormalMatrix", 
			glm::inverseTranspose(mat3(g_modelview)));
	g_program.setUniform("MousePosition", mouse);
	
	g_program.setUniform("Time", elapsed);
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	renderLand();

	d_program.use();
	
	glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &plv); 
	glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &plf); 

	glActiveTexture(GL_TEXTURE9);
	glBindTexture(GL_TEXTURE_2D, plane);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	renderPlane(scene->mRootNode);

	glDisable(GL_DEPTH_TEST);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	d_program.setUniform("FrameTime", clockdiff);
	d_program.setUniform("Elapsed", elapsed);
	glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, &pav); 
	glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &paf); 
	renderParticles();

	glEnable(GL_DEPTH_TEST);
	glDisable(GL_BLEND);
}
    void GLES2Lesson::render() {
        clearBuffers();
        prepareShaderProgram();
        setPerspective();
        resetTransformMatrices();

        for (auto &star : mStars) {

            glUniform4fv(fragmentTintPosition, 1, &star->mColor[0]);

            drawGeometry(vboCubeVertexDataIndex,
                         vboCubeVertexIndicesIndex,
                         4,
                         star->mTransform
            );
        }
    }