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;
}
