FixedRect GeodataMock::calculateBoundingBox(const Relation* relation) const { coord_t maxX = std::numeric_limits<coord_t>::min(); coord_t maxY = std::numeric_limits<coord_t>::min(); coord_t minX = std::numeric_limits<coord_t>::max(); coord_t minY = std::numeric_limits<coord_t>::max(); const std::vector<NodeId>& nodeIDs = relation->getNodeIDs(); if (nodeIDs.size() > 0) { FixedRect result = calculateBoundingBox(nodeIDs); minX = result.minX; minY = result.minY; maxX = result.maxX; maxY = result.maxY; } const std::vector<WayId>& wayIDs = relation->getWayIDs(); for (WayId i : wayIDs) { FixedRect bounds = calculateBoundingBox(getWay(i)); minX = std::min(minX, bounds.minX); minY = std::min(minY, bounds.minY); maxX = std::max(maxX, bounds.maxX); maxY = std::max(maxY, bounds.maxY); } if (maxX < minX || maxY < minY) return FixedRect(0, 0, 0, 0); return FixedRect(minX, minY, maxX, maxY); }
void FlowDesigner::updateConnectionCoords(QMouseEvent *event) { if (m_connectingPort == NULL) return; float x = event->x(); float y = event->y(); // Find the starting x and y's QRectF compBounds = calculateBoundingBox(*m_connectingPort->getComponent()); QRectF bounds = calculatePortBoundingBox(*m_connectingPort, compBounds); m_connectingSX = bounds.x() + 0.5f * bounds.width(); m_connectingSY = bounds.y() + 0.5f * bounds.height(); float ex = x; float ey = y; // Do a snap-to for the final x and y's Component *comp = getComponentIntersection(x, y); if (comp != NULL) { Port *port = getPortIntersection(comp, x, y); if (port) { QRectF compBounds = calculateBoundingBox(*comp); QRectF bounds = calculatePortBoundingBox(*port, compBounds); ex = bounds.x() + 0.5f * bounds.width(); ey = bounds.y() + 0.5f * bounds.height(); } } m_connectingEX = ex; m_connectingEY = ey; repaint(); }
struct OBJ_Model * loadObj(char * directory,char * filename /*This does not have a .obj extension*/,int compileDisplayList) { fprintf(stderr,"Starting to load OBJ file %s \n",filename); struct OBJ_Model * obj = ( struct OBJ_Model * ) malloc(sizeof(struct OBJ_Model)); if ( obj == 0 ) { fprintf(stderr,"Could not allocate enough space for model %s \n",filename); return 0; } memset (obj,0,sizeof(struct OBJ_Model)); obj->scale=1.0f; unsigned int directory_length = strlen(directory); if (directory_length > MAX_MODEL_PATHS ) { fprintf(stderr,"Huge directory filename provided , will not loadObject ( %u char limit ) \n",MAX_MODEL_PATHS); free(obj); return 0; } strncpy(obj->directory, directory, MAX_MODEL_PATHS ); unsigned int file_name_length = strlen(filename); if (file_name_length > MAX_MODEL_PATHS ) { fprintf(stderr,"Huge filename provided , will not loadObject ( %u char limit ) \n",MAX_MODEL_PATHS); free(obj); return 0; } strncpy(obj->filename, filename, MAX_MODEL_PATHS ); if (!readOBJ(obj) ) { fprintf(stderr," Could not read object %s \n",filename); unloadObj(obj); return 0;} if (!calculateBoundingBox(obj)) { fprintf(stderr," Could not calculate bounding box for object %s \n",filename); unloadObj(obj); return 0;} if (!prepareObject(obj)) { fprintf(stderr," Could not prepare object %s \n",filename); unloadObj(obj); return 0;} if (!calculateBoundingBox(obj)) { fprintf(stderr," Could not calculate bounding box for object %s \n",filename); unloadObj(obj); return 0;} if (compileDisplayList) { compileOBJList(obj); } return obj; }
void QuadNode::calculateBoundingBox( QuadNode* n ) { if (NULL == n) { return; } n->boundingBox_.max_ = Vector3(n->rect_.right_, 0.0f, n->rect_.top_); n->boundingBox_.min_ = Vector3(n->rect_.left_, 0.0f, n->rect_.bottom_); // if (n->insideChunk_) // { // for (int x = n->xNumber_; x !) // { // } // } // else { if (n->leaf_) { Chunk* ck = getSceneManager()->getTerrain()->getChunkFromTopology(n->xNumber_, n->zNumber_); n->boundingBox_.max_.y = ck->getMaxHeight(); n->boundingBox_.min_.y = ck->getMinHeight(); } } QuadNode* m = NULL; m = n->children_[eQuadNode_LeftBottom]; if (m) { calculateBoundingBox(m); n->boundingBox_.max_.y = max(n->boundingBox_.max_.y, m->boundingBox_.max_.y); n->boundingBox_.min_.y = min(n->boundingBox_.min_.y, m->boundingBox_.min_.y); } m = n->children_[eQuadNode_RightBottom]; if (m) { calculateBoundingBox(m); n->boundingBox_.max_.y = max(n->boundingBox_.max_.y, m->boundingBox_.max_.y); n->boundingBox_.min_.y = min(n->boundingBox_.min_.y, m->boundingBox_.min_.y); } m = n->children_[eQuadNode_LeftTop]; if (m) { calculateBoundingBox(m); n->boundingBox_.max_.y = max(n->boundingBox_.max_.y, m->boundingBox_.max_.y); n->boundingBox_.min_.y = min(n->boundingBox_.min_.y, m->boundingBox_.min_.y); } m = n->children_[eQuadNode_RightTop]; if (m) { calculateBoundingBox(m); n->boundingBox_.max_.y = max(n->boundingBox_.max_.y, m->boundingBox_.max_.y); n->boundingBox_.min_.y = min(n->boundingBox_.min_.y, m->boundingBox_.min_.y); } }
bool Timeseries_2ndDerivative::updateCache() { size_t data_size = _source_data->size(); if( data_size <= 2) { _cached_data.clear(); _bounding_box = QRectF(); return true; } data_size = data_size - 2; _cached_data.resize( data_size ); for (size_t i=0; i < data_size; i++ ) { const auto& p0 = _source_data->at( i ); const auto& p1 = _source_data->at( i+1 ); const auto& p2 = _source_data->at( i+2 ); const auto delta = (p2.x - p0.x) *0.5; const auto acc = ( p2.y - 2.0* p1.y + p0.y)/(delta*delta); QPointF p( (p2.x + p0.x)*0.5, acc ); _cached_data[i] = { p.x(), p.y() }; } calculateBoundingBox(); return true; }
bool Timeseries_1stDerivative::updateCache() { size_t data_size = _source_data->size(); if( data_size <= 1) { _cached_data.clear(); _bounding_box = QRectF(); return true; } data_size = data_size - 1; _cached_data.resize( data_size ); for (size_t i=0; i < data_size; i++ ) { const auto& p0 = _source_data->at( i ); const auto& p1 = _source_data->at( i+1 ); const auto delta = p1.x - p0.x; const auto vel = (p1.y - p0.y) /delta; QPointF p( (p1.x + p0.x)*0.5, vel); _cached_data[i] = { p.x(), p.y() }; } calculateBoundingBox(); return true; }
Room::Room(const Room& rhs) { this->filename = rhs.filename; //int filenameLength = strlen(rhs.filename); //this->filename = new char[filenameLength]; //this->filename = ""; //stringCopy(this->filename, rhs.filename); this->world = rhs.world; tilemap = 0; doorsGrid = 0; collisionGrid = 0; rowStart = 0; rowEnd = 0; colStart = 0; colEnd = 0; roomWidth = 0; roomHeight = 0; box = 0; distance=0.0f; doors.clear(); loadMap(); calculateBoundingBox(); locateDoors(); for(unsigned int i=0; i < doors.size(); i++) { Door* door = doors[i]; door->opened=true; } this->graphic = tilemap; }
Room::Room(char* filename, GameWorld* gameWorld) : Entity() { this->filename = filename; this->world = gameWorld; tilemap = 0; doorsGrid = 0; collisionGrid = 0; rowStart = 0; rowEnd = 0; colStart = 0; colEnd = 0; roomWidth = 0; roomHeight = 0; box = 0; distance=0.0f; doors.clear(); loadMap(); calculateBoundingBox(); locateDoors(); this->graphic = tilemap; }
// called after the shape data changed // used to sync extra short-hand data with the basic shape modified data // ex: sync relative points with absolute points // used to sync relative points with absolute points void basicShape::onShapeModified(){ // todo: position stuff // update boundingbox calculateBoundingBox(); }
VoroNode::VoroNode(ofVboMesh _mesh, VoroNode& vnParent) { counter++; isSplit = false; bDraw = true; level = vnParent.level+1; // make the mesh vertices local for the node // move th relative position to the nodes position // transformations on the unit are around the centroid of the mesh not the centroid of the parent mesh = _mesh; setPosition(mesh.getCentroid()); for(int i=0; i<_mesh.getNumVertices(); i++) { mesh.setVertex(i, _mesh.getVertex(i)-_mesh.getCentroid()); } mesh.setupIndicesAuto(); mesh.getVbo(); calculateBoundingBox(); setParent(vnParent); };
QgsRectangle QgsAbstractGeometryV2::boundingBox() const { if ( mBoundingBox.isNull() ) { mBoundingBox = calculateBoundingBox(); } return mBoundingBox; }
QgsRectangle QgsCurve::boundingBox() const { if ( mBoundingBox.isNull() ) { mBoundingBox = calculateBoundingBox(); } return mBoundingBox; }
QgsRectangle QgsGeometryCollection::boundingBox() const { if ( mBoundingBox.isNull() ) { mBoundingBox = calculateBoundingBox(); } return mBoundingBox; }
void Shape::makeClean() const { if (dirty_) { Dirtable::makeClean(); calculateBoundingBox(bb_); } }
Component * FlowDesigner::getComponentIntersection(float x, float y) { for (Component *comp : m_project->getComponents()) { QRectF bounding = calculateBoundingBox(*comp); if (bounding.contains(x, y)) return comp; } return NULL; }
VoroNode::VoroNode(ofVboMesh _mesh) { counter++; isSplit = false; mesh = _mesh; level = 0; clearParent(); calculateBoundingBox(); mesh.getVbo(); };
Port * FlowDesigner::getPortIntersection(Component *comp, float x, float y) { QRectF bounds = calculateBoundingBox(*comp); for (Port *p : comp->getPorts()) { QRectF box = calculatePortBoundingBox(*p, bounds); if (box.contains(x, y)) return p; } return NULL; }
shared_ptr<std::vector<WayId> > GeodataMock::getWayIDs(const FixedRect& rect) const { shared_ptr<std::vector<WayId> > wayIDs = boost::make_shared< std::vector<WayId> >(); for(int i = 0; i < ways->size(); i++) { if(rect.intersects(calculateBoundingBox(&ways->at(i)))) { wayIDs->push_back(WayId(i)); } } return wayIDs; }
bool PointCloud::doBoundingBoxesOverlap( const BoundingBox &box) const { BoundingBox myBox = calculateBoundingBox(); bool noOverlap = myBox.topLeft.getX() > box.topLeft.getX() + box.width || box.topLeft.getX() > myBox.topLeft.getX() + myBox.width || myBox.topLeft.getY() > box.topLeft.getY() + box.height || box.topLeft.getY() > myBox.topLeft.getY() + myBox.width; return !noOverlap; }
shared_ptr<std::vector<RelId> > GeodataMock::getRelationIDs(const FixedRect& rect) const { shared_ptr<std::vector<RelId> > relationIDs = boost::make_shared< std::vector<RelId> >(); for(int i = 0; i < relations->size(); i++) { if ( rect.intersects ( calculateBoundingBox(&relations->at(i)))) { relationIDs->push_back(RelId(i)); } } return relationIDs; }
dp::math::Box3f ManagerBitSet::getBoundingBox( const GroupSharedPtr& group ) const { dp::util::ProfileEntry p("cull::getBoundingBox"); GroupBitSetSharedPtr groupImpl = std::static_pointer_cast<GroupBitSet>(group); if ( groupImpl->isBoundingBoxDirty() ) { groupImpl->setBoundingBox( calculateBoundingBox( group ) ); groupImpl->setBoundingBoxDirty( false ); } return groupImpl->getBoundingBox(); }
void FlowDesigner::paintComponent(QPainter *painter, const Component &comp) { QRectF bounds = calculateBoundingBox(comp); // // Now, do the painting: // paintComponentBox(painter, bounds, comp); paintComponentContent(painter, bounds, comp); paintComponentLinks(painter, bounds, comp); }
// called after the shape was (hard) edited // used to sync extra short-hand data with the basic shape original data // ex: sync relative points with absolute points void basicShape::onShapeEdited(){ // update boundingbox calculateBoundingBox(); #ifdef KM_EDITOR_APP // update GUI Toggle ? if( isInEditMode() ){ guiToggle.setPosition( boundingBox.getBottomLeft()+ofPoint(-5,5) ); } #endif }
SoSeparator* IVWorkSpace::getIvFromPQPScene(bool bounding) { SoSeparator* pqp= new SoSeparator; for(unsigned int i=0;i<robots.size(); i++){ pqp->addChild((SoSeparator*)robots[i]->getModelFromColl()); } for(unsigned int i=0;i<obstacles.size(); i++){ pqp->addChild((SoSeparator*)obstacles[i]->getModelFromColl()); } if(bounding) pqp->addChild(calculateBoundingBox(pqp)); return pqp; }
// // Updates the mesh by calling the optimizeInPlace method // of the D3DX object and reloading attribute information void DirectX::Mesh::update( ) { DWORD* adjacencyInfo = new DWORD[m_mesh->GetNumFaces( )*sizeof(DWORD)]; m_mesh->ConvertPointRepsToAdjacency( NULL, adjacencyInfo ); m_mesh->OptimizeInplace( D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_COMPACT, adjacencyInfo, NULL, NULL, NULL ); delete[] adjacencyInfo; if( m_attributeTable ) delete[] m_attributeTable; m_mesh->GetAttributeTable( NULL, &m_nAttributes ); m_attributeTable = new D3DXATTRIBUTERANGE[m_nAttributes]; m_mesh->GetAttributeTable( m_attributeTable, &m_nAttributes ); calculateBoundingSphere( ); calculateBoundingBox( ); }
SoSeparator* IVWorkSpace::getIvScene(bool bounding){ if(scene == NULL){ if(robots.size() != 0){ scene = new SoSeparator(); //scene->addChild(SoUnits::MILLIMETERS); for(unsigned int i=0; i<robots.size(); i++) scene->addChild((SoSeparator*)robots[i]->getModel()); for(unsigned int i=0; i<obstacles.size(); i++){ SoSeparator* sep = (SoSeparator*)obstacles[i]->getModel(); char str[20]; sprintf(str,"obstacle%d",i); sep->setName(str); scene->addChild(sep); //scene->addChild((SoSeparator*)obstacles[i]->getModel()); } for(unsigned int i=0; i<_mobileObstacle.size(); i++) scene->addChild((SoSeparator*)_mobileObstacle[i]->getModel()); scene->ref(); } } /* The following does not work properly when cildren should be accesseb by labels. The scene pointer should be returned instead.*/ /* SoSeparator* temp = new SoSeparator(); temp->addChild(scene); temp->ref(); if(bounding) temp->addChild(calculateBoundingBox(scene)); return temp; */ //comporvacio //SoNode *sepgrid = scene->getByName("obstacle1"); //int c = scene->findChild(sepgrid); //scene->removeChild(sepgrid); if(bounding) scene->addChild(calculateBoundingBox(scene)); return scene; }
MeshOctTree::MeshOctTree(ObjMesh *mesh) { QTime t; t.start(); m_mesh = mesh; maxDepth = 4; minTrianglesForSplitting = 5; calculateBoundingBox(); m_root = new OctTreeNode(boundingMin, boundingMax, maxDepth-1); for (int i = 0; i < m_mesh->triangles.size(); i++){ insertTriangle(m_mesh->triangles.at(i)); } cout << "done building octtree: "<< t.restart() << "ms" << endl; }
void PainterBezier::paint(QPainter * painter) { painter->setBrush(Qt::transparent); QRectF rect = calculateBoundingBox(); setX(rect.topLeft().x() - 10); setY( rect.topLeft().y() - 10); setWidth( rect.width() + 20); setHeight( rect.height() + 20); QPen pen; pen.setWidthF(m_OutlineWidth); pen.setBrush(m_OutlineColor); painter->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform); painter->setPen(pen); painter->setBrush(m_FillColor); QPainterPath bezierPath; QPointF pos(x(),y()); bezierPath.moveTo(m_p1 - pos); bezierPath.cubicTo( m_p2 - pos, m_p3 - pos, m_p4 - pos ); QPainterPathStroker outliner; outliner.setWidth(m_FillWidth); outliner.setCapStyle( Qt::FlatCap ); m_Path = outliner.createStroke(bezierPath); painter->drawPath(m_Path); }
void initializeInteractiveMarker() { visualization_msgs::InteractiveMarker int_marker; int_marker.header.frame_id = latest_pose_.header.frame_id; int_marker.name = "marker"; int_marker.pose = geometry_msgs::Pose(latest_pose_.pose); visualization_msgs::Marker object_marker; if(object_type_ == std::string("cube")){ object_marker.type = visualization_msgs::Marker::CUBE; object_marker.scale.x = object_x_; object_marker.scale.y = object_y_; object_marker.scale.z = object_z_; object_marker.color.r = object_r_; object_marker.color.g = object_g_; object_marker.color.b = object_b_; object_marker.color.a = object_a_; object_marker.pose.orientation.w = 1.0; } else if( object_type_ == std::string("sphere") ){ object_marker.type = visualization_msgs::Marker::SPHERE; object_marker.scale.x = object_x_; object_marker.scale.y = object_y_; object_marker.scale.z = object_z_; object_marker.color.r = object_r_; object_marker.color.g = object_g_; object_marker.color.b = object_b_; object_marker.color.a = object_a_; object_marker.pose.orientation.w = 1.0; }else if(object_type_ == std::string("line")){ object_marker.type = visualization_msgs::Marker::LINE_LIST; object_marker.scale.x = line_width_; object_marker.color.g = object_g_; object_marker.color.b = object_b_; object_marker.color.a = object_a_; object_marker.pose.orientation.w = 1.0; calculateBoundingBox(object_marker); } visualization_msgs::InteractiveMarkerControl object_marker_control; object_marker_control.interaction_mode = visualization_msgs::InteractiveMarkerControl::BUTTON; object_marker_control.always_visible = true; object_marker_control.markers.push_back(object_marker); int_marker.controls.push_back(object_marker_control); visualization_msgs::InteractiveMarkerControl control; control.orientation.w = 1; control.orientation.x = 1; control.orientation.y = 0; control.orientation.z = 0; if (show_6dof_circle_) { control.name = "rotate_x"; control.interaction_mode = visualization_msgs::InteractiveMarkerControl::ROTATE_AXIS; int_marker.controls.push_back(control); } control.name = "move_x"; control.interaction_mode = visualization_msgs::InteractiveMarkerControl::MOVE_AXIS; int_marker.controls.push_back(control); control.orientation.w = 1; control.orientation.x = 0; control.orientation.y = 1; control.orientation.z = 0; if (show_6dof_circle_) { control.name = "rotate_z"; control.interaction_mode = visualization_msgs::InteractiveMarkerControl::ROTATE_AXIS; int_marker.controls.push_back(control); } control.name = "move_z"; control.interaction_mode = visualization_msgs::InteractiveMarkerControl::MOVE_AXIS; int_marker.controls.push_back(control); control.orientation.w = 1; control.orientation.x = 0; control.orientation.y = 0; control.orientation.z = 1; if (show_6dof_circle_) { control.name = "rotate_y"; control.interaction_mode = visualization_msgs::InteractiveMarkerControl::ROTATE_AXIS; int_marker.controls.push_back(control); } control.name = "move_y"; control.interaction_mode = visualization_msgs::InteractiveMarkerControl::MOVE_AXIS; int_marker.controls.push_back(control); int_marker.scale = std::max(object_x_, std::max(object_y_, object_z_)) + 0.5; server_->insert(int_marker, boost::bind(&Marker6DOF::processFeedbackCB, this, _1)); menu_handler_.apply(*server_, "marker"); server_->applyChanges(); }
void loadMeshes( CalCoreModel* calCoreModel, MeshesVector& meshes ) throw (std::runtime_error) { const int maxVertices = Constants::MAX_VERTEX_PER_MODEL; const int maxFaces = Constants::MAX_VERTEX_PER_MODEL * 3; std::auto_ptr< CalHardwareModel > calHardwareModel( new CalHardwareModel( calCoreModel ) ); osg::ref_ptr< VertexBuffer > vertexBuffer( new VertexBuffer( maxVertices ) ); osg::ref_ptr< WeightBuffer > weightBuffer( new WeightBuffer( maxVertices ) ); osg::ref_ptr< MatrixIndexBuffer > matrixIndexBuffer( new MatrixIndexBuffer( maxVertices ) ); osg::ref_ptr< NormalBuffer > normalBuffer( new NormalBuffer( maxVertices ) ); osg::ref_ptr< NormalBuffer > tangentBuffer( new NormalBuffer( maxVertices ) ); osg::ref_ptr< NormalBuffer > binormalBuffer( new NormalBuffer( maxVertices ) ); osg::ref_ptr< TexCoordBuffer > texCoordBuffer( new TexCoordBuffer( maxVertices ) ); std::vector< CalIndex > indexBuffer( maxFaces*3 ); std::vector< float > floatMatrixIndexBuffer( maxVertices*4 ); calHardwareModel->setVertexBuffer((char*)vertexBuffer->getDataPointer(), 3*sizeof(float)); #ifdef OSG_CAL_BYTE_BUFFERS std::vector< float > floatNormalBuffer( getVertexCount()*3 ); calHardwareModel->setNormalBuffer((char*)&floatNormalBuffer.begin(), 3*sizeof(float)); #else calHardwareModel->setNormalBuffer((char*)normalBuffer->getDataPointer(), 3*sizeof(float)); #endif calHardwareModel->setWeightBuffer((char*)weightBuffer->getDataPointer(), 4*sizeof(float)); calHardwareModel->setMatrixIndexBuffer((char*)&floatMatrixIndexBuffer.front(), 4*sizeof(float)); calHardwareModel->setTextureCoordNum( 1 ); calHardwareModel->setTextureCoordBuffer(0, // texture stage # (char*)texCoordBuffer->getDataPointer(), 2*sizeof(float)); calHardwareModel->setIndexBuffer( &indexBuffer.front() ); // calHardwareModel->setCoreMeshIds(_activeMeshes); // if ids not set all meshes will be used at load() time //std::cout << "calHardwareModel->load" << std::endl; calHardwareModel->load( 0, 0, Constants::MAX_BONES_PER_MESH ); //std::cout << "calHardwareModel->load ok" << std::endl; int vertexCount = calHardwareModel->getTotalVertexCount(); // int faceCount = calHardwareModel->getTotalFaceCount(); // std::cout << "vertexCount = " << vertexCount << "; faceCount = " << faceCount << std::endl; GLubyte* matrixIndexBufferData = (GLubyte*) matrixIndexBuffer->getDataPointer(); for ( int i = 0; i < vertexCount*4; i++ ) { matrixIndexBufferData[i] = static_cast< GLubyte >( floatMatrixIndexBuffer[i] ); } #ifdef OSG_CAL_BYTE_BUFFERS GLbyte* normals = (GLbyte*) normalBuffer->getDataPointer(); for ( int i = 0; i < vertexCount*3; i++ ) { normals[i] = static_cast< GLbyte >( floatNormalBuffer[i]*127.0 ); } #endif // invert UVs for OpenGL (textures are inverted otherwise - for example, see abdulla/klinok) GLfloat* texCoordBufferData = (GLfloat*) texCoordBuffer->getDataPointer(); for ( float* tcy = texCoordBufferData + 1; tcy < texCoordBufferData + 2*vertexCount; tcy += 2 ) { *tcy = 1.0f - *tcy; } // -- And now create meshes data -- int unriggedBoneIndex = calCoreModel->getCoreSkeleton()->getVectorCoreBone().size(); // we add empty bone in ModelData to handle unrigged vertices; for( int hardwareMeshId = 0; hardwareMeshId < calHardwareModel->getHardwareMeshCount(); hardwareMeshId++ ) { calHardwareModel->selectHardwareMesh(hardwareMeshId); int faceCount = calHardwareModel->getFaceCount(); if ( faceCount == 0 ) { continue; // we ignore empty meshes } CalHardwareModel::CalHardwareMesh* hardwareMesh = &calHardwareModel->getVectorHardwareMesh()[ hardwareMeshId ]; osg::ref_ptr< MeshData > m( new MeshData ); m->name = calCoreModel->getCoreMesh( hardwareMesh->meshId )->getName(); m->coreMaterial = hardwareMesh->pCoreMaterial; if ( m->coreMaterial == NULL ) { CalCoreMesh* coreMesh = calCoreModel->getCoreMesh( hardwareMesh->meshId ); CalCoreSubmesh* coreSubmesh = coreMesh->getCoreSubmesh( hardwareMesh->submeshId ); // hardwareMesh->pCoreMaterial = // coreModel->getCoreMaterial( coreSubmesh->getCoreMaterialThreadId() ); char buf[ 1024 ]; snprintf( buf, 1024, "pCoreMaterial == NULL for mesh '%s' (mesh material id = %d), verify your mesh file data", m->name.c_str(), coreSubmesh->getCoreMaterialThreadId() ); throw std::runtime_error( buf ); } // -- Create index buffer -- int indexesCount = faceCount * 3; int startIndex = calHardwareModel->getStartIndex(); if ( indexesCount <= 0x100 ) { m->indexBuffer = new osg::DrawElementsUByte( osg::PrimitiveSet::TRIANGLES, indexesCount ); GLubyte* data = (GLubyte*)m->indexBuffer->getDataPointer(); const CalIndex* i = &indexBuffer[ startIndex ]; const CalIndex* iEnd = &indexBuffer[ startIndex + indexesCount ]; while ( i < iEnd ) { *data++ = (GLubyte)*i++; } } else if ( indexesCount <= 0x10000 ) { m->indexBuffer = new osg::DrawElementsUShort( osg::PrimitiveSet::TRIANGLES, indexesCount ); GLushort* data = (GLushort*)m->indexBuffer->getDataPointer(); const CalIndex* i = &indexBuffer[ startIndex ]; const CalIndex* iEnd = &indexBuffer[ startIndex + indexesCount ]; while ( i < iEnd ) { *data++ = (GLushort)*i++; } } else { m->indexBuffer = new osg::DrawElementsUInt( osg::PrimitiveSet::TRIANGLES, indexesCount ); GLuint* data = (GLuint*)m->indexBuffer->getDataPointer(); const CalIndex* i = &indexBuffer[ startIndex ]; const CalIndex* iEnd = &indexBuffer[ startIndex + indexesCount ]; while ( i < iEnd ) { *data++ = (GLuint)*i++; } } // -- Create other buffers -- int vertexCount = calHardwareModel->getVertexCount(); int baseVertexIndex = calHardwareModel->getBaseVertexIndex(); #define SUB_BUFFER( _type, _name ) \ new _type( _name->begin() + baseVertexIndex, \ _name->begin() + baseVertexIndex + vertexCount ) m->vertexBuffer = SUB_BUFFER( VertexBuffer, vertexBuffer ); m->weightBuffer = SUB_BUFFER( WeightBuffer, weightBuffer ); m->matrixIndexBuffer = SUB_BUFFER( MatrixIndexBuffer, matrixIndexBuffer ); m->normalBuffer = SUB_BUFFER( NormalBuffer, normalBuffer ); m->texCoordBuffer = SUB_BUFFER( TexCoordBuffer, texCoordBuffer ); // -- Parameters and buffers setup -- m->boundingBox = calculateBoundingBox( m->vertexBuffer.get() ); m->bonesIndices = hardwareMesh->m_vectorBonesIndices; checkRigidness( m.get(), unriggedBoneIndex ); checkForEmptyTexCoord( m.get() ); generateTangentAndHandednessBuffer( m.get(), &indexBuffer[ startIndex ] ); meshes.push_back( m.get() ); } }