コード例 #1
0
	void GeometryManager::_updateGeometry(Ogre::Camera* c, const Ogre::Real& timeSinceLastFrame)
	{
		// Look for current camera data
		std::vector<VClouds::CameraData>& camerasData = mVClouds->_getCamerasData();
		std::vector<VClouds::CameraData>::iterator currentCameraDataIt;

		for (currentCameraDataIt = camerasData.begin(); currentCameraDataIt != camerasData.end(); currentCameraDataIt++)
		{
			if ((*currentCameraDataIt).camera == c)
			{
				break;
			}
		}

		std::vector<VClouds::CameraData>::reference currentCameraData = (*currentCameraDataIt);

		// Calculate wind offset
		Ogre::Vector2 CameraDirection = Ogre::Vector2(c->getDerivedDirection().x, c->getDerivedDirection().z);
		float offset = - CameraDirection.dotProduct(mVClouds->getWindDirectionV2()) * mVClouds->getWindSpeed() * timeSinceLastFrame;

		// Calculate camera offset
		Ogre::Vector2 CameraOffset = Ogre::Vector2(c->getDerivedPosition().x - currentCameraData.lastPosition.x, c->getDerivedPosition().z - currentCameraData.lastPosition.z);
		offset -= CameraOffset.dotProduct(CameraDirection);

		// Update camera data
		currentCameraData.cameraOffset += CameraOffset;
		currentCameraData.lastPosition = c->getDerivedPosition();

		// Update geometry displacement
		currentCameraData.geometryDisplacement += Ogre::Vector3(offset);

		if (currentCameraData.geometryDisplacement.z < 0 || currentCameraData.geometryDisplacement.z > (mC-mB)/mNc)
		{
			currentCameraData.geometryDisplacement.z -= ((mC-mB)/mNc)*Ogre::Math::IFloor((currentCameraData.geometryDisplacement.z)/((mC-mB)/mNc));
		}

		if (currentCameraData.geometryDisplacement.y < 0 || currentCameraData.geometryDisplacement.y > (mB-mA)/mNb)
		{
			currentCameraData.geometryDisplacement.y -= ((mB-mA)/mNb)*Ogre::Math::IFloor((currentCameraData.geometryDisplacement.y)/((mB-mA)/mNb));
		}

		if (currentCameraData.geometryDisplacement.x < 0 || currentCameraData.geometryDisplacement.x > mA/mNa)
		{
			currentCameraData.geometryDisplacement.x -= (mA/mNa)*Ogre::Math::IFloor((currentCameraData.geometryDisplacement.x)/(mA/mNa));
		}

		// Check under/over cloud rendering
		mCurrentDistance = c->getDerivedPosition()-mSceneNode->_getDerivedPosition();

		for (int k = 0; k < mNumberOfBlocks; k++)
		{
			mGeometryBlocks.at(k)->setWorldOffset(mWorldOffset + currentCameraData.cameraOffset);
			mGeometryBlocks.at(k)->updateGeometry(c, currentCameraData.geometryDisplacement, mCurrentDistance);
		}
	}
コード例 #2
0
	void GeometryManager::_updateGeometry(const Ogre::Real& timeSinceLastFrame)
	{
		// Calculate wind offset
		Ogre::Vector2 CameraDirection = Ogre::Vector2(mVClouds->getCamera()->getDerivedDirection().x, mVClouds->getCamera()->getDerivedDirection().z);
		float offset = - CameraDirection.dotProduct(mVClouds->getWindDirectionV2()) * mVClouds->getWindSpeed() * timeSinceLastFrame;
		mWorldOffset += mVClouds->getWindDirectionV2() * mVClouds->getWindSpeed() * timeSinceLastFrame;

		// Calculate camera offset
		Ogre::Vector2 CameraOffset = Ogre::Vector2(mVClouds->getCamera()->getDerivedPosition().x - mLastCameraPosition.x, mVClouds->getCamera()->getDerivedPosition().z - mLastCameraPosition.z);
		offset -= CameraOffset.dotProduct(CameraDirection);
		mWorldOffset += CameraOffset;

		for (int k = 0; k < mNumberOfBlocks; k++)
		{
			mGeometryBlocks.at(k)->update(offset);
			mGeometryBlocks.at(k)->setWorldOffset(mWorldOffset);
		}
	}
コード例 #3
0
//-----------------------------------------------------------------------
void Triangulator::addConstraints(const Shape& shape, DelaunayTriangleBuffer& tbuffer)
{	
	std::vector<DelaunaySegment> segList;
	// Determine which segments should be added
	for (int i = 0; i<shape.getPoints().size()-1; i++)
	{		
		bool isAlreadyIn = false;
		for (DelaunayTriangleBuffer::iterator it = tbuffer.begin(); it!=tbuffer.end();it++)
		{
			if (it->containsSegment(i,i+1)) 
			{
					isAlreadyIn = true;
					break;
			}			
		}
		// only do something for segments not already in DT
		if (!isAlreadyIn)
		{
			segList.push_back(DelaunaySegment(i, i+1));
		}
	}
	// Re-Triangulate according to the new segments
	for (std::vector<DelaunaySegment>::iterator it=segList.begin();it!=segList.end();it++)
	{
		// TODO remove all edges intersecting *it
		// TODO build two polygons
		// TODO Triangulate each polygon (directly into DelaunayTriangleBuffer)
	}
	// Clean up segments outside of shape
	if (shape.isClosed())
	{
		for (DelaunayTriangleBuffer::iterator it = tbuffer.begin(); it!=tbuffer.end();it++)
		{
			bool isTriangleOut = false;
			for (int i=0;i<3;i++)
			{
				int ind1 = it->i[i];
				int ind2 = it->i[(1+i)%3];					
				// if side of triangle==segment, it won't tell us if outside or inside => skip
				if (abs(ind1-ind2)!=1)
				{
					Ogre::Vector2 v = shape.getPoint(ind2)-shape.getPoint(ind1);
					Ogre::Real d1 = v.dotProduct(shape.getNormalBefore(ind1));
					Ogre::Real d2 = v.dotProduct(shape.getNormalAfter(ind1));
					Ogre::Vector2 t1 = shape.getDirectionBefore(ind1);
					Ogre::Vector2 n1 = shape.getNormalAfter(ind1);
					if (t1.dotProduct(n1)>0.)
					{
						if (d1>0. || d2>0.)
						{
							isTriangleOut = true;
							break;
						}
					}
					else
					{
						if (d1>0. && d2>0.)
						{
							isTriangleOut = true;
							break;
						}
					}					
				}
			}
			if (isTriangleOut)
			{
				it = tbuffer.erase(it);
				it--;
			}
		}			
	}

}