Jump to content
  • Advertisement
Sign in to follow this  
VitaliBR

OpenGL Texture in all?

This topic is 2903 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

I have a very strange error, I looked on google and here on GameDev about on it. But unsuccessfully.

When I start loading a texture (. Tag), before you even apply in a polygon (GL_QUADS), this texture is already applied to it by the coordinates passed (glTexCoord2f) and modify the colors of other polygons.

tgaload.h

/* Definitions for bitflags */
typedef unsigned int tgaFLAG;

#define TGA_DEFAULT 0x0000000000000000 /* In case we don't want any parameters */
#define TGA_FREE 0x0000000000000001 /* Bit flag 0 */
#define TGA_NO_PASS 0x0000000000000010 /* Bit flag 1 */
#define TGA_ALPHA 0x0000000000000100 /* Bit flag 2 */
#define TGA_LUMINANCE 0x0000000000001000 /* Bit flag 3 */
#define TGA_NO_MIPMAPS 0x0000000000010000 /* Bit flag 4 */
#define TGA_LOW_QUALITY 0x0000000000100000 /* Bit flag 5 */
#define TGA_COMPRESS 0x0000000001000000 /* Bit flag 6 */


/*
** GL_ARB_texture_compression
**
** Support:
** GeForce
** Radeon
** ???? <- Any suggestions?
*/

#ifndef GL_ARB_texture_compression
#define GL_ARB_texture_compression 1

#define GL_COMPRESSED_ALPHA_ARB 0x84E9
#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA
#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
#define GL_COMPRESSED_INTENSITY_ARB 0x84EC
#define GL_COMPRESSED_RGB_ARB 0x84ED
#define GL_COMPRESSED_RGBA_ARB 0x84EE
#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF
#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0
#define GL_TEXTURE_COMPRESSED_ARB 0x86A1
#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3

typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)(GLenum target, GLint level,
GLenum internalFormat, GLsizei width,
GLsizei height, GLsizei depth,
GLint border, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)(GLenum target, GLint level,
GLenum internalFormat, GLsizei width,
GLsizei height, GLint border,
GLsizei imageSize, const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)(GLenum target, GLint level,
GLenum internalFormat, GLsizei width,
GLint border, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLint zoffset, GLsizei width,
GLsizei height, GLsizei depth,
GLenum format, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)(GLenum target, GLint level,
GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height,
GLenum format, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)(GLenum target, GLint level,
GLint xoffset, GLsizei width,
GLenum format, GLsizei imageSize,
const GLvoid *data);
typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)(GLenum target, GLint lod,
GLvoid *img);


#endif /* GL_ARB_texture_compression */



typedef struct {
unsigned char id_length;
unsigned char colour_map_type;
unsigned char image_type;

// colourmap spec. 5 bytes
short int colour_map_first_entry; // Ignore
short int colour_map_length; // Usually 256
unsigned char colour_map_entry_size; // Usually 24-bit

// image spec. 10 bytes
short int x_origin; // Ignore
short int y_origin; // Ignore
short int width;
short int height;
unsigned char pixel_depth; // Usually 24 or 32
unsigned char image_descriptor; // Ignore

// Added for 'compeletness' :)
int components;
int bytes;

GLenum tgaColourType;

} tgaHeader_t;


typedef struct {
tgaHeader_t info;
unsigned char *data; /* Image data */
} image_t;


/* 'Public' functions */
void tgaLoad ( char *file_name, image_t *p, tgaFLAG mode );
GLuint tgaLoadAndBind ( char *file_name, tgaFLAG mode );

void tgaSetTexParams ( unsigned int min_filter, unsigned int mag_filter, unsigned int application );

void tgaFree ( image_t *p );







tgaload.cpp

/*
...

From: http://nehe.gamedev.net

Aug 19th:
Added support for runlength encoding - changed some stuff around to make this
possible. Works well :)

Sept 7th:
Improved error trapping and recovery.

Oct 22nd:
Major source clearout & Can compress the image using S3_TC algorithm if the
driver supports it.

Nov 10th:
'Settled' version of the code - traps for nearly all errors - added a
LoadAndBind function for even lazier people :)
TGA_NO_PASS was added in case you need to load an image and pass it yourself.
Finally exorcised all the paletted texture code...
*/


#include <windows.h>
#include <GL\glu.h>
#include <stdio.h>
#include <stdlib.h>
#include "tgaload.h"

/* Extension Management */
PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB = NULL;
PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB = NULL;

/* Default support - lets be optimistic! */
bool tgaCompressedTexSupport = true;


void tgaGetExtensions ( void )
{
glCompressedTexImage2DARB = ( PFNGLCOMPRESSEDTEXIMAGE2DARBPROC )
wglGetProcAddress ( "glCompressedTexImage2DARB" );
glGetCompressedTexImageARB = ( PFNGLGETCOMPRESSEDTEXIMAGEARBPROC )
wglGetProcAddress ( "glGetCompressedTexImageARB" );

if ( glCompressedTexImage2DARB == NULL || glGetCompressedTexImageARB == NULL )
tgaCompressedTexSupport = false;
}


void tgaSetTexParams ( unsigned int min_filter, unsigned int mag_filter, unsigned int application )
{
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter );

glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, application );
}


unsigned char *tgaAllocMem ( tgaHeader_t info )
{
unsigned char *block;

block = (unsigned char*) malloc ( info.bytes );

if ( block == NULL )
return 0;

memset ( block, 0x00, info.bytes );

return block;
}

void tgaPutPacketTuples ( image_t *p, unsigned char *temp_colour, int &current_byte )
{
if ( p->info.components == 3 )
{
p->data[current_byte] = temp_colour[2];
p->data[current_byte+1] = temp_colour[1];
p->data[current_byte+2] = temp_colour[0];
current_byte += 3;
}

if ( p->info.components == 4 ) // Because its BGR(A) not (A)BGR :(
{
p->data[current_byte] = temp_colour[2];
p->data[current_byte+1] = temp_colour[1];
p->data[current_byte+2] = temp_colour[0];
p->data[current_byte+3] = temp_colour[3];
current_byte += 4;
}
}


void tgaGetAPacket ( int &current_byte, image_t *p, FILE *file )
{
unsigned char packet_header;
int run_length;
unsigned char temp_colour[4] = { 0x00, 0x00, 0x00, 0x00 };

fread ( &packet_header, ( sizeof ( unsigned char )), 1, file );
run_length = ( packet_header&0x7F ) + 1;

if ( packet_header&0x80 ) // RLE packet
{
fread ( temp_colour, ( sizeof ( unsigned char )* p->info.components ), 1, file );

if ( p->info.components == 1 ) // Special optimised case :)
{
memset ( p->data + current_byte, temp_colour[0], run_length );
current_byte += run_length;
} else
for ( int i = 0; i < run_length; i++ )
tgaPutPacketTuples ( p, temp_colour, current_byte );
}

if ( !( packet_header&0x80 )) // RAW packet
{
for ( int i = 0; i < run_length; i++ )
{
fread ( temp_colour, ( sizeof ( unsigned char )* p->info.components ), 1, file );

if ( p->info.components == 1 )
{
memset ( p->data + current_byte, temp_colour[0], run_length );
current_byte += run_length;
} else
tgaPutPacketTuples ( p, temp_colour, current_byte );
}
}
}


void tgaGetPackets ( image_t *p, FILE *file )
{
int current_byte = 0;

while ( current_byte < p->info.bytes )
tgaGetAPacket ( current_byte, p, file );
}


void tgaGetImageData ( image_t *p, FILE *file )
{
unsigned char temp;

p->data = tgaAllocMem ( p->info );

/* Easy unRLE image */
if ( p->info.image_type == 1 || p->info.image_type == 2 || p->info.image_type == 3 )
{
fread ( p->data, sizeof (unsigned char), p->info.bytes, file );

/* Image is stored as BGR(A), make it RGB(A) */
for (int i = 0; i < p->info.bytes; i += p->info.components )
{
temp = p->data;
p->data = p->data[i + 2];
p->data[i + 2] = temp;
}
}

/* RLE compressed image */
if ( p->info.image_type == 9 || p->info.image_type == 10 )
tgaGetPackets ( p, file );
}


void tgaUploadImage ( image_t *p, tgaFLAG mode )
{
/* Determine TGA_LOWQUALITY internal format
This directs OpenGL to upload the textures at half the bit
precision - saving memory
*/

GLenum internal_format = p->info.tgaColourType;

if ( mode&TGA_LOW_QUALITY )
{
switch ( p->info.tgaColourType )
{
case GL_RGB : internal_format = GL_RGB4; break;
case GL_RGBA : internal_format = GL_RGBA4; break;
case GL_LUMINANCE : internal_format = GL_LUMINANCE4; break;
case GL_ALPHA : internal_format = GL_ALPHA4; break;
}
}

/* Let OpenGL decide what the best compressed format is each case. */
if ( mode&TGA_COMPRESS && tgaCompressedTexSupport )
{
switch ( p->info.tgaColourType )
{
case GL_RGB : internal_format = GL_COMPRESSED_RGB_ARB; break;
case GL_RGBA : internal_format = GL_COMPRESSED_RGBA_ARB; break;
case GL_LUMINANCE : internal_format = GL_COMPRESSED_LUMINANCE_ARB; break;
case GL_ALPHA : internal_format = GL_COMPRESSED_ALPHA_ARB; break;
}
}

/* Pass OpenGL Texture Image */
if ( !( mode&TGA_NO_MIPMAPS ))
gluBuild2DMipmaps ( GL_TEXTURE_2D, internal_format, p->info.width,
p->info.height, p->info.tgaColourType, GL_UNSIGNED_BYTE, p->data );
else
glTexImage2D ( GL_TEXTURE_2D, 0, internal_format, p->info.width,
p->info.height, 0, p->info.tgaColourType, GL_UNSIGNED_BYTE, p->data );
}


void tgaFree ( image_t *p )
{
if ( p->data != NULL )
free ( p->data );
}


void tgaChecker ( image_t *p )
{
unsigned char TGA_CHECKER[16384];
unsigned char *pointer;

// 8bit image
p->info.image_type = 3;

p->info.width = 128;
p->info.height = 128;

p->info.pixel_depth = 8;

// Set some stats
p->info.components = 1;
p->info.bytes = p->info.width * p->info.height * p->info.components;

pointer = TGA_CHECKER;

for ( int j = 0; j < 128; j++ )
{
for ( int i = 0; i < 128; i++ )
{
if ((i ^ j) & 0x10 )
pointer[0] = 0x00;
else
pointer[0] = 0xff;
pointer ++;
}
}

p->data = TGA_CHECKER;

glTexImage2D ( GL_TEXTURE_2D, 0, GL_LUMINANCE4, p->info.width,
p->info.height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, p->data );

/* Should we free? I dunno. The scope of TGA_CHECKER _should_ be local, so it
probably gets destroyed automatically when the function completes... */

// tgaFree ( p );
}


void tgaError ( char *error_string, char *file_name, FILE *file, image_t *p )
{
printf ( "%s - %s\n", error_string, file_name );
tgaFree ( p );

fclose ( file );

tgaChecker ( p );
}


void tgaGetImageHeader ( FILE *file, tgaHeader_t *info )
{
/* Stupid byte alignment means that we have to fread each field
individually. I tried splitting tgaHeader into 3 structures, no matter
how you arrange them, colour_map_entry_size comes out as 2 bytes instead
1 as it should be. Grrr. Gotta love optimising compilers - theres a pragma
for Borland, but I dunno the number for MSVC or GCC :(
*/

fread ( &info->id_length, ( sizeof (unsigned char )), 1, file );
fread ( &info->colour_map_type, ( sizeof (unsigned char )), 1, file );
fread ( &info->image_type, ( sizeof (unsigned char )), 1, file );

fread ( &info->colour_map_first_entry, ( sizeof (short int )), 1, file );
fread ( &info->colour_map_length , ( sizeof (short int )), 1, file );
fread ( &info->colour_map_entry_size , ( sizeof (unsigned char )), 1, file );

fread ( &info->x_origin , ( sizeof (short int )), 1, file );
fread ( &info->y_origin , ( sizeof (short int )), 1, file );
fread ( &info->width, ( sizeof (short int )), 1, file );
fread ( &info->height, ( sizeof (short int )), 1, file );

fread ( &info->pixel_depth, ( sizeof (unsigned char )), 1, file );
fread ( &info->image_descriptor,( sizeof (unsigned char )), 1, file );

// Set some stats
info->components = info->pixel_depth / 8;
info->bytes = info->width * info->height * info->components;
}

int tgaLoadTheImage ( char *file_name, image_t *p, tgaFLAG mode )
{
FILE *file;

tgaGetExtensions ( );

p->data = NULL;

if (( file = fopen ( file_name, "rb" )) == NULL )
{
tgaError ( "File not found", file_name, file, p );
return 0;
}

tgaGetImageHeader ( file, &p->info );

switch ( p->info.image_type )
{
case 1 :
tgaError ( "8-bit colour no longer supported", file_name, file, p );
return 0;

case 2 :
if ( p->info.pixel_depth == 24 )
p->info.tgaColourType = GL_RGB;
else if ( p->info.pixel_depth == 32 )
p->info.tgaColourType = GL_RGBA;
else
{
tgaError ( "Unsupported RGB format", file_name, file, p );
return 0;
}
break;

case 3 :
if ( mode&TGA_LUMINANCE )
p->info.tgaColourType = GL_LUMINANCE;
else if ( mode&TGA_ALPHA )
p->info.tgaColourType = GL_ALPHA;
else
{
tgaError ( "Must be LUMINANCE or ALPHA greyscale", file_name, file, p );
return 0;
}
break;

case 9 :
tgaError ( "8-bit colour no longer supported", file_name, file, p );
return 0;

case 10 :
if ( p->info.pixel_depth == 24 )
p->info.tgaColourType = GL_RGB;
else if ( p->info.pixel_depth == 32 )
p->info.tgaColourType = GL_RGBA;
else
{
tgaError ( "Unsupported compressed RGB format", file_name, file, p );
return 0;
}
}

tgaGetImageData ( p, file );

fclose ( file );

return 1;
}

void tgaLoad ( char *file_name, image_t *p, tgaFLAG mode )
{
if ( tgaLoadTheImage ( file_name, p, mode ))
{
if ( !( mode&TGA_NO_PASS ))
tgaUploadImage ( p, mode );

if ( mode&TGA_FREE )
tgaFree ( p );
}

}

GLuint tgaLoadAndBind ( char *file_name, tgaFLAG mode )
{
GLuint texture_id;
image_t *p;

glGenTextures ( 1, &texture_id );
glBindTexture ( GL_TEXTURE_2D, texture_id );

if ( tgaLoadTheImage ( file_name, p, mode ))
{
tgaUploadImage ( p, mode );
tgaFree ( p );
}

return texture_id;
}








Part of the main code responsible for loading the texture:

#define MAX_NO_TEXTURES 1
#define TEXTURE_FPS 0
// vector with the numbers of textures
GLuint texture_id[MAX_NO_TEXTURES];

void World::setup()
{

//===================================================================
// Load Texture
//===================================================================
image_t temp_image; // variable that will store the texture to be used

// Enables the use of texture
glEnable ( GL_TEXTURE_2D );

// Defines how to store the pixels in texture (1 = byte-alignment)
glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 );

// Define quantas texturas serão usadas no programa
glGenTextures (1, texture_id); // 1 = one texture
// texture_id = vector that guards the numbers of textures

//Sets the numbers of the texture
texture_id[TEXTURE_FPS] = 1;

// ****
// Sets the texture
// ****

// Defines what type of texture will be used
// GL_TEXTURE_2D ==> that defines a 2D texture is used (bitmaps)
// texture_id[TEXTURE_FPS] ==> define the number of texture
glBindTexture ( GL_TEXTURE_2D, texture_id[TEXTURE_FPS] );
// Load the image .TGA
tgaLoad ( "fps.tga", &temp_image, TGA_FREE | TGA_LOW_QUALITY );

}






main game loop:
    try
{
game->setup(); //Here init texture
while (!game->ended())
{

processEvents(game);
game->processLogics();
game->draw();

SDL_GL_SwapBuffers();

}

}






The texture should be applied when it was called:
glBindTexture ( GL_TEXTURE_2D, 1 ); // define texture 1 to use






Exemple:
    //
// Polygon
//
glPushMatrix();
glScalef(0.1,0.2,0.0);
glColor3f(1.0,1.0,1.0);
glBindTexture ( GL_TEXTURE_2D, 1 ); // HERE!! define texture 1 to use
glBegin(GL_QUADS); // Draw A Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 0.0f);// Top Left
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.0f);// Top Right
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f, 0.0f);// Bottom Right
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f, 0.0f);// Bottom Left
glEnd(); // Done Drawing The Quad
glPopMatrix();






But even without calling the function to apply the texture, it is applied to it and leaving the other strange polygons


Only the polygon in the middle of the screen that should receive the texture
After

If I remove the code that loads the texture, it back to normal

Normal

Thus we note that there was a change in all polygons drawn on the screen (which should not happen)

Thanks!

Share this post


Link to post
Share on other sites
Advertisement
openGL is a state machine. There's no such thing as applying texture.
You enable texturing, thus everything (points, lines, quads, everything) will be textured.
If you disable texturing, nothing will be textured.
If you bind a texture (what you refer as "applying") that texture will be active: that particular texture will be "applied" to everything, until another texture is bound. So if you have only one texture, you don't have to bind it over and over again.

Texture settings (every settings) apply to the currently bound texture.

This state machine thing applies to pretty much everything in openGL. Texture coordinates too. So texture coordinates are always valid, and the values are always the values set last time. That's why you have to call it before the glVertex calls.

The same applies to color, blending, fog, almost everything.

I hope that helps.

Share this post


Link to post
Share on other sites
Thanks szecs, I understand your explanation.

In short, I will not be able to apply the texture only to a polygon?
Leaving the rest without texture?

Sorry for the stubbornness :)

Thanks

I looked at your videos on youtube, great job! congratulations!
Regarding the "Tank simulator openGL demo III" as you did to show the fps onscreen?
I have an fps counter, but do not know how to show it. I'm using Opengl (and SDL for window-manager and control of events)

Share this post


Link to post
Share on other sites
Um.., you haven't understood the explanation...
Maybe this:
"openGL is a state machine. There's no such thing as applying texture.
You enable texturing, thus everything (points, lines, quads, everything) will be textured."
Is a bit fishy. Sorry, I'm not a native speaker, and I1m sleepy, I can't express it better...

glEnable(GL_TEXTURE_2D);
draw_that_you_want_to_be_textured();
glDisable(GL_TEXTURE_2D);
draw_untextured_stuff();

Thanks for you comment on the demos.

FPS counter: look into "render text" or "render fonts" it's a pretty commonly asked question here.

Share this post


Link to post
Share on other sites
szecs thanks!


As for your demo, it is very professional! I hope to get there someday!


[Edited by - VitaliBR on July 8, 2010 9:04:06 PM]

Share this post


Link to post
Share on other sites
Quote:
Original post by VitaliBR
szecs thanks!

as you can not see? lol
sorry!


As for your demo, it is very professional! I hope to get there someday!

Hugs


Um... What?

There's nothing to hope on it. It's a pretty demo, and pretty useless (it's not a big deal to throw some effects and physics, I never did the real and hard stuff). You will get there probably soon.

Share this post


Link to post
Share on other sites
Quote:
Original post by szecs
Quote:
Original post by VitaliBR
szecs thanks!

as you can not see? lol
sorry!


As for your demo, it is very professional! I hope to get there someday!

Hugs


Um... What?

There's nothing to hope on it. It's a pretty demo, and pretty useless (it's not a big deal to throw some effects and physics, I never did the real and hard stuff). You will get there probably soon.


Okay, I'm gone to sleep [grin]

Share this post


Link to post
Share on other sites
#define TGA_DEFAULT 0x0000000000000000 /* In case we don't want any parameters */
#define TGA_FREE 0x0000000000000001 /* Bit flag 0 */
#define TGA_NO_PASS 0x0000000000000010 /* Bit flag 1 */
#define TGA_ALPHA 0x0000000000000100 /* Bit flag 2 */


These defines are not correct. You don't address single bits because it's a hexadecimal formatting. That means 0x0000000000000010 is not bit 1, it's bit 5.

Use (1<<0), (1<<1), (1<<2) etc. to address bits.

Share this post


Link to post
Share on other sites
Quote:
Original post by Clausomat
#define TGA_DEFAULT 0x0000000000000000 /* In case we don't want any parameters */
#define TGA_FREE 0x0000000000000001 /* Bit flag 0 */
#define TGA_NO_PASS 0x0000000000000010 /* Bit flag 1 */
#define TGA_ALPHA 0x0000000000000100 /* Bit flag 2 */


These defines are not correct. You don't address single bits because it's a hexadecimal formatting. That means 0x0000000000000010 is not bit 1, it's bit 5.

Use (1<<0), (1<<1), (1<<2) etc. to address bits.


Sorry, I didn't understand

Thanks szecs, I solved the problem

Normal

:D

how to show FPS on screen, I found an interesting GLFT_font lib. if someone already used it and can tell if it's good


EDIT:

I link the librarie FreeType in my project to use the GLFT, But at compile, appears the following errors:

D:\...\GLFT_Font.cpp||In member function 'void GLFT_Font::open(const std::string&, unsigned int)':|
D:\...\GLFT_Font.cpp|165|error: 'memset' is not a member of 'std'|
D:\...\GLFT_Font.cpp||In member function 'void GLFT_Font::drawText(float, float, const char*, ...) const':|
D:\...\GLFT_Font.cpp|270|error: 'vsnprintf' is not a member of 'std'|
D:\...\GLFT_Font.cpp|276|error: 'strlen' is not a member of 'std'|
||=== Build finished: 3 errors, 0 warnings ===|



[Edited by - VitaliBR on July 8, 2010 8:37:22 PM]

Share this post


Link to post
Share on other sites
To be honest, I don't understand Clausomat either.

Start a new thread with fonts. I use the NEHE method. Look NEHE up.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
  • Advertisement
  • Popular Tags

  • Similar Content

    • By owenjr
      Hi, I'm a Multimedia Engineering student. I am about to finish my dergree and I'm already thinking about what topic to cover in my final college project.
      I'm interested in the procedural animation with c++ and OpenGL of creatures, something like a spider for example. Can someone tell me what are the issues I should investigate to carry it out? I understand that it has some dependence on artificial intelligence but I do not know to what extent. Can someone help me to find information about it? Thank you very much.
       
      Examples: 
      - Procedural multi-legged walking animation
      - Procedural Locomotion of Multi-Legged Characters in Dynamic Environments
    • By Lewa
      So, i'm still on my quest to unterstanding the intricacies of HDR and implementing this into my engine. Currently i'm at the step to implementing tonemapping. I stumbled upon this blogposts:
      http://filmicworlds.com/blog/filmic-tonemapping-operators/
      http://frictionalgames.blogspot.com/2012/09/tech-feature-hdr-lightning.html
      and tried to implement some of those mentioned tonemapping methods into my postprocessing shader.
      The issue is that none of them creates the same results as shown in the blogpost which definitely has to do with the initial range in which the values are stored in the HDR buffer. For simplicity sake i store the values between 0 and 1 in the HDR buffer (ambient light is 0.3, directional light is 0.7)
      This is the tonemapping code:
      vec3 Uncharted2Tonemap(vec3 x) { float A = 0.15; float B = 0.50; float C = 0.10; float D = 0.20; float E = 0.02; float F = 0.30; return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F; } This is without the uncharted tonemapping:
      This is with the uncharted tonemapping:
      Which makes the image a lot darker.
      The shader code looks like this:
      void main() { vec3 color = texture2D(texture_diffuse, vTexcoord).rgb; color = Uncharted2Tonemap(color); //gamma correction (use only if not done in tonemapping code) color = gammaCorrection(color); outputF = vec4(color,1.0f); } Now, from my understanding is that tonemapping should bring the range down from HDR to 0-1.
      But the output of the tonemapping function heavily depends on the initial range of the values in the HDR buffer. (You can't expect to set the sun intensity the first time to 10 and the second time to 1000 and excpect the same result if you feed that into the tonemapper.) So i suppose that this also depends on the exposure which i have to implement?
      To check this i plotted the tonemapping curve:
      You can see that the curve goes only up to around to a value of 0.21 (while being fed a value of 1) and then basically flattens out. (which would explain why the image got darker.)
       
      My guestion is: In what range should the values in the HDR buffer be which then get tonemapped? Do i have to bring them down to a range of 0-1 by multiplying with the exposure?
      For example, if i increase the values of the light by 10 (directional light would be 7 and ambient light 3) then i would need to divide HDR values by 10 in order to get a value range of 0-1 which then could be fed into the tonemapping curve. Is that correct?
    • By nOoNEE
      i am reading this book : link
      in the OpenGL Rendering Pipeline section there is a picture like this: link
      but the question is this i dont really understand why it is necessary to turn pixel data in to fragment and then fragment into pixel could please give me a source or a clear Explanation that why it is necessary ? thank you so mu
       
       
    • By Inbar_xz
      I'm using the OPENGL with eclipse+JOGL.
      My goal is to create movement of the camera and the player.
      I create main class, which create some box in 3D and hold 
      an object of PlayerAxis.
      I create PlayerAxis class which hold the axis of the player.
      If we want to move the camera, then in the main class I call to 
      the func "cameraMove"(from PlayerAxis) and it update the player axis.
      That's work good.
      The problem start if I move the camera on 2 axis, 
      for example if I move with the camera right(that's on the y axis)
      and then down(on the x axis) -
      in some point the move front is not to the front anymore..
      In order to move to the front, I do
      player.playerMoving(0, 0, 1);
      And I learn that in order to keep the front move, 
      I need to convert (0, 0, 1) to the player axis, and then add this.
      I think I dont do the convert right.. 
      I will be glad for help!

      Here is part of my PlayerAxis class:
       
      //player coordinate float x[] = new float[3]; float y[] = new float[3]; float z[] = new float[3]; public PlayerAxis(float move_step, float angle_move) { x[0] = 1; y[1] = 1; z[2] = -1; step = move_step; angle = angle_move; setTransMatrix(); } public void cameraMoving(float angle_step, String axis) { float[] new_x = x; float[] new_y = y; float[] new_z = z; float alfa = angle_step * angle; switch(axis) { case "x": new_z = addVectors(multScalar(z, COS(alfa)), multScalar(y, SIN(alfa))); new_y = subVectors(multScalar(y, COS(alfa)), multScalar(z, SIN(alfa))); break; case "y": new_x = addVectors(multScalar(x, COS(alfa)), multScalar(z, SIN(alfa))); new_z = subVectors(multScalar(z, COS(alfa)), multScalar(x, SIN(alfa))); break; case "z": new_x = addVectors(multScalar(x, COS(alfa)), multScalar(y, SIN(alfa))); new_y = subVectors(multScalar(y, COS(alfa)), multScalar(x, SIN(alfa))); } x = new_x; y = new_y; z = new_z; normalization(); } public void playerMoving(float x_move, float y_move, float z_move) { float[] move = new float[3]; move[0] = x_move; move[1] = y_move; move[2] = z_move; setTransMatrix(); float[] trans_move = transVector(move); position[0] = position[0] + step*trans_move[0]; position[1] = position[1] + step*trans_move[1]; position[2] = position[2] + step*trans_move[2]; } public void setTransMatrix() { for (int i = 0; i < 3; i++) { coordiTrans[0][i] = x[i]; coordiTrans[1][i] = y[i]; coordiTrans[2][i] = z[i]; } } public float[] transVector(float[] v) { return multiplyMatrixInVector(coordiTrans, v); }  
      and in the main class i have this:
       
      public void keyPressed(KeyEvent e) { if (e.getKeyCode()== KeyEvent.VK_ESCAPE) { System.exit(0); //player move } else if (e.getKeyCode()== KeyEvent.VK_W) { //front //moveAmount[2] += -0.1f; player.playerMoving(0, 0, 1); } else if (e.getKeyCode()== KeyEvent.VK_S) { //back //moveAmount[2] += 0.1f; player.playerMoving(0, 0, -1); } else if (e.getKeyCode()== KeyEvent.VK_A) { //left //moveAmount[0] += -0.1f; player.playerMoving(-1, 0, 0); } else if (e.getKeyCode()== KeyEvent.VK_D) { //right //moveAmount[0] += 0.1f; player.playerMoving(1, 0, 0); } else if (e.getKeyCode()== KeyEvent.VK_E) { //moveAmount[0] += 0.1f; player.playerMoving(0, 1, 0); } else if (e.getKeyCode()== KeyEvent.VK_Q) { //moveAmount[0] += 0.1f; player.playerMoving(0, -1, 0); //camera move } else if (e.getKeyCode()== KeyEvent.VK_I) { //up player.cameraMoving(1, "x"); } else if (e.getKeyCode()== KeyEvent.VK_K) { //down player.cameraMoving(-1, "x"); } else if (e.getKeyCode()== KeyEvent.VK_L) { //right player.cameraMoving(-1, "y"); } else if (e.getKeyCode()== KeyEvent.VK_J) { //left player.cameraMoving(1, "y"); } else if (e.getKeyCode()== KeyEvent.VK_O) { //right round player.cameraMoving(-1, "z"); } else if (e.getKeyCode()== KeyEvent.VK_U) { //left round player.cameraMoving(1, "z"); } }  
      finallt found it.... i confused with the transformation matrix row and col. thanks anyway!
    • By Lewa
      So, i'm currently trying to implement an SSAO shader from THIS tutorial and i'm running into a few issues here.
      Now, this SSAO method requires view space positions and normals. I'm storing the normals in my deferred renderer in world-space so i had to do a conversion and reconstruct the position from the depth buffer.
      And something there goes horribly wrong (which has probably to do with worldspace to viewspace transformations).
      (here is the full shader source code if someone wants to take a look at it)
      Now, i suspect that the normals are the culprit.
      vec3 normal = ((uNormalViewMatrix*vec4(normalize(texture2D(sNormals, vTexcoord).rgb),1.0)).xyz); "sNormals" is a 2D texture which stores the normals in world space in a RGB FP16 buffer.
      Now i can't use the camera viewspace matrix to transform the normals into viewspace as the cameras position isn't set at (0,0,0), thus skewing the result.
      So what i did is to create a new viewmatrix specifically for this normal without the position at vec3(0,0,0);
      //"camera" is the camera which was used for rendering the normal buffer renderer.setUniform4m(ressources->shaderSSAO->getUniform("uNormalViewMatrix"), glmExt::createViewMatrix(glm::vec3(0,0,0),camera.getForward(),camera.getUp())//parameters are (position,forwardVector,upVector) ); Though i have the feeling this is the wrong approach. Is this right or is there a better/correct way of transforming a world space normal into viewspace?
    • By HawkDeath
      Hi,
      I'm trying mix two textures using own shader system, but I have a problem (I think) with uniforms.
      Code: https://github.com/HawkDeath/shader/tree/test
      To debug I use RenderDocs, but I did not receive good results. In the first attachment is my result, in the second attachment is what should be.
      PS. I base on this tutorial https://learnopengl.com/Getting-started/Textures.


    • By norman784
      I'm having issues loading textures, as I'm clueless on how to handle / load images maybe I missing something, but the past few days I just google a lot to try to find a solution. Well theres two issues I think, one I'm using Kotlin Native (EAP) and OpenGL wrapper / STB image, so I'm not quite sure wheres the issue, if someone with more experience could give me some hints on how to solve this issue?
      The code is here, if I'm not mistaken the workflow is pretty straight forward, stbi_load returns the pixels of the image (as char array or byte array) and you need to pass those pixels directly to glTexImage2D, so a I'm missing something here it seems.
      Regards
    • By Hashbrown
      I've noticed in most post processing tutorials several shaders are used one after another: one for bloom, another for contrast, and so on. For example: 
      postprocessing.quad.bind() // Effect 1 effect1.shader.bind(); postprocessing.texture.bind(); postprocessing.quad.draw(); postprocessing.texture.unbind(); effect1.shader.unbind(); // Effect 2 effect2.shader.bind(); // ...and so on postprocessing.quad.unbind() Is this good practice, how many shaders can I bind and unbind before I hit performance issues? I'm afraid I don't know what the good practices are in open/webGL regarding binding and unbinding resources. 
      I'm guessing binding many shaders at post processing is okay since the scene has already been updated and I'm just working on a quad and texture at that moment. Or is it more optimal to put shader code in chunks and bind less frequently? I'd love to use several shaders at post though. 
      Another example of what I'm doing at the moment:
      1) Loop through GameObjects, bind its phong shader (send color, shadow, spec, normal samplers), unbind all.
      2) At post: bind post processor quad, and loop/bind through different shader effects, and so on ...
      Thanks all! 
    • By phil67rpg
      void collision(int v) { collision_bug_one(0.0f, 10.0f); glutPostRedisplay(); glutTimerFunc(1000, collision, 0); } void coll_sprite() { if (board[0][0] == 1) { collision(0); flag[0][0] = 1; } } void erase_sprite() { if (flag[0][0] == 1) { glColor3f(0.0f, 0.0f, 0.0f); glBegin(GL_POLYGON); glVertex3f(0.0f, 10.0f, 0.0f); glVertex3f(0.0f, 9.0f, 0.0f); glVertex3f(1.0f, 9.0f, 0.0f); glVertex3f(1.0f, 10.0f, 0.0f); glEnd(); } } I am using glutTimerFunc to wait a small amount of time to display a collision sprite before I black out the sprite. unfortunately my code only blacks out the said sprite without drawing the collision sprite, I have done a great deal of research on the glutTimerFunc and  animation.
    • By Lewa
      So, i stumbled upon the topic of gamma correction.
      https://learnopengl.com/Advanced-Lighting/Gamma-Correction
      So from what i've been able to gather: (Please correct me if i'm wrong)
      Old CRT monitors couldn't display color linearly, that's why gamma correction was nessecary. Modern LCD/LED monitors don't have this issue anymore but apply gamma correction anyway. (For compatibility reasons? Can this be disabled?) All games have to apply gamma correction? (unsure about that) All textures stored in file formats (.png for example) are essentially stored in SRGB color space (as what we see on the monitor is skewed due to gamma correction. So the pixel information is the same, the percieved colors are just wrong.) This makes textures loaded into the GL_RGB format non linear, thus all lighting calculations are wrong You have to always use the GL_SRGB format to gamma correct/linearise textures which are in SRGB format  
      Now, i'm kinda confused how to proceed with applying gamma correction in OpenGL.
      First of, how can i check if my Monitor is applying gamma correction? I noticed in my monitor settings that my color format is set to "RGB" (can't modify it though.) I'm connected to my PC via a HDMI cable. I'm also using the full RGB range (0-255, not the 16 to ~240 range)
       
      What i tried to do is to apply a gamma correction shader shown in the tutorial above which looks essentially like this: (it's a postprocess shader which is applied at the end of the renderpipeline)
      vec3 gammaCorrection(vec3 color){ // gamma correction color = pow(color, vec3(1.0/2.2)); return color; } void main() { vec3 color; vec3 tex = texture2D(texture_diffuse, vTexcoord).rgb; color = gammaCorrection(tex); outputF = vec4(color,1.0f); } The results look like this:
      No gamma correction:
      With gamma correction:
       
      The colors in the gamma corrected image look really wased out. (To the point that it's damn ugly. As if someone overlayed a white half transparent texture. I want the colors to pop.)
      Do i have to change the textures from GL_RGB to GL_SRGB in order to gamma correct them in addition to applying the post process gamma correction shader? Do i have to do the same thing with all FBOs? Or is this washed out look the intended behaviour?
  • Advertisement
  • Popular Now

  • Forum Statistics

    • Total Topics
      631373
    • Total Posts
      2999631
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

Participate in the game development conversation and more when you create an account on GameDev.net!

Sign me up!