void Helix::create() {
points_a.clear();
points_b.clear();
head_a.set(0,0,0);
head_b.set(0,0,0);
float angle = 0.0f;
for(int i = 0; i < num_iterations; ++i) {
angle += angle_increment;
float ca = cos(angle);
float sa = sin(angle);
head_a.x = ca * radius;
head_a.z = sa * radius;
ca = cos(angle - PI);
sa = sin(angle - PI);
head_b.x = ca * radius;
head_b.z = sa * radius;
head_a.y += grow_size;
head_b.y += grow_size;
points_a.push_back(head_a);
points_b.push_back(head_b);
}
generateVertices(points_a, mesh_ribbon_left);
generateVertices(points_b, mesh_ribbon_right);
generateVerticesForBasePairs(points_a, points_b);
}
void Font::renderText( const std::string& text, const mat4f& transformation, float fontHeight, const Color4f& color, const vec2f& relPos, bool drawWithShadow, bool fixedWidth )
{
Mesh* sMesh = nullptr;
if( drawWithShadow )
{
sMesh = generateVertices( text, vec3f( -1.0f, -1.0f, -0.001f ), fontHeight, vec3f( 1.0f, 0.0f, 0.0f ),
vec3f( 0.0f, 1.0f, 0.0f ), color::FADEDBLACK, relPos, fixedWidth );
}
Mesh* mesh = generateVertices( text, vec3f(), fontHeight, vec3f( 1.0f, 0.0f, 0.0f ),
vec3f( 0.0f, 1.0f, 0.0f ), color, relPos, fixedWidth );
Material* material = Material::getMaterial( mesh->getMaterial( 0 ) );
material->updateUniform( "uFontHeight", fontHeight );
//matStackf modelStack;
//modelStack.translate( pos );
NamedProperties params;
params.set( "modelMatrix", transformation );
params.set( "sMesh", sMesh );
if( sMesh )
fireEvent( "renderMesh", params );
params.set( "mesh", mesh );
fireEvent( "renderMesh", params );
SAFE_DELETE( sMesh );
SAFE_DELETE( mesh );
}
void initialize(unsigned int numVertices, unsigned int edgeSetSize, bool shouldGenerateEdges) {
dfpair(stdout, "prm vertex set size", "%lu", numVertices);
dfpair(stdout, "prm edge set size", "%lu", edgeSetSize);
dfpair(stdout, "prm edge collision check dt", "%g", collisionCheckDT);
startTime = clock();
clock_t vertexStart = clock();
generateVertices(numVertices);
clock_t end = clock();
double time = (double)(end-vertexStart) / CLOCKS_PER_SEC;
dfpair(stdout, "prm vertex build time", "%g", time);
if(shouldGenerateEdges) {
clock_t edgeStart = clock();
generateEdges(edgeSetSize);
end = clock();
time = (double)(end-edgeStart) / CLOCKS_PER_SEC;
dfpair(stdout, "prm edge build time", "%g", time);
dfpair(stdout, "prm collision checks", "%u", collisionChecks);
time = (double)(end-startTime) / CLOCKS_PER_SEC;
dfpair(stdout, "prm build time", "%g", time);
}
}
GLSprite::GLSprite(GLTexture* texture, Rectangle textureRectangle)
{
initializeVariables();
_texture = texture;
_textureRectangle = textureRectangle;
generateVertices();
generateTextureCoordinates();
}
void World::load(const char *filename) {
std::ifstream f(filename);
Segment s;
while (f >> s.p[0].c[0] >> s.p[0].c[1] >> s.p[1].c[0] >> s.p[1].c[1])
segments.push_back(s);
f.close();
generateVertices();
}
Quad2D::Quad2D(std::string texturePath, float width, float height, glm::vec3 pos) : texturePath(texturePath), Entity(pos), width(width), height(height) {
vertices = generateVertices(width, height);
uvs.push_back(glm::vec2(1.0f, 0.0f));
uvs.push_back(glm::vec2(0.0f, 0.0f));
uvs.push_back(glm::vec2(0.0f, 1.0f));
uvs.push_back(glm::vec2(0.0f, 1.0f));
uvs.push_back(glm::vec2(1.0f, 1.0f));
uvs.push_back(glm::vec2(1.0f, 0.0f));
}
SpotLight::SpotLight(const std::string& id, const sf::Vector2f& pos, float intensity, float radius, const sf::Color& color, float angle, float openAngle) :
Light(id, pos, intensity, radius, color),
m_angle(angle),
m_openAngle(openAngle)
{
setType(LT_SPOT);
generateVertices();
}
bool Terrain::loadHeightmap(const string& rawFile, int width)
{
const float HEIGHT_SCALE = 10.0f;
std::ifstream fileIn(rawFile.c_str(), std::ios::binary);
if (!fileIn.good())
{
std::cout << "File does not exist" << std::endl;
return false;
}
string stringBuffer(std::istreambuf_iterator<char>(fileIn), (std::istreambuf_iterator<char>()));
fileIn.close();
if (stringBuffer.size() != (width * width))
{
std::cout << "Image size does not match passed width" << std::endl;
return false;
}
vector<float> heights;
heights.reserve(width * width);
for (int i = 0; i < (width * width); ++i)
{
float value = (float)(unsigned char)stringBuffer[i] / 256.0f;
heights.push_back(value * HEIGHT_SCALE);
m_colors.push_back(Color(value, value, value));
}
glGenBuffers(1, &m_colorBuffer);
glBindBuffer(GL_ARRAY_BUFFER, m_colorBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * m_colors.size() * 3, &m_colors[0], GL_STATIC_DRAW);
generateVertices(heights, width);
generateIndices(width);
generateTexCoords(width);
generateNormals();
generateWaterVertices(width);
generateWaterIndices(width);
generateWaterTexCoords(width);
m_width = width;
return true;
}
void Font::render3DText( const std::string& text, const vec3f& pos, float fontHeight, vec3f rasterDir, vec3f up, const Color4f& color, const vec2f& relPos, bool fixedWidth )
{
Mesh* mesh = generateVertices( text, pos, fontHeight, rasterDir, up, color, relPos, fixedWidth );
matStackf modelStack;
modelStack.translate( pos );
NamedProperties params;
params.set( "modelMatrix", modelStack.top() );
params.set( "mesh", mesh );
fireEvent( "renderMesh", params );
SAFE_DELETE( mesh );
}
void ChunkBase::initPhysicsBody()
{
if (mPhysicsAttached) deactivatePhysicsBody();
if (mIsModified) generateVertices();
if (isEmpty) return;
btCollisionShape* newShape;
btTriangleIndexVertexArray* newIvArray = new btTriangleIndexVertexArray();
btIndexedMesh mesh;
mesh.m_numTriangles = mNumIndices / 3;
mesh.m_triangleIndexBase = (const unsigned char *) mIndices;
mesh.m_triangleIndexStride = 3 * sizeof(uint16_t);
mesh.m_numVertices = mNumVertices;
mesh.m_vertexBase = (const unsigned char *) mVertices;
mesh.m_vertexStride = VertexSize * sizeof(float);
newIvArray->addIndexedMesh(mesh, PHY_SHORT);
newShape = new btBvhTriangleMeshShape(newIvArray, true);
newShape->setMargin(0.1f);
if (mPhysicsBody == 0) {
btTransform trans;
trans.setIdentity();
trans.setOrigin(btVector3((btScalar)
(btScalar) (mX * ChunkSizeX),
(btScalar) (mY * ChunkSizeY),
(btScalar) (mZ * ChunkSizeZ)));
btMotionState* mState = new btDefaultMotionState(trans);
btRigidBody::btRigidBodyConstructionInfo cInfo(0.0f, mState, newShape);
mPhysicsBody = new btRigidBody(cInfo);
mPhysicsBody->setCollisionFlags(mPhysicsBody->getCollisionFlags() | btCollisionObject::CF_STATIC_OBJECT);
} else {
mPhysicsBody->setCollisionShape(newShape);
}
if (mPhysicsIvArray != 0) {
delete mPhysicsIvArray;
}
mPhysicsIvArray = newIvArray;
if (mPhysicsShape != 0) {
delete mPhysicsShape;
}
mPhysicsShape = newShape;
}
void grow() {
numVertices *= 2;
generateVertices(numVertices);
edges.clear();
if(shouldGenerateEdges) {
clock_t edgeStart = clock();
generateEdges(edgeSetSize);
dfpair(stdout, "prm edge build time", "%g", (double)(clock()-edgeStart) / CLOCKS_PER_SEC);
dfpair(stdout, "prm collision checks", "%u", collisionChecks);
}
}
antPlane::antPlane
( float width, float depth, int nColumns, int nRows,
int nVbo, bool genColors,
bool genNormals, bool genTexCoords ) :
antDrawable( nVbo, ATTR_POSITION ),
m_width( width ),
m_depth( depth ),
m_nColumns( nColumns ),
m_nRows( nRows )
{
m_nVertices = ( m_nColumns * m_nRows * 6 );
antRGBA color1( 0.f, 0.f, 0.f, 1.f );
antRGBA color2( 1.f, 1.f, 1.f, 1.f );
generateVertices();
if ( genColors ) { generateColors( color1, color2 ); }
if ( genNormals ) { generateNormals(); }
if ( genTexCoords ) { generateTexCoords(); }
}
void SpotLight::setOpenAngle(float openAngle)
{
m_openAngle = openAngle;
generateVertices();
}
Circle::Circle(int canvas_width, int canvas_height) : Shape(canvas_width, canvas_height)
{
generateVertices();
}
void Buttons::update() {
if(!is_visible) {
return;
}
h = 0;
bool needs_redraw = false;
bool needs_text_update = false;
if(is_open) {
vector<Element*>::iterator it = elements.begin();
while(it != elements.end()) {
Element& el = *(*it);
el.update();
if(el.is_child || !el.is_visible) {
++it;
continue;
}
h += el.h;
++it;
}
// check if we need to update the vertices or if a value is changed.
it = elements.begin();
if(!is_changed) { // is this panel self changed.
vector<Element*> value_changed_els;
bool value_changed = false;
while(it != elements.end()) {
Element& el = **it;
if(el.needs_redraw) {
needs_redraw = true;
}
if(el.needs_text_update) {
needs_text_update = true;
}
if(el.value_changed) {
if(el.is_child) {
el.parent->onChildValueChanged();
}
else {
value_changed_els.push_back(&el);
}
el.value_changed = false;
}
++it;
}
// notify after all "parents" had their change to update (e..g onChildValueChanged above)
it = value_changed_els.begin();
while(it != value_changed_els.end()) {
notifyListeners(BEVENT_VALUE_CHANGED, *it, (*it)->event_data);
++it;
}
}
else {
// when the gui itself is changed we always update!
needs_redraw = true;
}
}
if(needs_redraw || is_changed) {
positionElements();
updateDynamicTexts(); // need to update everything when a element i.e. get bigger
updateStaticTextPositions();
generateVertices();
notifyListeners(BEVENT_BUTTONS_REDRAW, NULL, NULL);
}
if(needs_text_update) {
updateDynamicTexts();
}
// do we need to grow our buffer?
glBindBuffer(GL_ARRAY_BUFFER, vbo);
eglGetError();
size_t size_needed = vd.size() * sizeof(ButtonVertex);
if(size_needed > allocated_bytes) {
while(allocated_bytes < size_needed) {
allocated_bytes = std::max<size_t>(allocated_bytes * 2, 256);
}
first_run = false; // we don't need this one anymore @todo cleanup
glBufferData(GL_ARRAY_BUFFER, allocated_bytes, NULL, GL_STREAM_DRAW);
eglGetError();
}
// And update the vbo.
glBindBuffer(GL_ARRAY_BUFFER, vbo);
eglGetError(); // roxlu
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(ButtonVertex)*vd.size(), (GLvoid*)vd.getPtr());
eglGetError();
}
void ChunkBase::generateMesh()
{
if (!mIsModified) return;
generateVertices();
if (isEmpty) {
return;
}
uint32_t numVertices, numIndices;
if (mNumVertices > DefaultFaces * 4) {
// more vertices than the default buffer can hold -> allocate new one;
if (mVertexBufferCreated) {
removeMesh();
}
numVertices = mNumVertices;
numIndices = mNumIndices;
} else {
numVertices = DefaultFaces * 4;
numIndices = DefaultFaces * 6;
}
if (!mVertexBufferCreated) {
mMeshPtr = Ogre::MeshManager::getSingleton().createManual(mChunkName, "Game");
Ogre::SubMesh* sub = mMeshPtr->createSubMesh();
/// Create vertex data structure for 8 vertices shared between submeshes
mMeshPtr->sharedVertexData = new Ogre::VertexData();
mMeshPtr->sharedVertexData->vertexCount = mNumVertices;
/// Create declaration (memory format) of vertex data
Ogre::VertexDeclaration* decl = mMeshPtr->sharedVertexData->vertexDeclaration;
size_t offset = 0;
// 1st buffer
decl->addElement(0, offset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
decl->addElement(0, offset, Ogre::VET_FLOAT3, Ogre::VES_NORMAL);
offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
decl->addElement(0, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES);
offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
/// Allocate vertex buffer of the requested number of vertices (vertexCount) and bytes per vertex (offset)
Ogre::HardwareVertexBufferSharedPtr vbuf = Ogre::HardwareBufferManager::getSingleton().
createVertexBuffer(offset, numVertices, Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
/// Upload the vertex data to the card
vbuf->writeData(0, (decl->getVertexSize(0) * mNumVertices), mVertices, true);
/// Set vertex buffer binding so buffer 0 is bound to our vertex buffer
Ogre::VertexBufferBinding* bind = mMeshPtr->sharedVertexData->vertexBufferBinding;
bind->setBinding(0, vbuf);
/// Allocate index buffer of the requested number of vertices (ibufCount)
Ogre::HardwareIndexBufferSharedPtr ibuf = Ogre::HardwareBufferManager::getSingleton().
createIndexBuffer(Ogre::HardwareIndexBuffer::IT_16BIT, numIndices, Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
/// Upload the index data to the card
ibuf->writeData(0, (ibuf->getIndexSize() * mNumIndices), mIndices, true);
/// Set parameters of the submesh
sub->indexData->indexBuffer = ibuf;
sub->indexData->indexCount = mNumIndices;
/// Set bounding information (for culling)
mMeshPtr->_setBounds(Ogre::AxisAlignedBox(0, 0, 0, Ogre::Real(ChunkSizeX), Ogre::Real(mHighestCube), Ogre::Real(ChunkSizeZ)));
mMeshPtr->_setBoundingSphereRadius((Ogre::Real) std::sqrt((float) (2 * 16 * 16 + 128 * 128)));
/// Notify -Mesh object that it has been loaded
mMeshPtr->load();
mVertexBufferCreated = true;
} else {
Ogre::VertexDeclaration* decl = mMeshPtr->sharedVertexData->vertexDeclaration;
mMeshPtr->sharedVertexData->vertexCount = mNumVertices;
Ogre::SubMesh* sub = mMeshPtr->getSubMesh(0);
sub->indexData->indexCount = mNumIndices;
/// Upload the new vertex data to the card
Ogre::HardwareVertexBufferSharedPtr vbuf = mMeshPtr->sharedVertexData->vertexBufferBinding->getBuffer(0);
vbuf->writeData(0, (decl->getVertexSize(0) * mNumVertices), mVertices, true);
/// Upload the index data to the card
Ogre::HardwareIndexBufferSharedPtr ibuf = sub->indexData->indexBuffer;
ibuf->writeData(0, (ibuf->getIndexSize() * mNumIndices), mIndices, true);
mMeshPtr->_setBounds(Ogre::AxisAlignedBox(0, 0, 0, Ogre::Real(ChunkSizeX), Ogre::Real(mHighestCube), Ogre::Real(ChunkSizeZ)));
mMeshPtr->load();
}
}