void GLInstancingRenderer::InitShaders() { int POSITION_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4); int ORIENTATION_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4); int COLOR_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*4); int SCALE_BUFFER_SIZE = (m_maxNumObjectCapacity*sizeof(float)*3); instancingShaderPointSprite = gltLoadShaderPair(vertexShaderPointSprite,fragmentShaderPointSprite); glUseProgram(instancingShaderPointSprite); ModelViewMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ModelViewMatrix"); ProjectionMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ProjectionMatrix"); screenWidthPointSprite = glGetUniformLocation(instancingShaderPointSprite, "screenWidth"); instancingShader = gltLoadShaderPair(vertexShader,fragmentShader); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); glUseProgram(0); //GLuint offset = 0; glGenBuffers(1, &m_data->m_vbo); checkError("glGenBuffers"); glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo); int size = m_maxShapeCapacityInBytes + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE+SCALE_BUFFER_SIZE; m_data->m_vboSize = size; glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }
GLPrimitiveRenderer::GLPrimitiveRenderer(int screenWidth, int screenHeight) :m_screenWidth(screenWidth), m_screenHeight(screenHeight) { m_data = new PrimInternalData; m_data->m_shaderProg = gltLoadShaderPair(vertexShader,fragmentShader); m_data->m_positionUniform = glGetUniformLocation(m_data->m_shaderProg, "p"); if (m_data->m_positionUniform < 0) { assert(0); } m_data->m_colourAttribute = glGetAttribLocation(m_data->m_shaderProg, "colour"); if (m_data->m_colourAttribute < 0) { assert(0); } m_data->m_positionAttribute = glGetAttribLocation(m_data->m_shaderProg, "position"); if (m_data->m_positionAttribute < 0) { assert(0); } m_data->m_textureAttribute = glGetAttribLocation(m_data->m_shaderProg,"texuv"); if (m_data->m_textureAttribute < 0) { assert(0); } loadBufferData(); }
void SetupRC() { instancingShader = gltLoadShaderPair("../../Data/Shaders/Chapter12/instancing.vs", "../../Data/Shaders/Chapter12/instancing.fs"); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); static const GLfloat square_vertices[] = { -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f }; static const GLfloat instance_colors[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f }; static const GLfloat instance_positions[] = { -2.0f, -2.0f, 0.0f, 0.0f, 2.0f, -2.0f, 0.0f, 0.0f, 2.0f, 2.0f, 0.0f, 0.0f, -2.0f, 2.0f, 0.0f, 0.0f }; GLuint offset = 0; glGenVertexArrays(1, &square_vao); glGenBuffers(1, &square_vbo); glBindVertexArray(square_vao); glBindBuffer(GL_ARRAY_BUFFER, square_vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(square_vertices) + sizeof(instance_colors) + sizeof(instance_positions), NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(square_vertices), square_vertices); glBufferSubData(GL_ARRAY_BUFFER, sizeof(square_vertices), sizeof(instance_colors), instance_colors); glBufferSubData(GL_ARRAY_BUFFER, sizeof(square_vertices) + sizeof(instance_colors), sizeof(instance_positions), instance_positions); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (GLvoid *)sizeof(square_vertices)); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, (GLvoid *)(sizeof(square_vertices) + sizeof(instance_colors))); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glVertexAttribDivisor(1, 1); glVertexAttribDivisor(2, 1); }
/////////////////////////////////////////////////////////////////////////////// // Load a shader pair from file. The shader pair root is added to the shader // lookup table and can be found again if necessary with LookupShader. GLuint GLShaderManager::LoadShaderPair(const char *szVertexProgFileName, const char *szFragProgFileName) { SHADERLOOKUPETRY shaderEntry; // Make sure it's not already loaded GLuint uiReturn = LookupShader(szVertexProgFileName, szFragProgFileName); if(uiReturn != 0) return uiReturn; // Load shader and test for fail shaderEntry.uiShaderID = gltLoadShaderPair(szVertexProgFileName, szFragProgFileName); if(shaderEntry.uiShaderID == 0) return 0; // Add to the table strncpy(shaderEntry.szVertexShaderName, szVertexProgFileName, MAX_SHADER_NAME_LENGTH); strncpy(shaderEntry.szFragShaderName, szFragProgFileName, MAX_SHADER_NAME_LENGTH); // shaderTable.push_back(shaderEntry); return shaderEntry.uiShaderID; }
void loadShader(){ sData.m_shaderProg= gltLoadShaderPair(vertexShader,fragmentShader); sData.m_positionUniform = glGetUniformLocation(sData.m_shaderProg, "p"); if (sData.m_positionUniform < 0) { b3Assert(0); } sData.m_colourAttribute = glGetAttribLocation(sData.m_shaderProg, "colour"); if (sData.m_colourAttribute < 0) { b3Assert(0); } sData.m_positionAttribute = glGetAttribLocation(sData.m_shaderProg, "position"); if (sData.m_positionAttribute < 0) { b3Assert(0); } sData.m_textureAttribute = glGetAttribLocation(sData.m_shaderProg,"texuv"); if (sData.m_textureAttribute < 0) { b3Assert(0); } }
void GLInstancingRenderer::InitShaders() { int POSITION_BUFFER_SIZE = (m_data->m_maxNumObjectCapacity*sizeof(float)*4); int ORIENTATION_BUFFER_SIZE = (m_data->m_maxNumObjectCapacity*sizeof(float)*4); int COLOR_BUFFER_SIZE = (m_data->m_maxNumObjectCapacity*sizeof(float)*4); int SCALE_BUFFER_SIZE = (m_data->m_maxNumObjectCapacity*sizeof(float)*3); linesShader = gltLoadShaderPair(linesVertexShader,linesFragmentShader); lines_ModelViewMatrix = glGetUniformLocation(linesShader, "ModelViewMatrix"); lines_ProjectionMatrix = glGetUniformLocation(linesShader, "ProjectionMatrix"); lines_colour=glGetUniformLocation(linesShader, "colour"); lines_position=glGetAttribLocation(linesShader, "position"); glLinkProgram(linesShader); glUseProgram(linesShader); { glGenVertexArrays(1, &linesVertexArrayObject); glBindVertexArray(linesVertexArrayObject); glGenBuffers(1, &linesVertexBufferObject); glGenBuffers(1, &linesIndexVbo); int sz = MAX_LINES_IN_BATCH*sizeof(b3Vector3); glBindVertexArray(linesVertexArrayObject); glBindBuffer(GL_ARRAY_BUFFER, linesVertexBufferObject); glBufferData(GL_ARRAY_BUFFER, sz, 0, GL_DYNAMIC_DRAW); glBindVertexArray(0); } { glGenVertexArrays(1, &lineVertexArrayObject); glBindVertexArray(lineVertexArrayObject); glGenBuffers(1, &lineVertexBufferObject); glGenBuffers(1, &lineIndexVbo); int sz = MAX_POINTS_IN_BATCH*sizeof(b3Vector3); glBindVertexArray(lineVertexArrayObject); glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject); glBufferData(GL_ARRAY_BUFFER, sz, 0, GL_DYNAMIC_DRAW); glBindVertexArray(0); } //glGetIntegerv(GL_ALIASED_LINE_WIDTH_RANGE, range); glGetIntegerv(GL_SMOOTH_LINE_WIDTH_RANGE, lineWidthRange); useShadowMapInstancingShader = gltLoadShaderPair(useShadowMapInstancingVertexShader,useShadowMapInstancingFragmentShader); glLinkProgram(useShadowMapInstancingShader); glUseProgram(useShadowMapInstancingShader); useShadow_ModelViewMatrix = glGetUniformLocation(useShadowMapInstancingShader, "ModelViewMatrix"); useShadow_MVP = glGetUniformLocation(useShadowMapInstancingShader, "MVP"); useShadow_ProjectionMatrix = glGetUniformLocation(useShadowMapInstancingShader, "ProjectionMatrix"); useShadow_DepthBiasModelViewMatrix = glGetUniformLocation(useShadowMapInstancingShader, "DepthBiasModelViewProjectionMatrix"); useShadow_uniform_texture_diffuse = glGetUniformLocation(useShadowMapInstancingShader, "Diffuse"); useShadow_shadowMap = glGetUniformLocation(useShadowMapInstancingShader,"shadowMap"); useShadow_lightDirIn = glGetUniformLocation(useShadowMapInstancingShader,"lightDirIn"); createShadowMapInstancingShader = gltLoadShaderPair(createShadowMapInstancingVertexShader,createShadowMapInstancingFragmentShader); glLinkProgram(createShadowMapInstancingShader); glUseProgram(createShadowMapInstancingShader); createShadow_depthMVP = glGetUniformLocation(createShadowMapInstancingShader, "depthMVP"); glUseProgram(0); instancingShader = gltLoadShaderPair(instancingVertexShader,instancingFragmentShader); glLinkProgram(instancingShader); glUseProgram(instancingShader); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); regularLightDirIn = glGetUniformLocation(instancingShader,"lightDirIn"); glUseProgram(0); instancingShaderPointSprite = gltLoadShaderPair(pointSpriteVertexShader,pointSpriteFragmentShader); glUseProgram(instancingShaderPointSprite); ModelViewMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ModelViewMatrix"); ProjectionMatrixPointSprite = glGetUniformLocation(instancingShaderPointSprite, "ProjectionMatrix"); screenWidthPointSprite = glGetUniformLocation(instancingShaderPointSprite, "screenWidth"); glUseProgram(0); //GLuint offset = 0; glGenBuffers(1, &m_data->m_vbo); checkError("glGenBuffers"); glBindBuffer(GL_ARRAY_BUFFER, m_data->m_vbo); int size = m_data->m_maxShapeCapacityInBytes + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE+SCALE_BUFFER_SIZE; m_data->m_vboSize = size; glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }
void InstancingApp::Initialize(void) { GLenum err = glewInit(); if (GLEW_OK != err) { /* Problem: glewInit failed, something is seriously wrong. */ fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); } instancingProg = gltLoadShaderPair("instancing.vs", "instancing.fs"); glBindAttribLocation(instancingProg, 0, "position"); glBindAttribLocation(instancingProg, 1, "instance_color"); glBindAttribLocation(instancingProg, 2, "instance_position"); glLinkProgram(instancingProg); glUseProgram(instancingProg); static const GLfloat square_vertices[] = { -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f }; static const GLfloat instance_colors[] = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f }; static const GLfloat instance_positions[] = { -2.0f, -2.0f, 0.0f, 0.0f, 2.0f, -2.0f, 0.0f, 0.0f, 2.0f, 2.0f, 0.0f, 0.0f, -2.0f, 2.0f, 0.0f, 0.0f }; GLuint offset = 0; glGenVertexArrays(1, &square_vao); glGenBuffers(1, &square_vbo); glBindVertexArray(square_vao); glBindBuffer(GL_ARRAY_BUFFER, square_vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(square_vertices) + sizeof(instance_colors) + sizeof(instance_positions), NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(square_vertices), square_vertices); offset += sizeof(square_vertices); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(instance_colors), instance_colors); offset += sizeof(instance_colors); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(instance_positions), instance_positions); offset += sizeof(instance_positions); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (GLvoid *)sizeof(square_vertices)); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, (GLvoid *)(sizeof(square_vertices) + sizeof(instance_colors))); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glVertexAttribDivisorARB(1, 1); glVertexAttribDivisorARB(2, 1); }
void InitShaders() { bool loadFromFile = false; instancingShader = gltLoadShaderPair("instancing.vs","instancing.fs", loadFromFile); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); GLuint offset = 0; glGenBuffers(1, &cube_vbo); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; int index=0; for (int i=0;i<NUM_OBJECTS_X;i++) { for (int j=0;j<NUM_OBJECTS_Y;j++) { for (int k=0;k<NUM_OBJECTS_Z;k++) { instance_positions_ptr[index*4]=-(i-NUM_OBJECTS_X/2)*10; instance_positions_ptr[index*4+1]=-(j-NUM_OBJECTS_Y/2)*10; instance_positions_ptr[index*4+2]=-k*10; instance_positions_ptr[index*4+3]=1; instance_quaternion_ptr[index*4]=0; instance_quaternion_ptr[index*4+1]=0; instance_quaternion_ptr[index*4+2]=0; instance_quaternion_ptr[index*4+3]=1; index++; } } } int size = sizeof(cube_vertices) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE; char* bla = (char*)malloc(size); int szc = sizeof(cube_vertices); memcpy(bla,&cube_vertices[0],szc); memcpy(bla+sizeof(cube_vertices),instance_positions_ptr,POSITION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE,instance_quaternion_ptr,ORIENTATION_BUFFER_SIZE); glBufferData(GL_ARRAY_BUFFER, size, bla, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); ///initialize parts of the buffer #ifdef _USE_SUB_DATA glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices)+ 16384, bla);//cube_vertices); #endif char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY memcpy(dest,cube_vertices,sizeof(cube_vertices)); //memcpy(dest+sizeof(cube_vertices),instance_colors,sizeof(instance_colors)); glUnmapBuffer( GL_ARRAY_BUFFER); writeTransforms(); /* glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr); */ glGenVertexArrays(1, &cube_vao); glBindVertexArray(cube_vao); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); glBindVertexArray(0); glGenBuffers(1, &index_vbo); int indexBufferSize = sizeof(cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); }
void InitShaders() { btOverlappingPairCache* overlappingPairCache=0; int maxObjects = btMax(256,NUM_OBJECTS); #ifdef USE_NEW int maxPairsSmallProxy = 32; sBroadphase = new btGridBroadphaseCl(overlappingPairCache,btVector3(4.f, 4.f, 4.f), 128, 128, 128,maxObjects, maxObjects, maxPairsSmallProxy, 100.f, 128, g_cxMainContext ,g_device,g_cqCommandQue, g_deviceCL); #else sBroadphase = new btGpu3DGridBroadphase(btVector3(2.f, 2.f, 2.f), 32, 32, 32,maxObjects, maxObjects, 64, 100.f, 64); #endif // sBroadphase = new bt3dGridBroadphaseOCL(overlappingPairCache,btVector3(10.f, 10.f, 10.f), 32, 32, 32,NUM_OBJECTS, NUM_OBJECTS, 64, 100.f, 16, // g_cxMainContext ,g_device,g_cqCommandQue); bool loadFromFile = false; instancingShader = gltLoadShaderPair("instancing.vs","instancing.fs", loadFromFile); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); GLuint offset = 0; glGenBuffers(1, &cube_vbo); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_colors_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_scale_ptr = (GLfloat*)new float[NUM_OBJECTS*3]; int index=0; for (int i=0;i<NUM_OBJECTS_X;i++) { for (int j=0;j<NUM_OBJECTS_Y;j++) { for (int k=0;k<NUM_OBJECTS_Z;k++) { instance_positions_ptr[index*4]=(i*X_GAP-NUM_OBJECTS_X/2); instance_positions_ptr[index*4+1]=(j*Y_GAP-NUM_OBJECTS_Y/2); instance_positions_ptr[index*4+2]=(k*Z_GAP-NUM_OBJECTS_Z/2)+(j&1); instance_positions_ptr[index*4+3]=1; int shapeType =0; void* userPtr = 0; btVector3 aabbMin( instance_positions_ptr[index*4], instance_positions_ptr[index*4+1], instance_positions_ptr[index*4+2]); btVector3 aabbMax = aabbMin; aabbMin -= btVector3(1.f,1.f,1.f); aabbMax += btVector3(1.f,1.f,1.f); void* myptr = (void*)index;//0;//&mBoxes[i] btBroadphaseProxy* proxy = sBroadphase->createProxy(aabbMin,aabbMax,shapeType,myptr,1,1,0,0);//m_dispatcher); proxyArray.push_back(proxy); instance_quaternion_ptr[index*4]=0; instance_quaternion_ptr[index*4+1]=0; instance_quaternion_ptr[index*4+2]=0; instance_quaternion_ptr[index*4+3]=1; instance_colors_ptr[index*4]=j<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+1]=k<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+2]=i<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+3]=1.f; instance_scale_ptr[index*3] = 1; instance_scale_ptr[index*3+1] = 1; instance_scale_ptr[index*3+2] = 1; float mass = 1.f;//j? 1.f : 0.f; bool writeToGpu = false; if (narrowphaseAndSolver) narrowphaseAndSolver->registerRigidBody(gShapeIndex,mass,&instance_positions_ptr[index*4],&instance_quaternion_ptr[index*4],writeToGpu); index++; } } } float posZero[4] = {0,-NUM_OBJECTS_Y/2-1,0,0}; float ornZero[4] = {0,0,0,1}; //register a 'plane' if (narrowphaseAndSolver) narrowphaseAndSolver->registerRigidBody(-1, 0.f, posZero,ornZero,false); if (narrowphaseAndSolver) narrowphaseAndSolver->writeAllBodiesToGpu(); int size = sizeof(cube_vertices) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE+SCALE_BUFFER_SIZE; VBOsize = size; char* bla = (char*)malloc(size); int szc = sizeof(cube_vertices); memcpy(bla,&cube_vertices[0],szc); memcpy(bla+sizeof(cube_vertices),instance_positions_ptr,POSITION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE,instance_quaternion_ptr,ORIENTATION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE,instance_colors_ptr, COLOR_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE,instance_scale_ptr, SCALE_BUFFER_SIZE); glBufferData(GL_ARRAY_BUFFER, size, bla, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); ///initialize parts of the buffer #ifdef _USE_SUB_DATA glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices)+ 16384, bla);//cube_vertices); #endif char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY memcpy(dest,cube_vertices,sizeof(cube_vertices)); //memcpy(dest+sizeof(cube_vertices),instance_colors,sizeof(instance_colors)); glUnmapBuffer( GL_ARRAY_BUFFER); writeTransforms(); /* glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr); */ glGenVertexArrays(1, &cube_vao); glBindVertexArray(cube_vao); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); glBindVertexArray(0); glGenBuffers(1, &index_vbo); int indexBufferSize = sizeof(cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); }
void InitShaders() { btOverlappingPairCache* overlappingPairCache=0; #ifdef USE_NEW sBroadphase = new btGridBroadphaseCl(overlappingPairCache,btVector3(3.f, 3.f, 3.f), 32, 32, 32,NUM_OBJECTS, NUM_OBJECTS, 64, 100.f, 16, g_cxMainContext ,g_device,g_cqCommandQue); #else sBroadphase = new btGpu3DGridBroadphase(btVector3(10.f, 10.f, 10.f), 32, 32, 32,NUM_OBJECTS, NUM_OBJECTS, 64, 100.f, 16); #endif // sBroadphase = new bt3dGridBroadphaseOCL(overlappingPairCache,btVector3(10.f, 10.f, 10.f), 32, 32, 32,NUM_OBJECTS, NUM_OBJECTS, 64, 100.f, 16, // g_cxMainContext ,g_device,g_cqCommandQue); bool loadFromFile = false; instancingShader = gltLoadShaderPair("instancing.vs","instancing.fs", loadFromFile); glLinkProgram(instancingShader); glUseProgram(instancingShader); angle_loc = glGetUniformLocation(instancingShader, "angle"); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); GLuint offset = 0; glGenBuffers(1, &cube_vbo); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_colors_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_scale_ptr = (GLfloat*)new float[NUM_OBJECTS*3]; int index=0; for (int i=0;i<NUM_OBJECTS_X;i++) { for (int j=0;j<NUM_OBJECTS_Y;j++) { for (int k=0;k<NUM_OBJECTS_Z;k++) { instance_positions_ptr[index*4]=-(i-NUM_OBJECTS_X/2)*10; instance_positions_ptr[index*4+1]=-(j-NUM_OBJECTS_Y/2)*10; instance_positions_ptr[index*4+2]=-(k-NUM_OBJECTS_Z/2)*10; instance_positions_ptr[index*4+3]=1; int shapeType =0; void* userPtr = 0; btVector3 aabbMin( instance_positions_ptr[index*4], instance_positions_ptr[index*4+1], instance_positions_ptr[index*4+2]); btVector3 aabbMax = aabbMin; aabbMin -= btVector3(1,1,1); aabbMax += btVector3(1,1,1); void* myptr = (void*)index;//0;//&mBoxes[i] btBroadphaseProxy* proxy = sBroadphase->createProxy(aabbMin,aabbMax,shapeType,myptr,1,1,0,0);//m_dispatcher); proxyArray.push_back(proxy); instance_quaternion_ptr[index*4]=0; instance_quaternion_ptr[index*4+1]=0; instance_quaternion_ptr[index*4+2]=0; instance_quaternion_ptr[index*4+3]=1; instance_colors_ptr[index*4]=j<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+1]=k<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+2]=i<NUM_OBJECTS_Y/2? 0.5f : 1.f; instance_colors_ptr[index*4+3]=1.f; instance_scale_ptr[index*3] = 1; instance_scale_ptr[index*3+1] = 1; instance_scale_ptr[index*3+2] = 1; index++; } } } int size = sizeof(cube_vertices) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE+SCALE_BUFFER_SIZE; char* bla = (char*)malloc(size); int szc = sizeof(cube_vertices); memcpy(bla,&cube_vertices[0],szc); memcpy(bla+sizeof(cube_vertices),instance_positions_ptr,POSITION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE,instance_quaternion_ptr,ORIENTATION_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE,instance_colors_ptr, COLOR_BUFFER_SIZE); memcpy(bla+sizeof(cube_vertices)+POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE+COLOR_BUFFER_SIZE,instance_scale_ptr, SCALE_BUFFER_SIZE); glBufferData(GL_ARRAY_BUFFER, size, bla, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); ///initialize parts of the buffer #ifdef _USE_SUB_DATA glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices)+ 16384, bla);//cube_vertices); #endif char* dest= (char*)glMapBuffer( GL_ARRAY_BUFFER,GL_WRITE_ONLY);//GL_WRITE_ONLY memcpy(dest,cube_vertices,sizeof(cube_vertices)); //memcpy(dest+sizeof(cube_vertices),instance_colors,sizeof(instance_colors)); glUnmapBuffer( GL_ARRAY_BUFFER); writeTransforms(); /* glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr); */ glGenVertexArrays(1, &cube_vao); glBindVertexArray(cube_vao); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); glBindVertexArray(0); glGenBuffers(1, &index_vbo); int indexBufferSize = sizeof(cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER,0); glBindVertexArray(0); }
void SetupRC() { bool loadFromFile = false; instancingShader = gltLoadShaderPair("instancing.vs", "instancing.fs", loadFromFile); glLinkProgram(instancingShader); glUseProgram(instancingShader); glFinish(); ModelViewMatrix = glGetUniformLocation(instancingShader, "ModelViewMatrix"); ProjectionMatrix = glGetUniformLocation(instancingShader, "ProjectionMatrix"); NormalMatrix = glGetUniformLocation(instancingShader, "NormalMatrix"); uniform_texture_diffuse = glGetUniformLocation(instancingShader, "Diffuse"); GLuint offset = 0; glGenVertexArrays(1, &cube_vao); glGenBuffers(1, &cube_vbo); glBindVertexArray(cube_vao); glBindBuffer(GL_ARRAY_BUFFER, cube_vbo); instance_positions_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; instance_quaternion_ptr = (GLfloat*)new float[NUM_OBJECTS*4]; int index=0; for (int i=0;i<NUM_OBJECTS_X;i++) for (int j=0;j<NUM_OBJECTS_Y;j++) for (int k=0;k<NUM_OBJECTS_Z;k++) { instance_positions_ptr[index*4]=-(i-NUM_OBJECTS_X/2)*10; instance_positions_ptr[index*4+1]=-(j-NUM_OBJECTS_Y/2)*10; instance_positions_ptr[index*4+2]=-k*10; instance_positions_ptr[index*4+3]=1; instance_quaternion_ptr[index*4]=0; instance_quaternion_ptr[index*4+1]=0; instance_quaternion_ptr[index*4+2]=0; instance_quaternion_ptr[index*4+3]=1; index++; } glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors) + POSITION_BUFFER_SIZE+ORIENTATION_BUFFER_SIZE, NULL, GL_DYNAMIC_DRAW);//GL_STATIC_DRAW); ///initialize parts of the buffer glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(cube_vertices), cube_vertices); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices), sizeof(instance_colors), instance_colors); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors), POSITION_BUFFER_SIZE, instance_positions_ptr); glBufferSubData(GL_ARRAY_BUFFER, sizeof(cube_vertices) + sizeof(instance_colors)+POSITION_BUFFER_SIZE,ORIENTATION_BUFFER_SIZE , instance_quaternion_ptr); glBindBuffer(GL_ARRAY_BUFFER,0); glGenBuffers(1, &index_vbo); int indexBufferSize = sizeof(cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,indexBufferSize,cube_indices); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }