示例#1
0
	//-----------------------------------------------------------------------
	void ConvexBody::storeEdgesOfPolygon(size_t poly, Polygon::EdgeMap *edgeMap ) const
	{
		OgreAssert(poly <= getPolygonCount(), "Search position out of range" );
		OgreAssert( edgeMap != NULL, "TEdgeMap ptr is NULL" );

		mPolygons[poly]->storeEdges(edgeMap);
	}
void LodOutputProviderBuffer::inject()
{
    unsigned short submeshCount = ushort(mBuffer.submesh.size());
    OgreAssert(mMesh->getNumSubMeshes() == submeshCount, "");
    mMesh->removeLodLevels();
    for (unsigned short i = 0; i < submeshCount; i++) {
        SubMesh::LODFaceList& lods = mMesh->getSubMesh(i)->mLodFaceList;
        typedef vector<LodIndexBuffer>::type GenBuffers;
        GenBuffers& buffers = mBuffer.submesh[i].genIndexBuffers;

        size_t buffCount = buffers.size();
        for (size_t n=0; n<buffCount;n++) {
            LodIndexBuffer& buff = buffers[n];
            size_t indexCount = (buff.indexBufferSize ? buff.indexBufferSize : buff.indexCount);
            OgreAssert((int)buff.indexCount >= 0, "");
            lods.push_back(OGRE_NEW IndexData());
            lods.back()->indexStart = buff.indexStart;
            lods.back()->indexCount = buff.indexCount;
            if(indexCount != 0) {
                if(n > 0 && buffers[n-1].indexBuffer == buff.indexBuffer){
                    lods.back()->indexBuffer = (*(++lods.rbegin()))->indexBuffer;
                } else {
                    lods.back()->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer(
                        buff.indexSize == 2 ?
                        HardwareIndexBuffer::IT_16BIT : HardwareIndexBuffer::IT_32BIT,
                        indexCount, mMesh->getIndexBufferUsage(), mMesh->isIndexBufferShadowed());
                    size_t sizeInBytes = lods.back()->indexBuffer->getSizeInBytes();
                    void* pOutBuff = lods.back()->indexBuffer->lock(0, sizeInBytes, HardwareBuffer::HBL_DISCARD);
                    memcpy(pOutBuff, buff.indexBuffer.get(), sizeInBytes);
                    lods.back()->indexBuffer->unlock();
                }
            }
        }
    }
}
示例#3
0
//-------------------------------------------------------
float Ground::GetHeightAt(float s, float t) const
{
    OgreAssert(0.0f <= s && s <= 1.0f && 0.0f <= t && t <= 1.0f, "S and T should be from [0, 1]");
    OgreAssert(nullptr != mImage.get(), "Ground[GetHeightAt]: Not initialized");

    size_t x = static_cast<size_t>(s * (mImage->getWidth() - 1));
    size_t y = static_cast<size_t>(t * (mImage->getHeight() - 1));

    return mImage->getColourAt(x, y, 0)[0];
}
示例#4
0
	//-----------------------------------------------------------------------
	void ConvexBody::insertPolygon(Polygon* pdata, size_t poly )
	{
		OgreAssert(poly <= getPolygonCount(), "Insert position out of range" );
		OgreAssert( pdata != NULL, "Polygon is NULL" );

		PolygonList::iterator it = mPolygons.begin();
		std::advance(it, poly);

		mPolygons.insert( it, pdata );

	}
示例#5
0
	//-----------------------------------------------------------------------
	void ConvexBody::setPolygon(Polygon* pdata, size_t poly)
	{
		OgreAssert(poly < getPolygonCount(), "Search position out of range" );
		OgreAssert(pdata != NULL, "Polygon is NULL" );

		if (pdata != mPolygons[poly])
		{
			// delete old polygon
			freePolygon(mPolygons[ poly ]);

			// set new polygon
			mPolygons[poly] = pdata;
		}
	}
示例#6
0
	//-----------------------------------------------------------------------
	void ConvexBody::insertPolygon(Polygon* pdata)
	{
		OgreAssert( pdata != NULL, "Polygon is NULL" );

		mPolygons.push_back( pdata );

	}
示例#7
0
    //-----------------------------------------------------------------------
    void RenderSystem::setDepthBufferFor( RenderTarget *renderTarget )
    {
        uint16 poolId = renderTarget->getDepthBufferPool();
        if( poolId == DepthBuffer::POOL_NO_DEPTH )
            return; //RenderTarget explicitly requested no depth buffer

        //Find a depth buffer in the pool
        DepthBufferVec::const_iterator itor = mDepthBufferPool[poolId].begin();
        DepthBufferVec::const_iterator end  = mDepthBufferPool[poolId].end();

        bool bAttached = false;
        while( itor != end && !bAttached )
            bAttached = renderTarget->attachDepthBuffer( *itor++ );

        //Not found yet? Create a new one!
        if( !bAttached )
        {
            DepthBuffer *newDepthBuffer = _createDepthBufferFor( renderTarget );

            if( newDepthBuffer )
            {
                newDepthBuffer->_setPoolId( poolId );
                mDepthBufferPool[poolId].push_back( newDepthBuffer );

                bAttached = renderTarget->attachDepthBuffer( newDepthBuffer );

                OgreAssert( bAttached ,"A new DepthBuffer for a RenderTarget was created, but after creation"
                                     " it says it's incompatible with that RT" );
            }
            else
                LogManager::getSingleton().logMessage( "WARNING: Couldn't create a suited DepthBuffer"
                                                       "for RT: " + renderTarget->getName() , LML_CRITICAL);
        }
    }
	std::pair< DynamicRenderable::MeshData::VertexData *, DynamicRenderable::MeshData::Index * > 
	DynamicRenderable::getMeshData( const int nLOD, const size_t nStitchFlags )
	{
		OgreAssert(_pvMeshData[nLOD] != NULL, "Resolution doesn't exist");
		return std::pair< DynamicRenderable::MeshData::VertexData *, DynamicRenderable::MeshData::Index * > 
			(& _pvMeshData[nLOD] ->vertices, & _pvMeshData[nLOD] ->indices[nStitchFlags]);
	}
示例#9
0
void MeshLodGenerator::calcLodVertexCount(const LodLevel& lodLevel,
                                          size_t uniqueVertexCount,
                                          size_t& outVertexCountLimit,
                                          Real& outCollapseCostLimit)
{
    switch(lodLevel.reductionMethod) {
    case LodLevel::VRM_PROPORTIONAL:
        outCollapseCostLimit = LodData::NEVER_COLLAPSE_COST;
        outVertexCountLimit = uniqueVertexCount - (size_t) ((Real) uniqueVertexCount * lodLevel.reductionValue);
        break;

    case LodLevel::VRM_CONSTANT:
        outCollapseCostLimit = LodData::NEVER_COLLAPSE_COST;
        outVertexCountLimit = (size_t) lodLevel.reductionValue;
        if(outVertexCountLimit < uniqueVertexCount) {
            outVertexCountLimit = uniqueVertexCount - outVertexCountLimit;
        } else {
            outVertexCountLimit = 0;
        }
        break;

    case LodLevel::VRM_COLLAPSE_COST:
        outCollapseCostLimit = lodLevel.reductionValue;
        outVertexCountLimit = 0;
        break;

    default:
        OgreAssert(0, "");
        outCollapseCostLimit = LodData::NEVER_COLLAPSE_COST;
        outVertexCountLimit = uniqueVertexCount;
        break;
    }
}
示例#10
0
	//-----------------------------------------------------------------------
	void Polygon::updateNormal( void ) const
	{
		OgreAssert( getVertexCount() >= 3, "Insufficient vertex count!" );

		if (mIsNormalSet)
			return;

		// vertex order is ccw
		const Vector3& a = getVertex( 0 );
		const Vector3& b = getVertex( 1 );
		const Vector3& c = getVertex( 2 );

		// used method: Newell
		mNormal.x = 0.5f * ( (a.y - b.y) * (a.z + b.z) +
							   (b.y - c.y) * (b.z + c.z) + 
							   (c.y - a.y) * (c.z + a.z));

		mNormal.y = 0.5f * ( (a.z - b.z) * (a.x + b.x) +
							   (b.z - c.z) * (b.x + c.x) + 
							   (c.z - a.z) * (c.x + a.x));

		mNormal.z = 0.5f * ( (a.x - b.x) * (a.y + b.y) +
							   (b.x - c.x) * (b.y + c.y) + 
							   (c.x - a.x) * (c.y + a.y));

		mNormal.normalise();

		mIsNormalSet = true;

	}
示例#11
0
	//-----------------------------------------------------------------------
	void Polygon::setVertex(const Vector3& vdata, size_t vertex )
	{
		// TODO: optional: check planarity
		OgreAssert(vertex < getVertexCount(), "Search position out of range" );

		// set new vertex
		mVertexList[ vertex ] = vdata;
	}
示例#12
0
	//-----------------------------------------------------------------------
	const Vector3& Polygon::getNormal( void ) const
	{
		OgreAssert( getVertexCount() >= 3, "Insufficient vertex count!" );

		updateNormal();

		return mNormal;
	}
示例#13
0
 //-----------------------------------------------------------------------
 void TextureUnitState::setNumMipmaps(int numMipmaps)
 {
     OgreAssert(mFramePtrs[0], "frame must not be blank");
     for (auto& frame : mFramePtrs)
         frame->setNumMipmaps(numMipmaps == MIP_DEFAULT
                                  ? TextureManager::getSingleton().getDefaultNumMipmaps()
                                  : numMipmaps);
 }
示例#14
0
 //---------------------------------------------------------------------
 String Serializer::readString(DataStreamPtr& stream, size_t numChars)
 {
     OgreAssert(numChars <= 255, "");
     char str[255];
     stream->read(str, numChars);
     str[numChars] = '\0';
     return str;
 }
示例#15
0
	DebugDisplay::CoordinateSystem::CoordinateSystem( 
		const String & sFile, const size_t nLine,
		const OverhangTerrainManager * pManager, 
		const OverhangCoordinateSpace enocsFrom, 
		const OverhangCoordinateSpace enocsTo 
	) : TransformationBase(sFile, nLine), _pManager(pManager), _from(enocsFrom), _to(enocsTo)
	{
		OgreAssert(pManager != NULL, "Manager is NULL");
	}
示例#16
0
	//-----------------------------------------------------------------------
	void Polygon::deleteVertex( size_t vertex )
	{
		OgreAssert( vertex < getVertexCount(), "Search position out of range" );

		VertexList::iterator it = mVertexList.begin();
		std::advance(it, vertex);

		mVertexList.erase( it );
	}
示例#17
0
//-------------------------------------------------------
// http://www.ogre3d.org/tikiwiki/Raycasting+to+the+polygon+level
std::pair<bool, float> Ground::GetVertexIntersection(const Ogre::Ray & ray, const Ogre::SubMesh* subMesh)
{
    OgreAssert(false == subMesh->useSharedVertices, "Mesh with shared data is not supported");

    const Ogre::VertexElement* posElem = subMesh->vertexData->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
    
    Ogre::HardwareVertexBufferSharedPtr vbuffer = subMesh->vertexData->vertexBufferBinding->getBuffer(posElem->getSource());

    unsigned char* vertexes = reinterpret_cast<unsigned char*>(vbuffer->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));

    size_t count = subMesh->vertexData->vertexCount;

    float intersection = -1.0f;

    OgreAssert(count == REGION_SIZE * REGION_SIZE * 4, "Wrong buffer size");
    float* pReal;
    for (size_t i = 0; i < REGION_SIZE * REGION_SIZE; ++i)
    {
        Ogre::Vector3 v0, v1, v2, v3;
        for (auto vp : { &v0, &v1, &v2, &v3 })
        {
            posElem->baseVertexPointerToElement(vertexes, &pReal);
            *vp = Ogre::Vector3(pReal[0], pReal[1], pReal[2]);
            vertexes += vbuffer->getVertexSize();
        }

        auto hit1 = Ogre::Math::intersects(ray, v1, v2, v0, true, false);
        if (hit1.first && (intersection < 0.0f || hit1.second < intersection))
        {
            intersection = hit1.second;
        }
        auto hit2 = Ogre::Math::intersects(ray, v3, v2, v1, true, false);
        if (hit2.first && (intersection < 0.0f || hit2.second < intersection))
        {
            intersection = hit2.second;
        }
    }
    vbuffer->unlock();
    if (intersection >= 0.0f)
    {
        return std::make_pair(true, intersection);
    }
    return std::make_pair(false, -1.0f);
}
示例#18
0
unsigned int LodData::Triangle::getVertexID(const LodData::Vertex* v) const
{
    for (int i = 0; i < 3; i++) {
        if (vertex[i] == v) {
            return vertexID[i];
        }
    }
    OgreAssert(0, "");
    return 0;
}
示例#19
0
	//-----------------------------------------------------------------------
	void ConvexBody::deletePolygon(size_t poly)
	{
		OgreAssert(poly < getPolygonCount(), "Search position out of range" );

		PolygonList::iterator it = mPolygons.begin();
		std::advance(it, poly);
		
		freePolygon(*it);
		mPolygons.erase(it);
	}
示例#20
0
	void ThreadingModelManager::registerMainThread()
	{
		{ boost::mutex::scoped_lock lock(mutex);
			if (mMainThreadSet)
				OHT_LOG_FATAL("Main thread already registered");
			OgreAssert(!mMainThreadSet, "Main thread already registered");
			mMainThread = boost::this_thread::get_id();
			mMainThreadSet = true;
		}
	}
示例#21
0
	//-----------------------------------------------------------------------
	void Polygon::insertVertex(const Vector3& vdata, size_t vertex )
	{
		// TODO: optional: check planarity
		OgreAssert(vertex <= getVertexCount(), "Insert position out of range" );

		VertexList::iterator it = mVertexList.begin();

		std::advance(it, vertex);
		mVertexList.insert(it, vdata);

	}
示例#22
0
void LodData::Vertex::addEdge( const LodData::Edge& edge )
{
    OgreAssert(edge.dst != this, "");
    VEdges::iterator it;
    it = edges.add(edge);
    if (it == edges.end()) {
        edges.back().refCount = 1;
    } else {
        it->refCount++;
    }
}
    void LodCollapseCostOutside::initCollapseCosts( LodData* data )
    {
        OgreAssert(mOutsideWeight != 0.0, "");

        delete mOutsideMarker;
        mOutsideMarker = new LodOutsideMarker(data->mVertexList, data->mMeshBoundingSphereRadius, mOutsideWalkAngle);
        mOutsideMarker->markOutside();


        mCostCalculator->initCollapseCosts(data);
    }
示例#24
0
    //-----------------------------------------------------------------------
    void Polygon::storeEdges( Polygon::EdgeMap *edgeMap ) const
    {
        OgreAssert( edgeMap != NULL, "EdgeMap ptr is NULL" );

        size_t vertexCount = getVertexCount();

        for ( size_t i = 0; i < vertexCount; ++i )
        {
            edgeMap->insert( Edge( getVertex( i ), getVertex( ( i + 1 ) % vertexCount ) ) );
        }
    }
示例#25
0
void CameraMan::setYawPitchDist(Ogre::Radian yaw, Ogre::Radian pitch, Ogre::Real dist)
{
    OgreAssert(mTarget, "no target set");

    mOffset = Ogre::Vector3::ZERO;
    mCamera->setPosition(mTarget->_getDerivedPosition());
    mCamera->setOrientation(mTarget->_getDerivedOrientation());
    mCamera->yaw(yaw);
    mCamera->pitch(-pitch);
    mCamera->translate(Ogre::Vector3(0, 0, dist), Ogre::Node::TS_LOCAL);
}
示例#26
0
    //-----------------------------------------------------------------------
    void ResourceManager::remove(ResourceHandle handle)
    {
        ResourcePtr res = getByHandle(handle);

#if OGRE_RESOURCEMANAGER_STRICT
        OgreAssert(res, "attempting to remove unknown resource");
#endif

        if (res)
        {
            removeImpl(res);
        }
    }
示例#27
0
    //-----------------------------------------------------------------------
    void ResourceManager::remove(const String& name, const String& group)
    {
        ResourcePtr res = getResourceByName(name, group);

#if OGRE_RESOURCEMANAGER_STRICT
        OgreAssert(res, ("attempting to remove unknown resource: "+name+" in group "+group).c_str());
#endif

        if (res)
        {
            removeImpl(res);
        }
    }
示例#28
0
    //-----------------------------------------------------------------------
    void ResourceManager::unload(ResourceHandle handle)
    {
        ResourcePtr res = getByHandle(handle);

#if OGRE_RESOURCEMANAGER_STRICT
        OgreAssert(res, "attempting to unload unknown resource");
#endif

        if (res)
        {
            res->unload();
        }
    }
 Real LodCollapseCostOutside::computeEdgeCollapseCost( LodData* data, LodData::Vertex* src, LodData::Edge* dstEdge )
 {
     Real cost = mCostCalculator->computeEdgeCollapseCost(data, src, dstEdge);
     if(mOutsideMarker->isVertexOutside(src) || mOutsideMarker->isVertexOutside(dstEdge->dst)) {
         if(mOutsideWeight != LodData::NEVER_COLLAPSE_COST && cost != LodData::NEVER_COLLAPSE_COST) {
             cost *= std::max<Real>(0.0078125f, mOutsideWeight * 8.0f);
         } else {
             return LodData::NEVER_COLLAPSE_COST;
         }
     }
     OgreAssert(cost >= 0 && cost != LodData::UNINITIALIZED_COLLAPSE_COST, "Invalid collapse cost");
     return cost;
 }
示例#30
0
    //-----------------------------------------------------------------------
    void BspSceneLoader::load(DataStreamPtr& stream,
        const String& group, SceneNode *rootNode)
    {
        BspSceneManager* mgr = dynamic_cast<BspSceneManager*>(rootNode->getCreator());

        OgreAssert(mgr, "only loading into a BspSceneManager supported");

        mgr->setLevel(BspLevelPtr()); // clear

        BspLevelPtr bspLevel(new BspLevel(NULL, "bsplevel", 0, group, false, NULL));
        bspLevel->load(stream);

        mgr->setLevel(bspLevel);
    }