示例#1
0
文件: texture.c 项目: marioux/Corange
void texture3d_write_to_file(texture* t, char* filename) {

	int t_width;
	int t_height;
	int t_depth;

	glBindTexture(t->type, texture_handle(t));
	glGetTexLevelParameteriv(t->type, 0, GL_TEXTURE_WIDTH, &t_width);
	glGetTexLevelParameteriv(t->type, 0, GL_TEXTURE_HEIGHT, &t_height);
	glGetTexLevelParameteriv(t->type, 0, GL_TEXTURE_DEPTH, &t_depth);

	int width = t_width;
	int height = t_height * t_depth;

	unsigned char* data = malloc(width * height * 4);

	glGetTexImage(t->type, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

	int xa= width % 256;
	int xb= (width-xa)/256;

	int ya= height % 256;
	int yb= (height-ya)/256;
	unsigned char header[18]={0,0,2,0,0,0,0,0,0,0,0,0,(char)xa,(char)xb,(char)ya,(char)yb,32,0};

	SDL_RWops* file = SDL_RWFromFile(filename, "wb");
	SDL_RWwrite(file, header, sizeof(header), 1);
	SDL_RWwrite(file, data, width * height * 4, 1 );
	SDL_RWclose(file);

	free(data);
}
示例#2
0
static void deferred_renderer_use_material(material* mat, shader_program* PROG) {
  
  /* Set material parameters */
  
  int tex_counter = 0;
  
  for(int i = 0; i < mat->keys->num_items; i++) {
    char* key = list_get(mat->keys, i);
    
    int* type = dictionary_get(mat->types, key);
    void* property = dictionary_get(mat->properties, key);
    
    GLint loc = glGetUniformLocation(shader_program_handle(PROG), key);
    
    GLint world_matrix_u = glGetUniformLocation(shader_program_handle(PROG), "world_matrix");
    glUniformMatrix4fv(world_matrix_u, 1, 0, WORLD_MATRIX);
  
    GLint proj_matrix_u = glGetUniformLocation(shader_program_handle(PROG), "proj_matrix");
    glUniformMatrix4fv(proj_matrix_u, 1, 0, PROJ_MATRIX);
    
    GLint view_matrix_u = glGetUniformLocation(shader_program_handle(PROG), "view_matrix");
    glUniformMatrix4fv(view_matrix_u, 1, 0, VIEW_MATRIX);
    
    if (*type == mat_type_texture) {
    
      glUniform1i(loc, tex_counter);
      glActiveTexture(GL_TEXTURE0 + tex_counter);
      glBindTexture(GL_TEXTURE_2D, texture_handle(property));
      tex_counter++;
    
    } else if (*type == mat_type_int) {
      
      glUniform1i(loc, *((int*)property));
    
    } else if (*type == mat_type_float) {
    
      glUniform1f(loc, *((float*)property));
      
    } else if (*type == mat_type_vector2) {
    
      vector2 v = *((vector2*)property);
      glUniform2f(loc, v.x, v.y);
    
    } else if (*type == mat_type_vector3) {
    
      vector3 v = *((vector3*)property);
      glUniform3f(loc, v.x, v.y, v.z);
  
    } else if (*type == mat_type_vector4) {
    
      vector4 v = *((vector4*)property);
      glUniform4f(loc, v.w, v.x, v.y, v.z);
    
    } else {
      /* Do nothing */
    }
     
  }  

}
示例#3
0
文件: texture.c 项目: marioux/Corange
void texture_set_filtering_linear(texture* t) {

	glBindTexture(t->type, texture_handle(t));
	glTexParameteri(t->type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(t->type, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(t->type, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0);

}
示例#4
0
文件: level.c 项目: marioux/Corange
void level_render_tiles(level* l, vec2 camera_position) {

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	glOrtho(camera_position.x - graphics_viewport_width() / 2,
			camera_position.x + graphics_viewport_width() / 2,
			-camera_position.y + graphics_viewport_height() / 2,
			-camera_position.y - graphics_viewport_height() / 2
			, -1, 1);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	glEnable(GL_TEXTURE_2D);

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

	/* Start from 1, 0 is no tiles! */

	for(int i = 1; i < l->num_tile_sets; i++) {

		texture* tile_tex = tile_get_texture(i);
		glBindTexture(GL_TEXTURE_2D, texture_handle(tile_tex));
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glEnableClientState(GL_VERTEX_ARRAY);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);

		glBindBuffer(GL_ARRAY_BUFFER, l->tile_sets[i].positions_buffer);
		glVertexPointer(3, GL_FLOAT, 0, (void*)0);

		glBindBuffer(GL_ARRAY_BUFFER, l->tile_sets[i].texcoords_buffer);
		glTexCoordPointer(2, GL_FLOAT, 0, (void*)0);

		glDrawArrays(GL_QUADS, 0, l->tile_sets[i].num_tiles * 4);

		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
		glDisableClientState(GL_VERTEX_ARRAY);

	}

	glDisable(GL_BLEND);
	glDisable(GL_TEXTURE_2D);

	glMatrixMode(GL_PROJECTION);
	glPopMatrix();

	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

}
示例#5
0
void deferred_renderer_render_light(light* l) {
  
  matrix_4x4 viewm = camera_view_matrix(CAMERA);
  matrix_4x4 projm = camera_proj_matrix(CAMERA, graphics_viewport_ratio() );
  
  vector4 light_pos = v4(l->position.x, l->position.y, l->position.z, 1);
  light_pos = m44_mul_v4(viewm, light_pos);
  light_pos = m44_mul_v4(projm, light_pos);
  
  light_pos = v4_div(light_pos, light_pos.w);
  
  glUseProgram(shader_program_handle(PROGRAM_UI));
  
	glMatrixMode(GL_PROJECTION);
  glPushMatrix();
	glLoadIdentity();
	glOrtho(0, graphics_viewport_width(), graphics_viewport_height(), 0, -1, 1);
  
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
	glLoadIdentity();
  
  float top = ((-light_pos.y + 1) / 2) * graphics_viewport_height() - 8;
  float bot = ((-light_pos.y + 1) / 2) * graphics_viewport_height() + 8;
  float left = ((light_pos.x + 1) / 2) * graphics_viewport_width() - 8;
  float right = ((light_pos.x + 1) / 2) * graphics_viewport_width() + 8;
  
  texture* lightbulb = asset_load_get("$CORANGE/ui/lightbulb.dds");
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, texture_handle(lightbulb));
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(shader_program_handle(PROGRAM_UI), "diffuse"), 0);
  
  glUniform1f(glGetUniformLocation(shader_program_handle(PROGRAM_UI), "alpha_test"), 0.5);
  
	glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(left, top, -light_pos.z);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(left,  bot, -light_pos.z);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(right,  bot, -light_pos.z);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(right, top, -light_pos.z);
	glEnd();
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();

  glUseProgram(0);

}
示例#6
0
文件: texture.c 项目: marioux/Corange
void texture_set_filtering_anisotropic(texture* t) {

	float max = 0;
	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max);

	glBindTexture(t->type, texture_handle(t));
	glTexParameteri(t->type, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(t->type, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(t->type, GL_TEXTURE_MAX_ANISOTROPY_EXT, max);

}
示例#7
0
void shader_program_set_texture(shader_program* p, char* name, int index, asset_hndl t) {

    GLint location = glGetUniformLocation(shader_program_handle(p), name);
    if ( location == -1) {
        warning("Shader has no uniform called '%s'", name);
    } else {
        glActiveTexture(GL_TEXTURE0 + index);
        glBindTexture(texture_type(asset_hndl_ptr(&t)), texture_handle(asset_hndl_ptr(&t)));
        glUniform1i(location, index);
    }

}
示例#8
0
文件: noise.c 项目: yanbin-ha/Corange
static void noise_render() {

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();

    material* noise_mat = asset_get(P("./noise.mat"));

    GLuint handle = shader_program_handle(material_get_entry(noise_mat, 0)->program);
    GLuint random_tex = texture_handle(asset_get(P("$CORANGE/textures/random.dds")));

    glUseProgram(handle);

    glActiveTexture(GL_TEXTURE0 + 0 );
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, random_tex);
    glUniform1i(glGetUniformLocation(handle, "noise_texture"), 0);

    glUniform1f(glGetUniformLocation(handle, "time"), shader_time);

    glBegin(GL_QUADS);
    glTexCoord2f(0.0f, 0.0f);
    glVertex3f(-1.0, -1.0,  0.0f);
    glTexCoord2f(1.0f, 0.0f);
    glVertex3f(1.0, -1.0,  0.0f);
    glTexCoord2f(1.0f, 1.0f);
    glVertex3f(1.0,  1.0,  0.0f);
    glTexCoord2f(0.0f, 1.0f);
    glVertex3f(-1.0,  1.0,  0.0f);
    glEnd();

    glActiveTexture(GL_TEXTURE0 + 0 );
    glDisable(GL_TEXTURE_2D);

    glMatrixMode(GL_PROJECTION);
    glPopMatrix();

    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();

    glUseProgram(0);

}
示例#9
0
文件: texture.c 项目: marioux/Corange
texture* bmp_load_file( char* filename ) {

	image* i = image_bmp_load_file(filename);

	texture* t = texture_new();
	glBindTexture(GL_TEXTURE_2D, texture_handle(t));
	glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE );
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0 );

	texture_set_image(t, i);
	texture_set_filtering_anisotropic(t);

	image_delete(i);

	return t;
}
示例#10
0
void coin_render(coin* c, vec2 camera_position) {

	glMatrixMode(GL_PROJECTION);
  glPushMatrix();
	glLoadIdentity();
	glOrtho(camera_position.x - graphics_viewport_width() / 2, 
          camera_position.x + graphics_viewport_width() / 2,
          -camera_position.y + graphics_viewport_height() / 2,
          -camera_position.y - graphics_viewport_height() / 2
          , 0, 1);
  
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
	glLoadIdentity();
  
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
  glEnable(GL_TEXTURE_2D);
  
  texture* coin_tex = asset_get(P("./tiles/coin.dds"));
  glBindTexture(GL_TEXTURE_2D, texture_handle(coin_tex));
  
  glBegin(GL_QUADS);
    
    glTexCoord2f(0, 1); glVertex3f(c->position.x, c->position.y + 32, 0);
    glTexCoord2f(1, 1); glVertex3f(c->position.x + 32, c->position.y + 32, 0);
    glTexCoord2f(1, 0); glVertex3f(c->position.x + 32, c->position.y, 0);
    glTexCoord2f(0, 0); glVertex3f(c->position.x, c->position.y, 0);
    
  glEnd();
  
  glDisable(GL_TEXTURE_2D);
  
  glDisable(GL_BLEND);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  
	glMatrixMode(GL_MODELVIEW);
  glPopMatrix();

}
示例#11
0
文件: level.c 项目: marioux/Corange
void level_render_background(level* l) {

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();
	glOrtho(0, graphics_viewport_width(), 0, graphics_viewport_height(), -1, 1);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	glEnable(GL_TEXTURE_2D);

	texture* background = asset_get_load(P("./backgrounds/bluesky.dds"));
	glBindTexture(GL_TEXTURE_2D, texture_handle(background));

	glBegin(GL_QUADS);

	glVertex3f(0, graphics_viewport_height(), 0.0);
	glTexCoord2f(1, 0);
	glVertex3f(graphics_viewport_width(), graphics_viewport_height(), 0.0);
	glTexCoord2f(1, 1);
	glVertex3f(graphics_viewport_width(), 0, 0.0);
	glTexCoord2f(0, 1);
	glVertex3f(0, 0, 0.0);
	glTexCoord2f(0, 0);

	glEnd();

	glDisable(GL_TEXTURE_2D);

	glMatrixMode(GL_PROJECTION);
	glPopMatrix();

	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

}
示例#12
0
文件: texture.c 项目: marioux/Corange
texture* lut_load_file( char* filename ) {

	SDL_RWops* file = SDL_RWFromFile(filename, "r");
	if(file == NULL) {
		error("Cannot load file %s", filename);
	}

	long size = SDL_RWseek(file,0,SEEK_END);
	unsigned char* contents = malloc(size+1);
	contents[size] = '\0';
	SDL_RWseek(file, 0, SEEK_SET);
	SDL_RWread(file, contents, size, 1);

	SDL_RWclose(file);

	int head = sizeof("CORANGE-LUT")-1;
	int lut_size = (unsigned char)contents[head] | (unsigned char)contents[head + 1];

	int offset = head + 3;

	texture* t = texture_new();
	t->type = GL_TEXTURE_3D;

	glBindTexture(t->type, texture_handle(t));
	glTexImage3D(t->type, 0, GL_RGB, lut_size, lut_size, lut_size, 0, GL_RGB, GL_UNSIGNED_BYTE, contents + offset);
	glTexParameteri(t->type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(t->type, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(t->type, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
	glTexParameteri(t->type, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
	glTexParameteri(t->type, GL_TEXTURE_WRAP_R, GL_MIRRORED_REPEAT);

	free(contents);

	return t;

}
示例#13
0
文件: texture.c 项目: marioux/Corange
image* texture_get_image(texture* t) {

	int width = 0;
	int height = 0;
	int format = 0;

	glBindTexture(GL_TEXTURE_2D, texture_handle(t));
	glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
	glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
	glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format);

	if ((width == 0) || (height == 0)) {
		error("Texture has zero size width/height: (%i, %i)", width, height);
	}

	unsigned char* data = malloc(width * height * 4);
	float* data_flt;
	unsigned int* data_int;

	switch (format) {

		case GL_RGBA:
		case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
			glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
			break;

		case GL_ALPHA16:

			data_flt = malloc(sizeof(float) * width * height);
			glGetTexImage(GL_TEXTURE_2D, 0, GL_ALPHA, GL_FLOAT, data_flt);

			for(int x = 0; x < width; x++)
				for(int y = 0; y < height; y++) {
					data[(y*4*width) + (x*4) + 0] = pow(data_flt[(y*width) + x], 256.0) * 255;
					data[(y*4*width) + (x*4) + 1] = pow(data_flt[(y*width) + x], 256.0) * 255;
					data[(y*4*width) + (x*4) + 2] = pow(data_flt[(y*width) + x], 256.0) * 255;
					data[(y*4*width) + (x*4) + 3] = pow(data_flt[(y*width) + x], 256.0) * 255;
				}

			free(data_flt);

			break;

		case GL_RGBA32F:
		case GL_RGBA16F:

			data_flt = malloc(4 * sizeof(float) * width * height);
			glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, data_flt);

			for(int x = 0; x < width; x++)
				for(int y = 0; y < height; y++) {
					data[(y*4*width) + (x*4) + 0] = clamp(data_flt[(y*4*width) + (x*4) + 0] * 127 + 127, 0, 255);
					data[(y*4*width) + (x*4) + 1] = clamp(data_flt[(y*4*width) + (x*4) + 1] * 127 + 127, 0, 255);
					data[(y*4*width) + (x*4) + 2] = clamp(data_flt[(y*4*width) + (x*4) + 2] * 127 + 127, 0, 255);
					data[(y*4*width) + (x*4) + 3] = clamp(data_flt[(y*4*width) + (x*4) + 3] * 127 + 127, 0, 255);
				}

			free(data_flt);

			break;

		case GL_DEPTH_COMPONENT:
		case GL_DEPTH_COMPONENT24:

			data_int = malloc(sizeof(unsigned int) * width * height);
			glGetTexImage(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, data_int);

			for(int x = 0; x < width; x++)
				for(int y = 0; y < height; y++) {
					data[(y*4*width) + (x*4) + 0] = data_int[(y*width) + x];
					data[(y*4*width) + (x*4) + 1] = data_int[(y*width) + x];
					data[(y*4*width) + (x*4) + 2] = data_int[(y*width) + x];
					data[(y*4*width) + (x*4) + 3] = data_int[(y*width) + x];
				}

			free(data_int);

			break;

		default:
			error("Can't convert that particular texture format %i to an image.", format);

	}

	SDL_GL_CheckError();

	image* i = image_new(width, height, data);

	free(data);

	return i;
}
示例#14
0
文件: texture.c 项目: marioux/Corange
texture* dds_load_file( char* filename ) {

	DdsLoadInfo loadInfoDXT1 =   { true,  false, false, 4, 8,  GL_COMPRESSED_RGBA_S3TC_DXT1 };
	DdsLoadInfo loadInfoDXT3 =   { true,  false, false, 4, 16, GL_COMPRESSED_RGBA_S3TC_DXT3 };
	DdsLoadInfo loadInfoDXT5 =   { true,  false, false, 4, 16, GL_COMPRESSED_RGBA_S3TC_DXT5 };
	DdsLoadInfo loadInfoBGRA8 =  { false, false, false, 1, 4,  GL_RGBA8,   GL_BGRA, GL_UNSIGNED_BYTE };
	DdsLoadInfo loadInfoBGR8 =   { false, false, false, 1, 3,  GL_RGB8,    GL_BGR,  GL_UNSIGNED_BYTE };
	DdsLoadInfo loadInfoBGR5A1 = { false, true,  false, 1, 2,  GL_RGB5_A1, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV };
	DdsLoadInfo loadInfoBGR565 = { false, true,  false, 1, 2,  GL_RGB5,    GL_RGB,  GL_UNSIGNED_SHORT_5_6_5 };
	DdsLoadInfo loadInfoIndex8 = { false, false, true,  1, 1,  GL_RGB8,    GL_BGRA, GL_UNSIGNED_BYTE };

	SDL_RWops* f = SDL_RWFromFile(filename, "rb");

	if (f == NULL) {
		error("Cannot load file %s", filename);
	}

	DDS_header hdr;
	SDL_RWread(f, &hdr, 1, sizeof(DDS_header));

	if( hdr.dwMagic != DDS_MAGIC || hdr.dwSize != 124 ||
			!(hdr.dwFlags & DDSD_PIXELFORMAT) || !(hdr.dwFlags & DDSD_CAPS) ) {
		error("Cannot Load File %s: Does not appear to be a .dds file.\n", filename);
	}

	int x = hdr.dwWidth;
	int y = hdr.dwHeight;
	int mip_map_num = (hdr.dwFlags & DDSD_MIPMAPCOUNT) ? hdr.dwMipMapCount : 1;

	if (!is_power_of_two(x)) { error("Texture %s with is %i pixels which is not a power of two!", filename, x); }
	if (!is_power_of_two(y)) { error("Texture %s height is %i pixels which is not a power of two!", filename, y); }

	DdsLoadInfo* li = &loadInfoDXT1;
	if      (PF_IS_DXT1(hdr.sPixelFormat  )) { li = &loadInfoDXT1;   }
	else if (PF_IS_DXT3(hdr.sPixelFormat  )) { li = &loadInfoDXT3;   }
	else if (PF_IS_DXT5(hdr.sPixelFormat  )) { li = &loadInfoDXT5;   }
	else if (PF_IS_BGRA8(hdr.sPixelFormat )) { li = &loadInfoBGRA8;  }
	else if (PF_IS_BGR8(hdr.sPixelFormat  )) { li = &loadInfoBGR8;   }
	else if (PF_IS_BGR5A1(hdr.sPixelFormat)) { li = &loadInfoBGR5A1; }
	else if (PF_IS_BGR565(hdr.sPixelFormat)) { li = &loadInfoBGR565; }
	else if (PF_IS_INDEX8(hdr.sPixelFormat)) { li = &loadInfoIndex8; }
	else { error("Cannot Load File %s: Unknown DDS File format type.", filename); }

	texture* t = texture_new();

	if (hdr.sCaps.dwCaps2 & DDSCAPS2_CUBEMAP) {
		t->type = GL_TEXTURE_CUBE_MAP;
		glBindTexture(GL_TEXTURE_CUBE_MAP, texture_handle(t));
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_GENERATE_MIPMAP, GL_FALSE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, 0);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, mip_map_num-1);
	} else {
		t->type = GL_TEXTURE_2D;
		glBindTexture(GL_TEXTURE_2D, texture_handle(t));
		glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mip_map_num-1);
		texture_set_filtering_anisotropic(t);
	}

	for (int i = 0; i < (t->type == GL_TEXTURE_CUBE_MAP ? 6 : 1); i++) {
		GLenum target = t->type;

		if (t->type == GL_TEXTURE_CUBE_MAP) {
			target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
		}

		int x = hdr.dwWidth;
		int y = hdr.dwHeight;
		int mip_map_num = (hdr.dwFlags & DDSD_MIPMAPCOUNT) ? hdr.dwMipMapCount : 1;

		if ( li->compressed ) {

			size_t size = max(li->div_size, x) / li->div_size * max(li->div_size, y) / li->div_size * li->block_bytes;
			char* data = malloc(size);

			for(int ix = 0; ix < mip_map_num; ix++) {

				SDL_RWread(f, data, 1, size);
				glCompressedTexImage2D(target, ix, li->internal_format, x, y, 0, size, data);

				x = (x+1)>>1;
				y = (y+1)>>1;

				size = max(li->div_size, x) / li->div_size * max(li->div_size, y) / li->div_size * li->block_bytes;
			}
			free(data);
		} else if ( li->palette ) {
示例#15
0
文件: texture.c 项目: marioux/Corange
void texture_set_image(texture* t, image* i) {
	glBindTexture(GL_TEXTURE_2D, texture_handle(t));
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, i->width, i->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, i->data );
}
示例#16
0
void deferred_renderer_end() {
  
  glDisable(GL_DEPTH_TEST);
  glDisable(GL_CULL_FACE);
  
  /* Render out ssao */
  
  glBindFramebuffer(GL_FRAMEBUFFER, ssao_fbo);
  
  glViewport(0, 0, graphics_viewport_width() / 2, graphics_viewport_height() / 2);
  
  GLuint ssao_handle = shader_program_handle(PROGRAM_SSAO);
  glUseProgram(ssao_handle);
  
	glMatrixMode(GL_PROJECTION);
  glPushMatrix();
	glLoadIdentity();
	glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
  
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
	glLoadIdentity();
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, depth_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(ssao_handle, "depth_texture"), 0);
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glBindTexture(GL_TEXTURE_2D, texture_handle(RANDOM));
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(ssao_handle, "random_texture"), 1);
  
  float seed = CAMERA->position.x + CAMERA->position.y + CAMERA->position.z;
  glUniform1f(glGetUniformLocation(ssao_handle, "seed"), seed);
  
	glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0,  1.0,  0.0f);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0,  1.0,  0.0f);
	glEnd();
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  
  /* End */
  
  /* Render full screen quad to hdr fbo */
  
  glBindFramebuffer(GL_FRAMEBUFFER, hdr_fbo);
  
  glViewport(0, 0, graphics_viewport_width(), graphics_viewport_height());
  
  GLuint screen_handle = shader_program_handle(PROGRAM_COMPOSE);
  glUseProgram(screen_handle);
  
	glMatrixMode(GL_PROJECTION);
  glPushMatrix();
	glLoadIdentity();
	glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
  
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
	glLoadIdentity();
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, diffuse_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "diffuse_texture"), 0);
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glBindTexture(GL_TEXTURE_2D, positions_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "positions_texture"), 1);
  
  glActiveTexture(GL_TEXTURE0 + 2 );
  glBindTexture(GL_TEXTURE_2D, normals_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "normals_texture"), 2);
  
  glActiveTexture(GL_TEXTURE0 + 3 );
  glBindTexture(GL_TEXTURE_2D, depth_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "depth_texture"), 3);
  
  glActiveTexture(GL_TEXTURE0 + 4 );
  glBindTexture(GL_TEXTURE_2D, texture_handle(SHADOW_TEX));
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "shadows_texture"), 4);
  
  glActiveTexture(GL_TEXTURE0 + 5 );
  glBindTexture(GL_TEXTURE_2D, ssao_texture);
  glEnable(GL_TEXTURE_2D);
  glGenerateMipmap(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "ssao_texture"), 5);
  
  glActiveTexture(GL_TEXTURE0 + 6 );
  glBindTexture(GL_TEXTURE_2D, texture_handle(ENVIRONMENT));
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_handle, "env_texture"), 6);
  
  GLint cam_position = glGetUniformLocation(screen_handle, "camera_position");
  glUniform3f(cam_position, CAMERA->position.x, CAMERA->position.y, CAMERA->position.z);
  
  GLint lproj_matrix_u = glGetUniformLocation(screen_handle, "light_proj");
  glUniformMatrix4fv(lproj_matrix_u, 1, 0, LIGHT_PROJ_MATRIX);
  
  GLint lview_matrix_u = glGetUniformLocation(screen_handle, "light_view");
  glUniformMatrix4fv(lview_matrix_u, 1, 0, LIGHT_VIEW_MATRIX);
  
  for(int i = 0; i < num_lights; i++) {
    light_power[i] = lights[i]->power;
    light_falloff[i] = lights[i]->falloff;
    light_position[i] = lights[i]->position;
    light_target[i] = lights[i]->target;
    light_diffuse[i] = lights[i]->diffuse_color;
    light_ambient[i] = lights[i]->ambient_color;
    light_specular[i] = lights[i]->specular_color;
  }
  
  glUniform1i(glGetUniformLocation(screen_handle, "num_lights"), num_lights);
  
  GLint light_power_u = glGetUniformLocation(screen_handle, "light_power");
  GLint light_falloff_u = glGetUniformLocation(screen_handle, "light_falloff");
  GLint light_position_u = glGetUniformLocation(screen_handle, "light_position");
  GLint light_target_u = glGetUniformLocation(screen_handle, "light_target");
  GLint light_diffuse_u = glGetUniformLocation(screen_handle, "light_diffuse");
  GLint light_ambient_u = glGetUniformLocation(screen_handle, "light_ambient");
  GLint light_specular_u = glGetUniformLocation(screen_handle, "light_specular");
  
  glUniform1fv(light_power_u, num_lights, (const GLfloat*)light_power);
  glUniform1fv(light_falloff_u, num_lights, (const GLfloat*)light_falloff);
  glUniform3fv(light_position_u, num_lights, (const GLfloat*)light_position);
  glUniform3fv(light_target_u, num_lights, (const GLfloat*)light_target);
  glUniform3fv(light_diffuse_u, num_lights, (const GLfloat*)light_diffuse);
  glUniform3fv(light_ambient_u, num_lights, (const GLfloat*)light_ambient);
  glUniform3fv(light_specular_u, num_lights, (const GLfloat*)light_specular);
  
	glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0,  1.0,  0.0f);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0,  1.0,  0.0f);
	glEnd();
  
  glActiveTexture(GL_TEXTURE0 + 6 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 5 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 4 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 3 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 2 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  
  glUseProgram(0);

  /* Render HDR to LDR buffer */
  
  glBindFramebuffer(GL_FRAMEBUFFER, ldr_fbo);
  
  GLuint screen_tonemap_handle = shader_program_handle(PROGRAM_TONEMAP);
  glUseProgram(screen_tonemap_handle);
  
	glMatrixMode(GL_PROJECTION);
  glPushMatrix();
	glLoadIdentity();
	glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
  
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
	glLoadIdentity();
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, hdr_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_tonemap_handle, "hdr_texture"), 0);

  glUniform1f(glGetUniformLocation(screen_tonemap_handle, "exposure"), EXPOSURE);
  
	glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0,  1.0,  0.0f);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0,  1.0,  0.0f);
	glEnd();
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  
  glUseProgram(0);
  
  /* Generate Mipmaps, adjust exposure */
  
  unsigned char color[4] = {0,0,0,0};
  int level = -1;
  int width = 0;
  int height = 0;
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, ldr_texture);
  glEnable(GL_TEXTURE_2D);
  
  glGenerateMipmap(GL_TEXTURE_2D);
  
  do {
    level++;
    glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
    glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &height);
    
    if (level > 50) { error("Unable to find lowest mip level. Perhaps mipmaps were not generated"); }
    
  } while ((width > 1) || (height > 1));
  
  glGetTexImage(GL_TEXTURE_2D, level, GL_RGBA, GL_UNSIGNED_BYTE, color);
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  float average = (float)(color[0] + color[1] + color[2]) / (3.0 * 255.0);
  
  EXPOSURE += (EXPOSURE_TARGET - average) * EXPOSURE_SPEED;
  
  /* Render final frame */
  
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  
  GLuint screen_post_handle = shader_program_handle(PROGRAM_POST);
  glUseProgram(screen_post_handle);
  
	glMatrixMode(GL_PROJECTION);
  glPushMatrix();
	glLoadIdentity();
	glOrtho(-1.0, 1.0, -1.0, 1.0, -1, 1);
  
	glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
	glLoadIdentity();
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, ldr_texture);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_post_handle, "diffuse_texture"), 0);
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glBindTexture(GL_TEXTURE_2D, texture_handle(VIGNETTING));
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(screen_post_handle, "vignetting_texture"), 1);
  
  glActiveTexture(GL_TEXTURE0 + 2 );
  glBindTexture(GL_TEXTURE_3D, texture_handle(COLOR_CORRECTION));
  glEnable(GL_TEXTURE_3D);
  glUniform1i(glGetUniformLocation(screen_post_handle, "lut"), 2);
  
  glUniform1i(glGetUniformLocation(screen_post_handle, "width"), graphics_viewport_width());
  glUniform1i(glGetUniformLocation(screen_post_handle, "height"), graphics_viewport_height());
  glUniform1i(glGetUniformLocation(screen_post_handle, "aa_type"), 1);
  
	glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0, -1.0,  0.0f);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0,  1.0,  0.0f);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0,  1.0,  0.0f);
	glEnd();
  
  glActiveTexture(GL_TEXTURE0 + 2 );
  glDisable(GL_TEXTURE_3D);
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
  
  glUseProgram(0);
  
}
示例#17
0
文件: texture.c 项目: marioux/Corange
void texture_generate_mipmaps(texture* t) {

	glBindTexture(t->type, texture_handle(t));
	glGenerateMipmap(t->type);

}