void VertexDataHelper::BuildPathVertexData(APath aPath, QOpenGLBuffer* linesVbo, QOpenGLVertexArrayObject* linesVao, QVector3D vecCol) { if (aPath.points.size() == 0) { return; } bool isInit = false; if (!linesVao->isCreated()) { linesVao->create(); linesVao->bind(); isInit = true; } size_t path_length = aPath.points.size(); QVector<VertexData> data; for (uint a = 0; a < path_length - 1; a++) { //if (a < _points.size() - 1) { lines.push_back(ALine(_points[a], _points[a + 1])); } //else { lines.push_back(ALine(_points[a], _points[0])); } data.append(VertexData(QVector3D(aPath.points[a].x, aPath.points[a].y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(aPath.points[a + 1].x, aPath.points[a + 1].y, 0), QVector2D(), vecCol)); } if (aPath.isClosed) { data.append(VertexData(QVector3D(aPath.points[path_length - 1].x, aPath.points[path_length - 1].y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(aPath.points[0].x, aPath.points[0].y, 0), QVector2D(), vecCol)); } BuildVboWithColor(data, linesVbo); if (isInit) { linesVao->release(); } }
void VertexDataHelper::BuildQuadsVertexData(std::vector<ABox> boxes, QOpenGLBuffer* vbo, QOpenGLVertexArrayObject* vao) { if (vao->isCreated()) { vao->destroy(); } vao->create(); vao->bind(); QVector<VertexData> data; // this diagram is wrong /* (0, 0) (witdh, 0) ptB ------------ ptD | | | | | | | | | | ptA ------------ ptC (0, height) (width, height) */ for (uint a = 0; a < boxes.size(); a++) { data.append(VertexData(QVector3D(boxes[a]._ptA.x, boxes[a]._ptA.y, 0), QVector2D(0, 1))); data.append(VertexData(QVector3D(boxes[a]._ptB.x, boxes[a]._ptB.y, 0), QVector2D(0, 0))); data.append(VertexData(QVector3D(boxes[a]._ptD.x, boxes[a]._ptD.y, 0), QVector2D(1, 0))); // flipped data.append(VertexData(QVector3D(boxes[a]._ptC.x, boxes[a]._ptC.y, 0), QVector2D(1, 1))); // flipped } BuildVboWithTexture(data, vbo); vao->release(); }
Scene::Scene() { initializeOpenGLFunctions(); this->setSkyBox(NULL); m_root.setName ("root"); this->setRenderType (DEFERRED_SHADING); m_mainRenderTarget = new RenderTarget(); m_mainRenderTarget->setType (RenderTarget::TargetType::ON_SCREEN); bloom_fbo1 = new RenderBuffer(1024,768); bloom_fbo2 = new RenderBuffer(1024,768); bloom_fbo3 = new RenderBuffer(1024,768); TMesh * mesh = new TMesh(); mesh->pushVertex (VertexData(QVector3D(-1,-1,0),QVector2D(0,0))); mesh->pushVertex (VertexData(QVector3D(1,-1,0),QVector2D(1,0))); mesh->pushVertex (VertexData(QVector3D(1,1,0),QVector2D(1,1))); mesh->pushVertex (VertexData(QVector3D(-1,1,0),QVector2D(0,1))); mesh->pushIndex (0); mesh->pushIndex (1); mesh->pushIndex (2); mesh->pushIndex (0); mesh->pushIndex (2); mesh->pushIndex (3); mesh->setMaterial (MaterialPool::getInstance ()->createOrGetMaterial ("default")); mesh->finishWithoutNormal (); m_quad = new Entity(); m_quad->addMesh (mesh); m_guiCamera = new Camera(); m_guiCamera->setOrtho (0,1024,0,768,0.01,1000); m_guiCamera->setPos (QVector3D(0,0,0)); m_renderType = DEFERRED_SHADING; }
void WireBoundingBox::_initWireBoundingBox() { mRenderOp.vertexData = OGRE_NEW VertexData(); mRenderOp.indexData = 0; mRenderOp.vertexData->vertexCount = 24; mRenderOp.vertexData->vertexStart = 0; mRenderOp.operationType = RenderOperation::OT_LINE_LIST; mRenderOp.useIndexes = false; mRenderOp.useGlobalInstancingVertexBufferIsAvailable = false; VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration; VertexBufferBinding* bind = mRenderOp.vertexData->vertexBufferBinding; decl->addElement(POSITION_BINDING, 0, VET_FLOAT3, VES_POSITION); HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().createVertexBuffer( decl->getVertexSize(POSITION_BINDING), mRenderOp.vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY); // Bind buffer bind->setBinding(POSITION_BINDING, vbuf); // set basic white material this->setMaterial("BaseWhiteNoLighting"); }
//-------------------------------------------------------------------------------// void OverlayPanelElement::initialise(const String& texName, float width, float height, float left, float top) { mTexture = TextureMgr::getSingletonPtr()->getByName(texName); setSize(width, height); setPosition(left, top); mIsVisible = true; if(!mIsInitialised) { mRenderData.vertexData = TITAN_NEW VertexData(); VertexDeclaration* decl = mRenderData.vertexData->vertexDecl; decl->addElement(0,0, VET_FLOAT3, VES_POSITION); mRenderData.vertexData->vertexStart = 0; mRenderData.vertexData->vertexCount = 4; VertexBufferPtr vbuf = HardwareBufferMgr::getSingletonPtr()->createVertexBuffer(decl->getVertexSize(0), mRenderData.vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); mRenderData.vertexData->vertexBufferBinding->setBinding(0, vbuf); mRenderData.useIndex = false; mRenderData.operationType = OT_TRIANGLE_STRIP; mIsInitialised = true; } notifyGeometryOld(); }
//----------------------------------------------------------------------- BillboardChain::BillboardChain(const String& name, size_t maxElements, size_t numberOfChains, bool useTextureCoords, bool useColours, bool dynamic) :MovableObject(name), mMaxElementsPerChain(maxElements), mChainCount(numberOfChains), mUseTexCoords(useTextureCoords), mUseVertexColour(useColours), mDynamic(dynamic), mVertexDeclDirty(true), mBuffersNeedRecreating(true), mBoundsDirty(true), mIndexContentDirty(true), mRadius(0.0f), mTexCoordDir(TCD_U), mFaceCamera(true), mNormalBase(Vector3::UNIT_X) { mVertexData = OGRE_NEW VertexData(); mIndexData = OGRE_NEW IndexData(); mOtherTexCoordRange[0] = 0.0f; mOtherTexCoordRange[1] = 1.0f; setupChainContainers(); mVertexData->vertexStart = 0; // index data set up later // set basic white material //this->setMaterialName("BaseWhiteNoLighting"); }
//--------------------------------------------------------------------- void PanelOverlayElement::initialise(void) { bool init = !mInitialised; OverlayContainer::initialise(); if (init) { // Setup render op in advance mRenderOp.vertexData = OGRE_NEW VertexData(); // Vertex declaration: 1 position, add texcoords later depending on #layers // Create as separate buffers so we can lock & discard separately VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration; decl->addElement(POSITION_BINDING, 0, VET_FLOAT3, VES_POSITION); // Basic vertex data mRenderOp.vertexData->vertexStart = 0; mRenderOp.vertexData->vertexCount = 4; // No indexes & issue as a strip mRenderOp.useIndexes = false; mRenderOp.operationType = RenderOperation::OT_TRIANGLE_STRIP; mRenderOp.useGlobalInstancingVertexBufferIsAvailable = false; mInitialised = true; _restoreManualHardwareResources(); } }
void TextAreaOverlayElement::initialise(void) { if (!mInitialised) { // Set up the render op // Combine positions and texture coords since they tend to change together // since character sizes are different mRenderOp.vertexData = OGRE_NEW VertexData(); VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration; size_t offset = 0; // Positions decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION); offset += VertexElement::getTypeSize(VET_FLOAT3); // Texcoords decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0); // Colours - store these in a separate buffer because they change less often decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE); mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST; mRenderOp.useIndexes = false; mRenderOp.vertexData->vertexStart = 0; mRenderOp.useGlobalInstancingVertexBufferIsAvailable = false; // Vertex buffer will be created in checkMemoryAllocation mRenderOp.srcRenderable = this; checkMemoryAllocation( DEFAULT_INITIAL_CHARS ); mInitialised = true; } }
/** * \brief Creates a vertex containing the vertex data and returns the id * of the new vertex id. Vertex ids are assigned in increasing order with * the first vertex having id 0. * Vertices are placed in atom vid % num_atoms */ vertex_id_type add_vertex(const VertexData& vdata = VertexData()) { vertex_id_type v = numv.inc_ret_last(); uint16_t owner = v % atoms.size(); atoms[owner]->add_vertex(v, owner, vdata); atoms[owner]->set_owner(v, owner); return v; }
//--------------------------------------------------------------------- void PanelOverlayElement::initialise(void) { bool init = !mInitialised; OverlayContainer::initialise(); if (init) { // Setup render op in advance mRenderOp.vertexData = OGRE_NEW VertexData(); // Vertex declaration: 1 position, add texcoords later depending on #layers // Create as separate buffers so we can lock & discard separately VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration; decl->addElement(POSITION_BINDING, 0, VET_FLOAT3, VES_POSITION); // Basic vertex data mRenderOp.vertexData->vertexStart = 0; mRenderOp.vertexData->vertexCount = 4; // Vertex buffer #1 HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().createVertexBuffer( decl->getVertexSize(POSITION_BINDING), mRenderOp.vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY// mostly static except during resizing ); // Bind buffer mRenderOp.vertexData->vertexBufferBinding->setBinding(POSITION_BINDING, vbuf); // No indexes & issue as a strip mRenderOp.useIndexes = false; mRenderOp.operationType = RenderOperation::OT_TRIANGLE_STRIP; mInitialised = true; } }
//--------------------------------------------------------------------- void BorderPanelOverlayElement::initialise(void) { bool init = !mInitialised; // init mRenderOp2 before calling superclass, as virtual _restoreManualHardwareResources would be called within if (init) { // Setup render op in advance mRenderOp2.vertexData = OGRE_NEW VertexData(); mRenderOp2.vertexData->vertexCount = 4 * 8; // 8 cells, can't necessarily share vertices cos // texcoords may differ mRenderOp2.vertexData->vertexStart = 0; // Vertex declaration VertexDeclaration* decl = mRenderOp2.vertexData->vertexDeclaration; // Position and texture coords each have their own buffers to allow // each to be edited separately with the discard flag decl->addElement(POSITION_BINDING, 0, VET_FLOAT3, VES_POSITION); decl->addElement(TEXCOORD_BINDING, 0, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0); // Index data mRenderOp2.operationType = RenderOperation::OT_TRIANGLE_LIST; mRenderOp2.useIndexes = true; mRenderOp2.indexData = OGRE_NEW IndexData(); mRenderOp2.indexData->indexCount = 8 * 6; mRenderOp2.indexData->indexStart = 0; mRenderOp2.useGlobalInstancingVertexBufferIsAvailable = false; // Create sub-object for rendering border mBorderRenderable = OGRE_NEW BorderRenderable(this); } // superclass will handle the interior panel area and call _restoreManualHardwareResources PanelOverlayElement::initialise(); }
/// add vertex, associate given Octnode with the vertex, and return index unsigned int GLData::addVertex(GLVertex v, Octnode* n) { // add vertex with empty polygon-list. unsigned int idx = vertexArray[workIndex].size(); vertexArray[workIndex].append(v); vertexDataArray.append( VertexData() ); vertexDataArray[idx].node = n; assert( vertexArray[workIndex].size() == vertexDataArray.size() ); return idx; // return index of newly appended vertex }
void VertexDataHelper::BuildTrianglesVertexData(std::vector<ATriangle> triangles, QOpenGLBuffer* vbo, QOpenGLVertexArrayObject* vao, QVector3D vecCol) { if (vao->isCreated()) { vao->destroy(); } vao->create(); vao->bind(); QVector<VertexData> data; for (uint a = 0; a < triangles.size(); a++) { data.append(VertexData(QVector3D(triangles[a]._ptA.x, triangles[a]._ptA.y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(triangles[a]._ptB.x, triangles[a]._ptB.y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(triangles[a]._ptC.x, triangles[a]._ptC.y, 0), QVector2D(), vecCol)); } BuildVboWithColor(data, vbo); vao->release(); }
void GUIFrame::setRenderRect() { m_mesh->clear(); unsigned short indices[] = { 0,1,2, 0,2,3, }; auto w = m_contentSize.x; auto h = m_contentSize.y; VertexData vertices[] = { // front VertexData(vec3(0, 0, -1.0f), m_color), // v0 VertexData(vec3( w, 0, -1.0f), m_color), // v1 VertexData(vec3( w, h, -1.0f), m_color), // v2 VertexData(vec3( 0, h, -1.0f), m_color)// v3 }; m_mesh->addVertices(vertices,sizeof(vertices)/sizeof(VertexData)); m_mesh->addIndices(indices,sizeof(indices)/sizeof(unsigned short)); m_mesh->finish(); }
//--------------------------------------------------------------------- void PrefabFactory::createPlane(Mesh* mesh) { SubMesh* sub = mesh->createSubMesh(); float vertices[32] = { -100, -100, 0, // pos 0,0,1, // normal 0,1, // texcoord 100, -100, 0, 0,0,1, 1,1, 100, 100, 0, 0,0,1, 1,0, -100, 100, 0 , 0,0,1, 0,0 }; mesh->sharedVertexData = OGRE_NEW VertexData(); mesh->sharedVertexData->vertexCount = 4; VertexDeclaration* decl = mesh->sharedVertexData->vertexDeclaration; VertexBufferBinding* bind = mesh->sharedVertexData->vertexBufferBinding; size_t offset = 0; decl->addElement(0, offset, VET_FLOAT3, VES_POSITION); offset += VertexElement::getTypeSize(VET_FLOAT3); decl->addElement(0, offset, VET_FLOAT3, VES_NORMAL); offset += VertexElement::getTypeSize(VET_FLOAT3); decl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0); offset += VertexElement::getTypeSize(VET_FLOAT2); HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().createVertexBuffer( offset, 4, HardwareBuffer::HBU_STATIC_WRITE_ONLY); bind->setBinding(0, vbuf); vbuf->writeData(0, vbuf->getSizeInBytes(), vertices, true); sub->useSharedVertices = true; HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton(). createIndexBuffer( HardwareIndexBuffer::IT_16BIT, 6, HardwareBuffer::HBU_STATIC_WRITE_ONLY); unsigned short faces[6] = {0,1,2, 0,2,3 }; sub->indexData->indexBuffer = ibuf; sub->indexData->indexCount = 6; sub->indexData->indexStart =0; ibuf->writeData(0, ibuf->getSizeInBytes(), faces, true); mesh->_setBounds(AxisAlignedBox(-100,-100,0,100,100,0), true); mesh->_setBoundingSphereRadius(Math::Sqrt(100*100+100*100)); }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- ManualObject::ManualObjectSection::ManualObjectSection(ManualObject* parent, const String& materialName, RenderOperation::OperationType opType, const String & groupName) : mParent(parent), mMaterialName(materialName), mGroupName(groupName), m32BitIndices(false) { mRenderOperation.operationType = opType; // default to no indexes unless we're told mRenderOperation.useIndexes = false; mRenderOperation.vertexData = OGRE_NEW VertexData(); mRenderOperation.vertexData->vertexCount = 0; }
void VertexDataHelper::BuildLinesVertexData(std::vector<ALine> lines, QOpenGLBuffer* linesVbo, QOpenGLVertexArrayObject* linesVao, QVector3D vecCol) { bool isInit = false; if (!linesVao->isCreated()) { linesVao->create(); linesVao->bind(); isInit = true; } QVector<VertexData> data; for (uint a = 0; a < lines.size(); a++) { data.append(VertexData(QVector3D(lines[a].XA, lines[a].YA, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(lines[a].XB, lines[a].YB, 0), QVector2D(), vecCol)); } BuildVboWithColor(data, linesVbo); if (isInit) { linesVao->release(); } }
size_t VertexDataHelper::BuildPathsVertexData(std::vector<APath> paths, QOpenGLBuffer* linesVbo, QOpenGLVertexArrayObject* linesVao, std::vector<QVector3D> colors) { if (paths.size() == 0) { return 0; } bool isInit = false; if (!linesVao->isCreated()) { linesVao->create(); linesVao->bind(); isInit = true; } QVector<VertexData> data; for (size_t a = 0; a < paths.size(); a++) { // your code here APath aPath = paths[a]; QVector3D vecCol = colors[a]; size_t path_length = aPath.points.size(); for (uint a = 0; a < path_length - 1; a++) { //if (a < _points.size() - 1) { lines.push_back(ALine(_points[a], _points[a + 1])); } //else { lines.push_back(ALine(_points[a], _points[0])); } data.append(VertexData(QVector3D(aPath.points[a].x, aPath.points[a].y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(aPath.points[a + 1].x, aPath.points[a + 1].y, 0), QVector2D(), vecCol)); } if (aPath.isClosed) { data.append(VertexData(QVector3D(aPath.points[path_length - 1].x, aPath.points[path_length - 1].y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(aPath.points[0].x, aPath.points[0].y, 0), QVector2D(), vecCol)); } } BuildVboWithColor(data, linesVbo); if (isInit) { linesVao->release(); } return data.size(); }
void VertexDataHelper::BuildLinesVertexData(std::vector<AVector> points, QOpenGLBuffer* linesVbo, QOpenGLVertexArrayObject* linesVao, QVector3D vecCol) { if (points.size() == 0) { return; } bool isInit = false; if (!linesVao->isCreated()) { linesVao->create(); linesVao->bind(); isInit = true; } QVector<VertexData> data; for (uint a = 0; a < points.size() - 1; a++) { data.append(VertexData(QVector3D(points[a].x, points[a].y, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(points[a + 1].x, points[a + 1].y, 0), QVector2D(), vecCol)); } BuildVboWithColor(data, linesVbo); if (isInit) { linesVao->release(); } }
void GLWidget::PrepareLinesVBO(std::vector<ALine> lines, QOpenGLBuffer* linesVbo, QOpenGLVertexArrayObject* linesVao, QVector3D vecCol) { bool isInit = false; if(!linesVao->isCreated()) { linesVao->create(); linesVao->bind(); isInit = true; } QVector<VertexData> data; for(uint a = 0; a < lines.size(); a++) { data.append(VertexData(QVector3D(lines[a].XA, lines[a].YA, 0), QVector2D(), vecCol)); data.append(VertexData(QVector3D(lines[a].XB, lines[a].YB, 0), QVector2D(), vecCol)); } linesVbo->create(); linesVbo->bind(); linesVbo->allocate(data.data(), data.size() * sizeof(VertexData)); quintptr offset = 0; _shaderProgram->enableAttributeArray(_vertexLocation); _shaderProgram->setAttributeBuffer(_vertexLocation, GL_FLOAT, 0, 3, sizeof(VertexData)); offset += sizeof(QVector3D); offset += sizeof(QVector2D); _shaderProgram->enableAttributeArray(_colorLocation); _shaderProgram->setAttributeBuffer(_colorLocation, GL_FLOAT, offset, 3, sizeof(VertexData)); if(isInit) { linesVao->release(); } }
//----------------------------------------------------------------------------- //-------------------------------------------------------------------------- ManualObject::ManualObjectSectionShadowRenderable::ManualObjectSectionShadowRenderable( ManualObject* parent, HardwareIndexBufferSharedPtr* indexBuffer, const VertexData* vertexData, bool createSeparateLightCap, bool isLightCap) : mParent(parent) { // Initialise render op mRenderOp.indexData = OGRE_NEW IndexData(); mRenderOp.indexData->indexBuffer = *indexBuffer; mRenderOp.indexData->indexStart = 0; // index start and count are sorted out later // Create vertex data which just references position component (and 2 component) mRenderOp.vertexData = OGRE_NEW VertexData(); // Map in position data mRenderOp.vertexData->vertexDeclaration->addElement(0,0,VET_FLOAT3, VES_POSITION); ushort origPosBind = vertexData->vertexDeclaration->findElementBySemantic(VES_POSITION)->getSource(); mPositionBuffer = vertexData->vertexBufferBinding->getBuffer(origPosBind); mRenderOp.vertexData->vertexBufferBinding->setBinding(0, mPositionBuffer); // Map in w-coord buffer (if present) if(!vertexData->hardwareShadowVolWBuffer.isNull()) { mRenderOp.vertexData->vertexDeclaration->addElement(1,0,VET_FLOAT1, VES_TEXTURE_COORDINATES, 0); mWBuffer = vertexData->hardwareShadowVolWBuffer; mRenderOp.vertexData->vertexBufferBinding->setBinding(1, mWBuffer); } // Use same vertex start as input mRenderOp.vertexData->vertexStart = vertexData->vertexStart; if (isLightCap) { // Use original vertex count, no extrusion mRenderOp.vertexData->vertexCount = vertexData->vertexCount; } else { // Vertex count must take into account the doubling of the buffer, // because second half of the buffer is the extruded copy mRenderOp.vertexData->vertexCount = vertexData->vertexCount * 2; if (createSeparateLightCap) { // Create child light cap mLightCap = OGRE_NEW ManualObjectSectionShadowRenderable(parent, indexBuffer, vertexData, false, true); } } }
std::shared_ptr<TextField> TextField::create(std::shared_ptr<Skin> skin, std::shared_ptr<WrappableText> default_text, std::shared_ptr<WrappableText> typed_text, glm::vec4 background_color, float padding, float screen_width, float screen_height, float x_pos, float y_pos, float width, float height, const unsigned int layer) { auto vertex_data = VertexData(); vertex_data.addVec(VertexData::DATA_TYPE::GEOMETRY, generateRect(screen_width, screen_height, 0, 0, width, height)); vertex_data.addVec(VertexData::DATA_TYPE::TEX_COORDS, basisTexCoords()); default_text->setSize(width - (2.0 * padding), height - (2.0 * padding)); typed_text->setSize(width - (2.0 * padding), height - (2.0 * padding)); typed_text->setText(""); auto field = std::make_shared<TextField>(default_text, typed_text, vertex_data, skin, layer); field->setColor(background_color); field->setAnchorPoint(glm::vec2(x_pos, y_pos)); field->setWidth(width); field->setHeight(height); field->setTextPadding(padding); return field; }
//------------------------------------------------------------------------ void TerrainBatch::createGpuVertexData() { if ( !mGpuVertexData ) { DefaultTerrainTilesGpuBufferAllocator& gpuBufferAllocator = mSurfaceManager->getDefaultTerrainTilesGpuBufferAllocator(); mOneVertexSize = mTileRender->getOneVertexSize(); Ogre::VertexData* tileVertexData = mTileRender->getCpuVertexData(); ///////////////////////////////////////////////////////////////////////////// mGpuVertexData = OGRE_NEW VertexData(); // copy vertex buffers // get new buffers HardwareVertexBufferSharedPtr destPosBuf; gpuBufferAllocator.allocateVertexBuffers(mOneVertexSize, mVertexTotalNum, destPosBuf); // set bindings mGpuVertexData->vertexBufferBinding->setBinding( TerrainTileRender::POSITION_BUFFER, destPosBuf); // Basic vertex info mGpuVertexData->vertexStart = 0; mGpuVertexData->vertexCount = mVertexTotalNum; // Copy elements const VertexDeclaration::VertexElementList elems = tileVertexData->vertexDeclaration->getElements(); VertexDeclaration::VertexElementList::const_iterator ei, eiend; eiend = elems.end(); for (ei = elems.begin(); ei != eiend; ++ei) { mGpuVertexData->vertexDeclaration->addElement( ei->getSource(), ei->getOffset(), ei->getType(), ei->getSemantic(), ei->getIndex() ); } } }
void VertexDataHelper::BuildPointsVertexData(std::vector<AVector> points, QOpenGLBuffer* ptsVbo, QOpenGLVertexArrayObject* ptsVao, QVector3D vecCol) { bool isInit = false; if (!ptsVao->isCreated()) { ptsVao->create(); ptsVao->bind(); isInit = true; } QVector<VertexData> data; for (uint a = 0; a < points.size(); a++) { data.append(VertexData(QVector3D(points[a].x, points[a].y, 0), QVector2D(), vecCol)); } BuildVboWithColor(data, ptsVbo); if (isInit) { ptsVao->release(); } }
//------------------------------------------------------------------------------// void GeoTerrainSection::_createConnectorRend() { for(int i = 0;i < GeoTerrain::TotalSides; ++i) { mConnectorRends[i].setCreator(this); mConnectorRends[i].setSectionPos(mSectionPos); RenderData* rend = mConnectorRends[i].getRenderData(); rend->vertexData = TITAN_NEW VertexData(mCreator->getVertexDecl(),mVertexBufferBinding); rend->vertexData->vertexCount = mCreator->getHorzVertexData()->getNumVertices(); rend->useIndex = true; rend->indexData = TITAN_NEW IndexData(); rend->indexData->indexStart = 0; Vector4 uvScaleOffset = Vector4((float)1.0f/(mCreator->getSectorCountX()+1), (float)1.0f/(mCreator->getSectorCountZ()+1), (float)mSectorX, (float)mSectorZ); mConnectorRends[i].setCustomShaderParam(0, uvScaleOffset); } }
DynamicRenderable::DynamicRenderable( VertexDeclaration * pVtxDecl, RenderOperation::OperationType enRenderOpType, bool bIndices, const size_t nLODLevels, const Real fPixelError, const Ogre::String & sName /*= ""*/ ) : LODRenderable(nLODLevels, fPixelError, false, 0, sName), _pVtxDecl(pVtxDecl), _pVtxBB(HardwareBufferManager::getSingletonPtr() ->createVertexBufferBinding()), _txWorld(Matrix4::IDENTITY), _pvMeshData(new MeshData * [nLODLevels]) { for (unsigned c = 0; c < nLODLevels; ++c) _pvMeshData[c] = NULL; oht_assert_threadmodel(ThrMdl_Single); // Initialize render operation _renderOp.operationType = enRenderOpType; _renderOp.useIndexes = bIndices; _renderOp.vertexData = OGRE_NEW VertexData(pVtxDecl, _pVtxBB); _renderOp.indexData = &_indexHWData; }
//----------------------------------------------------------------------- void PatchMesh::loadImpl(void) { SubMesh* sm = this->createSubMesh(); sm->vertexData = OGRE_NEW VertexData(); sm->useSharedVertices = false; // Set up vertex buffer sm->vertexData->vertexStart = 0; sm->vertexData->vertexCount = mSurface.getRequiredVertexCount(); sm->vertexData->vertexDeclaration = mDeclaration; HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton(). createVertexBuffer( mDeclaration->getVertexSize(0), sm->vertexData->vertexCount, mVertexBufferUsage, mVertexBufferShadowBuffer); sm->vertexData->vertexBufferBinding->setBinding(0, vbuf); // Set up index buffer sm->indexData->indexStart = 0; sm->indexData->indexCount = mSurface.getRequiredIndexCount(); sm->indexData->indexBuffer = HardwareBufferManager::getSingleton(). createIndexBuffer( HardwareIndexBuffer::IT_16BIT, // only 16-bit indexes supported, patches shouldn't be bigger than that sm->indexData->indexCount, mIndexBufferUsage, mIndexBufferShadowBuffer); // Build patch mSurface.build(vbuf, 0, sm->indexData->indexBuffer, 0); // Set bounds this->_setBounds(mSurface.getBounds(), true); this->_setBoundingSphereRadius(mSurface.getBoundingSphereRadius()); }
/* ******************************************************************************* | implement of CGrassSticks ******************************************************************************* */ void CGrassSticks::createGrassMesh() { MeshPtr mesh = MeshManager::getSingleton().createManual(GRASS_MESH_NAME, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); // create a submesh with the grass material SubMesh* sm = mesh->createSubMesh(); sm->setMaterialName("Examples/GrassBlades"); sm->useSharedVertices = false; sm->vertexData = OGRE_NEW VertexData(); sm->vertexData->vertexStart = 0; sm->vertexData->vertexCount = 12; sm->indexData->indexCount = 18; // specify a vertex format declaration for our mesh: 3 floats for position, 3 floats for normal, 2 floats for UV VertexDeclaration* decl = sm->vertexData->vertexDeclaration; decl->addElement(0, 0, VET_FLOAT3, VES_POSITION); decl->addElement(0, sizeof(float) * 3, VET_FLOAT3, VES_NORMAL); decl->addElement(0, sizeof(float) * 6, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0); // create a vertex buffer HardwareVertexBufferSharedPtr vb = HardwareBufferManager::getSingleton().createVertexBuffer (decl->getVertexSize(0), sm->vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY); GrassVertex* verts = (GrassVertex*)vb->lock(HardwareBuffer::HBL_DISCARD); // start filling in vertex data for (unsigned int i = 0; i < 3; i++) // each grass mesh consists of 3 planes { // planes intersect along the Y axis with 60 degrees between them Real x = Math::Cos(Degree(i * 60)) * GRASS_WIDTH / 2; Real z = Math::Sin(Degree(i * 60)) * GRASS_WIDTH / 2; for (unsigned int j = 0; j < 4; j++) // each plane has 4 vertices { GrassVertex& vert = verts[i * 4 + j]; vert.x = j < 2 ? -x : x; vert.y = j % 2 ? 0 : GRASS_HEIGHT; vert.z = j < 2 ? -z : z; // all normals point straight up vert.nx = 0; vert.ny = 1; vert.nz = 0; vert.u = j < 2 ? 0 : 1; vert.v = j % 2; } } vb->unlock(); // commit vertex changes sm->vertexData->vertexBufferBinding->setBinding(0, vb); // bind vertex buffer to our submesh // create an index buffer sm->indexData->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer (HardwareIndexBuffer::IT_16BIT, sm->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY); // start filling in index data Ogre::uint16* indices = (Ogre::uint16*)sm->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD); for (unsigned int i = 0; i < 3; i++) // each grass mesh consists of 3 planes { unsigned int off = i * 4; // each plane consists of 2 triangles *indices++ = 0 + off; *indices++ = 3 + off; *indices++ = 1 + off; *indices++ = 0 + off; *indices++ = 2 + off; *indices++ = 3 + off; } sm->indexData->indexBuffer->unlock(); // commit index changes // update mesh AABB Ogre::AxisAlignedBox aabb; aabb.setExtents(-1,-1,-1,1,1,1); mesh->_setBounds(aabb); // Ogre::MeshSerializer serial; // serial.exportMesh(mesh.getPointer(), "grass.mesh"); }
//--------------------------------------------------------------------- void PrefabFactory::createSphere(Mesh* mesh) { // sphere creation code taken from the DeferredShading sample, originally from the wiki SubMesh *pSphereVertex = mesh->createSubMesh(); const int NUM_SEGMENTS = 16; const int NUM_RINGS = 16; const Real SPHERE_RADIUS = 50.0; mesh->sharedVertexData = OGRE_NEW VertexData(); VertexData* vertexData = mesh->sharedVertexData; // define the vertex format VertexDeclaration* vertexDecl = vertexData->vertexDeclaration; size_t currOffset = 0; // positions vertexDecl->addElement(0, currOffset, VET_FLOAT3, VES_POSITION); currOffset += VertexElement::getTypeSize(VET_FLOAT3); // normals vertexDecl->addElement(0, currOffset, VET_FLOAT3, VES_NORMAL); currOffset += VertexElement::getTypeSize(VET_FLOAT3); // two dimensional texture coordinates vertexDecl->addElement(0, currOffset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0); // allocate the vertex buffer vertexData->vertexCount = (NUM_RINGS + 1) * (NUM_SEGMENTS+1); HardwareVertexBufferSharedPtr vBuf = HardwareBufferManager::getSingleton().createVertexBuffer(vertexDecl->getVertexSize(0), vertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); VertexBufferBinding* binding = vertexData->vertexBufferBinding; binding->setBinding(0, vBuf); float* pVertex = static_cast<float*>(vBuf->lock(HardwareBuffer::HBL_DISCARD)); // allocate index buffer pSphereVertex->indexData->indexCount = 6 * NUM_RINGS * (NUM_SEGMENTS + 1); pSphereVertex->indexData->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer(HardwareIndexBuffer::IT_16BIT, pSphereVertex->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); HardwareIndexBufferSharedPtr iBuf = pSphereVertex->indexData->indexBuffer; unsigned short* pIndices = static_cast<unsigned short*>(iBuf->lock(HardwareBuffer::HBL_DISCARD)); float fDeltaRingAngle = (Math::PI / NUM_RINGS); float fDeltaSegAngle = (2 * Math::PI / NUM_SEGMENTS); unsigned short wVerticeIndex = 0 ; // Generate the group of rings for the sphere for( int ring = 0; ring <= NUM_RINGS; ring++ ) { float r0 = SPHERE_RADIUS * sinf (ring * fDeltaRingAngle); float y0 = SPHERE_RADIUS * cosf (ring * fDeltaRingAngle); // Generate the group of segments for the current ring for(int seg = 0; seg <= NUM_SEGMENTS; seg++) { float x0 = r0 * sinf(seg * fDeltaSegAngle); float z0 = r0 * cosf(seg * fDeltaSegAngle); // Add one vertex to the strip which makes up the sphere *pVertex++ = x0; *pVertex++ = y0; *pVertex++ = z0; Vector3 vNormal = Vector3(x0, y0, z0).normalisedCopy(); *pVertex++ = vNormal.x; *pVertex++ = vNormal.y; *pVertex++ = vNormal.z; *pVertex++ = (float) seg / (float) NUM_SEGMENTS; *pVertex++ = (float) ring / (float) NUM_RINGS; if (ring != NUM_RINGS) { // each vertex (except the last) has six indicies pointing to it *pIndices++ = wVerticeIndex + NUM_SEGMENTS + 1; *pIndices++ = wVerticeIndex; *pIndices++ = wVerticeIndex + NUM_SEGMENTS; *pIndices++ = wVerticeIndex + NUM_SEGMENTS + 1; *pIndices++ = wVerticeIndex + 1; *pIndices++ = wVerticeIndex; wVerticeIndex ++; } }; // end for seg } // end for ring // Unlock vBuf->unlock(); iBuf->unlock(); // Generate face list pSphereVertex->useSharedVertices = true; // the original code was missing this line: mesh->_setBounds( AxisAlignedBox( Vector3(-SPHERE_RADIUS, -SPHERE_RADIUS, -SPHERE_RADIUS), Vector3(SPHERE_RADIUS, SPHERE_RADIUS, SPHERE_RADIUS) ), false ); mesh->_setBoundingSphereRadius(SPHERE_RADIUS); }
//--------------------------------------------------------------------- void PrefabFactory::createCube(Mesh* mesh) { SubMesh* sub = mesh->createSubMesh(); const int NUM_VERTICES = 4 * 6; // 4 vertices per side * 6 sides const int NUM_ENTRIES_PER_VERTEX = 8; const int NUM_VERTEX_ENTRIES = NUM_VERTICES * NUM_ENTRIES_PER_VERTEX; const int NUM_INDICES = 3 * 2 * 6; // 3 indices per face * 2 faces per side * 6 sides const Real CUBE_SIZE = 100.0f; const Real CUBE_HALF_SIZE = CUBE_SIZE / 2.0f; // Create 4 vertices per side instead of 6 that are shared for the whole cube. // The reason for this is with only 6 vertices the normals will look bad // since each vertex can "point" in a different direction depending on the face it is included in. float vertices[NUM_VERTEX_ENTRIES] = { // front side -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, // pos 0,0,1, // normal 0,1, // texcoord CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, 0,0,1, 1,1, CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE, 0,0,1, 1,0, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE , 0,0,1, 0,0, // back side CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,0,-1, 0,1, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,0,-1, 1,1, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,0,-1, 1,0, CUBE_HALF_SIZE, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,0,-1, 0,0, // left side -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -1,0,0, 0,1, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, -1,0,0, 1,1, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE, -1,0,0, 1,0, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -1,0,0, 0,0, // right side CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, 1,0,0, 0,1, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 1,0,0, 1,1, CUBE_HALF_SIZE, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 1,0,0, 1,0, CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE, 1,0,0, 0,0, // up side -CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE, 0,1,0, 0,1, CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE, 0,1,0, 1,1, CUBE_HALF_SIZE, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,1,0, 1,0, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,1,0, 0,0, // down side -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,-1,0, 0,1, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, 0,-1,0, 1,1, CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, 0,-1,0, 1,0, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, 0,-1,0, 0,0 }; mesh->sharedVertexData = OGRE_NEW VertexData(); mesh->sharedVertexData->vertexCount = NUM_VERTICES; VertexDeclaration* decl = mesh->sharedVertexData->vertexDeclaration; VertexBufferBinding* bind = mesh->sharedVertexData->vertexBufferBinding; size_t offset = 0; decl->addElement(0, offset, VET_FLOAT3, VES_POSITION); offset += VertexElement::getTypeSize(VET_FLOAT3); decl->addElement(0, offset, VET_FLOAT3, VES_NORMAL); offset += VertexElement::getTypeSize(VET_FLOAT3); decl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0); offset += VertexElement::getTypeSize(VET_FLOAT2); HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().createVertexBuffer( offset, NUM_VERTICES, HardwareBuffer::HBU_STATIC_WRITE_ONLY); bind->setBinding(0, vbuf); vbuf->writeData(0, vbuf->getSizeInBytes(), vertices, true); sub->useSharedVertices = true; HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton(). createIndexBuffer( HardwareIndexBuffer::IT_16BIT, NUM_INDICES, HardwareBuffer::HBU_STATIC_WRITE_ONLY); unsigned short faces[NUM_INDICES] = { // front 0,1,2, 0,2,3, // back 4,5,6, 4,6,7, // left 8,9,10, 8,10,11, // right 12,13,14, 12,14,15, // up 16,17,18, 16,18,19, // down 20,21,22, 20,22,23 }; sub->indexData->indexBuffer = ibuf; sub->indexData->indexCount = NUM_INDICES; sub->indexData->indexStart = 0; ibuf->writeData(0, ibuf->getSizeInBytes(), faces, true); mesh->_setBounds(AxisAlignedBox(-CUBE_HALF_SIZE, -CUBE_HALF_SIZE, -CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE, CUBE_HALF_SIZE), true); mesh->_setBoundingSphereRadius(CUBE_HALF_SIZE); }