400 lines
10 KiB
C
400 lines
10 KiB
C
/*
|
|
** Copyright 1992, Silicon Graphics, Inc.
|
|
** All Rights Reserved.
|
|
**
|
|
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
|
|
** the contents of this file may not be disclosed to third parties, copied or
|
|
** duplicated in any form, in whole or in part, without the prior written
|
|
** permission of Silicon Graphics, Inc.
|
|
**
|
|
** RESTRICTED RIGHTS LEGEND:
|
|
** Use, duplication or disclosure by the Government is subject to restrictions
|
|
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
|
|
** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
|
|
** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
|
|
** rights reserved under the Copyright Laws of the United States.
|
|
*/
|
|
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <GL/gl.h>
|
|
#include "shell.h"
|
|
|
|
|
|
typedef struct _textureRec {
|
|
long index[11];
|
|
long value[11];
|
|
char *name[11];
|
|
enumRec *enumTable[11];
|
|
} textureRec;
|
|
|
|
|
|
enumRec enum_TextureTarget[] = {
|
|
GL_TEXTURE_1D, "GL_TEXTURE_1D",
|
|
GL_TEXTURE_2D, "GL_TEXTURE_2D",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_TextureEnv[] = {
|
|
GL_MODULATE, "GL_MODULATE",
|
|
GL_DECAL, "GL_DECAL",
|
|
GL_BLEND, "GL_BLEND",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_S_TextureGenMode[] = {
|
|
GL_EYE_LINEAR, "GL_EYE_LINEAR",
|
|
GL_OBJECT_LINEAR, "GL_OBJECT_LINEAR",
|
|
GL_SPHERE_MAP, "GL_SPHERE_MAP",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_T_TextureGenMode[] = {
|
|
GL_EYE_LINEAR, "GL_EYE_LINEAR",
|
|
GL_OBJECT_LINEAR, "GL_OBJECT_LINEAR",
|
|
GL_SPHERE_MAP, "GL_SPHERE_MAP",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_S_TextureWrapMode[] = {
|
|
GL_REPEAT, "GL_REPEAT",
|
|
GL_CLAMP, "GL_CLAMP",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_T_TextureWrapMode[] = {
|
|
GL_REPEAT, "GL_REPEAT",
|
|
GL_CLAMP, "GL_CLAMP",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_TextureMinFilter[] = {
|
|
GL_NEAREST, "GL_NEAREST",
|
|
GL_LINEAR, "GL_LINEAR",
|
|
GL_NEAREST_MIPMAP_NEAREST, "GL_NEAREST_MIPMAP_NEAREST",
|
|
GL_LINEAR_MIPMAP_NEAREST, "GL_LINEAR_MIPMAP_NEAREST",
|
|
GL_NEAREST_MIPMAP_LINEAR, "GL_NEAREST_MIPMAP_LINEAR",
|
|
GL_LINEAR_MIPMAP_LINEAR, "GL_LINEAR_MIPMAP_LINEAR",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_TextureMagFilter[] = {
|
|
GL_NEAREST, "GL_NEAREST",
|
|
GL_LINEAR, "GL_LINEAR",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_TexImage_PixelFormat[] = {
|
|
GL_RED, "GL_RED",
|
|
GL_GREEN, "GL_GREEN",
|
|
GL_BLUE, "GL_BLUE",
|
|
GL_ALPHA, "GL_ALPHA",
|
|
GL_RGB, "GL_RGB",
|
|
GL_RGBA, "GL_RGBA",
|
|
GL_LUMINANCE, "GL_LUMINANCE",
|
|
GL_LUMINANCE_ALPHA, "GL_LUMINANCE_ALPHA",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_TexImage_PixelType[] = {
|
|
GL_UNSIGNED_BYTE, "GL_UNSIGNED_BYTE",
|
|
GL_BYTE, "GL_BYTE",
|
|
GL_UNSIGNED_SHORT, "GL_UNSIGNED_SHORT",
|
|
GL_SHORT, "GL_SHORT",
|
|
GL_UNSIGNED_INT, "GL_UNSIGNED_INT",
|
|
GL_INT, "GL_INT",
|
|
GL_FLOAT, "GL_FLOAT",
|
|
-1, "End of List"
|
|
};
|
|
|
|
enumRec enum_TextureBorder[] = {
|
|
0, "No Border",
|
|
1, "One Border",
|
|
-1, "End of List"
|
|
};
|
|
|
|
|
|
static void TextureMake(long format, long type, long size, GLfloat *src, GLfloat *dest)
|
|
{
|
|
long extract, stride, i, j;
|
|
|
|
size /= 4;
|
|
switch (format) {
|
|
case GL_RED:
|
|
src += 0;
|
|
extract = 1;
|
|
stride = 3;
|
|
break;
|
|
case GL_GREEN:
|
|
src += 1;
|
|
extract = 1;
|
|
stride = 3;
|
|
break;
|
|
case GL_BLUE:
|
|
src += 2;
|
|
extract = 1;
|
|
stride = 3;
|
|
break;
|
|
case GL_ALPHA:
|
|
src += 3;
|
|
extract = 1;
|
|
stride = 3;
|
|
break;
|
|
case GL_RGB:
|
|
src += 0;
|
|
extract = 3;
|
|
stride = 1;
|
|
break;
|
|
case GL_RGBA:
|
|
src += 0;
|
|
extract = 4;
|
|
stride = 0;
|
|
break;
|
|
case GL_LUMINANCE:
|
|
src += 0;
|
|
extract = 1;
|
|
stride = 3;
|
|
break;
|
|
case GL_LUMINANCE_ALPHA:
|
|
src += 0;
|
|
extract = 2;
|
|
stride = 2;
|
|
break;
|
|
}
|
|
switch (type) {
|
|
case GL_UNSIGNED_BYTE:
|
|
{
|
|
unsigned char *ptr = (unsigned char *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (unsigned char)(*src++ * 255.0);
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
case GL_BYTE:
|
|
{
|
|
char *ptr = (char *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (char)(*src++ * 255.0);
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
case GL_UNSIGNED_SHORT:
|
|
{
|
|
unsigned short *ptr = (unsigned short *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (unsigned short)(*src++ * 65535.0);
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
case GL_SHORT:
|
|
{
|
|
short *ptr = (short *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (short)(*src++ * 65535.0);
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
case GL_UNSIGNED_INT:
|
|
{
|
|
unsigned long *ptr = (unsigned long *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (unsigned long)(*src++ * 65535.0);
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
case GL_INT:
|
|
{
|
|
long *ptr = (long *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (long)(*src++ * 65535.0);
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
case GL_FLOAT:
|
|
{
|
|
float *ptr = (float *)dest;
|
|
for (i = 0; i < size; i++) {
|
|
for (j = 0; j < extract; j++) {
|
|
*ptr++ = (float)*src++;
|
|
}
|
|
src += stride;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TextureInit(void *data)
|
|
{
|
|
static GLfloat color[4] = {0.5, 0.5, 0.5, 1.0};
|
|
textureRec *ptr;
|
|
long i;
|
|
|
|
ptr = (textureRec *)malloc(sizeof(textureRec));
|
|
*((void **)data) = (void *)ptr;
|
|
|
|
ptr->enumTable[0] = enum_TextureTarget;
|
|
ptr->enumTable[1] = enum_TextureEnv;
|
|
ptr->enumTable[2] = enum_S_TextureGenMode;
|
|
ptr->enumTable[3] = enum_T_TextureGenMode;
|
|
ptr->enumTable[4] = enum_S_TextureWrapMode;
|
|
ptr->enumTable[5] = enum_T_TextureWrapMode;
|
|
ptr->enumTable[6] = enum_TextureMinFilter;
|
|
ptr->enumTable[7] = enum_TextureMagFilter;
|
|
ptr->enumTable[8] = enum_TexImage_PixelFormat;
|
|
ptr->enumTable[9] = enum_TexImage_PixelType;
|
|
ptr->enumTable[10] = enum_TextureBorder;
|
|
|
|
for (i = 0; i < 11; i++) {
|
|
ptr->index[i] = 0;
|
|
ptr->value[i] = ptr->enumTable[i]->value;
|
|
ptr->name[i] = ptr->enumTable[i]->name;
|
|
}
|
|
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
|
|
glTexParameterfv(ptr->enumTable[0]->value, GL_TEXTURE_BORDER_COLOR, color);
|
|
Probe();
|
|
}
|
|
|
|
long TextureUpdate(void *data)
|
|
{
|
|
textureRec *ptr = (textureRec *)data;
|
|
long flag, i;
|
|
|
|
flag = 1;
|
|
for (i = 10; i >= 0; i--) {
|
|
if (flag) {
|
|
ptr->index[i] += 1;
|
|
if (ptr->enumTable[i][ptr->index[i]].value == -1) {
|
|
ptr->index[i] = 0;
|
|
ptr->value[i] = ptr->enumTable[i]->value;
|
|
ptr->name[i] = ptr->enumTable[i]->name;
|
|
flag = 1;
|
|
} else {
|
|
ptr->value[i] = ptr->enumTable[i][ptr->index[i]].value;
|
|
ptr->name[i] = ptr->enumTable[i][ptr->index[i]].name;
|
|
flag = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return flag;
|
|
}
|
|
|
|
void TextureSet(long enabled, void *data)
|
|
{
|
|
static GLfloat textureSrc[4*4*4] = {
|
|
0.0,0.0,0.0,0.5, 1.0,1.0,1.0,0.5, 0.0,0.0,0.0,0.5, 1.0,1.0,1.0,0.5,
|
|
1.0,1.0,1.0,0.5, 0.0,0.0,0.0,0.5, 1.0,1.0,1.0,0.5, 0.0,0.0,0.0,0.5,
|
|
0.0,0.0,0.0,0.5, 1.0,1.0,1.0,0.5, 0.0,0.0,0.0,0.5, 1.0,1.0,1.0,0.5,
|
|
1.0,1.0,1.0,0.5, 0.0,0.0,0.0,0.5, 1.0,1.0,1.0,0.5, 0.0,0.0,0.0,0.5
|
|
};
|
|
textureRec *ptr = (textureRec *)data;
|
|
GLfloat buf[1], textureDest[1000];
|
|
GLint component;
|
|
GLsizei size;
|
|
|
|
if (enabled) {
|
|
buf[0] = (GLfloat)ptr->enumTable[1]->value;
|
|
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, buf);
|
|
|
|
glTexGeniv(GL_S, GL_TEXTURE_GEN_MODE, (GLint *)&ptr->enumTable[2]->value);
|
|
glTexGeniv(GL_T, GL_TEXTURE_GEN_MODE, (GLint *)&ptr->enumTable[3]->value);
|
|
|
|
buf[0] = (float)ptr->enumTable[4]->value;
|
|
glTexParameterfv(ptr->enumTable[0]->value, GL_TEXTURE_WRAP_S, buf);
|
|
buf[0] = (float)ptr->enumTable[5]->value;
|
|
glTexParameterfv(ptr->enumTable[0]->value, GL_TEXTURE_WRAP_T, buf);
|
|
buf[0] = (float)ptr->enumTable[6]->value;
|
|
glTexParameterfv(ptr->enumTable[0]->value, GL_TEXTURE_MIN_FILTER, buf);
|
|
buf[0] = (float)ptr->enumTable[7]->value;
|
|
glTexParameterfv(ptr->enumTable[0]->value, GL_TEXTURE_MAG_FILTER, buf);
|
|
|
|
TextureMake(ptr->enumTable[8]->value, ptr->enumTable[9]->value, 64, textureSrc, textureDest);
|
|
|
|
switch (ptr->enumTable[8]->value) {
|
|
case GL_RED:
|
|
component = 1;
|
|
break;
|
|
case GL_GREEN:
|
|
component = 1;
|
|
break;
|
|
case GL_BLUE:
|
|
component = 1;
|
|
break;
|
|
case GL_ALPHA:
|
|
component = 1;
|
|
break;
|
|
case GL_RGB:
|
|
component = 3;
|
|
break;
|
|
case GL_RGBA:
|
|
component = 4;
|
|
break;
|
|
case GL_LUMINANCE:
|
|
component = 1;
|
|
break;
|
|
case GL_LUMINANCE_ALPHA:
|
|
component = 2;
|
|
break;
|
|
}
|
|
switch (ptr->enumTable[10]->value) {
|
|
case 0:
|
|
size = 4;
|
|
break;
|
|
case 1:
|
|
size = 2;
|
|
break;
|
|
}
|
|
switch (ptr->enumTable[0]->value) {
|
|
case GL_TEXTURE_1D:
|
|
glTexImage1D(ptr->enumTable[0]->value, 0, component, size, ptr->enumTable[10]->value, ptr->enumTable[8]->value, ptr->enumTable[9]->value, (GLubyte *)textureDest);
|
|
glEnable(GL_TEXTURE_1D);
|
|
break;
|
|
case GL_TEXTURE_2D:
|
|
glTexImage2D(ptr->enumTable[0]->value, 0, component, size, size, ptr->enumTable[10]->value, ptr->enumTable[8]->value, ptr->enumTable[9]->value, (GLubyte *)textureDest);
|
|
glEnable(GL_TEXTURE_2D);
|
|
break;
|
|
}
|
|
} else {
|
|
glDisable(GL_TEXTURE_1D);
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
Probe();
|
|
}
|
|
|
|
void TextureStatus(long enabled, void *data)
|
|
{
|
|
textureRec *ptr = (textureRec *)data;
|
|
|
|
if (enabled) {
|
|
Output("Texture on.\n");
|
|
Output("\t%s.\n", ptr->name[1]);
|
|
Output("\tGL_S, %s, %s, GL_T, %s, %s.\n", ptr->name[2], ptr->name[4],
|
|
ptr->name[3], ptr->name[5]);
|
|
Output("\t%s, %s.\n", ptr->name[6], ptr->name[7]);
|
|
Output("\t%s, %s, %s, %s.\n", ptr->name[0], ptr->name[8], ptr->name[9],
|
|
ptr->name[10]);
|
|
} else {
|
|
Output("Texture off.\n");
|
|
}
|
|
}
|