Пример #1
1
void Terrain :: CalculateNormals(){
	CVertex3 f1, f2, f3, f4;
	float magnitude;
	int size1;
	for(int i = 0; i < map_size; ++i){
		for(int k = 0;  k < map_size; ++k){
			size1 = i*map_size+k;
			
			
			if(i > 1){
				f1.x =  heightmap[i][k] - heightmap[i-1][k];
				f1.y = 1;
				f1.z = 0;
			}
			else{
				f1.x = 0;
				f1.y = 0;
				f1.z = 0;
			}
			
			if(k < map_size - 1){
				f2.x = 0;
				f2.y = 1;
				f2.z = heightmap[i][k+1] - heightmap[i][k];
			}
			
			else{
				f2.x = 0;
				f2.y = 0;
				f2.z = 0;
			}

			if(i < map_size - 1){
				f3.x = heightmap[i+1][k] - heightmap[i][k];
				f3.y = 1;
				f3.z = 0;
			}

			else{
				f3.x = 0;
				f3.y = 0;
				f3.z = 0;
			}

			if(k > 1){
				f4.x = 0;
				f4.y = 1;
				f4.z = heightmap[i][k-1] - heightmap[i][k];
			}
			else{
				f4.x = 0;
				f4.y = 0;
				f4.z = 0;
			}



			data[size1].n.x = (f1.x + f2.x + f3.x + f4.x)/4;
			data[size1].n.y = (f1.y + f2.y + f3.y + f4.y)/4;
			data[size1].n.z = (f1.z + f2.z + f3.z + f4.z)/4;
			magnitude = (float)sqrt( (data[size1].n.x * data[size1].n.x) + (data[size1].n.y * data[size1].n.y) + (data[size1].n.z * data[size1].n.z) );
			data[size1].n.x /= magnitude;
			data[size1].n.y /= magnitude;
			data[size1].n.z /= magnitude;
			
		}
	}

    glBindBuffer(GL_ARRAY_BUFFER, VertexVBID);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*map_size*map_size, NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Vertex)*map_size*map_size, data);

	
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexVBID);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLint)*fc.size(), NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(GLint)*fc.size(), &fc[0]);
}
Пример #2
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 sglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
{
   glBufferSubData(target, offset, size, data);
}
Пример #4
0
SplineSegmentNode::SplineSegmentNode(const char * name, SceneNode * parent): SceneNode(name, parent)
{
  if(m_program == 0)
  {
    std::vector<GLuint> shaderList;

    // Push vertex shader and fragment shader
	shaderList.push_back(pgr::createShader(GL_VERTEX_SHADER,    strVertexShader  ));
    shaderList.push_back(pgr::createShader(GL_FRAGMENT_SHADER,  strFragmentShader));

    // Create the program with two shaders
    m_program       = pgr::createProgram(shaderList);

    m_PVMmatrixLoc  = glGetUniformLocation( m_program, "PVMmatrix");
    m_colLoc        = glGetUniformLocation(  m_program, "color");

    m_posLoc        = glGetAttribLocation(  m_program, "position");
  }

  if(m_vertexArrayObject == 0) 
  {
    const size_t resoulution = 10;   // number of samples per parameter step
    m_numberOfCurveSamples = resoulution * curveTestSize;  // samples of the drawn curve
     
    glGenBuffers(1, &m_vertexBufferObject);
    glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject);
      
      // reserve space for control points + the curve 
      glBufferData(GL_ARRAY_BUFFER, (curveTestSize + m_numberOfCurveSamples + 4) * sizeof(vec3), NULL, GL_STATIC_DRAW);  // 4 for tangents
      
      // put given control points first
      glBufferSubData(GL_ARRAY_BUFFER, 0, curveTestSize * sizeof(vec3), curveTestPoints );  
      
      // put computed curve points after
      GLintptr offset = curveTestSize * sizeof(vec3);                 
      for( unsigned i = 0; i < m_numberOfCurveSamples; i++ )
      {
        float t = (float)i/m_numberOfCurveSamples;
        vec3 position = evaluateCurveSegment( curveTestPoints[0], curveTestPoints[1], curveTestPoints[2], curveTestPoints[3],  t);  // one point along the curve for parameter t
        glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(position) );
        offset += sizeof(vec3);
      }

      // tangent endpoints
      vec3 t0 = (curveTestPoints[2] - curveTestPoints[0]) * 0.2f;
      vec3 t1 = (curveTestPoints[3] - curveTestPoints[1]) * 0.2f;
      glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[1]-t0) ); offset += sizeof(vec3);
      glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[1]+t0) ); offset += sizeof(vec3);
      glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[2]-t1) ); offset += sizeof(vec3);
      glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(vec3), value_ptr(curveTestPoints[2]+t1) ); offset += sizeof(vec3);

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenVertexArrays(1, &m_vertexArrayObject );
    glBindVertexArray( m_vertexArrayObject );
      glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject);
      // Control points folowed by the points along the curve
      glEnableVertexAttribArray(m_posLoc);
      glVertexAttribPointer(m_posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glBindVertexArray( 0 );
  }

}
Пример #5
0
 void operator()( size_t index )
 {
   glBufferSubData( GL_SHADER_STORAGE_BUFFER, index * sizeof(dp::math::Mat44f), sizeof(dp::math::Mat44f), m_matricesInBasePtr + index * m_matricesInStride );
 }
Пример #6
0
void init()
{
	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
    };  

	planet = tetrahedron(5);
	object = ObjLoadModel("include/obj/torus.obj");

	vec3 tangent[planet.vertexNumber];
	vec3 bitangent[planet.vertexNumber];
	*tangent = *generateTangents(planet.vertexNumber, planet.points, tangent, bitangent);
	
	vec3 vna[planet.vertexNumber];
	*vna = *generateSmoothNormals(planet.vertexNumber, vna, planet.points, planet.normals);
	
	createShader(&skyboxShader, "src/shaders/skybox.vert",
		"src/shaders/skybox.frag");
	createShader(&sunShader, "src/shaders/sun.vert",
		"src/shaders/sun.frag");
	createShader(&planetShader, "src/shaders/planet.vert",
		"src/shaders/planet.frag");
		
	createShader(&atmosphereShader, "src/shaders/atmosphere.vert",
		"src/shaders/atmosphere.frag");
    
    
    glGenFramebuffers(1, &hdrFBO);
    glGenTextures(1, &colorBuffer);
    glBindTexture(GL_TEXTURE_2D, colorBuffer);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, WIDTH, HEIGHT, 0, GL_RGB, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    
    glGenRenderbuffers(1, &rboDepth);
    glBindRenderbuffer(GL_RENDERBUFFER, rboDepth);
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, WIDTH, HEIGHT);
    
    glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorBuffer, 0);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepth);
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
        printf("Framebuffer not complete!\n");
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

	glGenVertexArrays(1, &planetVAO);
	glBindVertexArray(planetVAO);
	glGenBuffers(1, &planetVBO);
	glBindBuffer(GL_ARRAY_BUFFER, planetVBO);
	glBufferData(GL_ARRAY_BUFFER, planet.size + planet.nsize, NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ARRAY_BUFFER, 0, planet.size, planet.points);
	glBufferSubData(GL_ARRAY_BUFFER, planet.size, planet.nsize, vna);
	
	glBufferSubData(GL_ARRAY_BUFFER, planet.size+planet.nsize, sizeof(tangent), tangent);
	glBufferSubData(GL_ARRAY_BUFFER, planet.size+planet.nsize+sizeof(tangent), sizeof(tangent), tangent);
	
	vPosition = glGetAttribLocation(planetShader, "vPosition");
    glEnableVertexAttribArray(vPosition);
    glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0));	
    vNormal = glGetAttribLocation(planetShader, "vNormal");
    glEnableVertexAttribArray(vNormal);
    glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size));
    
    vTangent = glGetAttribLocation(planetShader, "vTangent");
    glEnableVertexAttribArray(vTangent);
    glVertexAttribPointer(vTangent, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size+planet.nsize));
    
    vBitangent = glGetAttribLocation(planetShader, "vBitangent");
    glEnableVertexAttribArray(vBitangent);
    glVertexAttribPointer(vBitangent, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size+planet.nsize+sizeof(tangent)));
    
	glBindVertexArray(0);
	
	glGenVertexArrays(1, &skyboxVAO);
	glBindVertexArray(skyboxVAO);
    glGenBuffers(1, &skyboxVBO);
    glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW);
    vPosition = glGetAttribLocation(skyboxShader, "vPosition");
    glEnableVertexAttribArray(vPosition);
    glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
    glBindVertexArray(0);
    
    glGenVertexArrays(1, &objectVAO);
	glBindVertexArray(objectVAO);
	glGenBuffers(1, &objectVBO);
	glBindBuffer(GL_ARRAY_BUFFER, objectVBO);
	glBufferData(GL_ARRAY_BUFFER, object.size + object.nsize, NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ARRAY_BUFFER, 0, object.size, object.points);
	glBufferSubData(GL_ARRAY_BUFFER, object.size, object.nsize, object.normals);
	vPosition = glGetAttribLocation(sunShader, "vPosition");
    glEnableVertexAttribArray(vPosition);
    glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0));	
    
    vNormal = glGetAttribLocation(sunShader, "vNormal");
    glEnableVertexAttribArray(vNormal);
    glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(object.size));
	glBindVertexArray(0);
	
	glGenVertexArrays(1, &atmosphereVAO);
	glBindVertexArray(atmosphereVAO);
	glGenBuffers(1, &atmosphereVBO);
	glBindBuffer(GL_ARRAY_BUFFER, atmosphereVBO);
	glBufferData(GL_ARRAY_BUFFER, planet.size + planet.nsize, NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ARRAY_BUFFER, 0, planet.size, planet.points);
	glBufferSubData(GL_ARRAY_BUFFER, planet.size, planet.nsize, planet.normals);
	vPosition = glGetAttribLocation(atmosphereShader, "vPosition");
    glEnableVertexAttribArray(vPosition);
    glVertexAttribPointer(vPosition, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(0));	
    
    vNormal = glGetAttribLocation(atmosphereShader, "vNormal");
    glEnableVertexAttribArray(vNormal);
    glVertexAttribPointer(vNormal, 3, GL_FLOAT, GL_FALSE, 3*sizeof(GLfloat), BUFFER_OFFSET(planet.size));
	glBindVertexArray(0);
	
    glEnable(GL_DEPTH_TEST);
}
// OpenGL initialization
void
init()
{
    colorcube();

    // Create a vertex array object
    GLuint vao;
    glGenVertexArrays( 1, &vao );
    glBindVertexArray( vao );

    // Create and initialize a buffer object
    GLuint buffer;
    glGenBuffers( 1, &buffer );
    glBindBuffer( GL_ARRAY_BUFFER, buffer );
    glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(normals),
		  NULL, GL_STATIC_DRAW );
    glBufferSubData( GL_ARRAY_BUFFER, 0, sizeof(points), points );
    glBufferSubData( GL_ARRAY_BUFFER, sizeof(points),
		     sizeof(normals), normals );

    // Load shaders and use the resulting shader program
    GLuint program = InitShader( "vshader53.glsl", "fshader53.glsl" );
    glUseProgram( program );

    // set up vertex arrays
    GLuint vPosition = glGetAttribLocation( program, "vPosition" );
    glEnableVertexAttribArray( vPosition );
    glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
			   BUFFER_OFFSET(0) );

    GLuint vNormal = glGetAttribLocation( program, "vNormal" ); 
    glEnableVertexAttribArray( vNormal );
    glVertexAttribPointer( vNormal, 3, GL_FLOAT, GL_FALSE, 0,
			   BUFFER_OFFSET(sizeof(points)) );

    // Initialize shader lighting parameters
    point4 light_position( 0.0, 0.0, -1.0, 0.0 );
    color4 light_ambient( 0.2, 0.2, 0.2, 1.0 );
    color4 light_diffuse( 1.0, 1.0, 1.0, 1.0 );
    color4 light_specular( 1.0, 1.0, 1.0, 1.0 );

    color4 material_ambient( 1.0, 0.0, 1.0, 1.0 );
    color4 material_diffuse( 1.0, 0.8, 0.0, 1.0 );
    color4 material_specular( 1.0, 0.8, 0.0, 1.0 );
    float  material_shininess = 100.0;

    color4 ambient_product = light_ambient * material_ambient;
    color4 diffuse_product = light_diffuse * material_diffuse;
    color4 specular_product = light_specular * material_specular;

    glUniform4fv( glGetUniformLocation(program, "AmbientProduct"),
		  1, ambient_product );
    glUniform4fv( glGetUniformLocation(program, "DiffuseProduct"),
		  1, diffuse_product );
    glUniform4fv( glGetUniformLocation(program, "SpecularProduct"),
		  1, specular_product );
	
    glUniform4fv( glGetUniformLocation(program, "LightPosition"),
		  1, light_position );

    glUniform1f( glGetUniformLocation(program, "Shininess"),
		 material_shininess );
		 
    // Retrieve transformation uniform variable locations
    ModelView = glGetUniformLocation( program, "ModelView" );
    Projection = glGetUniformLocation( program, "Projection" );

    glEnable( GL_DEPTH_TEST );

    glShadeModel(GL_FLAT);

    glClearColor( 1.0, 1.0, 1.0, 1.0 ); 
}
Пример #8
0
void BufferInfo::InsertIndexSubBuffer(GLuint /*bufferID*/, Mesh * mesh, GLsizei indexOffsetBytes)
{
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferID);
	glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, /*Vert byte offset*/indexOffsetBytes, mesh->GetIndexSizeInBytes(), mesh->GetIndexDataStart());

}
Пример #9
0
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);

}
Пример #10
0
/////////////////////////////////////////////////////////////////////////////////////////////
//void recursive_render (const struct aiScene *sc, const struct aiNode* nd)
//{
//	unsigned int n = 0;
//	struct aiMatrix4x4 m = nd->mTransformation;
//
//	// update transform
//	aiTransposeMatrix4(&m);
//	glPushMatrix();
//	glMultMatrixf((float*)&m);
//
//	// draw all meshes assigned to this node
//	for (; n < nd->mNumMeshes; ++n) {
//		const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
//
//		apply_material(sc->mMaterials[mesh->mMaterialIndex]);
///*
//		if(mesh->mNormals == NULL) {
//			glDisable(GL_LIGHTING);
//		} else {
//			glEnable(GL_LIGHTING);
//		}
//
//		if(mesh->mColors[0] != NULL) {
//			glEnable(GL_COLOR_MATERIAL);
//		} else {
//			glDisable(GL_COLOR_MATERIAL);
//		}
//*/
//		for (unsigned int t = 0; t < mesh->mNumFaces; ++t) {
//			const struct aiFace* face = &mesh->mFaces[t];
//			GLenum face_mode;
//
//			switch(face->mNumIndices) {
//				case 1: face_mode = GL_POINTS; break;
//				case 2: face_mode = GL_LINES; break;
//				case 3: face_mode = GL_TRIANGLES; break;
//				default: face_mode = GL_POLYGON; break;
//			}
//
//			glBegin(face_mode);
//
//			for(unsigned int i = 0; i < face->mNumIndices; i++) {
//				int index = face->mIndices[i];
//				if(mesh->mColors[0] != NULL)
//					Color4f(&mesh->mColors[0][index]);
//				if(mesh->mNormals != NULL) 
//					glNormal3fv(&mesh->mNormals[index].x);
//				glVertex3fv(&mesh->mVertices[index].x);
//			}
//
//			glEnd();
//		}
//
//	}
//
//	// draw all children
//	for (n = 0; n < nd->mNumChildren; ++n) {
//		recursive_render(sc, nd->mChildren[n]);
//	}
//
//	glPopMatrix();
//}
/////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
void recursive_meshGenerator (const struct aiScene *sc, const struct aiNode* nd, pSceneGeometry*& LocalScene)
{
	LocalScene = new pSceneGeometry;
	int NbVertices = 0;
	int NbFaces = 0;
	struct aiMatrix4x4 m = nd->mTransformation;

	LocalScene->Matrix = m;  //ModelmMatrix

	if(nd->mNumChildren)
	LocalScene->children= new pSceneGeometry*[nd->mNumChildren];
	else
	LocalScene->children =NULL;


	LocalScene->nbChildren=nd->mNumChildren;
	if(nd->mNumMeshes)
	{
		glGenBuffers(1,&(LocalScene->VBOID));
		glGenBuffers(1,&(LocalScene->VBOIDNormal));
		glGenBuffers(1,&(LocalScene->VBOIDtextureCoor));
		glGenBuffers(1,&(LocalScene->VBOIDtangent));
		glGenBuffers(1,&(LocalScene->VBOIDbitangent));
		glGenBuffers(1,&(LocalScene->IBOID));

		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,LocalScene->IBOID);

		for (unsigned int n = 0; n < nd->mNumMeshes; ++n) 
		{
			const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
			NbVertices+=mesh->mNumVertices;
			NbFaces+=mesh->mNumFaces;
		}

		LocalScene->NbFaces=NbFaces;
		glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOID);
		glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW);

		glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDNormal);
		glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW);

		glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtextureCoor);
		glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW);

		glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtangent);
		glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW);

		glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDbitangent);
		glBufferData(GL_ARRAY_BUFFER,NbVertices*3*sizeof(float), NULL, GL_STATIC_DRAW);


		unsigned short* Indices = new unsigned short[NbFaces*3];

		unsigned int trueNbOfFace = 0;
		unsigned int nbVerticesWhenSkipped = 0;
    
		int nbverticesLocal=0;
		int nbFacesLocal=0;
		for (unsigned int n = 0; n < nd->mNumMeshes; ++n) 
		{
			const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];

			glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOID);
			glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mVertices);

			glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDNormal);
			glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mNormals);

			glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtextureCoor);
			glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mTextureCoords[0]);

			glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDtangent);
			glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mTangents);

			glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOIDbitangent);
			glBufferSubData(GL_ARRAY_BUFFER,nbverticesLocal*3*sizeof(float), 3*sizeof(float)*mesh->mNumVertices, mesh->mBitangents);



			nbverticesLocal+=mesh->mNumVertices;
     

			for (unsigned int t = 0; t < mesh->mNumFaces; ++t) 
			{
				const struct aiFace* face = &mesh->mFaces[t];

				if ( face->mNumIndices == 3 )
				{
					Indices[trueNbOfFace*3+0] = face->mIndices[0] + nbVerticesWhenSkipped ;
					Indices[trueNbOfFace*3+1] = face->mIndices[1] + nbVerticesWhenSkipped ;
					Indices[trueNbOfFace*3+2] = face->mIndices[2] + nbVerticesWhenSkipped;
					trueNbOfFace++;
				}
				else
				{
					nbVerticesWhenSkipped = mesh->mNumVertices;
				}
			} 

		}
		glBufferData(GL_ELEMENT_ARRAY_BUFFER,(trueNbOfFace)*3*sizeof(unsigned short) , Indices, GL_STATIC_DRAW);

		glBindBuffer(GL_ARRAY_BUFFER,LocalScene->VBOID);
		aiVector3D* bufferVertexRichard =  (aiVector3D*)glMapBuffer(GL_ARRAY_BUFFER,GL_READ_WRITE);

		glUnmapBuffer(GL_ARRAY_BUFFER);
	}

	for (unsigned int n = 0; n < nd->mNumChildren; ++n) 
	{
		recursive_meshGenerator(sc, nd->mChildren[n], LocalScene->children[n]);
	}

}
Пример #11
0
void GLInstancingRenderer::drawLine(const float from[4], const float to[4], const float color[4], float lineWidth)
{
		
	b3Assert(glGetError() ==GL_NO_ERROR);

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D,0);
	b3Assert(glGetError() ==GL_NO_ERROR);



	glUseProgram(linesShader);

	b3Assert(glGetError() ==GL_NO_ERROR);

	glUniformMatrix4fv(lines_ProjectionMatrix, 1, false, &m_data->m_projectionMatrix[0]);
	glUniformMatrix4fv(lines_ModelViewMatrix, 1, false, &m_data->m_viewMatrix[0]);
	glUniform4f(lines_colour,color[0],color[1],color[2],color[3]);


	b3Assert(glGetError() ==GL_NO_ERROR);

	const float vertexPositions[] = {
		from[0],from[1],from[2],1,
		to[0],to[1],to[2],1
	};
	int sz = sizeof(vertexPositions);
	b3Assert(glGetError() ==GL_NO_ERROR);


	b3Clamp(lineWidth,(float)lineWidthRange[0],(float)lineWidthRange[1]);
	glLineWidth(lineWidth);

	b3Assert(glGetError() ==GL_NO_ERROR);

	glBindVertexArray(lineVertexArrayObject);
	b3Assert(glGetError() ==GL_NO_ERROR);

    glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject);

	b3Assert(glGetError() ==GL_NO_ERROR);


	{
		glBufferSubData(GL_ARRAY_BUFFER, 0,sz, vertexPositions);
	}


	b3Assert(glGetError() ==GL_NO_ERROR);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ARRAY_BUFFER, lineVertexBufferObject);
	b3Assert(glGetError() ==GL_NO_ERROR);

	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
	b3Assert(glGetError() ==GL_NO_ERROR);

	glDrawArrays(GL_LINES, 0, 2);
	b3Assert(glGetError() ==GL_NO_ERROR);


	glBindVertexArray(0);
	glLineWidth(1);

	b3Assert(glGetError() ==GL_NO_ERROR);
	glUseProgram(0);
}
void Initialize()
{
	printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION));
	printf("Type de GPU : %s\n", glGetString(GL_RENDERER));
	printf("Fabricant : %s\n", glGetString(GL_VENDOR));
	printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
	int numExtensions;
	glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);

	GLenum error = glewInit();
	if (error != GL_NO_ERROR) {
		// TODO
	}

	for (int index = 0; index < numExtensions; ++index)
	{
		printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index));
	}

#ifdef _WIN32
	// on coupe la synchro vertical pour voir l'effet du delta time
	wglSwapIntervalEXT(0);
#endif

	basicShader.LoadVertexShader("basic.vs");
	basicShader.LoadFragmentShader("basic.fs");
	basicShader.Create();

	auto program = basicShader.GetProgram();

	// UN UBO SERAIT UTILE ICI
	auto basicProgram = basicShader.GetProgram();
	auto blockIndex = glGetUniformBlockIndex(basicProgram, "ViewProj");
	GLuint blockBinding = 1;

	glGenBuffers(1, &g_Camera.UBO);
	glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO);

	glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(g_Camera.projectionMatrix));
	glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(g_Camera.viewMatrix));
	glBindBufferBase(GL_UNIFORM_BUFFER, blockBinding, g_Camera.UBO);
	glBindBuffer(GL_UNIFORM_BUFFER, 0);

	glUniformBlockBinding(basicProgram, blockIndex, blockBinding);

	previousTime = glutGet(GLUT_ELAPSED_TIME);

	InitCube();

	glBindVertexArray(g_Cube.VAO);
	glBindVertexArray(g_Cube.IBO);
	
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0);

	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, (void*)iPosSize);

	// render states par defaut
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);
	glEnable(GL_CULL_FACE);
}
Пример #13
0
void VertexBufferObject::updateVertices(void const * vertices, unsigned int numBytes, unsigned int byteOffset)
{
	glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
	glBufferSubData(GL_ARRAY_BUFFER, byteOffset, numBytes, vertices);
}
Пример #14
0
	void BufferObject::reSetData(const GLvoid *data, GLuint offset, GLuint size)
	{
		bind();
		glBufferSubData(target, offset, size, data);
	}
Пример #15
0
Floor::Floor(const unsigned int width, const unsigned int height):
    Model(false)
{
    _key = "FLOOR";
    Logger_locator::get()(Logger::DBG, "Creating floor");
    glm::vec2 ll(-0.5f * (float)width, 0.5f * (float)height);
    glm::vec2 ur(0.5f * (float)width, -0.5f * (float)height);

    std::vector<glm::vec3> vert_pos =
    {
        glm::vec3(ll.x, 0.0f, ll.y),
        glm::vec3(ur.x, 0.0f, ll.y),
        glm::vec3(ll.x, 0.0f, ur.y),
        glm::vec3(ur.x, 0.0f, ur.y)
    };

    std::vector<glm::vec2> vert_tex_coords =
    {
        glm::vec2(0.0f, 0.0f),
        glm::vec2((float)width, 0.0f),
        glm::vec2(0.0f, (float)height),
        glm::vec2((float)width, (float)height)
    };

    std::vector<glm::vec3> vert_normals =
    {
        glm::vec3(0.0f, 1.0f, 0.0f),
        glm::vec3(0.0f, 1.0f, 0.0f),
        glm::vec3(0.0f, 1.0f, 0.0f),
        glm::vec3(0.0f, 1.0f, 0.0f)
    };

    std::vector<glm::vec3> vert_tangents =
    {
        glm::vec3(1.0f, 0.0f, 0.0f),
        glm::vec3(1.0f, 0.0f, 0.0f),
        glm::vec3(1.0f, 0.0f, 0.0f),
        glm::vec3(1.0f, 0.0f, 0.0f)
    };

    _meshes.emplace_back();
    Mesh & mesh = _meshes.back();

    mesh.count = vert_pos.size();

    _vao.bind();
    _vbo.bind();

    glBufferData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size() +
        sizeof(glm::vec3) * vert_normals.size() +
        sizeof(glm::vec3) * vert_tangents.size(), NULL, GL_STATIC_DRAW);

    glBufferSubData(_vbo.type(), 0, sizeof(glm::vec3) * vert_pos.size(), vert_pos.data());
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(0);

    glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size(),
        sizeof(glm::vec2) * vert_tex_coords.size(), vert_tex_coords.data());
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size()));
    glEnableVertexAttribArray(1);

    glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size(),
        sizeof(glm::vec3) * vert_normals.size(), vert_normals.data());
    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size()));
    glEnableVertexAttribArray(2);

    glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size() +
        sizeof(glm::vec3) * vert_normals.size(),
        sizeof(glm::vec3) * vert_tangents.size(), vert_tangents.data());
    glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size() +
        sizeof(glm::vec3) * vert_normals.size()));
    glEnableVertexAttribArray(3);
    glBindVertexArray(0);

    _mats.emplace_back();
    Material & mat = _mats.back();
    mat.specular_color = glm::vec3(0.1f, 0.1f, 0.1f);
    mat.diffuse_map = Texture_2D::create(check_in_pwd("mdl/AncientFlooring.jpg"), GL_RGB8);
    mat.normal_shininess_map = Texture_2D::create(check_in_pwd("mdl/AncientFlooring_N.jpg"), GL_RGB8);
    mat.shininess = 500.0f;

    mesh.mat = &_mats.back();

    check_error("Floor::Floor");
}
Пример #16
0
void TextureAtlas::drawNumberOfQuads(ssize_t numberOfQuads, ssize_t start)
{
    CCASSERT(numberOfQuads>=0 && start>=0, "numberOfQuads and start must be >= 0");

    if(!numberOfQuads)
        return;

    GL::bindTexture2D(_texture->getName());

    if (Configuration::getInstance()->supportsShareableVAO())
    {
        //
        // Using VBO and VAO
        //

        // FIXME:: update is done in draw... perhaps it should be done in a timer
        if (_dirty) 
        {
            glBindBuffer(GL_ARRAY_BUFFER, _buffersVBO[0]);
            // option 1: subdata
//            glBufferSubData(GL_ARRAY_BUFFER, sizeof(_quads[0])*start, sizeof(_quads[0]) * n , &_quads[start] );

            // option 2: data
//            glBufferData(GL_ARRAY_BUFFER, sizeof(quads_[0]) * (n-start), &quads_[start], GL_DYNAMIC_DRAW);

            // option 3: orphaning + glMapBuffer
            glBufferData(GL_ARRAY_BUFFER, sizeof(_quads[0]) * _capacity, nullptr, GL_DYNAMIC_DRAW);
            void *buf = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
            memcpy(buf, _quads, sizeof(_quads[0])* _totalQuads);
            glUnmapBuffer(GL_ARRAY_BUFFER);
            
            glBindBuffer(GL_ARRAY_BUFFER, 0);

            _dirty = false;
        }

        GL::bindVAO(_VAOname);

#if CC_REBIND_INDICES_BUFFER
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffersVBO[1]);
#endif

        glDrawElements(GL_TRIANGLES, (GLsizei) numberOfQuads*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(_indices[0])) );

#if CC_REBIND_INDICES_BUFFER
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
#endif

//    glBindVertexArray(0);
    }
    else
    {
        //
        // Using VBO without VAO
        //

#define kQuadSize sizeof(_quads[0].bl)
        glBindBuffer(GL_ARRAY_BUFFER, _buffersVBO[0]);

        // FIXME:: update is done in draw... perhaps it should be done in a timer
        if (_dirty) 
        {
            glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(_quads[0]) * _totalQuads , &_quads[0] );
            _dirty = false;
        }

        GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);

        // vertices
        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof(V3F_C4B_T2F, vertices));

        // colors
        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, (GLvoid*) offsetof(V3F_C4B_T2F, colors));

        // tex coords
        glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, kQuadSize, (GLvoid*) offsetof(V3F_C4B_T2F, texCoords));

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _buffersVBO[1]);

        glDrawElements(GL_TRIANGLES, (GLsizei)numberOfQuads*6, GL_UNSIGNED_SHORT, (GLvoid*) (start*6*sizeof(_indices[0])));

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    }

    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,numberOfQuads*6);

    CHECK_GL_ERROR_DEBUG();
}
Пример #17
0
Walls::Walls(const unsigned int width, const unsigned int height):
    Model(true),
    _grid(width, height, Grid::MAZEGEN_DFS, 25, 100)
{
    _key = "WALLS";
    Logger_locator::get()(Logger::DBG, "Creating walls");

    std::vector<glm::vec3> vert_pos;
    std::vector<glm::vec2> vert_tex_coords;
    std::vector<glm::vec3> vert_normals;
    std::vector<glm::vec3> vert_tangents;

    _meshes.emplace_back();
    Mesh & mesh = _meshes.back();

    glm::vec3 cell_scale(1.0f, 1.0f, 1.0f);
    glm::vec3 base(-0.5f * (float)_grid.grid[0].size(), 0.0f, -0.5f * (float)_grid.grid.size());

    glm::vec3 left_normal(1.0f, 0.0f, 0.0f);
    glm::vec3 left_tangent(0.0f, 0.0f, -1.0f);
    glm::vec3 up_normal(0.0f, 0.0f, 1.0f);
    glm::vec3 up_tangent(1.0f, 0.0f, 0.0f);

    // draw border walls
    for(std::size_t col = 0; col < _grid.grid[0].size(); ++col)
    {
        glm::vec3 origin(cell_scale.x * (float)col, 0.0f, cell_scale.z * (float)_grid.grid.size());
        origin += base;

        vert_pos.push_back(origin);
        vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f));
        vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f));

        vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f));
        vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f));
        vert_pos.push_back(origin + glm::vec3(cell_scale.x, cell_scale.y, 0.0f));

        for(int i = 0; i < 6; ++i)
        {
            vert_normals.push_back(up_normal);
            vert_tangents.push_back(up_tangent);
        }
    }
    for(std::size_t row = 0; row < _grid.grid.size(); ++row)
    {
        glm::vec3 origin(cell_scale.x * (float)_grid.grid[row].size(), 0.0f, cell_scale.z * (float)row);
        origin += base;

        vert_pos.push_back(origin + glm::vec3(0.0f, 0.0f, cell_scale.z));
        vert_pos.push_back(origin);
        vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z));

        vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z));
        vert_pos.push_back(origin);
        vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f));

        for(int i = 0; i < 6; ++i)
        {
            vert_normals.push_back(left_normal);
            vert_tangents.push_back(left_tangent);
        }
    }

    // draw cell walls
    for(std::size_t row = 0; row < _grid.grid.size(); ++row)
    {
        for(std::size_t col = 0; col < _grid.grid[row].size(); ++col)
        {
            glm::vec3 origin(cell_scale.x * (float)col, 0.0f, cell_scale.y * (float)row);
            origin += base;

            if(_grid.grid[row][col].walls[UP])
            {
                vert_pos.push_back(origin);
                vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f));
                vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f));

                vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f));
                vert_pos.push_back(origin + glm::vec3(cell_scale.x, 0.0f, 0.0f));
                vert_pos.push_back(origin + glm::vec3(cell_scale.x, cell_scale.y, 0.0f));

                for(int i = 0; i < 6; ++i)
                {
                    vert_normals.push_back(up_normal);
                    vert_tangents.push_back(up_tangent);
                }
            }

            if(_grid.grid[row][col].walls[LEFT])
            {
                vert_pos.push_back(origin + glm::vec3(0.0f, 0.0f, cell_scale.z));
                vert_pos.push_back(origin);
                vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z));

                vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, cell_scale.z));
                vert_pos.push_back(origin);
                vert_pos.push_back(origin + glm::vec3(0.0f, cell_scale.y, 0.0f));

                for(int i = 0; i < 6; ++i)
                {
                    vert_normals.push_back(left_normal);
                    vert_tangents.push_back(left_tangent);
                }
            }
        }
    }

    // add tex coords
    for(std::size_t i = 0; i < vert_pos.size(); i += 6)
    {
        vert_tex_coords.push_back(glm::vec2(0.0f, 0.0f));
        vert_tex_coords.push_back(glm::vec2(1.0f, 0.0f));
        vert_tex_coords.push_back(glm::vec2(0.0f, 1.0f));

        vert_tex_coords.push_back(glm::vec2(0.0f, 1.0f));
        vert_tex_coords.push_back(glm::vec2(1.0f, 0.0f));
        vert_tex_coords.push_back(glm::vec2(1.0f, 1.0f));
    }

    mesh.count = vert_pos.size();

    _vao.bind();
    _vbo.bind();

    glBufferData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size() +
        sizeof(glm::vec3) * vert_normals.size() +
        sizeof(glm::vec3) * vert_tangents.size(), NULL, GL_STATIC_DRAW);

    glBufferSubData(_vbo.type(), 0, sizeof(glm::vec3) * vert_pos.size(), vert_pos.data());
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    glEnableVertexAttribArray(0);

    glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size(),
        sizeof(glm::vec2) * vert_tex_coords.size(), vert_tex_coords.data());
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size()));
    glEnableVertexAttribArray(1);

    glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size(),
        sizeof(glm::vec3) * vert_normals.size(), vert_normals.data());
    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size()));
    glEnableVertexAttribArray(2);

    glBufferSubData(_vbo.type(), sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size() +
        sizeof(glm::vec3) * vert_normals.size(),
        sizeof(glm::vec3) * vert_tangents.size(), vert_tangents.data());
    glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(sizeof(glm::vec3) * vert_pos.size() +
        sizeof(glm::vec2) * vert_tex_coords.size() +
        sizeof(glm::vec3) * vert_normals.size()));
    glEnableVertexAttribArray(3);

    glBindVertexArray(0);

    _mats.emplace_back();
    Material & mat = _mats.back();
    mat.specular_color = glm::vec3(0.1f, 0.1f, 0.1f);
    mat.diffuse_map = Texture_2D::create(check_in_pwd("img/GroundCover.jpg"), GL_RGB8);
    mat.normal_shininess_map = Texture_2D::create(check_in_pwd("img/normals/GroundCover_N.jpg"), GL_RGB8);
    mat.shininess = 500.0f;

    mesh.mat = &_mats.back();

    check_error("Walls::Walls");
}
Пример #18
0
// -------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------
bool cRender::create_vao_shader(const cShader *shader)
{
  if(!cRender::m_new_render)
    return false;

  if(!shader || !m_vertex || !m_normal || !m_color)
    return false;

  int size = 0, size_tex = 0;

  // index buffer index
  size = m_geometry_type * m_num_geometries * sizeof(GLuint);
  glGenBuffers(1, &m_ibo_id);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, m_index, GL_DYNAMIC_DRAW);
  // end of index buffer index

  GLenum error = glGetError();
  if(error != GL_NO_ERROR)
    printf("Error %s - %d\n" __FILE__, __LINE__);

  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

  // vertex buffer object
  size = 3 * m_num_vertex * sizeof(GLfloat);
  glGenBuffers(1, &m_vbo_id);
  glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id);
  glBufferData(GL_ARRAY_BUFFER, (4 * size) + size_tex, 0, GL_DYNAMIC_DRAW);
  glBufferSubData(GL_ARRAY_BUFFER, 0, size, m_vertex);
  glBufferSubData(GL_ARRAY_BUFFER, size, size, m_normal);
  // to render with texture is not necessary add color data
  if(m_render_texture)
  {
    size_tex = 2 * m_num_vertex * sizeof(GLfloat);
    glBufferSubData(GL_ARRAY_BUFFER, 2 * size, size_tex, m_texture_coord);
  }
  else
  {
    glBufferSubData(GL_ARRAY_BUFFER, 2 * size, size, m_color);
  }
  // end of vertex buffer object

  error = glGetError();
  if(error != GL_NO_ERROR)
    printf("Error %s - %d\n" __FILE__, __LINE__);

  glBindBuffer(GL_ARRAY_BUFFER, 0);

  // vertex array object
  glGenVertexArrays(1, &m_vao_id);

  m_vec_vao_id.push_back(m_vao_id);

  glBindVertexArray(m_vao_id);
  glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id);
  glVertexAttribPointer(shader->m_in_vertex_loc, 3, GL_FLOAT, GL_FALSE, 0, 0);
  glVertexAttribPointer(shader->m_in_normal_loc, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (size));
  // to render with texture is not necessary add color data
  if(m_render_texture)
    glVertexAttribPointer(shader->m_in_texture_coord_loc, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (2 * size));
  else
    glVertexAttribPointer(shader->m_in_color_loc, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (2 * size));

  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id);

  error = glGetError();
  if(error != GL_NO_ERROR)
    printf("Error %s - %d\n" __FILE__, __LINE__);

  // Enable attributes
  glEnableVertexAttribArray(shader->m_in_vertex_loc);
  glEnableVertexAttribArray(shader->m_in_normal_loc);
  if(m_render_texture)
    glEnableVertexAttribArray(shader->m_in_texture_coord_loc);
  else 
  {
    glEnableVertexAttribArray(shader->m_in_color_loc);
  }
  // end of vertex array object

  // disable
  glBindVertexArray(0);
  glDisableVertexAttribArray(shader->m_in_vertex_loc);
  glDisableVertexAttribArray(shader->m_in_normal_loc);
  glDisableVertexAttribArray(shader->m_in_color_loc);
  glDisableVertexAttribArray(shader->m_in_texture_coord_loc);
  //glDisableVertexAttribArray(shader->m_in_pick_loc);
  glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

  return true;
}
void init()
{
	// Vertices of a square
	double ext = 1.0;
	vec4 points[NumPoints] = {
		vec4( -ext, -ext,  0, 1.0 ), //v1
		vec4(  ext, -ext,  0, 1.0 ), //v2
		vec4( -ext,  ext,  0, 1.0 ), //v3	
		vec4( -ext,  ext,  0, 1.0 ), //v3	
		vec4(  ext, -ext,  0, 1.0 ), //v2
		vec4(  ext,  ext,  0, 1.0 )  //v4
	};

	// Texture coordinates
	vec2 tex_coords[NumPoints] = {
		vec2( 0.0, 0.0 ),
		vec2( 1.0, 0.0 ),
		vec2( 0.0, 1.0 ),
		vec2( 0.0, 1.0 ),
		vec2( 1.0, 0.0 ),
		vec2( 1.0, 1.0 )
	};

	// Initialize texture objects
	GLuint texture;
	glGenTextures( 1, &texture );

	glBindTexture( GL_TEXTURE_2D, texture );
	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, WIN_WIDTH, WIN_HEIGHT, 0,
		GL_RGB, GL_FLOAT, frame );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
	glActiveTexture( GL_TEXTURE0 );

	// Create and initialize a buffer object
	GLuint buffer;
	glGenBuffers( 1, &buffer );
	glBindBuffer( GL_ARRAY_BUFFER, buffer );
	glBufferData( GL_ARRAY_BUFFER, sizeof(points) + sizeof(tex_coords), NULL, GL_STATIC_DRAW );
	GLintptr offset = 0;
	glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(points), points );
	offset += sizeof(points);
	glBufferSubData( GL_ARRAY_BUFFER, offset, sizeof(tex_coords), tex_coords );

	// Load shaders and use the resulting shader program
	GLuint program = InitShader( "vshader.glsl", "fshader.glsl" );
	glUseProgram( program );

	// set up vertex arrays
	offset = 0;
	GLuint vPosition = glGetAttribLocation( program, "vPosition" );
	glEnableVertexAttribArray( vPosition );
	glVertexAttribPointer( vPosition, 4, GL_FLOAT, GL_FALSE, 0,
		BUFFER_OFFSET(offset) );

	offset += sizeof(points);
	GLuint vTexCoord = glGetAttribLocation( program, "vTexCoord" ); 
	glEnableVertexAttribArray( vTexCoord );
	glVertexAttribPointer( vTexCoord, 2, GL_FLOAT, GL_FALSE, 0,
		BUFFER_OFFSET(offset) );

	glUniform1i( glGetUniformLocation(program, "texture"), 0 );

	glClearColor( 1.0, 1.0, 1.0, 1.0 );
}
//Called to update the display.
//You should call glutSwapBuffers after all of your rendering to display what you rendered.
//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
void display()
{
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	if(g_pConeMesh && g_pCylinderMesh && g_pCubeTintMesh && g_pCubeColorMesh && g_pPlaneMesh)
	{
		const glm::vec3 &camPos = ResolveCamPosition();

		glutil::MatrixStack camMatrix;
		camMatrix.SetMatrix(CalcLookAtMatrix(camPos, g_camTarget, glm::vec3(0.0f, 1.0f, 0.0f)));

		glBindBuffer(GL_UNIFORM_BUFFER, g_GlobalMatricesUBO);
		glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(camMatrix.Top()));
		glBindBuffer(GL_UNIFORM_BUFFER, 0);

		glutil::MatrixStack modelMatrix;

		//Render the ground plane.
		{
			glutil::PushStack push(modelMatrix);

			modelMatrix.Scale(glm::vec3(100.0f, 1.0f, 100.0f));

			glUseProgram(UniformColor.theProgram);
			glUniformMatrix4fv(UniformColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
			glUniform4f(UniformColor.baseColorUnif, 0.302f, 0.416f, 0.0589f, 1.0f);
			g_pPlaneMesh->Render();
			glUseProgram(0);
		}

		//Draw the trees
		DrawForest(modelMatrix);

		//Draw the building.
		{
			glutil::PushStack push(modelMatrix);
			modelMatrix.Translate(glm::vec3(20.0f, 0.0f, -10.0f));

			DrawParthenon(modelMatrix);
		}

		if(g_bDrawLookatPoint)
		{
			glDisable(GL_DEPTH_TEST);

			glutil::PushStack push(modelMatrix);

			modelMatrix.Translate(g_camTarget);
			modelMatrix.Scale(1.0f, 1.0f, 1.0f);

			glUseProgram(ObjectColor.theProgram);
			glUniformMatrix4fv(ObjectColor.modelToWorldMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top()));
			g_pCubeColorMesh->Render();
			glUseProgram(0);
			glEnable(GL_DEPTH_TEST);
		}
	}

	glutSwapBuffers();
}
Пример #21
0
int main(int argc, char *argv[])
{
    SDL_Surface *screen;

    // Slightly different SDL initialization
    if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
        printf("Unable to initialize SDL: %s\n", SDL_GetError());
        return 1;
    }

    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new*

    screen = SDL_SetVideoMode( 640, 480, 16, SDL_OPENGL ); // *changed*
    if ( !screen ) {
        printf("Unable to set video mode: %s\n", SDL_GetError());
        return 1;
    }
    
    // Set the OpenGL state after creating the context with SDL_SetVideoMode

    glClearColor( 0, 0, 0, 0 );
    
#ifndef __EMSCRIPTEN__
    glEnable( GL_TEXTURE_2D ); // Need this to display a texture XXX unnecessary in OpenGL ES 2.0/WebGL
#endif

    glViewport( 0, 0, 640, 480 );
    
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    
    // Clear the screen before drawing
    glClear( GL_COLOR_BUFFER_BIT );
    
    typedef struct Vertex {
        GLfloat x;
        GLfloat y;
    } Vertex;
    
    typedef struct Color {
        GLubyte r;
        GLubyte g;
        GLubyte b;
        GLubyte a;
    } Color;
    
    typedef struct Type1 {
        Vertex location;
        Color  color;
    } Type1;
    
    typedef struct Type2 {
        GLuint unused1;
        Vertex location;
        GLfloat unused2;
        Color  color;
    } Type2;
    
    Type1 first[3] = {
        {{-1.0, 0.0}, {0xFF, 0x00, 0x00, 0xFF}},
        {{ 0.0, 1.0}, {0x00, 0xFF, 0x00, 0xFF}},
        {{ 1.0, 0.0}, {0x00, 0x00, 0xFF, 0xFF}}
    };
    
    Type2 second[3] = {
        {0.0, {-1.0,  0.0}, 0.0, {0xFF, 0x00, 0x00, 0xFF}},
        {0.0, { 1.0,  0.0}, 0.0, {0x00, 0x00, 0xFF, 0xFF}},
        {0.0, { 0.0, -1.0}, 0.0, {0x00, 0xFF, 0x00, 0xFF}}};
    
    // make two vbo objects
    GLuint vbo[2];
    glGenBuffers(2, &vbo[0]);
    
    // load the first into the context
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
    
    // allocate enough space for 100 vertices
    glBufferData(GL_ARRAY_BUFFER, sizeof(Type1)*100, NULL, GL_DYNAMIC_DRAW);
    
    // load the second into the context
    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
    
    // allocate enough space for 100 vertices
    glBufferData(GL_ARRAY_BUFFER, sizeof(Type2)*100, NULL, GL_DYNAMIC_DRAW);
    
    // DRAW
    
    GLbyte * pointer;

    // Clear the screen before drawing
    glClear( GL_COLOR_BUFFER_BIT );
    
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    
    // FIRST
    // load the first into the context
    glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
    
    // Load actual data in
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Type1)*3, &first[0]);
    
    // point to the buffer's location data
    glVertexPointer(2, GL_FLOAT, sizeof(Type1), NULL);
    
    pointer = (GLbyte*)(((GLbyte*)&first[0].color) - ((GLbyte*)&first[0].location));

    printf("location = %p\n", pointer);
    // point to the buffer's color data
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Type1), pointer);
    
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 3);

    // SECOND
    
    // load the first into the context
    glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);
    
    // Load actual data in
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Type2)*3, &second[0]);
    
    pointer = (GLbyte*)((GLbyte*)&second[0].location - (GLbyte*)&second[0].unused1);
    
    // point to the buffer's location data
    printf("location = %p\n", pointer);
    glVertexPointer(2, GL_FLOAT, sizeof(Type2), pointer);
    
    pointer = (GLbyte*)((GLbyte*)&second[0].color - (GLbyte*)&second[0].unused1);
    
    // point to the buffer's location data
    printf("location = %p\n", pointer);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Type2), pointer);
    
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 3);
    
    glDisableClientState(GL_COLOR_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);

    SDL_GL_SwapBuffers();
    
#ifndef __EMSCRIPTEN__
    // Wait for 3 seconds to give us a chance to see the image
    SDL_Delay(3000);
#endif

    SDL_Quit();
    
    return 0;
}
Пример #22
0
void	SkyBox::draw()
{
	static float size=viewdistance/4;
	glPushMatrix();
	static GLfloat M[16];

#if defined(USE_GLES)
    static float old_size;
    int offset;
    int vtx_size, tex_size;

    static int vtxA_Offset, vtxB_Offset, vtxC_Offset, vtxD_Offset, vtxE_Offset, vtxF_Offset;
    static int texA_Offset, texB_Offset, texC_Offset;

    GLfloat vtxA[] = {
        -size, -size,   size,
         size, -size,   size,
         size,  size,   size,
        -size,  size,   size
    };

    GLfloat vtxB[] = {
        -size, -size,  -size,
        -size,  size,  -size,
         size,  size,  -size,
         size, -size,  -size
    };

    GLfloat vtxC[] = {
        -size,  size,  -size,
        -size,  size,   size,
         size,  size,   size,
         size,  size,  -size
    };

    GLfloat vtxD[] = {
        -size, -size,  -size,
         size, -size,  -size,
         size, -size,   size,
        -size, -size,   size
    };

    GLfloat vtxE[] = {
         size, -size,  -size,
         size,  size,  -size,
         size,  size,   size,
         size, -size,   size
    };

    GLfloat vtxF[] = {
         -size, -size, -size,
         -size, -size,  size,
         -size,  size,  size,
         -size,  size, -size
    };

    GLfloat texA[] = {
        0,      0,
        1,      0,
        1,      1,
        0,      1
    };

    GLfloat texB[] = {
        1,      0,
        1,      1,
        0,      1,
        0,      0
    };

    GLfloat texC[] = {
        0,      1,
        0,      0,
        1,      0,
        1,      1
    };


    vtx_size = sizeof(GLfloat)*12;
    tex_size = sizeof(GLfloat)*8;

    if(!BufferName) {
        glGenBuffers(1, &BufferName);

        glBindBuffer(GL_ARRAY_BUFFER, BufferName);
        glBufferData(GL_ARRAY_BUFFER, (vtx_size*6)+(tex_size*3), NULL, GL_STATIC_DRAW);
    }
    else
    {
        glBindBuffer(GL_ARRAY_BUFFER, BufferName);
    }


    if (old_size!=size)
    {
        vtxA_Offset = offset = 0;
        glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxA);
        vtxB_Offset = (offset += vtx_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxB);
        vtxC_Offset = (offset += vtx_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxC);
        vtxD_Offset = (offset += vtx_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxD);
        vtxE_Offset = (offset += vtx_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxE);
        vtxF_Offset = (offset += vtx_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, vtx_size, vtxF);
        texA_Offset = (offset += vtx_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, tex_size, texA);
        texB_Offset = (offset += tex_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, tex_size, texB);
        texC_Offset = (offset += tex_size);
        glBufferSubData(GL_ARRAY_BUFFER, offset, tex_size, texC);
    }
#endif

	glGetFloatv(GL_MODELVIEW_MATRIX,M);

	M[12]=0;
	M[13]=0;
	M[14]=0;
	glLoadMatrixf(M);
	//if(environment==2)glTranslatef(0,blurness*viewdistance/1000,0);
	if(environment==2)glScalef(1+blurness/1000,1,1+blurness/1000);
	if(environment!=2) {
#if defined(USE_GLES)
        glColor4f(.85*skyboxr,.85*skyboxg,.95*skyboxb,1.0);
#else
        glColor3f(.85*skyboxr,.85*skyboxg,.95*skyboxb);
#endif
	}
	else {
#if defined(USE_GLES)
        glColor4f(1*skyboxr,.95*skyboxg,.95*skyboxb,1.0);
#else
        glColor3f(1*skyboxr,.95*skyboxg,.95*skyboxb);
#endif
	}

	if(!skyboxtexture){
		glDisable(GL_TEXTURE_2D); 
#if defined(USE_GLES)
		glColor4f(skyboxr*.8,skyboxg*.8,skyboxb*.8,1.0);
#else
		glColor3f(skyboxr*.8,skyboxg*.8,skyboxb*.8);
#endif
	}
	glDepthMask(0);
	glDisable(GL_CULL_FACE);
	glEnable(GL_BLEND);
	glDisable(GL_LIGHTING);
	glActiveTexture(GL_TEXTURE0);
	//glActiveTexture(GL_TEXTURE0_ARB);
	if(skyboxtexture)glEnable(GL_TEXTURE_2D);
	glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
	glBindTexture(GL_TEXTURE_2D, front); 
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#if defined(USE_GLES)
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	glNormal3f( 0.0f, 0.0f, -1);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxA_Offset));
    glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texA_Offset));
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
#else
	glBegin(GL_QUADS);
	glNormal3f( 0.0f, 0.0f, -1);
	glTexCoord2f(0, 0); glVertex3f(-size, -size,  size);
	glTexCoord2f(1, 0); glVertex3f( size, -size,  size);
	glTexCoord2f(1, 1); glVertex3f( size,  size,  size);
	glTexCoord2f(0, 1); glVertex3f(-size,  size,  size);
	glEnd();
#endif
	glBindTexture(GL_TEXTURE_2D, back);
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#if defined(USE_GLES)
	glNormal3f( 0.0f, 0.0f, 1);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxB_Offset));
    glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texB_Offset));
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
#else
	glBegin(GL_QUADS);
	glNormal3f( 0.0f, 0.0f, 1);
	glTexCoord2f(1, 0); glVertex3f(-size, -size, -size);
	glTexCoord2f(1, 1); glVertex3f(-size,  size, -size);
	glTexCoord2f(0, 1); glVertex3f( size,  size, -size);
	glTexCoord2f(0, 0); glVertex3f( size, -size, -size);
	glEnd();
#endif
	glBindTexture(GL_TEXTURE_2D, up);
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#if defined(USE_GLES)
	glNormal3f( 0.0f, -1.0f, 0);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxC_Offset));
    glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texC_Offset));
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
#else
	glBegin(GL_QUADS);
	glNormal3f( 0.0f, -1.0f, 0);
	glTexCoord2f(0, 1); glVertex3f(-size,  size, -size);
	glTexCoord2f(0, 0); glVertex3f(-size,  size,  size);
	glTexCoord2f(1, 0); glVertex3f( size,  size,  size);
	glTexCoord2f(1, 1); glVertex3f( size,  size, -size);
	glEnd();
#endif
	//if(detail!=0){
	glBindTexture(GL_TEXTURE_2D, down);
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#if defined(USE_GLES)
	glNormal3f( 0.0f, 1.0f, 0);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxD_Offset));
    glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texA_Offset));
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
#else
	glBegin(GL_QUADS);
	glNormal3f( 0.0f, 1.0f, 0);
	glTexCoord2f(0, 0); glVertex3f(-size, -size, -size);
	glTexCoord2f(1, 0); glVertex3f( size, -size, -size);
	glTexCoord2f(1, 1); glVertex3f( size, -size,  size);
	glTexCoord2f(0, 1); glVertex3f(-size, -size,  size);
	glEnd();
#endif
	//}
	glBindTexture(GL_TEXTURE_2D, right);
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#if defined(USE_GLES)
	glNormal3f( -1.0f, 0.0f, 0);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxE_Offset));
    glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texB_Offset));
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
#else
	glBegin(GL_QUADS);
	glNormal3f( -1.0f, 0.0f, 0);
	glTexCoord2f(1, 0); glVertex3f( size, -size, -size);
	glTexCoord2f(1, 1); glVertex3f( size,  size, -size);
	glTexCoord2f(0, 1); glVertex3f( size,  size,  size);
	glTexCoord2f(0, 0); glVertex3f( size, -size,  size);
	glEnd();
#endif
	glBindTexture(GL_TEXTURE_2D, left);
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
#if defined(USE_GLES)
	glNormal3f( 1.0f, 0.0f, 0);
    glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(vtxF_Offset));
    glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(texA_Offset));
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#else
	glBegin(GL_QUADS);
	glNormal3f( 1.0f, 0.0f, 0);
	glTexCoord2f(0, 0); glVertex3f(-size, -size, -size);
	glTexCoord2f(1, 0); glVertex3f(-size, -size,  size);
	glTexCoord2f(1, 1); glVertex3f(-size,  size,  size);
	glTexCoord2f(0, 1); glVertex3f(-size,  size, -size);
	glEnd();
#endif
	/*
	glEnable(GL_BLEND);
	glColor4f(1,1,1,1);
	glBindTexture(GL_TEXTURE_2D, cloud);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 
	glBegin(GL_QUADS);
	glNormal3f( 0.0f, -1.0f, 0);
	glTexCoord2f(0, 				(1+cloudmove)*30);	glVertex3f(-size,  	size/200, -size);
	glTexCoord2f(0, 				0); 				glVertex3f(-size,  	size/200,  size);
	glTexCoord2f((1+cloudmove)*30, 	0); 				glVertex3f( size, 	size/200,  size);
	glTexCoord2f((1+cloudmove)*30, 	(1+cloudmove)*30); 	glVertex3f( size,  	size/200, -size);
	glEnd();
	glDisable(GL_BLEND);*/
	glEnable(GL_CULL_FACE);
	glDepthMask(1);
	glPopMatrix();

#if defined(USE_GLES)
    glBindBuffer(GL_ARRAY_BUFFER,0);

    old_size = size;
#endif
}
Пример #23
0
// Update texture coordinates for a vbo
void _Graphics::UpdateVBOTextureCoords(int VBO, float *Data) {
	glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[VBO]);
	glBufferSubData(GL_ARRAY_BUFFER, sizeof(float) * 8, sizeof(float) * 8, (GLvoid *)(&Data[0]));
}
Пример #24
0
void LightRenderer::renderToBackbuffer()
{
    glEnable(GL_BLEND);

    Debug::checkGLError();
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    Debug::checkGLError();

    m_shaderPassthrough->bindProgram();
    Debug::checkGLError();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, m_fboTexture);
    Debug::checkGLError();

    GLint lightFBOLoc = glGetUniformLocation(m_shaderPassthrough->shaderProgram(), "lightFBO");
    glUniform1i(lightFBOLoc, 0);

    Debug::checkGLError();
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, m_tileRendererTexture);

    GLint tileFBOLoc = glGetUniformLocation(m_shaderPassthrough->shaderProgram(), "tileFBO");
    glUniform1i(tileFBOLoc, 1);
    Debug::checkGLError();

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_eboBackbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_vboBackbuffer);
    glBindVertexArray(m_vaoBackbuffer);

    Debug::checkGLError();

    int index = 0;
    // vertices that will be uploaded.
    Vertex vertices[4];

    // vertices[n][0] -> X, and [1] -> Y
    // vertices[0] -> top left
    // vertices[1] -> bottom left
    // vertices[2] -> bottom right
    // vertices[3] -> top right

//    const glm::vec2& position = torch->position();
//    const float radius = torch->radius();

    float x = -1.0f; //position.x - radius;
    float width = 1.0f; //position.x +  radius;

    float y = 1.0f; //position.y - radius;
    float height = -1.0f; //position.y  +  radius;

    vertices[0].x = x; // top left X
    vertices[0].y = y; //top left Y

    vertices[1].x = x; // bottom left X
    vertices[1].y = height; // bottom left Y

    vertices[2].x = width; // bottom right X
    vertices[2].y = height; //bottom right Y

    vertices[3].x = width; // top right X
    vertices[3].y = y; // top right Y

    Debug::checkGLError();

    // copy color to the buffer
    for (size_t i = 0; i < sizeof(vertices) / sizeof(*vertices); i++) {
        //        *colorp = color.bgra;
        uint8_t red = 255;
        uint8_t blue = 255;
        uint8_t green = 255;
        uint8_t alpha = 255;
        int32_t color = red | (green << 8) | (blue << 16) | (alpha << 24);
        vertices[i].color = color;
    }

    // copy texcoords to the buffer
    vertices[0].u = vertices[1].u = 0.0f;
    vertices[0].v = vertices[3].v = 1.0f;
    vertices[1].v = vertices[2].v = 0.0f;
    vertices[2].u = vertices[3].u = 1.0f;

    Debug::checkGLError();
    // finally upload everything to the actual vbo
    glBindBuffer(GL_ARRAY_BUFFER, m_vboBackbuffer);
    glBufferSubData(
        GL_ARRAY_BUFFER,
        sizeof(vertices) * 0,
        sizeof(vertices),
        vertices);
    Debug::checkGLError();

    Debug::checkGLError();
    ////////////////////////////////FINALLY RENDER IT ALL //////////////////////////////////////////
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_eboBackbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_vboBackbuffer);
    glBindVertexArray(m_vaoBackbuffer);

    Debug::checkGLError();


    Debug::checkGLError();

    glDrawElements(
        GL_TRIANGLES,
        6 * (1), // 6 indices per 2 triangles
        GL_UNSIGNED_INT,
        (const GLvoid*)0);
    Debug::checkGLError();

    m_shaderPassthrough->unbindProgram();

    glDisable(GL_BLEND);
    Debug::checkGLError();
    glBindVertexArray(0);
    Debug::checkGLError();
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    Debug::checkGLError();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glActiveTexture(GL_TEXTURE0);

    Debug::checkGLError();
}
Пример #25
0
 static GHL_GL_API void _glBufferSubData (GLenum target, GL::GLintptr offset, GL::GLsizeiptr size, const GLvoid *data) {
     glBufferSubData(target, offset, size, data);
 }
Пример #26
0
//FIXME: TODO: take a slightly different approach, clear to white instead, draw black whereever there are tiles that have back-tiles, and then draw user-placed lights which would brighten up those tiles
void LightRenderer::renderToFBO()
{
    m_camera->setShader(m_shader);
    m_shader->bindProgram();

    Debug::checkGLError();

    glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
    glBindRenderbuffer(GL_RENDERBUFFER, m_rb);

    if (m_renderingEnabled) {
        glClearColor(0.f, 0.f, 0.f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
    } else {
        //clear the lightmap to all white, aka no darkness at all, and don't bother rendering light sources
        //NOTE: this is just for debugging purposes..don't plan on ever using it for anything else, you sick, sick bastard...
        glClearColor(1.f, 1.f, 1.f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        return;
    }

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, m_torchLightTexture);

    GLint lightMapLoc = glGetUniformLocation(m_shader->shaderProgram(), "lightMap");
    glUniform1i(lightMapLoc, 0);

    GLint timeLoc = glGetUniformLocation(m_shader->shaderProgram(), "time");
    glUniform1f(timeLoc, float(SDL_GetTicks()));

    int index = 0;
    Debug::checkGLError();
for (Torch * torch : m_torches) {

        // vertices that will be uploaded.
        Vertex vertices[4];

        // vertices[n][0] -> X, and [1] -> Y
        // vertices[0] -> top left
        // vertices[1] -> bottom left
        // vertices[2] -> bottom right
        // vertices[3] -> top right

        const glm::vec2& position = torch->position();
        const float radius = torch->radius();

        float x = position.x - radius;
        float width = position.x +  radius;

        float y = position.y - radius;
        float height = position.y  +  radius;

        vertices[0].x = x; // top left X
        vertices[0].y = y; //top left Y

        vertices[1].x = x; // bottom left X
        vertices[1].y = height; // bottom left Y

        vertices[2].x = width; // bottom right X
        vertices[2].y = height; //bottom right Y

        vertices[3].x = width; // top right X
        vertices[3].y = y; // top right Y

        Debug::checkGLError();

        // copy color to the buffer
        for (size_t i = 0; i < sizeof(vertices) / sizeof(*vertices); i++) {
            //        *colorp = color.bgra;
            uint8_t red = 255;
            uint8_t green = 255;
            uint8_t blue = 255;
            uint8_t alpha = 255;
            int32_t color = red | (green << 8) | (blue << 16) | (alpha << 24);
            vertices[i].color = color;
        }

        // copy texcoords to the buffer
        vertices[0].u = vertices[1].u = 0.0f;
        vertices[0].v = vertices[3].v = 1.0f;
        vertices[1].v = vertices[2].v = 0.0f;
        vertices[2].u = vertices[3].u = 1.0f;

        Debug::checkGLError();
        // finally upload everything to the actual vbo
        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
        glBufferSubData(
            GL_ARRAY_BUFFER,
            sizeof(vertices) * index,
            sizeof(vertices),
            vertices);
        Debug::checkGLError();

        ++index;
    }

    Debug::checkGLError();
    ////////////////////////////////FINALLY RENDER IT ALL //////////////////////////////////////////
    glEnable(GL_BLEND);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
    glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
    glBindVertexArray(m_vao);

    Debug::checkGLError();

    glDrawElements(
        GL_TRIANGLES,
        6 * (m_torches.size()), // 6 indices per 2 triangles
        GL_UNSIGNED_INT,
        (const GLvoid*)0);
    Debug::checkGLError();

    m_shader->unbindProgram();
    Debug::checkGLError();
    glBindVertexArray(0);
    Debug::checkGLError();
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    Debug::checkGLError();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    Debug::checkGLError();
    glDisable(GL_BLEND);

    Debug::checkGLError();
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glBindRenderbuffer(GL_RENDERBUFFER, 0);
}
Пример #27
0
void BoundingBox::Set(int index, int value)
{
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, s_bbox_buffer_id);
  glBufferSubData(GL_SHADER_STORAGE_BUFFER, index * sizeof(int), sizeof(int), &value);
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
}
Пример #28
0
void Cylinder::init(const char *textureFile)
{
	m_textureOn = (textureFile[0] != '\0')? true: false;

	// Allocate space for vertices
	memAlloc();
	m_circlePoints = new vec2[m_numDivisions];

	generateCylinder();	// generate cylinder points

	// Create a vertex array object
#ifdef __APPLE__
    glGenVertexArraysAPPLE(1, &m_vertexArrayObject);
    glBindVertexArrayAPPLE(m_vertexArrayObject);
#else
	glGenVertexArrays(1, &m_vertexArrayObject);
    glBindVertexArray(m_vertexArrayObject);
#endif

	 // Create a buffer object
    glGenBuffers(1, &m_vertexBufferObject);
    glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject);    

	// Initialize buffer
	glBufferData(GL_ARRAY_BUFFER, (sizeof(m_vertices[0]) + sizeof(m_normals[0]) + sizeof(m_textureUV[0]))*m_numVertices + sizeof(m_edges[0])*m_numEdges, NULL, GL_STATIC_DRAW);
	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(m_vertices[0])*m_numVertices, m_vertices);
	glBufferSubData(GL_ARRAY_BUFFER, sizeof(m_vertices[0])*m_numVertices, sizeof(m_edges[0])*m_numEdges, m_edges);
	glBufferSubData(GL_ARRAY_BUFFER, sizeof(m_vertices[0])*m_numVertices + sizeof(m_edges[0])*m_numEdges, sizeof(m_normals[0])*m_numVertices, m_normals);
	glBufferSubData(GL_ARRAY_BUFFER, (sizeof(m_vertices[0]) + sizeof(m_normals[0]))*m_numVertices + sizeof(m_edges[0])*m_numEdges, sizeof(m_textureUV[0])*m_numVertices, m_textureUV);

	// Load shaders and use the resulting shader program
    m_program = InitShader("vshader.glsl", "fshader.glsl");
	glUseProgram(m_program);

	// Specify vertex positions as an input to the shader program
    GLuint position = glGetAttribLocation(m_program, "vPosition");
    glEnableVertexAttribArray(position);
    glVertexAttribPointer(position, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); 

	// Specify normal vectors as an input to the shader program
	GLuint normal = glGetAttribLocation(m_program, "vNormal");
	glEnableVertexAttribArray(normal);
	glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(m_vertices[0])*m_numVertices + sizeof(m_edges[0])*m_numEdges));

	// Specify texture positions as an input to the shader program
	GLuint texture = glGetAttribLocation(m_program, "vTexture");
	glEnableVertexAttribArray(texture);
	glVertexAttribPointer(texture, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET((sizeof(m_vertices[0]) + sizeof(m_normals[0]))*m_numVertices + sizeof(m_edges[0])*m_numEdges)); 

	// Load image
	TgaImage image;
	if(m_textureOn && !image.loadTGA(textureFile))
	{
		printf("Error loading image file\n");
		exit(1);
	}

	// Bind texture
	glGenTextures(1, &m_textureBufferObject);
	glBindTexture(GL_TEXTURE_2D, m_textureBufferObject);
	glTexImage2D(GL_TEXTURE_2D, 0, 4, image.width, image.height, 0, (image.byteCount == 3) ? GL_BGR : GL_BGRA, GL_UNSIGNED_BYTE, image.data);
    
	glGenerateMipmap(GL_TEXTURE_2D);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

	glUniform1i(glGetUniformLocation(m_program, "Tex"), 0);

	// Clean up
	delete [] m_vertices;
	delete [] m_edges;
	delete [] m_textureUV;
	delete [] m_normals;
	delete [] m_circlePoints;
}
Пример #29
0
void ParticleMesh::calculate(LevelsetCollider &LC, int size, float r, float mass)
 {
	
	float scale = 2 * r / (LC.gridStep*(LC.gridSize.x - 4) / size);
	vec3<double> center = vec3<double>(0, 0, 0);
	vec3<double> MaxB = LC.MaxBoundary;
	vec3<double> MinB = LC.MinBoundary;
	scale = CalScale(MaxB, MinB, r, size);
	int index_par = 0;
	par_list = new triple[20000];
	sdf_list = new SDF[20000];
	float step = r * 2 / scale;
	

	for (int i = 0; i < size; i++)
	{
		for (int j = 0; j < size; j++)
		{
			for (int k = 0; k <size; k++)
			{
				vec3<int> gridPos = vec3<int>(i, j, k);
				vec3<double> pos = vec3<double>(i + 0.5, j + 0.5, k + 0.5) * (2 * r / scale) + MinB;
				int gridInd = dot(gridPos, LC.gridSizeOffset);
				double sdf = 0;
				LC.getGridDist(pos, sdf);
				if (sdf < 0 && sdf > -r * 2 / scale * 2)
				{
					vec3<double> pos_par = pos - MinB;// -vec3<double>(0.5, 0.5, 0.5) * (2 * r / scale);

					center += mass*pos_par * scale;
					par_list[index_par].x[0] = pos_par.x * scale;
					par_list[index_par].x[1] = pos_par.y * scale;
					par_list[index_par].x[2] = pos_par.z * scale;

					sdf_list[index_par].sdf = sdf * scale;
					vec3<double> gradient;
					LC.checkCollision(pos, sdf, gradient, -1);
					sdf_list[index_par].gradient[0] = gradient.x;
					sdf_list[index_par].gradient[1] = gradient.y;
					sdf_list[index_par].gradient[2] = gradient.z;
					index_par++;
				}
			}
		}
	}


	center /= index_par*mass;
	float3 center_f3 = make_float3(center[0], center[1], center[2]);
	m_totalParticles = index_par;
	m_totalConnectedPoints = LC.meshModel->m_totalConnectedPoints;
	m_totalFaces = LC.meshModel->m_totalFaces;
	float3 vertex,relative;
	mp_vertexXYZ = new float[m_totalConnectedPoints * 3];
	Relative_Vertex = new float3[m_totalConnectedPoints];
	mp_vertexNorm = new float[m_totalConnectedPoints * 3];
	mp_vertexRGB = new float[m_totalConnectedPoints * 3];
	for (int i = 0; i < m_totalConnectedPoints; i++)
	{
		vertex.x = LC.meshModel->mp_vertexXYZ[i * 3];
		vertex.y = LC.meshModel->mp_vertexXYZ[i * 3 + 1];
		vertex.z = LC.meshModel->mp_vertexXYZ[i * 3 + 2];
		//vertex *= scale;
		vertex -= make_float3(MinB[0], MinB[1], MinB[2]);// +make_float3(0.5, 0.5, 0.5) * (2 * r / scale);
		vertex *= scale;
		relative = vertex - center_f3;
		*(float3*)(mp_vertexXYZ + i * 3) = vertex;


		mp_vertexRGB[i * 3] = LC.meshModel->mp_vertexRGB[i * 3];
		mp_vertexRGB[i * 3 + 1] = LC.meshModel->mp_vertexRGB[i * 3 + 1];
		mp_vertexRGB[i * 3 + 2] = LC.meshModel->mp_vertexRGB[i * 3 + 2];

		mp_vertexNorm[i * 3] = 0; //LC.meshModel->mp_vertexNorm[i * 3];
		mp_vertexNorm[i * 3 + 1] = 0; //LC.meshModel->mp_vertexNorm[i * 3 + 1];
		mp_vertexNorm[i * 3 + 2] = 0;// LC.meshModel->mp_vertexNorm[i * 3 + 2];


		Relative_Vertex[i] = relative;
	}

	FaceVerInd = new uint[3 * m_totalFaces];
	//memcpy(FaceVerInd, LC.meshModel->mp_face, 9 * m_totalFaces * sizeof(uint));
	float3  n;
	for (int i = 0; i < m_totalFaces; i++)
	{
		uint i_1 = FaceVerInd[3 * i] = LC.meshModel->mp_face[3 * i];
		uint i_2 = FaceVerInd[3 * i + 1] = LC.meshModel->mp_face[3 * i + 1];
		uint i_3 = FaceVerInd[3 * i + 2] = LC.meshModel->mp_face[3 * i + 2];

		float3 v1 = make_float3(mp_vertexXYZ[i_1 * 3], mp_vertexXYZ[i_1 * 3 + 1], mp_vertexXYZ[i_1 * 3 + 2]);
		float3 v2 = make_float3(mp_vertexXYZ[i_2 * 3], mp_vertexXYZ[i_2 * 3 + 1], mp_vertexXYZ[i_2 * 3 + 2]);
		float3 v3 = make_float3(mp_vertexXYZ[i_3 * 3], mp_vertexXYZ[i_3 * 3 + 1], mp_vertexXYZ[i_3 * 3 + 2]);

		float3 e12 = v2 - v1;
		float3 e13 = v3 - v1;
		n = cross(e12, e13);
		n /= length(n);
		mp_vertexNorm[i_1 * 3] += n.x;
		mp_vertexNorm[i_1 * 3 + 1] += n.y;
		mp_vertexNorm[i_1 * 3 + 2] += n.z;

		//atomicAdd(&num_tri_per_point[i_1], 1);

		float3 e21 = -e12;
		float3 e23 = v3 - v2;
		n = cross(e23, e21);
		n /= length(n);
		mp_vertexNorm[i_2 * 3] += n.x;
		mp_vertexNorm[i_2 * 3 + 1] += n.y;
		mp_vertexNorm[i_2 * 3 + 2] += n.z;

		//atomicAdd(&num_tri_per_point[i_2], 1);

		float3 e31 = -e13;
		float3 e32 = -e23;
		n = cross(e31, e32);
		n /= length(n);
		mp_vertexNorm[i_3 * 3] += n.x;
		mp_vertexNorm[i_3 * 3 + 1] += n.y;
		mp_vertexNorm[i_3 * 3 + 2] += n.z;
	}
	for (int i = 0; i < m_totalConnectedPoints; i++)
	{
		

		float3 n = make_float3(mp_vertexNorm[i * 3], mp_vertexNorm[i * 3 + 1], mp_vertexNorm[i * 3 + 2]);

		mp_vertexNorm[i * 3] /= length(n); 
		mp_vertexNorm[i * 3 + 1] /= length(n);
		mp_vertexNorm[i * 3 + 2] /= length(n);
	}
	m_vertexVbo = createVBO(m_totalConnectedPoints * 3 * sizeof(float));
	registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource);

	m_indexVBO = createVBO(3 * m_totalFaces * sizeof(uint));
	registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource);

	m_colorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float));
	registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);

	m_NorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float));
	registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource);

	unregisterGLBufferObject(m_cuda_vertexvbo_resource);
	glBindBuffer(GL_ARRAY_BUFFER, m_vertexVbo);
	glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexXYZ);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource);

	unregisterGLBufferObject(m_cuda_indexvbo_resource);
	glBindBuffer(GL_ARRAY_BUFFER, m_indexVBO);
	glBufferSubData(GL_ARRAY_BUFFER, 0, 3 * m_totalFaces * sizeof(uint), FaceVerInd);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource);

	unregisterGLBufferObject(m_cuda_colorvbo_resource);
	glBindBuffer(GL_ARRAY_BUFFER, m_colorVBO);
	glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexRGB);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);



	unregisterGLBufferObject(m_cuda_normalvbo_resource);
	glBindBuffer(GL_ARRAY_BUFFER, m_NorVBO);
	glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexNorm);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource);

	allocateArray((void**)&dRelative_Vertex, m_totalConnectedPoints * 3 * sizeof(float));
	copyArrayToDevice(dRelative_Vertex, Relative_Vertex, 0, m_totalConnectedPoints * 3 * sizeof(float));
	hasMesh = true;
}
Пример #30
0
void kore::Mesh::
createAttributeBuffers(const kore::EMeshBufferType bufferType) {

  if (_attributes.size() == 0) {
    Log::getInstance()->write("[ERROR] Can't create GL buffer objects for Mesh"
                              "%s because it has no loaded attributes!",
                              _name.c_str());
    return;
  }
  glGenVertexArrays(1,&_VAOloc);
  glBindVertexArray(_VAOloc);

  GLuint uVBO;
  glGenBuffers(1, &uVBO);

  // Determine byte-size needed for the VBO
  uint uBufferSizeByte = 0;
  for (uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) {
    MeshAttributeArray& rAttArray = _attributes[iAtt];
    uBufferSizeByte += rAttArray.byteSize *
                      (rAttArray.numValues / rAttArray.numComponents);
  }

  glBindBuffer(GL_ARRAY_BUFFER, uVBO);
  glBufferData(GL_ARRAY_BUFFER,
              (uBufferSizeByte),
               NULL,
               GL_STATIC_DRAW );

  // In case of sequential layout: add all attribute arrays sequentially 
  // into the buffer
  uint byteOffset = 0;
  if (bufferType == BUFFERTYPE_SEQUENTIAL) {
    for (uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) {
      MeshAttributeArray& rAttArray = _attributes[iAtt];
      uint attribArrayByteSize = rAttArray.byteSize *
                               (rAttArray.numValues / rAttArray.numComponents);

      glBufferSubData(GL_ARRAY_BUFFER,
                      byteOffset,
                      attribArrayByteSize,
                      rAttArray.data);

      free(rAttArray.data);  // Delete the attribute-list
      rAttArray.data = reinterpret_cast<void*>(byteOffset);  // Data now has the value of the offset in the 
                           // VBO to this attribute list.
                           // (always 0 for sequential layout)
      rAttArray.stride = 0;
      byteOffset += attribArrayByteSize;
    }
  } else if (bufferType == BUFFERTYPE_INTERLEAVED) {
    uint stride = 0;
    const uint numVertices = _numVertices;
    for (uint iVert = 0; iVert < numVertices; ++iVert) {
      stride = 0;
      for(uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) {
        MeshAttributeArray& rAttArray = _attributes[iAtt];
        stride += rAttArray.byteSize;
        // Calculate the address of the current element.
        // Note: We are assuming that every attribute consists of floats here
        float* pDataPointer = static_cast<float*>(rAttArray.data);
        pDataPointer = &pDataPointer[iVert * rAttArray.numComponents];

        glBufferSubData(GL_ARRAY_BUFFER,
                        byteOffset,
                        rAttArray.byteSize,
                        pDataPointer);
        byteOffset += rAttArray.byteSize;
      }  // End Attributes
    }  // End Vertices

    // Now loop through attributes again to delete the attribute list and set 
    // the correct offset value.
    uint offset = 0;
    for(uint iAtt = 0; iAtt < _attributes.size(); ++iAtt) {
      MeshAttributeArray& rAttArray = _attributes[iAtt];
      free(rAttArray.data);
      rAttArray.data = reinterpret_cast<void*>(offset);
      rAttArray.stride = stride;
      offset += rAttArray.byteSize;
    }
  }  // End Interleaved

  _VBOloc = uVBO;
  glBindBuffer(GL_ARRAY_BUFFER, 0);

  // Load indices into IBO
  if (_indices.size() > 0) {
    GLuint uIBO;
    glGenBuffers(1, &uIBO);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, uIBO);

    // TODO(dlazarek) implement other index-sizes (currently assumung a 
    // byte-size of 4 for each element)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                 _indices.size() * 4,
                 &_indices[0],
                 GL_STATIC_DRAW);
    _IBOloc = uIBO;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  }
}