void Painter::draw_elements(DrawMode mode, VertexBuffer& indices, etc::size_type start, etc::size_type count) { ETC_TRACE.debug("draw elements"); if (indices.attributes().size() == 0) throw Exception{ "No attributes found in indices VertexBuffer." }; if (indices.attributes().size() > 1) throw Exception{ "Indices VertexBuffer contains more that one attributes." }; auto const& attr = indices.attributes()[0]; if (count == ((etc::size_type) -1)) count = attr->nb_elements - start; else if (count > attr->nb_elements - start) throw Exception{"Count is out of range."}; Bindable::Guard guard{indices, this->state()}; _renderer.draw_elements( mode, count, attr->type, (uint8_t*)0 + (start * get_content_type_size(attr->type)) ); }
void SkinController::OnFirstUpdate() { // Get access to the vertex buffer positions to store the blended targets. Visual* visual = reinterpret_cast<Visual*>(mObject); VertexBuffer* vbuffer = visual->GetVertexBuffer().get(); if (mNumVertices == static_cast<int>(vbuffer->GetNumElements())) { // Get the position data. VertexFormat vformat = vbuffer->GetFormat(); int const numAttributes = vformat.GetNumAttributes(); for (int i = 0; i < numAttributes; ++i) { VASemantic semantic; DFType type; unsigned int unit, offset; if (vformat.GetAttribute(i, semantic, type, unit, offset)) { if (semantic == VA_POSITION && (type == DF_R32G32B32_FLOAT || type == DF_R32G32B32A32_FLOAT)) { mPosition = vbuffer->GetData() + offset; mStride = vformat.GetVertexSize(); mCanUpdate = true; break; } } } } mCanUpdate = (mPosition != nullptr); }
VertexBuffer *VertexBuffer::createQuad() { VertexBuffer *vbo = new VertexBuffer(); GLfloat vertices[] = {0, 1.0, 0, // top left corner 1.0, 1.0, 0, // top right corner 1.0, 0, 0, // bottom right corner 0, 0, 0}; // bottom left corner GLfloat uvs[] = { 0, 1, 1, 1, 1, 0, 0, 0 }; GLubyte indices[] = {0,1,2, // first triangle (bottom left - top left - top right) 0,2,3}; // second triangle (bottom left - top right - bottom right) for(int i = 0; i < 4; i++) vbo->addVertex(glm::vec3(vertices[i*3], vertices[(i*3)+1], vertices[(i*3)+2])); for(int i = 0; i < 4; i++) vbo->addUV(glm::vec2(uvs[i*2], uvs[(i*2)+1])); for(int i = 0; i < 6; i++) vbo->addIndex(indices[i]); vbo->upload(); return vbo; }
void PrimitiveShape::doadvance() { VertexBuffer* vb = m_vertexbuffer; if( vb ) { vb->advance(); } // IndexBuffer* ib = m_indexbuffer; // if( ib ) // { // ib->advance(); // } Program* pr = m_program; if( pr ) { pr->advance(); } // for( int i = 0; i < 8; ++i ) // { // Texture* t = m_textures[ i ]; // if( t ) // { // t->advance(); // } // } }
bool Fluids3DWindow::CreateNestedBoxes() { std::string path = mEnvironment.GetPath("VolumeRender.hlsl"); std::shared_ptr<VisualProgram> program = mProgramFactory.CreateFromFiles(path, path, ""); if (!program) { return false; } mPVWMatrixBuffer = std::make_shared<ConstantBuffer>( sizeof(Matrix4x4<float>), true); *mPVWMatrixBuffer->Get<Matrix4x4<float>>() = Matrix4x4<float>::Identity(); mTrilinearClampSampler = std::make_shared<SamplerState>(); mTrilinearClampSampler->filter = SamplerState::MIN_L_MAG_L_MIP_P; mTrilinearClampSampler->mode[0] = SamplerState::CLAMP; mTrilinearClampSampler->mode[1] = SamplerState::CLAMP; mTrilinearClampSampler->mode[2] = SamplerState::CLAMP; program->GetVShader()->Set("PVWMatrix", mPVWMatrixBuffer); program->GetPShader()->Set("volumeTexture", mFluid.GetState()); program->GetPShader()->Set("trilinearClampSampler", mTrilinearClampSampler); std::shared_ptr<VisualEffect> effect = std::make_shared<VisualEffect>(program); struct Vertex { Vector3<float> position, tcoord; }; VertexFormat vformat; vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0); vformat.Bind(VA_TEXCOORD, DF_R32G32B32_FLOAT, 0); MeshFactory mf; mf.SetVertexFormat(vformat); int const numBoxes = 128; for (int i = 1; i <= numBoxes; ++i) { float extent = 0.5f*i/(numBoxes - 1.0f); std::shared_ptr<Visual> visual(mf.CreateBox(extent, extent, extent)); VertexBuffer* vbuffer = visual->GetVertexBuffer().get(); Vertex* vertex = vbuffer->Get<Vertex>(); for (unsigned int j = 0; j < vbuffer->GetNumElements(); ++j, ++vertex) { Vector3<float>& tcd = vertex->tcoord; Vector3<float> pos = vertex->position; Vector4<float> tmp{ pos[0] + 0.5f, pos[1] + 0.5f, pos[2] + 0.5f, 0.0f }; for (int k = 0; k < 3; ++k) { tcd[k] = 0.5f*(tmp[k] + 1.0f); } } visual->SetEffect(effect); mVisible.push_back(visual); } return true; }
//---------------------------------------------------------------------------- void GeoObjFactory::UpdateCtrlColor1(Movable *mov, Float4 color) { PX2::Node *node = DynamicCast<Node>(mov); if (!node) return; for (int i = 0; i < node->GetNumChildren(); i++) { PX2::Movable *child = node->GetChild(i); PX2::TriMesh *mesh = DynamicCast<TriMesh>(child); if (mesh) { VertexBuffer *vBuffer = mesh->GetVertexBuffer(); VertexFormat *vf = PX2_GR.GetVertexFormat(GraphicsRoot::VFT_PC); VertexBufferAccessor vba(vf, vBuffer); for (int i = 0; i < vBuffer->GetNumElements(); i++) { vba.Color<Float4>(0, i) = color; } Renderer::UpdateAll(vBuffer); } } }
void ProjectPass::Process(VertexBuffer& localBuf,VertexBuffer& globalBuf,Int32 p) { VertexBuffer& buf = p < 0 ? globalBuf : localBuf; p = p >= 0 ? p : -p; Point& pt = buf.GetPosition(p); pt = r_pCamera->GetProjectMatrix() * pt; pt.ProjectDiv(); pt = r_pCamera->GetScreenMatrix() * pt; if(localBuf.HasAttribute(VA_TEXTCOOR)) { TextureCoord& coor = buf.GetTextureCoord(p); coor.t *= pt.z; coor.s *= pt.z; Int32 nT = TextFix::Double2Fix(coor.t); Int32 nS = TextFix::Double2Fix(coor.s); ++nS; } if(localBuf.HasAttribute(VA_TEXTCOOR1)) { TextureCoord& coor1 = buf.GetTextureCoord1(p); coor1.t *= pt.z; coor1.s *= pt.z; TextFix::Double2Fix(coor1.t); TextFix::Double2Fix(coor1.s); } Fix28::Double2Fix(pt.z); }
void BasicRenderer::DrawIndexedPrimitive(PrimitiveTypeEnum pt, ObjectGUID vbId, ObjectGUID ibId, uint32_t startIndex, uint32_t indexCount, uint32_t startVertex, float* color, float* xform) { if(!m_context) return; UpdateCbPerDraw(xform,color); // Set primitive topology m_context->IASetPrimitiveTopology( (D3D11_PRIMITIVE_TOPOLOGY)pt ); // set vertex buffer VertexBuffer* vb = reinterpret_cast<VertexBuffer*>(vbId); UINT stride = vb->GetStride(); UINT Offset = 0; ID3D11Buffer* buffer = vb->GetBuffer(); m_context->IASetVertexBuffers( 0, 1, &buffer, &stride, &Offset); // set index buffer IndexBuffer* ib = reinterpret_cast<IndexBuffer*>(ibId); m_context->IASetIndexBuffer(ib->GetBuffer(),(DXGI_FORMAT)ib->GetFormat(),0); m_context->DrawIndexed(indexCount,startIndex,startVertex); }
Skydome::Skydome() { VertexBuffer buff; int nb_segments=64; int i,j; const float R = 1./(float)(nb_segments-1); for(i = 0; i<nb_segments; i++) { for(j = 0; j<nb_segments; j++) { float x = cos(2*M_PI*j*R)*sin(M_PI*i*R); float y = sin(-M_PI_2+M_PI*i*R); float z = sin(2*M_PI*j*R)*sin(M_PI*i*R); buff.addVertex(Vertex3D(glm::vec3(x,y,z), glm::vec3(-x,-y,-z), glm::vec2(0,0), sf::Color(255,255,255,255))); } } for(i=0; i<nb_segments; i++){ for(j=0; j<nb_segments; j++){ //buff.getVertex(i*nb_segments+j).normal = glm::normalize(buff.getVertex(i*nb_segments+j).normal); buff.addTriangle(sf::Vector3i((i*nb_segments+j), (i*nb_segments+j+1), ((i+1)*nb_segments+j))); buff.addTriangle(sf::Vector3i((i*nb_segments+j+1), ((i+1)*nb_segments+j+1), ((i+1)*nb_segments+j))); } } loadFromMemory(buff); }
GCAMERA() { running=false; JNIEnv *env = g_getJNIEnv(); jclass localClass = env->FindClass( "com/giderosmobile/android/plugins/camera/GCamera"); cls_ = (jclass) env->NewGlobalRef(localClass); env->DeleteLocalRef(localClass); shader = ShaderEngine::Engine->createShaderProgram(VShaderCode, FShaderCode, ShaderProgram::Flag_FromCode, camUniforms, camAttributes); indices.resize(4); vertices.resize(4); texcoords.resize(4); indices[0] = 0; indices[1] = 1; indices[2] = 3; indices[3] = 2; indices.Update(); texcoords[0] = Point2f(0, 0); texcoords[1] = Point2f(1, 0); texcoords[2] = Point2f(1, 1); texcoords[3] = Point2f(0, 1); texcoords.Update(); }
virtual void redisplay () { static GLuint buf [] = { 0, 0, 0, 0 }; static GLuint counters [4]; counterBuf.setData ( sizeof ( buf ), buf, GL_DYNAMIC_DRAW ); glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); mat4 mv = mat4 :: rotateZ ( toRadians ( rot.z ) ) * mat4 :: rotateY ( toRadians ( rot.y ) ) * mat4 :: rotateX ( toRadians ( rot.x ) ); mat3 nm = normalMatrix ( mv ); program.bind (); program.setUniformMatrix ( "mv", mv ); program.setUniformMatrix ( "nm", nm ); mesh -> render (); program.unbind (); glFinish (); counterBuf.getSubData ( 0, sizeof ( buf ), counters ); printf ( "%4d %4d %d %d\n", counters [0], counters [1], counters [2], counters [3] ); }
//! adds an entity to a render map void EntityRenderer::AddToRenderMap(RenderMap& renderMap, GraphicComponent* pGraphic) { Material* pMaterial = pGraphic->GetMaterial(); VertexBuffer* pVertexBuffer = pGraphic->GetVertexBuffer(); if(pMaterial && pVertexBuffer) { if(pVertexBuffer->GetNumVertices() || pVertexBuffer->GetNumIndices()) { SHOOT_ASSERT(pGraphic->GetParent()->IsA(RenderableEntity::TypeID), "Invalid GraphicComponent"); RenderableEntity* pEntity = static_cast<RenderableEntity*>(pGraphic->GetParent()); u32 materialID = (u32)pMaterial; u32 ID = ((pGraphic->GetRenderingPriority()&0xFF)<<24) | (materialID&0x00FFFFFF); u32 vbID = (u32)pVertexBuffer; renderMap[ID].pMaterial = pMaterial; renderMap[ID].m_VertexMap[vbID].pVertexBuffer = pVertexBuffer; renderMap[ID].m_VertexMap[vbID].aWorldTransforms.push_back(pEntity->GetTransformationMatrix()); renderMap[ID].m_VertexMap[vbID].aTextureTransforms.push_back(pEntity->GetTextureTransformationMatrix()); } } else { SHOOT_WARNING(false, "Incomplete GraphicComponent found"); } }
void nativeRender(int camtex, float *mat) { if (!running) return; ShaderEngine::Engine->reset(); ShaderBuffer *oldfbo = ShaderEngine::Engine->setFramebuffer(rdrTgt); ShaderEngine::Engine->setViewport(0, 0, tex->width, tex->height); Matrix4 projection = ShaderEngine::Engine->setOrthoFrustum(0, tex->baseWidth, 0, tex->baseHeight, -1, 1); ShaderEngine::Engine->setProjection(projection); Matrix4 model; ShaderEngine::Engine->setModel(model); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_EXTERNAL_OES, camtex); shader->setConstant(shader->getConstantByName("tMatrix"), ShaderProgram::CMATRIX, 1, mat); shader->setData(ShaderProgram::DataVertex, ShaderProgram::DFLOAT, 2, &vertices[0], vertices.size(), vertices.modified, &vertices.bufferCache); shader->setData(ShaderProgram::DataTexture, ShaderProgram::DFLOAT, 2, &texcoords[0], texcoords.size(), texcoords.modified, &texcoords.bufferCache); shader->drawElements(ShaderProgram::TriangleStrip, indices.size(), ShaderProgram::DUSHORT, &indices[0], indices.modified, &indices.bufferCache); vertices.modified = false; texcoords.modified = false; indices.modified = false; ShaderEngine::Engine->setFramebuffer(oldfbo); }
const ShaderFeatures& Submesh::features() { if (mFeatures.isEmpty() && !mVertexBuffers.empty()) { // build the features struct for (VertexBuffers::iterator it = mVertexBuffers.begin(); it != mVertexBuffers.end(); ++it) { VertexBuffer* vb = *it; int nElems = vb->vertexElementCount(); for (int i=0; i<nElems; ++i) { VertexElement* elem = vb->vertexElement(i); switch(elem->mUsage) { case VEU_POSITION: mFeatures.setFeature(INTERP_POSITION); break; case VEU_NORMAL: mFeatures.setFeature(INTERP_NORMAL); break; case VEU_TEXCOORD: mFeatures.setFeature(INTERP_TEXCOORD, elem->mIndex); break; } } } } return mFeatures; }
VertexBuffer* VertexBufferManager::CreateVertexBuffer( const VertexSettings& Settings ) { VertexBuffer* pVertex = new VertexBuffer( Settings ); pVertex->Init(); mVBOs[ mVboCount++ ] = pVertex; return pVertex; }
//---------------------------------------------------------------------------- void GeoObjFactory::UpdateCtrlColor(PX2::Renderer *renderer, PX2::Movable *mov, Float4 color) { PX2::Node *node = DynamicCast<Node>(mov); if (!node) return; for (int i = 0; i < node->GetNumChildren(); i++) { PX2::Movable *child = node->GetChild(i); PX2::Polysegment *poly = DynamicCast<Polysegment>(child); if (poly) { VertexBuffer *vBuffer = poly->GetVertexBuffer(); VertexFormat *vf = PX2_GR.GetVertexFormat(GraphicsRoot::VFT_PC); VertexBufferAccessor vba(vf, vBuffer); for (int i = 0; i < vBuffer->GetNumElements(); i++) { vba.Color<Float4>(0, i) = color; } renderer->Update(vBuffer); } } }
//! called during the initialization of the entity void PelletManager::Init() { super::Init(); GraphicComponent* pGraphic = GetComponent<GraphicComponent>(); if(!pGraphic->GetMaterial()) { pGraphic->SetMaterial(snew Material()); } u32 maxBullets = m_BulletPoolSize/sizeof(Bullet); VertexBuffer* pVB = GraphicsDriver::Instance()->CreateVertexBuffer(); pVB->SetVertexFlag(Vertex3D::VF_Pos); pVB->SetName(GetClassName()); if(GraphicExtensionHandler::Instance()->HasExtension(GraphicExtensionHandler::E_PointSprite)) { pVB->SetPrimitiveType(GraphicsDriver::PT_Point); pVB->SetRenderStateSetter(snew PointSpriteStateSetter(m_fBulletSize)); pVB->SetVertices(snew Vertex3D[maxBullets], maxBullets); } else { pVB->SetPrimitiveType(GraphicsDriver::PT_Triangle); pVB->SetVertexFlag(Vertex3D::VF_UV); pVB->SetVertices(snew Vertex3D[maxBullets*6], maxBullets*6); } pGraphic->SetVertexBuffer(pVB); pVB->SetDynamic(true); }
bool RenderDevice::bindBuffers(RenderBatch* renderable) { BufferManager* buffers = activeContext->bufferManager; GeometryBuffer* gb = renderable->getGeometryBuffer().get(); VertexBuffer* vb = buffers->getVertexBuffer(gb).get(); IndexBuffer* ib = buffers->getIndexBuffer(gb).get(); if( !vb ) return false; if( !vb->isBuilt() || gb->needsRebuild ) { // If the vertex buffer is not built yet, then we build it. renderBackend->buildVertexBuffer(vb); } renderBackend->bindVertexBuffer(vb); // If there is no index buffer associated with the geometry, we are done. if( !ib ) goto done; renderBackend->bindIndexBuffer(ib); if( !ib->isBuilt || gb->needsRebuild ) { // If the index buffer is not built, we also need to build it. renderBackend->buildIndexBuffer(ib); } done: gb->needsRebuild = false; return true; }
bool HasDynamicBuffers(Model* model, unsigned lodLevel) { unsigned numGeometries = model->GetNumGeometries(); for (unsigned i = 0; i < numGeometries; ++i) { Geometry* geometry = model->GetGeometry(i, lodLevel); if (!geometry) continue; unsigned numVertexBuffers = geometry->GetNumVertexBuffers(); for (unsigned j = 0; j < numVertexBuffers; ++j) { VertexBuffer* buffer = geometry->GetVertexBuffer(j); if (!buffer) continue; if (buffer->IsDynamic()) return true; } IndexBuffer* buffer = geometry->GetIndexBuffer(); if (buffer && buffer->IsDynamic()) return true; } return false; }
void Plane::ToLineList(VertexBuffer &vb, float uWidth, float vHeight, const vec ¢erPoint, int numLinesU, int numLinesV) const { vec topLeft = Point(-uWidth*0.5f, -vHeight *0.5f, centerPoint); vec uEdge = (Point(uWidth*0.5f, -vHeight *0.5f, centerPoint) - topLeft) / (float)numLinesU; vec vEdge = (Point(-uWidth*0.5f, vHeight *0.5f, centerPoint) - topLeft) / (float)numLinesV; int i = vb.AppendVertices((numLinesU + numLinesV) * 2); for(int y = 0; y < numLinesV; ++y) { float4 start = POINT_TO_FLOAT4(topLeft + vEdge * (float)y); float4 end = POINT_TO_FLOAT4(topLeft + uWidth * uEdge + vEdge * (float)y); vb.Set(i, VDPosition, start); vb.Set(i+1, VDPosition, end); i += 2; } for(int x = 0; x < numLinesU; ++x) { float4 start = POINT_TO_FLOAT4(topLeft + uEdge * (float)x); float4 end = POINT_TO_FLOAT4(topLeft + vHeight * vEdge + uEdge * (float)x); vb.Set(i, VDPosition, start); vb.Set(i+1, VDPosition, end); i += 2; } }
void GraphicsPanel::drawFingertip(const FingerTip & stuff, const Shape theShape) { ODL_OBJENTER(); //#### ODL_P1("stuff = ", &stuff); //#### ODL_I1("theShape = ", theShape); //#### if (stuff._valid) { const Location & where = stuff._where; VertexBuffer * selected; switch (theShape) { case kShapeCube : if (! _cubeData) { setUpCube(); } selected = _cubeData; break; case kShapeTetrahedron : if (! _tetrahedronData) { setUpTetrahedron(); } selected = _tetrahedronData; break; case kShapeOctahedron : if (! _octahedronData) { setUpOctahedron(); } selected = _octahedronData; break; default : selected = NULL; break; } if (selected) { ODL_LOG("(selected)"); //#### if (NULL != _offsetUniform) { _offsetUniform->set(static_cast<float>(where.x), static_cast<float>(where.y), static_cast<float>(where.z), 0.0f); } selected->bind(); enableVertexAttributes(); glDrawElements(GL_TRIANGLES, selected->numberOfIndices(), GL_UNSIGNED_INT, 0); disableVertexAttributes(); } } ODL_OBJEXIT(); //#### } // GraphicsPanel::drawFingertip
void SPK_PLQuadRenderer::UpdateVertexBuffer(const SPK::Group &group) { // Get the vertex buffer instance from m_pSPK_PLBuffer and lock it VertexBuffer *pVertexBuffer = m_pSPK_PLBuffer->GetVertexBuffer(); if (pVertexBuffer->Lock(Lock::WriteOnly)) { // Get particle renderer to use void (SPK_PLQuadRenderer::*pRenderParticle)(const SPK::Particle&); // Pointer to the right render method switch (texturingMode) { case SPK::TEXTURE_2D: if (group.getModel()->isEnabled(SPK::PARAM_TEXTURE_INDEX)) pRenderParticle = group.getModel()->isEnabled(SPK::PARAM_ANGLE) ? &SPK_PLQuadRenderer::Render2DAtlasRot : &SPK_PLQuadRenderer::Render2DAtlas; else pRenderParticle = group.getModel()->isEnabled(SPK::PARAM_ANGLE) ? &SPK_PLQuadRenderer::Render2DRot : &SPK_PLQuadRenderer::Render2D; break; case SPK::TEXTURE_3D: pRenderParticle = group.getModel()->isEnabled(SPK::PARAM_ANGLE) ? &SPK_PLQuadRenderer::Render3DRot : &SPK_PLQuadRenderer::Render3D; break; case SPK::TEXTURE_NONE: pRenderParticle = group.getModel()->isEnabled(SPK::PARAM_ANGLE) ? &SPK_PLQuadRenderer::Render2DRot : &SPK_PLQuadRenderer::Render2D; break; default: pRenderParticle = nullptr; break; } // Get current vertex buffer data m_nCurrentVertexSize = pVertexBuffer->GetVertexSize(); m_pfCurrentPosition = static_cast<float*>(pVertexBuffer->GetData(0, VertexBuffer::Position)); m_pfCurrentTexCoord = static_cast<float*>(pVertexBuffer->GetData(0, VertexBuffer::TexCoord)); m_pCurrentVertexBuffer = pVertexBuffer; m_nCurrentVertex = 0; // Calculate the current orientation const bool bGlobalOrientation = precomputeOrientation3D( group, SPK::Vector3D(-m_mWorldViewInverse.fM[8], -m_mWorldViewInverse.fM[9], -m_mWorldViewInverse.fM[10]), SPK::Vector3D( m_mWorldViewInverse.fM[4], m_mWorldViewInverse.fM[5], m_mWorldViewInverse.fM[6]), SPK::Vector3D( m_mWorldViewInverse.fM[12], m_mWorldViewInverse.fM[13], m_mWorldViewInverse.fM[14])); if (pRenderParticle) { if (bGlobalOrientation) { computeGlobalOrientation3D(); for (size_t i=0; i<group.getNbParticles(); i++) (this->*pRenderParticle)(group.getParticle(i)); } else { for (size_t i=0; i<group.getNbParticles(); i++) { const SPK::Particle &cParticle = group.getParticle(i); computeSingleOrientation3D(cParticle); (this->*pRenderParticle)(cParticle); } } } // Unlock the vertex buffer pVertexBuffer->Unlock(); } }
// static angle::Result VertexDataManager::StoreStaticAttrib(const gl::Context *context, TranslatedAttribute *translated) { ASSERT(translated->attribute && translated->binding); const auto &attrib = *translated->attribute; const auto &binding = *translated->binding; gl::Buffer *buffer = binding.getBuffer().get(); ASSERT(buffer && attrib.enabled && !DirectStoragePossible(context, attrib, binding)); BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); // Compute source data pointer const uint8_t *sourceData = nullptr; const int offset = static_cast<int>(ComputeVertexAttributeOffset(attrib, binding)); ANGLE_TRY(bufferD3D->getData(context, &sourceData)); sourceData += offset; unsigned int streamOffset = 0; translated->storage = nullptr; ANGLE_TRY(bufferD3D->getFactory()->getVertexSpaceRequired(context, attrib, binding, 1, 0, &translated->stride)); auto *staticBuffer = bufferD3D->getStaticVertexBuffer(attrib, binding); ASSERT(staticBuffer); if (staticBuffer->empty()) { // Convert the entire buffer int totalCount = ElementsInBuffer(attrib, binding, static_cast<unsigned int>(bufferD3D->getSize())); int startIndex = offset / static_cast<int>(ComputeVertexAttributeStride(attrib, binding)); ANGLE_TRY(staticBuffer->storeStaticAttribute(context, attrib, binding, -startIndex, totalCount, 0, sourceData)); } unsigned int firstElementOffset = (static_cast<unsigned int>(offset) / static_cast<unsigned int>(ComputeVertexAttributeStride(attrib, binding))) * translated->stride; VertexBuffer *vertexBuffer = staticBuffer->getVertexBuffer(); CheckedNumeric<unsigned int> checkedOffset(streamOffset); checkedOffset += firstElementOffset; ANGLE_CHECK_HR_MATH(GetImplAs<ContextD3D>(context), checkedOffset.IsValid()); translated->vertexBuffer.set(vertexBuffer); translated->serial = vertexBuffer->getSerial(); translated->baseOffset = streamOffset + firstElementOffset; // Instanced vertices do not apply the 'start' offset translated->usesFirstVertexOffset = (binding.getDivisor() == 0); return angle::Result::Continue(); }
VertexBuffer* VertexArray::addBuffer(uint index, VertexBuffer::BufferType type, size_t size, void* data) { VertexBuffer* buf = getContext()->createVertexBuffer(); buf->setType(type); buf->setData(size, data); setBuffer(index, buf); return buf; }
void VertexArray::addAttribute(uint buffer, uint index, const String& name, VertexBuffer::AttributeType type, bool normalize, uint components, uint offset, uint stride) { VertexBuffer* buf = getBuffer(buffer); buf->setAttribute(index, type, normalize, components, offset, stride); setAttributeBinding(buffer, index, name); }
//! sets the bullet size void PelletManager::SetBulletSize(f32 fSize) { VertexBuffer* pVB = GetComponent<GraphicComponent>()->GetVertexBuffer(); if(GraphicExtensionHandler::Instance()->HasExtension(GraphicExtensionHandler::E_PointSprite)) { static_cast<PointSpriteStateSetter*>(pVB->GetRenderStateSetter())->SetPointSize(fSize); } m_fBulletSize = fSize; }
void InitVertexBuffer(VertexBuffer & pVB, LPVOID vertices, DWORD fvf, UINT vtxCnt, UINT stride) { GetD3D9Device()->CreateVertexBuffer(vtxCnt * stride, NULL, fvf, D3DPOOL_MANAGED, &pVB, NULL); LPVOID pVertex; pVB->Lock(0, 0, (LPVOID*)&pVertex, 0); memcpy(pVertex, vertices, vtxCnt * stride); pVB->Unlock(); }
VertexBuffer *VertexBuffer::createCube() { VertexBuffer *vbo = new VertexBuffer(); GLfloat skyboxVertices[] = { // Positions -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f }; for(int i = 0; i < 36; i++) vbo->addVertex(glm::vec3(skyboxVertices[i*3], skyboxVertices[(i*3)+1], skyboxVertices[(i*3)+2])); vbo->upload(); return vbo; }
void AABB::ToLineList(VertexBuffer &vb) const { Array<vec> pos; pos.Resize_pod(NumVerticesInEdgeList()); ToEdgeList(&pos[0]); int startIndex = vb.AppendVertices((int)pos.size()); for(int i = 0; i < (int)pos.size(); ++i) vb.Set(startIndex+i, VDPosition, POINT_TO_FLOAT4(pos[i])); }
RenderBuffer RenderBuffer::operator =(VertexBuffer buffer) { size = buffer.getSize(); for (int i = 0; i < size; i++) { ptr[i] = buffer.getValue(i); } return *this; }