static void inittextures(void) { glGenTextures(1, &t1id); glBindTexture(GL_TEXTURE_2D, t1id); if (!LoadRGBMipmaps("../images/tile.rgb", GL_RGB)) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenTextures(1, &t2id); glBindTexture(GL_TEXTURE_2D, t2id); if (!LoadRGBMipmaps("../images/bw.rgb", GL_RGB)) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); }
static void inittextures(void) { glGenTextures(1,&t1id); glBindTexture(GL_TEXTURE_2D,t1id); glPixelStorei(GL_UNPACK_ALIGNMENT,4); if (!LoadRGBMipmaps(DEMOS_DATA_DIR "tile.rgb", GL_RGB)) { fprintf(stderr,"Error reading a texture.\n"); exit(-1); } 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_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); glGenTextures(1,&t2id); glBindTexture(GL_TEXTURE_2D,t2id); glPixelTransferf(GL_RED_SCALE, 0.75); glPixelTransferf(GL_RED_BIAS, 0.25); glPixelTransferf(GL_GREEN_SCALE, 0.75); glPixelTransferf(GL_GREEN_BIAS, 0.25); glPixelTransferf(GL_BLUE_SCALE, 0.75); glPixelTransferf(GL_BLUE_BIAS, 0.25); if (!LoadRGBMipmaps(DEMOS_DATA_DIR "bw.rgb", GL_RGB)) { fprintf(stderr,"Error reading a texture.\n"); exit(-1); } glPixelTransferf(GL_RED_SCALE, 1.0); glPixelTransferf(GL_RED_BIAS, 0.0); glPixelTransferf(GL_GREEN_SCALE, 1.0); glPixelTransferf(GL_GREEN_BIAS, 0.0); glPixelTransferf(GL_BLUE_SCALE, 1.0); glPixelTransferf(GL_BLUE_BIAS, 0.0); 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_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); }
static void Init( int argc, char *argv[] ) { GLuint u; for (u = 0; u < 2; u++) { glActiveTextureARB(GL_TEXTURE0_ARB + u); glBindTexture(GL_TEXTURE_2D, 10+u); if (u == 0) glEnable(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if (u == 0) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } } glLineStipple(1, 0xff); if (argc > 1 && strcmp(argv[1], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } }
static void Init(void) { GLfloat lightPos[4] = {1.0, 10.0, 10.0, 0.0}; glClearColor(0.5, 0.8, 0.99, 1.0); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_POSITION, lightPos); glShadeModel(GL_FLAT); LoadRGBMipmaps("logo.bw", 1); }
static void Init( void ) { static const char *modulate2D = "!!ARBfp1.0\n" "TEMP R0;\n" "TEX R0, fragment.texcoord[0], texture[0], 2D; \n" "MUL result.color, R0, fragment.color; \n" "END" ; GLuint modulateProg; GLuint Texture; if (!glutExtensionSupported("GL_ARB_fragment_program")) { printf("Error: GL_ARB_fragment_program not supported!\n"); exit(1); } printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); /* Setup the fragment program */ glGenProgramsARB(1, &modulateProg); glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, modulateProg); glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(modulate2D), (const GLubyte *)modulate2D); printf("glGetError = 0x%x\n", (int) glGetError()); printf("glError(GL_PROGRAM_ERROR_STRING_ARB) = %s\n", (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB)); assert(glIsProgramARB(modulateProg)); glEnable(GL_FRAGMENT_PROGRAM_ARB); /* Load texture */ glGenTextures(1, &Texture); glBindTexture(GL_TEXTURE_2D, Texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { printf("Error: couldn't load texture image file %s\n", TEXTURE_FILE); exit(1); } /* XXX this enable shouldn't really be needed!!! */ glEnable(GL_TEXTURE_2D); glClearColor(.3, .3, .3, 0); }
TexturedScreenRenderer::TexturedScreenRenderer(const char* filename) { glGenTextures(1, ssTexName_); glBindTexture(GL_TEXTURE_2D, ssTexName_[0]); LoadRGBMipmaps(filename, GL_RGB); }
static void Init(int argc, char *argv[]) { GLfloat fogColor[4] = {0.5,1.0,0.5,1.0}; xrot = 0; yrot = 0; dist = -6; plane[0] = 1.0; plane[1] = 0.0; plane[2] = -1.0; plane[3] = 0.0; glClearColor(0.0, 0.0, 1.0, 0.0); glEnable( GL_DEPTH_TEST ); glEnable( GL_VERTEX_ARRAY_EXT ); glEnable( GL_NORMAL_ARRAY_EXT ); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum( -1.0, 1.0, -1.0, 1.0, 5, 25 ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glClipPlane(GL_CLIP_PLANE0, plane); InitMaterials(); set_matrix(); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); /* Green fog is easy to see */ glFogi(GL_FOG_MODE,GL_EXP2); glFogfv(GL_FOG_COLOR,fogColor); glFogf(GL_FOG_DENSITY,0.15); glHint(GL_FOG_HINT,GL_DONT_CARE); { static int firsttime = 1; if (firsttime) { firsttime = 0; compactify_arrays(); expand_arrays(); make_tri_indices(); if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } } } ModeMenu(SHADE_SMOOTH| LIT| POINT_FILTER| NO_USER_CLIP| NO_MATERIALS| NO_FOG| NO_STIPPLE| IMMEDIATE| STRIPS| UNLOCKED| GLVERTEX); if (PrintInfo) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } }
static void Init( int argc, char *argv[] ) { GLboolean convolve = GL_FALSE; GLboolean fullscreen = GL_FALSE; int i; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } else if (strcmp(argv[i], "-c")==0) { convolve = GL_TRUE; } else if (strcmp(argv[i], "-f")==0) { fullscreen = GL_TRUE; } } if (fullscreen) glutFullScreen(); /* Cylinder object */ { static GLfloat height = 100.0; static GLfloat radius = 40.0; static GLint slices = 24; /* pie slices around Z axis */ static GLint stacks = 10; /* subdivisions along length of cylinder */ static GLint rings = 4; /* rings in the end disks */ GLUquadricObj *q = gluNewQuadric(); assert(q); gluQuadricTexture(q, GL_TRUE); CylinderObj = glGenLists(1); glNewList(CylinderObj, GL_COMPILE); glPushMatrix(); glTranslatef(0.0, 0.0, -0.5 * height); glMatrixMode(GL_TEXTURE); glLoadIdentity(); /*glScalef(8.0, 4.0, 2.0);*/ glMatrixMode(GL_MODELVIEW); /* cylinder */ gluQuadricNormals(q, GL_SMOOTH); gluQuadricTexture(q, GL_TRUE); gluCylinder(q, radius, radius, height, slices, stacks); /* end cap */ glMatrixMode(GL_TEXTURE); glLoadIdentity(); glScalef(3.0, 3.0, 1.0); glMatrixMode(GL_MODELVIEW); glTranslatef(0.0, 0.0, height); gluDisk(q, 0.0, radius, slices, rings); /* other end cap */ glTranslatef(0.0, 0.0, -height); gluQuadricOrientation(q, GLU_INSIDE); gluDisk(q, 0.0, radius, slices, rings); glPopMatrix(); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glEndList(); gluDeleteQuadric(q); } /* Teapot */ { TeapotObj = glGenLists(1); glNewList(TeapotObj, GL_COMPILE); glFrontFace(GL_CW); glutSolidTeapot(40.0); glFrontFace(GL_CCW); glEndList(); } /* show cylinder by default */ Object = CylinderObj; /* lighting */ glEnable(GL_LIGHTING); { GLfloat pos[4] = { 3, 3, 3, 1 }; glLightfv(GL_LIGHT0, GL_AMBIENT, Black); glLightfv(GL_LIGHT0, GL_DIFFUSE, White); glLightfv(GL_LIGHT0, GL_SPECULAR, White); glLightfv(GL_LIGHT0, GL_POSITION, pos); glEnable(GL_LIGHT0); glMaterialfv(GL_FRONT, GL_AMBIENT, Black); glMaterialf(GL_FRONT, GL_SHININESS, Shininess); glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1); } /* Base texture */ glGenTextures(1, &BaseTexture); glBindTexture(GL_TEXTURE_2D, BaseTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); if (!LoadRGBMipmaps(BASE_TEXTURE_FILE, GL_RGB)) { printf("Error: couldn't load texture image file %s\n", BASE_TEXTURE_FILE); exit(1); } /* Specular texture */ glGenTextures(1, &SpecularTexture); glBindTexture(GL_TEXTURE_2D, SpecularTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); if (convolve) { /* use convolution to blur the texture to simulate a dull finish * on the object. */ GLubyte *img; GLenum format; GLint w, h; GLfloat filter[FILTER_SIZE][FILTER_SIZE][4]; for (h = 0; h < FILTER_SIZE; h++) { for (w = 0; w < FILTER_SIZE; w++) { const GLfloat k = 1.0 / (FILTER_SIZE * FILTER_SIZE); filter[h][w][0] = k; filter[h][w][1] = k; filter[h][w][2] = k; filter[h][w][3] = k; } } glEnable(GL_CONVOLUTION_2D); glConvolutionParameteri(GL_CONVOLUTION_2D, GL_CONVOLUTION_BORDER_MODE, GL_CONSTANT_BORDER); glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGBA, FILTER_SIZE, FILTER_SIZE, GL_RGBA, GL_FLOAT, filter); img = LoadRGBImage(SPECULAR_TEXTURE_FILE, &w, &h, &format); if (!img) { printf("Error: couldn't load texture image file %s\n", SPECULAR_TEXTURE_FILE); exit(1); } glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, format, GL_UNSIGNED_BYTE, img); free(img); } else { /* regular path */ if (!LoadRGBMipmaps(SPECULAR_TEXTURE_FILE, GL_RGB)) { printf("Error: couldn't load texture image file %s\n", SPECULAR_TEXTURE_FILE); exit(1); } } /* misc */ glEnable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); glEnable(GL_NORMALIZE); glPolygonOffset( -1, -1 ); }
static void inittextures(void) { GLubyte tsky[TEX_SKY_HEIGHT][TEX_SKY_WIDTH][3]; GLuint x, y; GLfloat fact; GLenum gluerr; /* Brick */ glGenTextures(1, &t1id); glBindTexture(GL_TEXTURE_2D, t1id); if (!LoadRGBMipmaps("../images/bw.rgb", 3)) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /* Sky */ glGenTextures(1, &t2id); glBindTexture(GL_TEXTURE_2D, t2id); for (y = 0; y < TEX_SKY_HEIGHT; y++) for (x = 0; x < TEX_SKY_WIDTH; x++) if (y < TEX_SKY_HEIGHT / 2) { fact = y / (GLfloat) (TEX_SKY_HEIGHT / 2); tsky[y][x][0] = (GLubyte) (255.0f * (0.1f * fact + 0.3f * (1.0f - fact))); tsky[y][x][1] = (GLubyte) (255.0f * (0.2f * fact + 1.0f * (1.0f - fact))); tsky[y][x][2] = 255; } else { tsky[y][x][0] = tsky[TEX_SKY_HEIGHT - y - 1][x][0]; tsky[y][x][1] = tsky[TEX_SKY_HEIGHT - y - 1][x][1]; tsky[y][x][2] = 255; } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); if ( (gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TEX_SKY_WIDTH, TEX_SKY_HEIGHT, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *) (tsky)))) { fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr)); exit(-1); } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); }
static void inittextures(void) { GLenum gluerr; GLubyte tex[128][128][4]; glGenTextures(1, &groundid); glBindTexture(GL_TEXTURE_2D, groundid); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); if (!LoadRGBMipmaps(DEMOS_DATA_DIR "s128.rgb", GL_RGB)) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glGenTextures(1, &treeid); glBindTexture(GL_TEXTURE_2D, treeid); if (1) { int w, h; GLenum format; int x, y; GLubyte *image = LoadRGBImage(DEMOS_DATA_DIR "tree3.rgb", &w, &h, &format); if (!image) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } for (y = 0; y < 128; y++) for (x = 0; x < 128; x++) { tex[x][y][0] = image[(y + x * 128) * 3]; tex[x][y][1] = image[(y + x * 128) * 3 + 1]; tex[x][y][2] = image[(y + x * 128) * 3 + 2]; if ((tex[x][y][0] == tex[x][y][1]) && (tex[x][y][1] == tex[x][y][2]) && (tex[x][y][2] == 255)) tex[x][y][3] = 0; else tex[x][y][3] = 255; } if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 4, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) (tex)))) { fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr)); exit(-1); } } else { if (!LoadRGBMipmaps(DEMOS_DATA_DIR "tree2.rgba", GL_RGBA)) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); }
static void Init( void ) { GLfloat maxBias; if (!glutExtensionSupported("GL_EXT_texture_lod_bias")) { printf("Sorry, GL_EXT_texture_lod_bias not supported by this renderer.\n"); exit(1); } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &TexObj); glBindTexture(GL_TEXTURE_2D, TexObj); if (glutExtensionSupported("GL_SGIS_generate_mipmap")) { /* test auto mipmap generation */ GLint width, height, i; GLenum format; GLubyte *image = LoadRGBImage(TEXTURE_FILE, &width, &height, &format); if (!image) { printf("Error: could not load texture image %s\n", TEXTURE_FILE); exit(1); } /* resize to 256 x 256 */ if (width != 256 || height != 256) { GLubyte *newImage = malloc(256 * 256 * 4); gluScaleImage(format, width, height, GL_UNSIGNED_BYTE, image, 256, 256, GL_UNSIGNED_BYTE, newImage); free(image); image = newImage; } printf("Using GL_SGIS_generate_mipmap\n"); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE); glTexImage2D(GL_TEXTURE_2D, 0, format, 256, 256, 0, format, GL_UNSIGNED_BYTE, image); free(image); /* make sure mipmap was really generated correctly */ width = height = 256; for (i = 0; i < 9; i++) { GLint w, h; glGetTexLevelParameteriv(GL_TEXTURE_2D, i, GL_TEXTURE_WIDTH, &w); glGetTexLevelParameteriv(GL_TEXTURE_2D, i, GL_TEXTURE_HEIGHT, &h); printf("Level %d size: %d x %d\n", i, w, h); assert(w == width); assert(h == height); width /= 2; height /= 2; } } else if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { printf("Error: could not load texture image %s\n", TEXTURE_FILE); exit(1); } /* mipmapping required for this extension */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS_EXT, &maxBias); printf("LOD bias range: [%g, %g]\n", -maxBias, maxBias); BiasMin = -100 * maxBias; BiasMax = 100 * maxBias; /* Since we have (about) 8 mipmap levels, no need to bias beyond * the range [-1, +8]. */ if (BiasMin < -100) BiasMin = -100; if (BiasMax > 800) BiasMax = 800; }
static void Init( int argc, char *argv[] ) { GLuint texObj[2]; GLint units; if (!glutExtensionSupported("GL_ARB_multitexture")) { printf("Sorry, GL_ARB_multitexture not supported by this renderer.\n"); exit(1); } if (!glutExtensionSupported("GL_EXT_paletted_texture")) { printf("Sorry, GL_EXT_paletted_texture not supported by this renderer.\n"); exit(1); } glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &units); printf("%d texture units supported\n", units); /* allocate two texture objects */ glGenTextures(2, texObj); /* setup texture obj 0 */ glBindTexture(GL_TEXTURE_2D, texObj[0]); #ifdef LINEAR_FILTER /* linear filtering looks much nicer but is much slower for Mesa */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); foo #else glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); #endif glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); load_tex(TEXTURE_1_FILE, 0); #if 0 if (!LoadRGBMipmaps(TEXTURE_1_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } #endif /* setup texture obj 1 */ glBindTexture(GL_TEXTURE_2D, texObj[1]); #ifdef LINEAR_FILTER /* linear filtering looks much nicer but is much slower for Mesa */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); foo #else glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); #endif glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); load_tex(TEXTURE_2_FILE, 1); #if 0 if (!LoadRGBMipmaps(TEXTURE_2_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } #endif /* now bind the texture objects to the respective texture units */ #ifdef GL_ARB_multitexture glActiveTextureARB(GL_TEXTURE0_ARB); glBindTexture(GL_TEXTURE_2D, texObj[0]); glActiveTextureARB(GL_TEXTURE1_ARB); glBindTexture(GL_TEXTURE_2D, texObj[1]); #endif glShadeModel(GL_FLAT); glClearColor(0.3, 0.3, 0.4, 1.0); ModeMenu(TEXBOTH); if (argc > 1 && strcmp(argv[1], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } }
static void Init( int argc, char *argv[] ) { GLUquadricObj *q = gluNewQuadric(); CylinderObj = glGenLists(1); glNewList(CylinderObj, GL_COMPILE); glTranslatef(0.0, 0.0, -1.0); /* cylinder */ gluQuadricNormals(q, GL_SMOOTH); gluQuadricTexture(q, GL_TRUE); gluCylinder(q, 0.6, 0.6, 2.0, 24, 1); /* end cap */ glTranslatef(0.0, 0.0, 2.0); gluDisk(q, 0.0, 0.6, 24, 1); /* other end cap */ glTranslatef(0.0, 0.0, -2.0); gluQuadricOrientation(q, GLU_INSIDE); gluDisk(q, 0.0, 0.6, 24, 1); glEndList(); gluDeleteQuadric(q); /* lighting */ glEnable(GL_LIGHTING); { GLfloat gray[4] = {0.2, 0.2, 0.2, 1.0}; GLfloat white[4] = {1.0, 1.0, 1.0, 1.0}; GLfloat teal[4] = { 0.0, 1.0, 0.8, 1.0 }; glMaterialfv(GL_FRONT, GL_DIFFUSE, teal); glLightfv(GL_LIGHT0, GL_AMBIENT, gray); glLightfv(GL_LIGHT0, GL_DIFFUSE, white); glEnable(GL_LIGHT0); } /* fitering = nearest, initially */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP); if (!LoadRGBMipmaps(TEXTURE_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } glEnable(GL_CULL_FACE); /* don't need Z testing for convex objects */ SetMode(LIT); if (argc > 1 && strcmp(argv[1], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } }
static void inittextures(void) { GLenum gluerr; GLubyte tex[128][128][4]; glGenTextures(1, &groundid); glBindTexture(GL_TEXTURE_2D, groundid); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); #ifndef MONA if (!LoadRGBMipmaps("../images/s128.rgb", GL_RGB)) { #else if (!LoadRGBMipmaps("/MESA/S128.RGB", GL_RGB)) { #endif fprintf(stderr, "Error reading a texture.\n"); exit(-1); } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); glGenTextures(1, &treeid); glBindTexture(GL_TEXTURE_2D, treeid); if (1) { int w, h; GLenum format; int x, y; GLubyte *image = LoadRGBImage("../images/tree3.rgb", &w, &h, &format); if (!image) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } for (y = 0; y < 128; y++) for (x = 0; x < 128; x++) { tex[x][y][0] = image[(y + x * 128) * 3]; tex[x][y][1] = image[(y + x * 128) * 3 + 1]; tex[x][y][2] = image[(y + x * 128) * 3 + 2]; if ((tex[x][y][0] == tex[x][y][1]) && (tex[x][y][1] == tex[x][y][2]) && (tex[x][y][2] == 255)) tex[x][y][3] = 0; else tex[x][y][3] = 255; } if ((gluerr = gluBuild2DMipmaps(GL_TEXTURE_2D, 4, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) (tex)))) { fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr)); exit(-1); } } else { if (!LoadRGBMipmaps("../images/tree2.rgba", GL_RGBA)) { fprintf(stderr, "Error reading a texture.\n"); exit(-1); } } 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_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } static void inittree(void) { int i; float dist; for (i = 0; i < NUMTREE; i++) do { treepos[i][0] = vrnd() * TREEOUTR * 2.0 - TREEOUTR; treepos[i][1] = 0.0; treepos[i][2] = vrnd() * TREEOUTR * 2.0 - TREEOUTR; dist = sqrt(treepos[i][0] * treepos[i][0] + treepos[i][2] * treepos[i][2]); } while ((dist < TREEINR) || (dist > TREEOUTR)); }
static void Init( int argc, char *argv[] ) { GLuint texObj[8]; GLint size, i; const char *exten = (const char *) glGetString(GL_EXTENSIONS); if (!strstr(exten, "GL_ATI_fragment_shader")) { printf("Sorry, GL_ATI_fragment_shader not supported by this renderer.\n"); exit(1); } glGetIntegerv(GL_MAX_TEXTURE_SIZE, &size); printf("%d x %d max texture size\n", size, size); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); for (i = 0; i < NumUnits; i++) { if (i < 6) TexEnabled[i] = GL_TRUE; else TexEnabled[i] = GL_FALSE; } /* allocate two texture objects */ glGenTextures(NumUnits, texObj); /* setup the texture objects */ for (i = 0; i < NumUnits; i++) { glActiveTextureARB(GL_TEXTURE0_ARB + i); glBindTexture(GL_TEXTURE_2D, texObj[i]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); if (i == 0) { if (!LoadRGBMipmaps(TEXTURE_1_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } } else if (i == 1) { if (!LoadRGBMipmaps(TEXTURE_2_FILE, GL_RGB)) { printf("Error: couldn't load texture image\n"); exit(1); } } else { /* checker */ GLubyte image[8][8][3]; GLint i, j; for (i = 0; i < 8; i++) { for (j = 0; j < 8; j++) { if ((i + j) & 1) { image[i][j][0] = 50; image[i][j][1] = 50; image[i][j][2] = 50; } else { image[i][j][0] = 25; image[i][j][1] = 25; image[i][j][2] = 25; } } } glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 8, 8, 0, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *) image); } /* Bind texObj[i] to ith texture unit */ /* if (i < 2) glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); else glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);*/ if (TexEnabled[i]) glEnable(GL_TEXTURE_2D); } boringshaderID = glGenFragmentShadersATI(1); boring2passID = glGenFragmentShadersATI(1); if (boring2passID == 0) { fprintf(stderr, "couldn't get frag shader id\n"); exit(1); } glBindFragmentShaderATI(boringshaderID); /* maybe not the most creative shader but at least I know how it should look like! */ glBeginFragmentShaderATI(); glSampleMapATI(GL_REG_0_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_1_ATI, GL_TEXTURE1_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_2_ATI, GL_TEXTURE2_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_3_ATI, GL_TEXTURE3_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_4_ATI, GL_TEXTURE4_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_5_ATI, GL_TEXTURE5_ARB, GL_SWIZZLE_STR_ATI); glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE); glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE); glColorFragmentOp3ATI(GL_MAD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_1_ATI, GL_NONE, GL_NONE, GL_REG_2_ATI, GL_NONE, GL_NONE); glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_3_ATI, GL_NONE, GL_NONE); glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_4_ATI, GL_NONE, GL_NONE); glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_5_ATI, GL_NONE, GL_NONE); glEndFragmentShaderATI(); /* mathematically equivalent to first shader but using 2 passes together with some tex coord rerouting */ glBindFragmentShaderATI(boring2passID); glBeginFragmentShaderATI(); glPassTexCoordATI(GL_REG_1_ATI, GL_TEXTURE0_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_2_ATI, GL_TEXTURE2_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_3_ATI, GL_TEXTURE3_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_4_ATI, GL_TEXTURE4_ARB, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_5_ATI, GL_TEXTURE5_ARB, GL_SWIZZLE_STR_ATI); glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_2_ATI, GL_NONE, GL_NONE, GL_REG_3_ATI, GL_NONE, GL_NONE); glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_4_ATI, GL_NONE, GL_NONE); glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_5_ATI, GL_NONE, GL_NONE); /* not really a dependant read */ glSampleMapATI(GL_REG_0_ATI, GL_REG_1_ATI, GL_SWIZZLE_STR_ATI); glSampleMapATI(GL_REG_1_ATI, GL_TEXTURE1_ARB, GL_SWIZZLE_STR_ATI); glPassTexCoordATI(GL_REG_5_ATI, GL_REG_0_ATI, GL_SWIZZLE_STR_ATI); glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE); glAlphaFragmentOp1ATI(GL_MOV_ATI, GL_REG_0_ATI, GL_NONE, GL_PRIMARY_COLOR, GL_NONE, GL_NONE); glColorFragmentOp3ATI(GL_MAD_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_1_ATI, GL_NONE, GL_NONE, GL_REG_5_ATI, GL_NONE, GL_NONE); /* in principle we're finished here, but to test a bit more we do some fun with dot ops, replication et al. */ glSetFragmentShaderConstantATI(GL_CON_3_ATI, shaderconstant); glColorFragmentOp2ATI(GL_DOT4_ATI, GL_REG_3_ATI, GL_GREEN_BIT_ATI, GL_EIGHTH_BIT_ATI, GL_ZERO, GL_NONE, GL_COMP_BIT_ATI | GL_NEGATE_BIT_ATI, GL_CON_3_ATI, GL_RED, GL_2X_BIT_ATI); /* those args must get ignored, except dstReg */ glAlphaFragmentOp2ATI(GL_DOT4_ATI, GL_REG_4_ATI, GL_NONE, GL_ZERO, GL_NONE, GL_NONE, GL_ZERO, GL_NONE, GL_NONE); /* -> reg3 g = reg4 alpha = -0.5 */ glAlphaFragmentOp2ATI(GL_ADD_ATI, GL_REG_5_ATI, GL_NONE, GL_REG_3_ATI, GL_GREEN, GL_NONE, GL_REG_4_ATI, GL_NONE, GL_NONE); /* -> reg5 a = -1 */ glColorFragmentOp3ATI(GL_DOT2_ADD_ATI, GL_REG_4_ATI, GL_BLUE_BIT_ATI, GL_HALF_BIT_ATI, GL_REG_5_ATI, GL_ALPHA, GL_NEGATE_BIT_ATI, GL_ONE, GL_NONE, GL_BIAS_BIT_ATI, GL_ONE, GL_ALPHA, GL_2X_BIT_ATI | GL_NEGATE_BIT_ATI); /* -> reg 4 b = -0.5 */ glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, GL_REG_4_ATI, GL_BLUE, GL_NEGATE_BIT_ATI | GL_2X_BIT_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE); glEndFragmentShaderATI(); glBindFragmentShaderATI(boringshaderID); glEnable(GL_FRAGMENT_SHADER_ATI); glShadeModel(GL_FLAT); glClearColor(0.3, 0.3, 0.4, 1.0); if (argc > 1 && strcmp(argv[1], "-info")==0) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); } printf("output should be identical with both shaders to multiarb demo when 6 textures are enabled\n"); }