//----------------------------------------------------------------------- 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(); } } } } }
//------------------------------------------------------- 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]; }
//----------------------------------------------------------------------- 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 ); }
//----------------------------------------------------------------------- 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; } }
//----------------------------------------------------------------------- void ConvexBody::insertPolygon(Polygon* pdata) { OgreAssert( pdata != NULL, "Polygon is NULL" ); mPolygons.push_back( pdata ); }
//----------------------------------------------------------------------- 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]); }
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; } }
//----------------------------------------------------------------------- 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; }
//----------------------------------------------------------------------- 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; }
//----------------------------------------------------------------------- const Vector3& Polygon::getNormal( void ) const { OgreAssert( getVertexCount() >= 3, "Insufficient vertex count!" ); updateNormal(); return mNormal; }
//----------------------------------------------------------------------- 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); }
//--------------------------------------------------------------------- String Serializer::readString(DataStreamPtr& stream, size_t numChars) { OgreAssert(numChars <= 255, ""); char str[255]; stream->read(str, numChars); str[numChars] = '\0'; return str; }
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"); }
//----------------------------------------------------------------------- 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 ); }
//------------------------------------------------------- // 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); }
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; }
//----------------------------------------------------------------------- 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); }
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; } }
//----------------------------------------------------------------------- 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); }
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); }
//----------------------------------------------------------------------- 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 ) ) ); } }
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); }
//----------------------------------------------------------------------- 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); } }
//----------------------------------------------------------------------- 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); } }
//----------------------------------------------------------------------- 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; }
//----------------------------------------------------------------------- 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); }