コード例 #1
0
ファイル: wxOgre.cpp プロジェクト: johnfredcee/meshmixer
void wxOgre::cameraTrackNode(Ogre::SceneNode* target)
{
	static const wxString camCalcPosCaption(wxT("CalcCamPos:X:%08.4f, Y:%08.4f, Z:%08.4f"));
	static const wxString camRealPosCaption(wxT("CalcCamPos:X:%08.4f, Y:%08.4f, Z:%08.4f"));

	// TODO: Position camera somwehere sensible relative to object
	if (target)
	{
		Ogre::LogManager* logMgr = Ogre::LogManager::getSingletonPtr();
		Ogre::Log* log(logMgr->getDefaultLog());
		mTarget = target;
		Ogre::Vector3 size( target->getAttachedObject(0)->getBoundingBox().getSize() );
		Ogre::Vector3 camPos(target->getPosition() + size * 1.2f); 
		setZoomScale(size.length() / 30.0f);
		mCameraNode->setPosition(camPos);
		mCamera->lookAt(target->getPosition());
		mDebugPanelOverlay->show();
		wxString msg(wxString::Format(camCalcPosCaption, camPos.x, camPos.y, camPos.x));
		log->logMessage(Ogre::String(msg.mb_str(wxConvUTF8)));
		Ogre::Vector3 camRealPos(mCamera->getRealPosition());
		msg = wxString(wxString::Format(camCalcPosCaption, camRealPos.x, camRealPos.y, camRealPos.x));
		log->logMessage(Ogre::String(msg.mb_str(wxConvUTF8)));
	} else {
		mTarget = NULL;
	}

}
コード例 #2
0
ファイル: CcdChapter.cpp プロジェクト: oksangman/Ant
int CcdChapter::OnUpdateGame()
{
	Vector3 camPos(Vector3::ZERO);
	if( m_nKeyState & 1 )
		camPos.z -= 5.f;
	else if( m_nKeyState & 2 )
		camPos.z += 5.f;

	if( m_nKeyState & 4 )
		camPos.x -= 5.f;
	else if( m_nKeyState & 8 )
		camPos.x += 5.f;

	m_pkCamera->moveRelative(camPos);

	if( m_nMouseState & 2 )
	{
		POINT pt;
		GetCursorPos( &pt );
		m_pkCamera->pitch( Degree(m_MousePos.y-pt.y) );
		m_pkCamera->yaw( Degree(m_MousePos.x-pt.x) );
		SetCursorPos(m_MousePos.x, m_MousePos.y);
	}
	return 0;
}
コード例 #3
0
ファイル: Rectangle.cpp プロジェクト: Tastyep/cpp-rt
double Rectangle::intersect(Vector rayVec, Camera camera) const {
  Position vecPos = camera.pos;
  this->applyTransformations(vecPos, rayVec);
  Vector normal(-this->width, 0, this->height);
  Vector objPos(pos.x, pos.y, pos.z);
  Vector camPos(vecPos.x, vecPos.y, vecPos.z);
  Vector B(this->width, 0, this->height);
  double r, d, n;

  d = normal.dot(rayVec);
  n = normal.dot(objPos) - normal.dot(camPos);
  if (d == 0)
    return -1;
  r = n / d;
  if (r < 0)
    return -1;
  return r;
  Position inter;
  inter.x = vecPos.x + r * rayVec.x;
  inter.y = vecPos.y + r * rayVec.y;
  inter.z = vecPos.z + r * rayVec.z;
  Vector interVec(pos.x - inter.x, pos.y - inter.y, pos.z - inter.z);
  interVec.makeUnit();
  B.makeUnit();
  double p = interVec.dot(B);
  // std::cout << p << "\n";
  if (p >= -0.000001 && p <= 0.000001)
    return r;
  return -1;
}
コード例 #4
0
bool CD3DGraphics11::RenderBumpMapShdaer(D3DXMATRIX world, int numIndices, CMaterialDX11 mat)
{
	CGameScene& scene = SYSTEM::PROJECT::GetScene();
	CGameobjectList l = scene.GetLightList();
	int n_l = l.GetNumObjects();
	CCamera* c = scene.GetCamera(0);

	if (!c)
		return false;

	D3DXVECTOR4 amb(mat.GetAmbientColor().r, mat.GetAmbientColor().g, mat.GetAmbientColor().b, mat.GetAmbientColor().a);
	D3DXVECTOR4 spec(mat.GetSpecularColor().r, mat.GetSpecularColor().g, mat.GetSpecularColor().b, mat.GetSpecularColor().a);
	D3DXVECTOR3 camPos(c->GetTransform().GetTranslation().x, c->GetTransform().GetTranslation().y,
		c->GetTransform().GetTranslation().z);

	ID3D11ShaderResourceView* difTex = mat.GetDiffuseTexture();
	ID3D11ShaderResourceView* specTex = mat.GetSpecularMap();
	ID3D11ShaderResourceView* bumpTex = mat.GetBumpMap();

	if (!difTex)
		difTex = m_pDefaultTexture;
	if (!specTex)
		specTex = m_pDefaultTexture;
	if (!bumpTex)
		bumpTex = m_pDefaultTexture;

	return m_bumpMapShader.Render(*this, numIndices, m_matrices.view, world, m_matrices.projection, difTex, specTex, bumpTex, 
		l, n_l,amb, camPos, spec, 64.0f);

	return true;
}
コード例 #5
0
bool GameRenderer::Initialize(MaterialHandler* mtlHandlerPtr, MeshHandler* meshHandlerPtr, TextureHandler* texHandlerPtr, TransformHandler* transformHandlerPtr)
{
	materialHandler = mtlHandlerPtr;
	meshHandler = meshHandlerPtr;
	textureHandler = texHandlerPtr;
	transformHandler = transformHandlerPtr;

	glfwWindow = glfwGetCurrentContext();

	glfwGetFramebufferSize(glfwWindow, &screenWidth, &screenHeight);

	float ratio = (float)screenWidth / (float) screenHeight;
	glViewport(0, 0, screenWidth, screenHeight);
	glClearColor(0.4f, 0.4f, 0.5f, 1.0f);

	glm::vec3 camPos(0.0f, 25.0f, -70.0f);
	glm::vec3 treePos(0.0f, 0.0f, 0.0f);
	glm::vec3 scalingVector(1.5f);
	glm::vec3 targetOffset = glm::vec3(0.0f, 6.0f, 0.0f) * scalingVector;

	scaleMatrix = glm::scale(glm::mat4(), scalingVector);

	wvpMatrixStruct.projMatrix = glm::perspective(45.0f, ratio, 0.25f, 300.0f);
	wvpMatrixStruct.viewMatrix = glm::lookAt(	
		camPos,
		treePos+targetOffset,
		glm::vec3(0.0f, 1.0f, 0.0f)
		);


	glGenBuffers(1, &matrixUBO);
	glBindBuffer(GL_UNIFORM_BUFFER, matrixUBO);
	glBufferData(GL_UNIFORM_BUFFER, sizeof(Matrices), (void *)(&wvpMatrixStruct), GL_DYNAMIC_DRAW);
	glBindBuffer(GL_UNIFORM_BUFFER, 0);

	SetupRenderPasses();

	//Loading and compiling all shaders etc
	if(!shaderManager.Initialize())
	{
		return false;
	}

	Shader* genericShader = nullptr;
	if(!shaderManager.GetShader("objshader", &genericShader))
	{
		LOG(ERROR) << "Couldn't fetch objshader from shadermanager. Aborting.";
		return false;
	}
	else
	{
		objShader = static_cast<OBJShader*>(genericShader);
		objShader->SetupBuffers(matrixUBO, 0);
	}

	return true;
}
コード例 #6
0
void AppMain()
{
	Vector3 camFr(0.476459, -0.334238, 0.813186);
	Vector3 camUp(00.168968, 0.942489, 0.288382);
	Vector3 camRi = camUp ^ camFr;
	Vector3 camPos(-6, 10, -13);

	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(50,
				   (float)SCREEN_W / (float)SCREEN_H, // Aspect ratio
				   0.1, 1000); // Far plane

	while (!g_keys[KEY_ESC])
	{
		glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

		float camPosMag = camPos.Mag();
		float moveSpeed = 0.01f * camPosMag;
		int velx, vely;
		get_mouse_mickeys(&velx, &vely);
		if (mouse_b & 2)
		{
			camFr.RotateAroundY((float)-velx / 100.0f);
			camUp.RotateAroundY((float)-velx / 100.0f);
			camRi = camUp ^ camFr;
			camFr.RotateAround(camRi, (float)vely / 100.0f);
			camUp.RotateAround(camRi, (float)vely / 100.0f);
			moveSpeed *= 3.0f;
		}

		if (key[KEY_W])	camPos += camFr * moveSpeed;
		if (key[KEY_S])	camPos -= camFr * moveSpeed;
		if (key[KEY_A])	camPos += camRi * moveSpeed;
		if (key[KEY_D])	camPos -= camRi * moveSpeed;
		if (key[KEY_Q]) camPos.y -= moveSpeed;
		if (key[KEY_E]) camPos.y += moveSpeed;

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		Vector3 lookAtPos = camPos + camFr;
		gluLookAt(camPos.x, camPos.y, camPos.z,
				  lookAtPos.x, lookAtPos.y, lookAtPos.z,
				  camUp.x, camUp.y, camUp.z);
	
		DrawGrid(camPos);

		// *** Do the maths we actually want to test
		MainUserLoop();

		allegro_gl_flip();
	}

	return 0;
}
コード例 #7
0
ファイル: omnimapd3d.cpp プロジェクト: elumenati/omnimap
void OmniMapD3D::LoadAndPush_ProjectiveTexturing_Matricies()
{
  D3DXMATRIX matView;
  D3DXVECTOR3 camPos( ProjectorPosition.pos.x, ProjectorPosition.pos.y, ProjectorPosition.pos.z ); // Camera position
  D3DXVECTOR3 camLookat( ProjectorPosition.lookAtpos.x, ProjectorPosition.lookAtpos.y, ProjectorPosition.lookAtpos.z );   // Look-at point
  D3DXVECTOR3 camUp( ProjectorPosition.headsUp.x, ProjectorPosition.headsUp.y, ProjectorPosition.headsUp.z ); // Up vector

  D3DXMatrixOrthoRH(&worldViewProjection, 2.0, 2.0, 0.0, 1.0f);
  D3DXMatrixLookAtRH( &worldView, &camPos, &camLookat, &camUp);
}
コード例 #8
0
ファイル: wxOgre.cpp プロジェクト: johnfredcee/meshmixer
bool wxOgre::frameEnded(const Ogre::FrameEvent& evt)
{
	static const wxString camPosCaption(wxT("CamPos:X:%06.3f, Y:%06.3f, Z:%06.3f"));
	Ogre::OverlayElement* guiCurr  = Ogre::OverlayManager::getSingleton().getOverlayElement("TextAreaOverlayElement");
	Ogre::Vector3 camPos(mCamera->getRealPosition());
	wxString camText(wxString::Format(camPosCaption, camPos.x, camPos.y, camPos.z));
	guiCurr->setCaption(Ogre::String(camText.mb_str(wxConvUTF8)));
	return true;
		
}
コード例 #9
0
ファイル: getAngle.cpp プロジェクト: 463243109/Eu_test
void getcamPose(cv::Point3f & campose)
{
	cv::Mat invR(3,3,CV_64F);
	invR=rotateMat.t();
	cv::Mat camPos(3,1,CV_64F);	//正交阵求逆
	camPos=invR*tranVector;

   // std::cout<<"invR="<<invR<<std::endl;
	//std::cout<<"camPos"<<camPos<<std::endl;
	campose.x=-1*camPos.at<double>(0,0);
	campose.y=-1*camPos.at<double>(1,0);
	campose.z=-1*camPos.at<double>(2,0);

}
コード例 #10
0
void ObjcetControl::cameraMove( float x,float y,float z )
{
	//根据箭头与摄像机的距离,动态调整箭头的大小
	Ogre::Vector3 camPos(x,y,z);
	camPos-=mArrowNode->getPosition();
	float camDistance=camPos.squaredLength();
	camDistance/=5000;
	if (camDistance<=1)
	{
		camDistance=1;
	}

	mArrowNode->setScale(camDistance,camDistance,camDistance);
}
コード例 #11
0
ファイル: ShipRace.cpp プロジェクト: PatB92/Ship_Race
// Disables the game and ship
void ShipRace::DisableGame()
{
	D3DXVECTOR3 camPos(0.0f, 0.0f, -1000.0f);
	gEngine->GetCamera()->SetCamPos(camPos);
	endScreen->SetVisible(true);
	raceTrack->SetTrackStatus(false);
	ship->SetShipStatus(false);
	mIsGameOver = true;

	for (int i = 0; i < 9; ++i)
	{
		mObstacles[i]->SetActive(false);
	}
}
コード例 #12
0
ファイル: CCameraController.cpp プロジェクト: whztt07/CG2015
void CCameraController::update(float dtime)
{
	if (m_active && m_object != nullptr && m_camera != nullptr)
	{
		// Update camera movement
		glm::vec3 pos = m_object->getPosition();
		glm::vec3 forward = m_object->getForward();

		// Where the camera should be
		glm::vec3 camPos(pos.x - forward.x * 8.f, pos.y * 0.95f + 3.f, pos.z - forward.z * 8.f);
		m_camera->setPosition(camPos);

		// Init on first update
		if (m_first)
		{
			m_first = false;
			m_prevLookAt = pos + forward * 3.f;
		}
		// 
		glm::vec3 targetLookAt = pos + forward * 3.f;

		float distance = glm::distance(targetLookAt, m_prevLookAt);
		glm::vec3 d = glm::normalize(targetLookAt - m_prevLookAt);
		
		if (distance > 5.f)
		{
			m_speed = 26.f;
		}
		if (distance < 2.f)
		{
			m_speed = 20.f;
		}
		float move = m_speed * dtime;
		if (move >= distance || distance > 8.f)
		{
			m_prevLookAt = targetLookAt;
		}
		else
		{
			m_prevLookAt += d * move;
		}

		m_camera->lookAt(m_prevLookAt, glm::vec3(0.f, 1.f, 0.f));
	}
}
コード例 #13
0
void OgreWidget::initOgreSystem()
{
    ogreRoot = new Ogre::Root();

    Ogre::RenderSystem *renderSystem = ogreRoot->getRenderSystemByName("OpenGL Rendering Subsystem");
    ogreRoot->setRenderSystem(renderSystem);
    ogreRoot->initialise(false);

    ogreSceneManager = ogreRoot->createSceneManager(Ogre::ST_GENERIC);

    Ogre::NameValuePairList viewConfig;
    Ogre::String widgetHandle;
#ifdef Q_WS_WIN
    widgetHandle = Ogre::StringConverter::toString((size_t)((HWND)winId()));
#else
    QWidget *q_parent = dynamic_cast <QWidget *> (parent());
    QX11Info xInfo = x11Info();

    widgetHandle = Ogre::StringConverter::toString ((unsigned long)xInfo.display()) +
        ":" + Ogre::StringConverter::toString ((unsigned int)xInfo.screen()) +
        ":" + Ogre::StringConverter::toString ((unsigned long)q_parent->winId());

#endif
    viewConfig["externalWindowHandle"] = widgetHandle;
    ogreRenderWindow = ogreRoot->createRenderWindow("Ogre rendering window",
                width(), height(), false, &viewConfig);

    ogreCamera = ogreSceneManager->createCamera("myCamera");
    Ogre::Vector3 camPos(0, 50,150);
        ogreCamera->setPosition(camPos);
        ogreCamera->lookAt(0,50,0);
    emit cameraPositionChanged(camPos);

    ogreViewport = ogreRenderWindow->addViewport(ogreCamera);
    ogreViewport->setBackgroundColour(Ogre::ColourValue(0,0,255));
    ogreCamera->setAspectRatio(Ogre::Real(width()) / Ogre::Real(height()));

        setupNLoadResources();
        createScene();
}
コード例 #14
0
void DistanceSensor::drawObject(const VisualizationParameterSet& visParams)
{
  if(visParams.visualizeSensors && !visParams.drawForSensor)
  {
    glColor3d(visualizationColor.v[0],
      visualizationColor.v[1],
      visualizationColor.v[2]);
    Vector3d camPos(position);
    if(projection == SPHERICAL_PROJECTION)
    {
      glBegin(GL_LINES);
        for(unsigned int i=0; i< sensorDataSize; i++)
        {
          Vector3d distanceVec(sensorReading.data.doubleArray[i],0,0);
          double maxAngle(angleX);
          double zRotation(maxAngle/(double)resolutionX);
          zRotation *= (double)i;
          zRotation -= maxAngle/2.0;
          distanceVec.rotateZ(zRotation);
          distanceVec.rotate(rotation);
          distanceVec+=position;
          glVertex3d (camPos.v[0], camPos.v[1], camPos.v[2]);
          glVertex3d (distanceVec.v[0], distanceVec.v[1], distanceVec.v[2]);
        }
      glEnd();
    }
    else
    {
      Vector3d distanceVec(sensorReading.data.doubleArray[0],0,0);
      distanceVec.rotate(rotation);
      distanceVec+=position;
      //Draw distance vector
      glBegin(GL_LINES);
        glVertex3d (camPos.v[0], camPos.v[1], camPos.v[2]);
        glVertex3d (distanceVec.v[0], distanceVec.v[1], distanceVec.v[2]);
      glEnd();
    }
  }
}
コード例 #15
0
ファイル: Functions.hpp プロジェクト: blitzprog/flua
inline void flua_setCamera(float x, float y, float z, float camAngleX, float camAngleY) {
    glm::vec3 lookat(0, 0, 0);

    lookat.x = sinf(camAngleX) * cosf(camAngleY);
    lookat.y = sinf(camAngleY);
    lookat.z = -cosf(camAngleX) * cosf(camAngleY);

    glm::vec3 camPos(x, y, z);
    glm::vec3 camUp(0.0, 1.0, 0.0);

#ifdef _WIN32
    int nWidth = glutGet(GLUT_WINDOW_WIDTH);
    int nHeight = glutGet(GLUT_WINDOW_HEIGHT);

    if(flua_width != nWidth || flua_height != nHeight) {
        flua_onReshape(nWidth, nHeight);
    }
#endif

    flua_viewMatrix = glm::lookAt(camPos, camPos + lookat, camUp);
    flua_viewAndProjectionMatrix = flua_projectionMatrix * flua_viewMatrix;
}
コード例 #16
0
void SegmentedRayCastingRenderer::preRender() {
    _tfTex->bind(1);

    _shader->setUniform2f("imageScale", 1.0f / (float)_renderWindow->width(), 1.0f / (float)_renderWindow->height());
    _shader->setUniform1f("sampleInterval", (*_ps)["sampleStep"].toFloat() * _model->scaledDim().length());
    _shader->setUniform4f("lightParam", (*_ps)["ambient"].toFloat(), (*_ps)["diffuse"].toFloat(), (*_ps)["specular"].toFloat(), (*_ps)["shininess"].toFloat());
    Vector3 v = _renderWindow->getCamera().getCamPosition();
    Vector3f camPos((float)v.x(), (float)v.y(), (float)v.z());
    _shader->setUniform3f("viewVec", camPos);

    _visOrder.clear();
    for (int i = 0; i < _model->blockCount(); i++) {
        RegularGridDataBlock &dataBlock = _model->volumeDataBlock(i, (*_ps)["timestep"].toInt() - 1, (*_ps)["compIdx"].toInt());
        float dist = (dataBlock.boxCenter() - camPos).length();
        _visOrder.append(std::pair<float, int>(dist, i));
    }
    std::sort(_visOrder.begin(), _visOrder.end());

    for (int i = 0; i < _visOrder.size(); i++)
        qDebug("%d: (%f, %d)", i, _visOrder[i].first, _visOrder[i].second);

}
コード例 #17
0
ファイル: VoxelEditor.cpp プロジェクト: bytesnake/voxelart
vaEngine::Vector cubiverse::VoxelEditor::checkCollision(float p_x, float p_y, float p_z) {
	float matrix[16];
	glGetFloatv( GL_MODELVIEW_MATRIX, matrix );
	vaEngine::Vector camera( matrix[2], matrix[6], matrix[10] );
	camera = camera / 2.0f;

	vaEngine::Vector camPos(p_x, p_y, p_z);

	cout << "X:" << camera[0] << " Y:" << camera[1] << " Z:" << camera[2] << endl;
	if(p_y > 20 && camera.y > 0) {
		bool run = true;
		while(camPos.y > 20 && run) {
			camPos = camPos - camera;
			for(int mesh = 0; mesh < meshs.size(); mesh++) {
				if(hasVoxel(camPos.x,camPos.y,camPos.z, mesh)) run = false;
			}
		}
		cout << "FOUND POS:" << camPos.x  << " : " << camPos.z << endl;
		return camPos;
	}			
	

}
コード例 #18
0
ファイル: Camera.cpp プロジェクト: duxing/GhostSPH
void Camera::aim()
{
	// Get the window size
	int width, height;
	glfwGetWindowSize(&width, &height);
	// Make sure that height is non-zero to avoid division by zero
	height = height < 1 ? 1 : height;

	glViewport(0, 0, width, height);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Set up the projection matrix  
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	// Window aspect (assumes square pixels)
	float aspectRatio = (float)width / (float)height;
	// Set perspective view
	gluPerspective(mFov, aspectRatio, mNearPlane, mFarPlane);

	vec3 camPos(mLookX + mRadius * std::cos(DEG2RAD(mHead)) * std::cos(DEG2RAD(mPitch)),
				mLookY + mRadius * std::sin(DEG2RAD(mHead)),
				mLookZ + mRadius * std::cos(DEG2RAD(mHead)) * std::sin(DEG2RAD(mPitch)));

	mForward = vec3(mLookX - camPos.x, mLookY - camPos.y, mLookZ - camPos.z);
	mForward = glm::normalize(mForward);
	vec3 up = vec3(0.0f, (std::cos(DEG2RAD(mHead)) > 0.0f) ? 1.0f : -1.0f, 0.0f);
	mSide = glm::cross(mForward, up);
	mUp = glm::cross(mSide, mForward);

	// Set up modelview matrix
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(camPos.x, camPos.y, camPos.z,
		mLookX, mLookY, mLookZ,
		up.x, up.y, up.z); 
}
コード例 #19
0
void SeleneDev::CGame::Tick(float deltaTime)
{
	Selene::CVirtualFileSystem* pVfs = GetSupervisor()->GetVFS();
	Selene::CGraphics* pGraphics = GetSupervisor()->GetGraphics();

	// test
	//
	m_ElapsedTime += deltaTime;
	float period = 8.0f;
	float phaseTime = fmodf(m_ElapsedTime, period);
	float phase = phaseTime / period;
	float radius = 10.0f;
	float pi = 3.141592f;
	Selene::Vector3 camPos(13.0f, 10.0, 4.0f);
	Selene::Vector3 lookAt(-1.5f, 1.0f, -5.0f);
	Selene::Vector3 camUp(0.0f, 1.0f, 0.0f);
	camPos.m_X = cosf(pi * 2.0f * phase) * radius + lookAt.m_X;
	camPos.m_Z = sinf(pi * 2.0f * phase) * radius + lookAt.m_Z;
	//pGraphics->GetActiveCamera()->Look(camPos, lookAt, camUp);

	m_pTestNode->Update(deltaTime);
	m_pFpsNode->Update(deltaTime);
	m_pHudNode->Update(deltaTime);
}
コード例 #20
0
bool CD3DGraphics11::RenderTextureLightingShader(D3DXMATRIX world, int numIndices, CMaterialDX11 mat)
{
	CGameScene& scene = SYSTEM::PROJECT::GetScene();
	CGameobjectList l = scene.GetLightList();
	int n_l = l.GetNumObjects();
	CCamera* c = scene.GetCamera(0);

	if(!c)
		return false;

	D3DXVECTOR4 amb(mat.GetAmbientColor().r,mat.GetAmbientColor().g,mat.GetAmbientColor().b,mat.GetAmbientColor().a);
	D3DXVECTOR4 spec(mat.GetSpecularColor().r,mat.GetSpecularColor().g,mat.GetSpecularColor().b,mat.GetSpecularColor().a);
	D3DXVECTOR3 camPos(c->GetTransform().GetTranslation().x,c->GetTransform().GetTranslation().y,
		c->GetTransform().GetTranslation().z);

	if (mat.GetDiffuseTexture())
		return m_textureLightingShader.Render(*this, numIndices, m_matrices.view, world, m_matrices.projection, mat.GetDiffuseTexture(),
			l, n_l, amb, camPos, spec, 64.0f);
	else
		return m_textureLightingShader.Render(*this, numIndices, m_matrices.view, world, m_matrices.projection, m_pDefaultTexture,
			l, n_l, amb, camPos, spec, 64.0f);

	return true;
}
コード例 #21
0
ファイル: cameraMan.cpp プロジェクト: gradunza5/projects
bool CameraMan::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
	// update accelerations
	Ogre::Vector3 accel = calculateAccelerations();

	// if accelerating, try to reach top speed in a certain time
	Ogre::Real topSpeed = mFastMove ? mTopSpeed * 2 : mTopSpeed;
	double y_tmp = mVelocity.y;
	if (accel.squaredLength() != 0)
	{
		accel.normalise();
		mVelocity += accel * topSpeed * evt.timeSinceLastFrame * 10;
	}
	// if not accelerating, try to stop in a certain time
	else 
	{
		mVelocity -= mVelocity * evt.timeSinceLastFrame * 10;
	}
	mVelocity.y = y_tmp;

	// vertical movement
	if (mJump) mVelocity.y = jumpSpeed;
	mJump = false;
	mVelocity.y -= gravityAccel * evt.timeSinceLastFrame;

	Ogre::Real tooSmall = std::numeric_limits<Ogre::Real>::epsilon();

	y_tmp = mVelocity.y;
	mVelocity.y = 0;
	// keep camera velocity below top speed and above epsilon
	if (mVelocity.squaredLength() > topSpeed * topSpeed)
	{
		mVelocity.normalise();
		mVelocity *= topSpeed;
	}
	else if (mVelocity.squaredLength() < tooSmall * tooSmall)
	{
		mVelocity = Ogre::Vector3::ZERO;
	}
	mVelocity.y = y_tmp;

	// terrain handling, raycast each unit direction
	PolyVox::RaycastResult resultXH;
	PolyVox::RaycastResult resultXL;
	PolyVox::RaycastResult resultY;
	PolyVox::RaycastResult resultZH;
	PolyVox::RaycastResult resultZL;

	double width = 0.5;
	PolyVox::Vector3DFloat cameraPos( mCamera->getPosition().x, mCamera->getPosition().y,						mCamera->getPosition().z );
	PolyVox::Vector3DFloat cameraPosH( mCamera->getPosition().x, mCamera->getPosition().y + width,				mCamera->getPosition().z );
	PolyVox::Vector3DFloat cameraPosL( mCamera->getPosition().x, mCamera->getPosition().y - charHeight + width,	mCamera->getPosition().z );

	if( mVelocity.x > 0 )
	{
		mTerrain->raycast( cameraPosH, PolyVox::Vector3DFloat( width, 0, 0), resultXH);
		mTerrain->raycast( cameraPosL, PolyVox::Vector3DFloat( width, 0, 0), resultXL);
	}
	else if( mVelocity.x < 0 )
	{
		mTerrain->raycast( cameraPosH, PolyVox::Vector3DFloat(-width, 0, 0), resultXH);
		mTerrain->raycast( cameraPosL, PolyVox::Vector3DFloat(-width, 0, 0), resultXL);
	}
	else
	{
		resultXH.foundIntersection = false;
		resultXL.foundIntersection = false;
	}

	if( mVelocity.y > 0 )
	{
		mTerrain->raycast( cameraPosH, PolyVox::Vector3DFloat( 0, width, 0), resultY);
	}
	else if( mVelocity.y < 0 )
	{
		mTerrain->raycast( cameraPosL, PolyVox::Vector3DFloat( 0,-width, 0), resultY);
	}
	else
	{
		resultY.foundIntersection = false;
	}

	if( mVelocity.z > 0 )
	{
		mTerrain->raycast( cameraPosH, PolyVox::Vector3DFloat( 0, 0, width), resultZH);
		mTerrain->raycast( cameraPosL, PolyVox::Vector3DFloat( 0, 0, width), resultZL);
	}
	else if( mVelocity.z < 0 )
	{
		mTerrain->raycast( cameraPosH, PolyVox::Vector3DFloat( 0, 0,-width), resultZH);
		mTerrain->raycast( cameraPosL, PolyVox::Vector3DFloat( 0, 0,-width), resultZL);
	}
	else
	{
		resultZH.foundIntersection = false;
		resultZL.foundIntersection = false;
	}

	Ogre::Vector3 camPos( mCamera->getPosition() );
	// handle horizontal movement
	if( resultXH.foundIntersection || resultXL.foundIntersection )
	{
		mVelocity.x = 0;
		
		if( resultXH.foundIntersection )
		{
			camPos.x = resultXH.previousVoxel.getX();
		}
		else
		{
			camPos.x = resultXL.previousVoxel.getX();
		}
	}
	if( resultZH.foundIntersection || resultZL.foundIntersection )
	{
		mVelocity.z = 0;

		if( resultZH.foundIntersection )
		{
			camPos.z = resultZH.previousVoxel.getZ();
		}
		else
		{
			camPos.z = resultZL.previousVoxel.getZ();
		}
	}

	// handle ground/ceiling
	if( resultY.foundIntersection )
	{
		camPos.y = resultY.previousVoxel.getY();
		if( mVelocity.y < 0 )
		{
			camPos.y += charHeight - 1.0;
		}

		mVelocity.y = 0;
	}
	else
	{
		if( mVelocity.y < -fallSpeedMax )
		{
			mVelocity.y = -fallSpeedMax;
		}
	}

	// set new position, not in a voxel
	mCamera->setPosition( camPos );

	if (mVelocity != Ogre::Vector3::ZERO) mCamera->move(mVelocity * evt.timeSinceLastFrame);

	return true;
}
コード例 #22
0
ファイル: Mesh.cpp プロジェクト: BigJohnn/TextureMapping
void Mesh::Draw(Shader shader, bool drawFBO)
{
	// Bind appropriate textures
	GLuint diffuseNr = 1;
	GLuint specularNr = 1;
	GLuint reflectionNr = 1;

	//设备坐标系->纹理坐标系
	glm::mat4 biasMatrix(
		0.5, 0.0, 0.0, 0.0,
		0.0, 0.5, 0.0, 0.0,
		0.0, 0.0, 0.5, 0.0,
		0.5, 0.5, 0.5, 1.0
		);

	for (GLuint i = 0; i < this->textures.size(); i++)
	//int i = 1;
	{
		//float w = this->cam_pos[this->textures[i].id].at<float>(3, 0);
		glm::vec3 imageNorm(this->img_norm[this->textures[i].id].at<float>(0, 0), this->img_norm[this->textures[i].id].at<float>(1, 0), 
			this->img_norm[this->textures[i].id].at<float>(2, 0));
		glm::vec3 camPos(this->cam_pos[this->textures[i].id].at<float>(0, 0), this->cam_pos[this->textures[i].id].at<float>(1, 0), 
			this->cam_pos[this->textures[i].id].at<float>(2, 0));
		
		//cv::Mat VM = this->viewMatrices[i] * this->modelMatrix;// .inv() * this->modelMatrix.inv();
		cv::Mat VM = this->viewMatrices[i].inv() * this->modelMatrix.inv();

		cv::Mat vVM(VM, cv::Rect(3, 0, 1, 4));

		glm::vec3 cam(vVM.at<float>(0, 0), vVM.at<float>(1, 0), vVM.at<float>(2, 0));

		// Compute the MVP matrix from the light's point of view
		glm::mat4 depthProjectionMatrix = glm::perspective<float>(45.0f, 1.0f, near_plane, far_plane);

		glm::vec3 origin(0, 0, 0);
		glm::mat4 depthViewMatrix = glm::lookAt(camPos, origin, glm::vec3(0, 1, 0));//glm::lookAt(lightInvDir, glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
		
		glm::mat4 depthModelMatrix;
		
		depthModelMatrix = glm::scale(depthModelMatrix, glm::vec3(0.01f, 0.01f, 0.01f));	// It's a bit too big for our scene, so scale it down
		glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;

		
		if (drawFBO == false)
		{
			
			glActiveTexture(GL_TEXTURE0 + i); // Active proper texture unit before binding
			// Retrieve texture number (the N in diffuse_textureN)
			stringstream ss;
			string number;
			string name = this->textures[i].type;
			if (name == "texture_diffuse")
				ss << diffuseNr++; // Transfer GLuint to stream
			
			number = ss.str();
			// Now set the sampler to the correct texture unit
			glUniform1i(glGetUniformLocation(shader.Program, ( name).c_str()), i);

			glUniform3fv(glGetUniformLocation(shader.Program, "imgNorm" ), 1, glm::value_ptr(imageNorm));

			glUniform3fv(glGetUniformLocation(shader.Program, "camPos"), 1, glm::value_ptr(camPos));

			// And finally bind the texture
			glBindTexture(GL_TEXTURE_2D, i+1);
			
			glm::mat4 depthBiasMVP = biasMatrix*depthMVP;
			glUniformMatrix4fv(glGetUniformLocation(shader.Program, "DepthBiasMVP"), 1, GL_FALSE, glm::value_ptr(depthBiasMVP));

			//zhongyao
			int d = this->textures.size() + i;
			glActiveTexture(GL_TEXTURE0 + d);
			glBindTexture(GL_TEXTURE_2D, in.depthTexture[i]);
			glUniform1i(glGetUniformLocation(shader.Program, "shadowMap"), d);

			glEnable(GL_CULL_FACE);
			glCullFace(GL_BACK); // Cull back-facing triangles -> draw only front-facing triangles
			glBindVertexArray(this->VAO[textures[i].id]);
			glDrawElements(GL_TRIANGLES, this->indices4draw[textures[i].id].size(), GL_UNSIGNED_INT, 0);
			glCullFace(GL_FRONT); // Cull back-facing triangles -> draw only front-facing triangles
			glBindVertexArray(0);
		}
		else
		{
			glBindFramebuffer(GL_DRAW_FRAMEBUFFER, in.depthMapFBO[i]);
			
			// Clear the screen
			glClear(GL_DEPTH_BUFFER_BIT);

			glm::mat4 shadowProj = glm::perspective(90.0f, 1.0f, 1.0f, 25.0f);

			glm::mat4 depthMVPD = shadowProj *
				glm::lookAt(camPos, camPos + glm::vec3(1.0, 0.0, 0.0), glm::vec3(0.0, -1.0, 0.0));
			glUniformMatrix4fv(glGetUniformLocation(shader.Program, "depthMVP"), 1, GL_FALSE, glm::value_ptr(depthMVPD));
			
			glEnable(GL_CULL_FACE);
			glCullFace(GL_BACK); // Cull back-facing triangles -> draw only front-facing triangles
			glBindVertexArray(this->VAO[textures[i].id]);
			glDrawElements(GL_TRIANGLES, this->indices4draw[textures[i].id].size(), GL_UNSIGNED_INT, 0);
			glCullFace(GL_FRONT);
			glBindVertexArray(0);
			
		}
		glActiveTexture(GL_TEXTURE0);	
	}
}
コード例 #23
0
//--------------------------------------------------------------------------------------------------
std::vector<PointData> generateImagePoints( const cv::Mat& cameraWorldMtx, const cv::Mat& cameraCalibMtx,
        int32_t imageWidth, int32_t imageHeight, const cv::Mat& chessboardPoseMtx )
{
    std::vector<PointData> points;
    points.reserve( imageWidth*imageHeight );

    cv::Mat camAxisX( cameraWorldMtx, cv::Rect( 0, 0, 1, 3 ) );
    cv::Mat camAxisY( cameraWorldMtx, cv::Rect( 1, 0, 1, 3 ) );
    cv::Mat camAxisZ( cameraWorldMtx, cv::Rect( 2, 0, 1, 3 ) );
    cv::Mat camPos( cameraWorldMtx, cv::Rect( 3, 0, 1, 3 ) );

    cv::Mat chessboardAxisX( chessboardPoseMtx, cv::Rect( 0, 0, 1, 3 ) );
    cv::Mat chessboardAxisY( chessboardPoseMtx, cv::Rect( 1, 0, 1, 3 ) );
    cv::Mat chessboardAxisZ( chessboardPoseMtx, cv::Rect( 2, 0, 1, 3 ) );
    cv::Mat chessboardPos( chessboardPoseMtx, cv::Rect( 3, 0, 1, 3 ) );

    double chessboardPlaneDist = cv::Mat( chessboardPos.t()*chessboardAxisZ ).at<double>( 0 );

    // Used to calculate plane intersection
    double intersectionConstant = chessboardPlaneDist - cv::Mat(camPos.t()*chessboardAxisZ).at<double>( 0 );

    // Generate the image points using very simple ray tracing
    for ( int32_t y = 0; y < imageHeight; y++ )
    {
        for ( int32_t x = 0; x < imageWidth; x++ )
        {
            double imagePlaneX = (x - cameraCalibMtx.at<double>( 0, 2 )) / cameraCalibMtx.at<double>( 0, 0 );
            double imagePlaneY = (y - cameraCalibMtx.at<double>( 1, 2 )) / cameraCalibMtx.at<double>( 1, 1 );
            cv::Mat rayDir = camAxisZ + imagePlaneX*camAxisX + imagePlaneY*camAxisY;

            double cosOfAngleToChessboard = cv::Mat(rayDir.t()*chessboardAxisZ).at<double>( 0 );
            if ( 0.0 != cosOfAngleToChessboard )
            {
                double distanceToBoard = intersectionConstant/cosOfAngleToChessboard;

                if ( distanceToBoard > 0.0 )
                {
                    cv::Mat intersectionPos = camPos + rayDir*distanceToBoard;
                    cv::Mat fromCentreVec = intersectionPos - chessboardPos;

                    double chessX = cv::Mat(chessboardAxisX.t()*fromCentreVec).at<double>( 0 );
                    double chessY = cv::Mat(chessboardAxisY.t()*fromCentreVec).at<double>( 0 );

                    ePixelColour pixelColour = ePC_None;

                    if ( gbDrawCircles )
                    {
                        double boardU = chessX + 0.5*CHESSBOARD_TOTAL_WIDTH;
                        double boardV = chessY + 0.5*CHESSBOARD_TOTAL_HEIGHT;
                        pixelColour = getCircleboardPixelColour( boardU, boardV );
                    }
                    else
                    {
                        double u = chessX/CHESSBOARD_TOTAL_WIDTH + 0.5;
                        double v = chessY/CHESSBOARD_TOTAL_HEIGHT + 0.5;
                        pixelColour = getChessboardPixelColour( u, v );
                    }

                    if ( ePC_None != pixelColour )
                    {
                        PointData pointData;
                        pointData.mPixelX = x;
                        pointData.mPixelY = y;
                        pointData.mWorldX = intersectionPos.at<double>( 0 );
                        pointData.mWorldY = intersectionPos.at<double>( 1 );
                        pointData.mWorldZ = intersectionPos.at<double>( 2 );
                        pointData.mPixelColour = pixelColour;

                        points.push_back( pointData );
                    }
                }
            }
        }
    }

    return points;
}
コード例 #24
0
ファイル: scatterSky.cpp プロジェクト: AkiraofAstra/Torque3D
void ScatterSky::_render( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
{
   if ( overrideMat || (!mShader && !_initShader()) )
      return;

   GFXTransformSaver saver;

   if ( mVB.isNull() || mPrimBuffer.isNull() )
      _initVBIB();

   GFX->setShader( mShader );
   GFX->setShaderConstBuffer( mShaderConsts );

   Point4F sphereRadii( mSphereOuterRadius, mSphereOuterRadius * mSphereOuterRadius,
                        mSphereInnerRadius, mSphereInnerRadius * mSphereInnerRadius );

   Point4F scatteringCoeffs( mRayleighScattering * mSkyBrightness, mRayleighScattering4PI,
                             mMieScattering * mSkyBrightness, mMieScattering4PI );

   Point4F invWavelength(  1.0f / mWavelength4[0],
                           1.0f / mWavelength4[1],
                           1.0f / mWavelength4[2], 1.0f );

   Point3F camPos( 0, 0, smViewerHeight );
   Point4F miscParams( camPos.z, camPos.z * camPos.z, mScale, mScale / mRayleighScaleDepth );

   Frustum frust = state->getFrustum();
   frust.setFarDist( smEarthRadius + smAtmosphereRadius );
   MatrixF proj( true );
   frust.getProjectionMatrix( &proj );

   Point3F camPos2 = state->getCameraPosition();
   MatrixF xfm(true);
   xfm.setPosition(camPos2);//-Point3F( 0, 0, 200000.0f));
   GFX->multWorld(xfm);
   MatrixF xform(proj);//GFX->getProjectionMatrix());
   xform *= GFX->getViewMatrix();
   xform *=  GFX->getWorldMatrix();

   mShaderConsts->setSafe( mModelViewProjSC, xform );
   mShaderConsts->setSafe( mMiscSC, miscParams );
   mShaderConsts->setSafe( mSphereRadiiSC, sphereRadii );
   mShaderConsts->setSafe( mScatteringCoefficientsSC, scatteringCoeffs );
   mShaderConsts->setSafe( mCamPosSC, camPos );
   mShaderConsts->setSafe( mLightDirSC, mLightDir );
   mShaderConsts->setSafe( mSunDirSC, mSunDir );
   mShaderConsts->setSafe( mNightColorSC, mNightColor );
   mShaderConsts->setSafe( mInverseWavelengthSC, invWavelength );
   mShaderConsts->setSafe( mNightInterpolantAndExposureSC, Point2F( mExposure, mNightInterpolant ) );
   mShaderConsts->setSafe( mColorizeSC, mColorize*mColorizeAmt );

   if ( GFXDevice::getWireframe() )
   {
      GFXStateBlockDesc desc( mStateBlock->getDesc() );
      desc.setFillModeWireframe();
      GFX->setStateBlockByDesc( desc );
   }
   else
      GFX->setStateBlock( mStateBlock );

   if ( mUseNightCubemap && mNightCubemap )
   {
      mShaderConsts->setSafe( mUseCubemapSC, 1.0f );

      if ( !mNightCubemap->mCubemap )
         mNightCubemap->createMap();

      GFX->setCubeTexture( 0, mNightCubemap->mCubemap );
   }
   else
   {
      GFX->setCubeTexture( 0, NULL );
      mShaderConsts->setSafe( mUseCubemapSC, 0.0f );
   }

	GFX->setPrimitiveBuffer( mPrimBuffer );
   GFX->setVertexBuffer( mVB );

   GFX->drawIndexedPrimitive( GFXTriangleList, 0, 0, mVertCount, 0, mPrimCount );
}
コード例 #25
0
	bool operator()(Chunk* c1, Chunk* c2) {
		glm::vec3 chunkPos1(c1->GetPos().x,c1->GetPos().y,c1->GetPos().z);
		glm::vec3 chunkPos2(c2->GetPos().x,c2->GetPos().y,c2->GetPos().z);
		glm::vec3 camPos((int)floor(Engine::m_pCameraInstance->GetPos().x / Chunk::CHUNKSIZEX), (int)floor(Engine::m_pCameraInstance->GetPos().y / Chunk::CHUNKSIZEY), (int)floor(Engine::m_pCameraInstance->GetPos().z / Chunk::CHUNKSIZEZ));
		return glm::distance(chunkPos1, camPos) < glm::distance(chunkPos2, camPos);
	}