void slop::Framebuffer::draw( float time, unsigned int desktop ) {
if ( !( m_flags & color ) ) {
return;
}
generateBuffers();
//slop::Shader* shader = shaders->get( "simple" );
m_shader->bind();
m_shader->setParameter( "texture", 0 );
m_shader->setParameter( "desktop", 1 );
m_shader->setParameter( "time", time );
m_shader->setParameter( "desktopWidth", (int)xengine->getWidth() );
m_shader->setParameter( "desktopHeight", (int)xengine->getHeight() );
m_shader->setAttribute( "vertex", m_buffers[0], 2 );
m_shader->setAttribute( "uv", m_buffers[1], 2 );
glActiveTexture(GL_TEXTURE0 + 0);
glBindTexture( GL_TEXTURE_2D, m_texture );
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture( GL_TEXTURE_2D, desktop );
glActiveTexture(GL_TEXTURE0 + 0);
glEnable( GL_TEXTURE_2D );
glDrawArrays( GL_QUADS, 0, 4 );
glDisable( GL_TEXTURE_2D );
m_shader->unbind();
}
void KinectMeshData::update(){
if(bBuffersDirty) {
generateBuffers();
}
// calculate real world coordinates
XnDepthPixel* pDepthPixels = kinect->getDepthRawPixels().getPixels();
float *pz = ((float*)xyzP.getPixels()) + 2; // pointer to the first projective z-coordinate
int left = roi->x; // left,top,right,bottom indices in the depth map
int top = roi->y;
int right = roi->x + roi->width;
int bottom = roi->y + roi->height;
int i; // the current index in the depth map
for(int y=top; y<bottom; y+=step) { // walk through the crop area
for(int x=left; x<right; x+=step) {
i = x + y * KINECT_W;
*pz = float(pDepthPixels[i]) / 1000.f; // depth pixel value is distance in mm but we want meters
pz += 3; // move pointer to next z value
}
}
// coordinates returned are *meters*. the less points we feed in the better performance
kinect->getDepthGenerator().ConvertProjectiveToRealWorld(numPixels, (XnPoint3D*)xyzP.getPixels(), (XnPoint3D*)xyzW.getPixels());
// upload world positions data to GPU
worldPosTexture.loadData(xyzW);
}
void Chunk::generate()
{
if (m_generated)
return;
generateData();
generateBuffers();
m_generated = true;
}
void GECube::generate(float width, float height, float depth, unsigned int segments_x, unsigned segments_y, unsigned int segments_z)
{
// Vertex and index mesh count.
m_vertexCount = ((segments_x + 1) * (segments_y + 1) + (segments_z + 1) * (segments_y + 1) + (segments_x + 1) * (segments_z + 1)) * 16;
m_indexCount = (segments_x * segments_y + segments_z * segments_y + segments_x * segments_z) * 12;
// Generate the data holders.
m_vertexBuffer = new float[m_vertexCount];
m_indexBuffer = new unsigned int[m_indexCount];
float xOrigin = 1.0 / 2.0f;
float yOrigin = 1.0 / 2.0f;
float zOrigin = 1.0 / 2.0f;
unsigned int vertexOffset = 0;
unsigned int indexOffset = 0;
// Top
createPlane(1.0f, 1.0, segments_x, segments_z, yOrigin, { 0.0f, 1.0f, 0.0f }, 0, 0);
// Bottom
vertexOffset = (segments_x + 1) * (segments_z + 1);
indexOffset = segments_x * segments_z;
createPlane(1.0f, 1.0f, segments_x, segments_z, yOrigin, { 0.0f, -1.0f, 0.0f }, vertexOffset, indexOffset);
// Left
vertexOffset = (segments_x + 1) * (segments_z + 1) * 2;
indexOffset = segments_x * segments_z * 2;
createPlane(1.0f, 1.0f, segments_z, segments_y, xOrigin, { -1.0f, 0.0f, 0.0f }, vertexOffset, indexOffset);
//Right
vertexOffset = (segments_x + 1) * (segments_z + 1) * 2 + (segments_z + 1) * (segments_y + 1);
indexOffset = segments_x * segments_z * 2 + segments_z * segments_y;
createPlane(1.0f, 1.0f, segments_z, segments_y, xOrigin, { 1.0f, 0.0f, 0.0f }, vertexOffset, indexOffset);
//Back
vertexOffset = ((segments_x + 1) * (segments_z + 1) + (segments_z + 1) * (segments_y + 1)) * 2;
indexOffset = (segments_x * segments_z + segments_z * segments_y) * 2;
createPlane(1.0f, 1.0f, segments_x, segments_y, zOrigin, { 0.0f, 0.0f, -1.0f }, vertexOffset, indexOffset);
//Back
vertexOffset = ((segments_x + 1) * (segments_z + 1) + (segments_z + 1) * (segments_y + 1)) * 2 + (segments_x + 1) * (segments_y + 1);
indexOffset = (segments_x * segments_z + segments_z * segments_y) * 2 + segments_x * segments_y;
createPlane(1.0f, 1.0f, segments_x, segments_y, zOrigin, { 0.0f, 0.0f, 1.0f }, vertexOffset, indexOffset);
m_scale = { width, height, depth };
m_scaleChanged = true;
m_width = width;
m_height = height;
m_depth = depth;
generateBuffers();
}
void Cube::init() {
generateBuffers();
centre = glm::vec3(0, 0, 0);
width = 0.2;
height = 0.2;
vertices.resize(8);
colors.resize(8);
normals.resize(8);
// Vertices are
// On the y = -0.1 plane, On the y = 0.1 plane
// v2 - v3 v6 - v7
// v1 - v0 v5 - v4
//Eight vertices of the cube
vertices[0] = glm::vec3(-0.1, -0.1, -0.1);
vertices[1] = glm::vec3(0.1, -0.1, -0.1);
vertices[2] = glm::vec3(0.1, -0.1, 0.1);
vertices[3] = glm::vec3(-0.1, -0.1, 0.1);
vertices[4] = glm::vec3(-0.1, 0.1, -0.1);
vertices[5] = glm::vec3(0.1, 0.1, -0.1);
vertices[6] = glm::vec3(0.1, 0.1, 0.1);
vertices[7] = glm::vec3(-0.1, 0.1, 0.1);
// 12 Triangles, 3 vertices
indices.reserve(36);
indexVec3.push_back(glm::vec3(0, 1, 2));
indexVec3.push_back(glm::vec3(0, 2, 3));
indexVec3.push_back(glm::vec3(4, 5, 6));
indexVec3.push_back(glm::vec3(4, 6, 7));
indexVec3.push_back(glm::vec3(0, 3, 4));
indexVec3.push_back(glm::vec3(3, 4, 7));
indexVec3.push_back(glm::vec3(1, 2, 5));
indexVec3.push_back(glm::vec3(2, 5, 6));
indexVec3.push_back(glm::vec3(2, 6, 7));
indexVec3.push_back(glm::vec3(2, 3, 7));
indexVec3.push_back(glm::vec3(1, 4, 5));
indexVec3.push_back(glm::vec3(0, 1, 4));
for (unsigned int i = 0; i < indexVec3.size(); i++) {
indices.push_back(indexVec3.at(i).x);
indices.push_back(indexVec3.at(i).y);
indices.push_back(indexVec3.at(i).z);
}
calculateNormals();
// 12 triangles for a cube
primitivePar.setValues(GL_TRIANGLES, 0, indices.size());
updateBuffers();
}
void init()
{
glClearColor(0.0, 0.0, 0.0, 0.0);
memset(options, 0, sizeof(bool) * OPTSIZE);
options[OPT_STDOUT_TEXT] = TRUE;
options[OPT_OSP_SHORT_LONG] = TRUE;
uTessellation = WELL_FORM_TESS;
/* set starting default setting */
currentShape = SHAPE_GRID;
sprintf(tessString, "Tessellation: %d x %d",uTessellation,uTessellation);
sprintf(bumpSizeString,"Number Of Bumps: %d x %d",uNumOfBumps,uNumOfBumps);
strcpy(localViewString,"LocalView: Off ");
strcpy(infoString, "Shader: Fixed pipeline");
strcpy(drawMethodString,currentDrawingMethod[currentShape][0]);
createShape(currentShape);
generateBuffers();
enableVertexArrays();
generateBuffers();
bufferData();
}
void KinectMeshData::setup(ofxOpenNI *k){
kinect = k;
step.set("step", 1, 1, 8);
roi.set("roi", ofRectangle(0, 0, kinect->getWidth(), kinect->getHeight()));
// these params realocate so we listen for changes
step.addListener(this, &KinectMeshData::onStepChange);
roi.addListener(this, &KinectMeshData::onRoiChange);
parameters.setName("kinect data");
parameters.add(step);
parameters.add(roi);
generateBuffers();
}
bool Chunk::generateAsync()
{
if (m_generated)
return true;
if (!m_generatingAsync) {
m_generatingAsync = true;
m_generatingFuture = std::async(std::launch::async, Chunk::doGenerate, this);
return false;
}
//Otherwise, check the status of the future
std::future_status status = m_generatingFuture.wait_for(std::chrono::seconds(0));
if (status != std::future_status::ready)
return false;
//Async work finished, generate the vertex buffer
m_generatingAsync = false;
generateBuffers();
m_generated = true;
return true;
}
void OnlineFusionObject::draw(){
pi::ScopedMutex lock(_mutex);
if(!_currentMeshInterleaved) return;
glColor3f(1,1,1);
if(_currentMeshInterleaved->faces.size()<1) return;
if(_currentMeshInterleaved->vertices.size() != _currentNV ||
_currentMeshInterleaved->faces.size() != _currentNF){
eprintf("\nReassigning Buffers for interleaved Mesh");
if(!_vertexBuffer){
generateBuffers();
}
_currentNV = _currentMeshInterleaved->vertices.size();
_currentNF = _currentMeshInterleaved->faces.size();
glBindBuffer(GL_ARRAY_BUFFER,_vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,_currentMeshInterleaved->vertices.size()*3*sizeof(float),_currentMeshInterleaved->vertices.data(), GL_STATIC_DRAW);
if(_currentMeshInterleaved->colors.size()){
glBindBuffer(GL_ARRAY_BUFFER,_colorBuffer);
glBufferData(GL_ARRAY_BUFFER,_currentMeshInterleaved->colors.size()*3,_currentMeshInterleaved->colors.data(), GL_STATIC_DRAW);
}
if(_currentMeshInterleaved->faces.size()){
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,_faceBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, _currentMeshInterleaved->faces.size()*sizeof(unsigned int),
_currentMeshInterleaved->faces.data(), GL_STATIC_DRAW);
}
eprintf("\nChecking Mesh...");
std::vector<bool> checks(_currentMeshInterleaved->vertices.size(),false);
for(size_t i=0;i<_currentMeshInterleaved->faces.size();i++)
checks[_currentMeshInterleaved->faces[i]] = true;
bool loneVertex = false;
for(size_t i=0;i<checks.size();i++) loneVertex |= !checks[i];
if(loneVertex){
fprintf(stderr,"\nThere were lone Vertices!");
}
eprintf("\nMesh Check done");
}
glBindBuffer(GL_ARRAY_BUFFER,_vertexBuffer);
glVertexPointer(3, GL_FLOAT, 0, 0);
if(_currentMeshInterleaved->colors.size()){
glBindBuffer(GL_ARRAY_BUFFER,_colorBuffer);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
}
else{
glColor3f(0.5f,0.5f,0.5f);
}
glEnableClientState(GL_VERTEX_ARRAY);
if(_colorEnabled) {
glEnableClientState(GL_COLOR_ARRAY);
}
else{
glColor3f(0.5f,0.5f,0.5f);
}
if(_displayMode==1){
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);
glLineWidth(0.5f);
}
else{
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
}
if(_displayMode==2){
glPointSize(2.0);
glBindBuffer(GL_ARRAY_BUFFER,_vertexBuffer);
glDrawArrays(GL_POINTS,0,_currentMeshInterleaved->vertices.size());
}
else{
glDrawElements(GL_TRIANGLES, _currentMeshInterleaved->faces.size(), GL_UNSIGNED_INT,0);
}
if(_colorEnabled) glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
