コード例 #1
0
ファイル: buffer.hpp プロジェクト: armando-2011/DynamO
      /*! \brief Draw all the elements in the current buffer multiple
       * times using instancing.
       */
      inline void drawInstancedElements(element_type::Enum type, size_t instances)
      { 
	initTest();
	bind(buffer_targets::ELEMENT_ARRAY);
	if (GLEW_EXT_draw_instanced)
	  glDrawElementsInstancedEXT(type, size(), detail::c_type_to_gl_enum<T>::val, 0, instances);
	else if (GLEW_ARB_draw_instanced)
	  glDrawElementsInstancedEXT(type, size(), detail::c_type_to_gl_enum<T>::val, 0, instances);
	else
	  M_throw() << "Cannot perform instanced drawing, GL_ARB_draw_instanced/GL_EXT_draw_instanced extensions are missing.";
      }
コード例 #2
0
 inline void VL_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
 {
   if (glDrawElementsInstanced)
     glDrawElementsInstanced(mode, count, type, indices, primcount);
   else
   if (glDrawElementsInstancedARB)
     glDrawElementsInstancedARB(mode, count, type, indices, primcount);
   else
   if (glDrawElementsInstancedEXT)
     glDrawElementsInstancedEXT(mode, count, type, indices, primcount);
   else
     VL_UNSUPPORTED_FUNC();
 }
コード例 #3
0
ファイル: gl_commands.hpp プロジェクト: codeoneclick/game-box
    inline void gl_draw_elements_instanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
    {
#if defined(__OSX__)
        
        glDrawElementsInstanced(mode, count, type, indices, instancecount);
        
#elif defined(__IOS__)
#if defined(__OPENGL_20__)
        
        glDrawElementsInstancedEXT(mode, count, type, indices, instancecount);
        
#else
        
        glDrawElementsInstanced(mode, count, type, indices, instancecount);
        
#endif
#endif
        
#if defined(DEBUG)
        gl_get_error();
#endif
    }
コード例 #4
0
ファイル: main.cpp プロジェクト: astrellon/GPP
void display(void)
{
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	if(displayError)
	{
		orthographicView();

		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		txtInstructions.render((screenWidth - txtInstructions.getTextureWidth()) / 2.0f, (screenHeight - txtInstructions.getTextureHeight()) / 2.0f);

		glFlush();
		return;
	}

	glPushMatrix();

	// Setup the navigation
	glTranslated(0, 0, -zoom);
	glRotatef(camRotateX, 1, 0, 0);
	glRotatef(camRotateY, 0, 1, 0);
	glTranslated(0, ROOM_SIZE, 0);

	// Setup drawing for the scene.
	perspectiveView();
	
#if _USE_MT
	// If the render thread needs to wait for new spheres to be added.
	while(pauseSimulation)
	{
		boost::this_thread::yield();
	}

	threadStarted();
#endif

	renderFrame++;
	renderFrameCounter++;

	glEnable(GL_DEPTH_TEST);

	glColor3f(1.0f, 1.0f, 1.0f);
	
	glUseProgram(g_program);
	glUniform3fv(g_programCameraPositionLocation, 1, g_cameraPosition);
	glUniform3fv(g_programLightDirectionLocation, 1, g_lightDirection);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, sphereMesh.indexBufferId);

	// We are using instanced rendering, however we cannot draw all the spheres at once.
	// So we have a maximum number of objects that can be rendered at once and we'll just
	// render that many at a time until we have less spheres than MAX_OBJECTS_PER_RENDER 
	// left to render.
	for(int objectIndex = 0; objectIndex < numSpheres; objectIndex += MAX_OBJECTS_PER_RENDER)
	{
		int numObjects = MAX_OBJECTS_PER_RENDER;
		// Are we going to be rendering more spheres than we should?
		if (numObjects + objectIndex > numSpheres)
		{
			numObjects = numSpheres - objectIndex;
		}
		Vector3 *positionIndex = spherePositions + objectIndex;
		glUniform4fv(g_programObjectPositionLocation, numObjects, (float *)positionIndex);
		// Tell the shader the size of the user sphere.
		// Due to the way the shader renders multiple instances, it only knows the id
		// of the current instance it is rendering, which does not reflect the sphere's actual
		// id.
		// So we will set that the size of the userSphere only on the first instanced render
		// and all later renders it will be zero.
		glUniform1f(g_programUserSphereLocation, (objectIndex == 0) * userSphereSize);

		glDrawElementsInstancedEXT(GL_TRIANGLES, sphereMesh.numIndicies, GL_UNSIGNED_INT, 0, numObjects);
	}

	glUseProgram(0);
	
#if _USE_MT
	threadStopped();
#endif

	glPopMatrix();

	// Setup drawing for the interface.
	orthographicView();

	char buff[64];

	sprintf(buff, "FPS: %d", framesPerSecond);
	txtRenderFrames.setText(buff);

	sprintf(buff, "PPS: %.1f", physicsPerSecond);
	txtPhysicsFrames.setText(buff);

	glDisable(GL_DEPTH_TEST);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	float yPos = -2.0f;
	
	txtInstructions.render(10, yPos += 12.0f);
	txtInstructions2.render(10, yPos += 12.0f);
	txtNumThreads.render(10, yPos += 12.0f);
	txtNumSpheres.render(10, yPos += 12.0f);
	txtRenderFrames.render(10, yPos += 12.0f);
	txtPhysicsFrames.render(10, yPos += 12.0f);
	
	glDisable(GL_BLEND);

	glFlush();
}
コード例 #5
0
bool drawCallback(CPUTModel* pModel, CPUTRenderParameters &renderParams, CPUTMesh* pMesh, CPUTMaterialEffect* pMaterial, CPUTMaterialEffect* , void* )
{
	UINT mVertexCount = 0;
	UINT mIndexCount = 0;
	int index = 0;
	float rows = 0.0;
	float columns = 0.0;
	float instances = 0.0;
	float angle_value = 0.0;

	// Uniform locations
	GLint vpMatrixBufferLoc = -1;
	GLint worldMatrixBufferLoc = -1;
	
	float4x4 viewProj;
    float4x4 parents_world;
	
	rows = (float) currentRowCount;
	columns = (float) currentColCount;

	angle_value = 360.0 / columns;

	const int numInstances = (int)columns * (int) rows;
	pMaterial->SetRenderStates(renderParams);

	parents_world = pModel->GetParentsWorldMatrix();
    CPUTCamera *pCamera   = renderParams.mpCamera;
	
	// Set Uniform Data
	if(pCamera)
    {
		viewProj = *pCamera->GetViewMatrix() * *pCamera->GetProjectionMatrix();
    }
	
	// Drawing
	mVertexCount = ((CPUTMeshOGL*)pMesh)->GetVertexCount();
	mIndexCount = ((CPUTMeshOGL*)pMesh)->GetIndexCount();
	CPUTBufferOGL * mpIndexBuffer = ((CPUTMeshOGL*)pMesh)->GetIndexBuffer();

	if(mVertexCount == 0 && mIndexCount == 0)
        return false;

	((CPUTMeshOGL*)pMesh)->EnableVertexArray();
	
	
	CPUTMaterialEffectOGL *pMatEffect = (CPUTMaterialEffectOGL*) pMaterial;
	GLuint shaderProgID = pMatEffect->GetShaderID();
	
    vpMatrixBufferLoc = glGetUniformLocation( shaderProgID, "viewProjMatrix" );
	worldMatrixBufferLoc = glGetUniformLocation( shaderProgID, "worldMatrix" );

	if( isInstanced )
	{   

		glUniformMatrix4fv( vpMatrixBufferLoc, 1, GL_FALSE, (const GLfloat *) &viewProj );
        glUniformMatrix4fv( worldMatrixBufferLoc, numInstances, GL_FALSE, (const GLfloat *) &world[0] );

		if(mpIndexBuffer != NULL)
			GL_CHECK(glDrawElementsInstancedEXT( GL_TRIANGLES, mIndexCount, GL_UNSIGNED_INT, NULL, numInstances ));
		else
			GL_CHECK(glDrawArraysInstanced(GL_TRIANGLES, 0, numInstances, mVertexCount));
	}
	else
	{
		index = 0;
		glUniformMatrix4fv( vpMatrixBufferLoc, 1, GL_FALSE, (const GLfloat *) &viewProj );

		for (int i = 0; i < rows; ++i)
		{
			for (int j = 0; j < columns; ++j)
			{
				glUniformMatrix4fv( worldMatrixBufferLoc, 1, GL_FALSE, (const GLfloat *) &world[index] );
				if(mpIndexBuffer != NULL)
					GL_CHECK(glDrawElements(GL_TRIANGLES, mIndexCount, GL_UNSIGNED_INT, NULL));
				else
					GL_CHECK(glDrawArrays(GL_TRIANGLES, 0, mVertexCount));
				++index;
			}
		}
	}

	((CPUTMeshOGL*)pMesh)->DisableVertexArray();
    
    glUseProgram(0);

	return true;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawElementsInstancedEXTBO(JNIEnv *env, jclass clazz, jint mode, jint count, jint type, jlong indices_buffer_offset, jint primcount, jlong function_pointer) {
	const GLvoid *indices_address = (const GLvoid *)(intptr_t)offsetToPointer(indices_buffer_offset);
	glDrawElementsInstancedEXTPROC glDrawElementsInstancedEXT = (glDrawElementsInstancedEXTPROC)((intptr_t)function_pointer);
	glDrawElementsInstancedEXT(mode, count, type, indices_address, primcount);
}