static GLuint link_program(GLuint vert, GLuint frag, const char **attributes) {
GLuint program = glCreateProgram();
glAttachShader(program, vert);
glAttachShader(program, frag);
if (attributes) {
unsigned i = 0;
while (*attributes != NULL) {
glBindAttribLocation(program, i, *attributes);
gl_errors();
i++;
attributes++;
}
}
glLinkProgram(program);
GLint result = GL_FALSE;
int log_len;
glGetProgramiv(program, GL_LINK_STATUS, &result);
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_len);
char *prog_err = alloca(log_len + 1);
glGetProgramInfoLog(program, log_len, NULL, prog_err);
if (result != GL_TRUE) {
printf("Linking:\n%s\n", prog_err);
}
return program;
}
void WZMOpenGLWidget::setModel(MODEL *model)
{
double dimension;
if (!model)
{
return;
}
prepareModel(model);
gl_errors();
psModel = model;
// Calculate best z offset
for (int i = 0; i < psModel->meshes; i++)
{
MESH *psMesh = &psModel->mesh[i];
for (int j = 0; j < psMesh->vertices * 3; j++)
{
dimension = MAX(fabs(psMesh->vertexArray[j]), dimension);
}
}
setSceneRadius(dimension);
showEntireScene();
timer.start();
}
int main() {
attribute_count = 0;
SDL_Init(SDL_INIT_VIDEO);
SDL_SetVideoMode(640, 480, 0, SDL_OPENGL);
glewInit();
glEnable(GL_PROGRAM_POINT_SIZE);
glEnable(GL_POINT_SPRITE);
gl_errors();
glClearColor(0.3, 0.4, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
int hold = 1;
extern int glstuff_main(float time);
uint32_t startTime = SDL_GetTicks();
float time = 0.0f;
while (hold && glstuff_main(time) != 0) {
SDL_GL_SwapBuffers();
SDL_Delay(14);
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT || event.type == SDL_KEYDOWN) {
hold = 0;
}
}
uint32_t nowTime = SDL_GetTicks();
time = 0.001f * (nowTime - startTime);
}
SDL_GL_SwapBuffers();
if (hold) {
wait_quit();
}
SDL_Quit();
return 0;
}
void WZMOpenGLWidget::init()
{
qWarning("OpenGL version: %s", glGetString(GL_VERSION));
qWarning("OpenGL renderer: %s", glGetString(GL_RENDERER));
qWarning("OpenGL vendor: %s", glGetString(GL_VENDOR));
glEnable(GL_TEXTURE_2D);
glDisable(GL_FOG);
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, 0.05f);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
gl_errors();
}
void CachedTexture::reload() {
//..... load file ......
GLenum internal_format = GL_RGB;
GLenum data_format = GL_RGB;
unsigned char *data = NULL;
if (filename.size() >= 4 && filename.substr(filename.size()-4,4) == ".png") {
//Load a png file, as per the libpng docs:
FILE *fp = fopen(filename.c_str(), "rb");
if (!fp) {
cerr << " cannot open file." << endl;
return;
}
png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL);
if (!png) {
cerr << " cannot alloc read struct." << endl;
fclose(fp);
return;
}
png_infop info = png_create_info_struct(png);
if (!info) {
cerr << " cannot alloc info struct." << endl;
png_destroy_read_struct(&png, (png_infopp)NULL, (png_infopp)NULL);
fclose(fp);
return;
}
png_bytep *row_pointers = NULL;
if (setjmp(png_jmpbuf(png))) {
cerr << " png interal error." << endl;
png_destroy_read_struct(&png, &info, (png_infopp)NULL);
if (data != NULL) delete[] data;
if (row_pointers != NULL) delete[] row_pointers;
fclose(fp);
return;
}
png_init_io(png, fp);
png_read_info(png, info);
w = png_get_image_width(png, info);
h = png_get_image_height(png, info);
{ //find power-of-two dimensions...
tw = 1;
while (tw < w) tw *= 2;
th = 1;
while (th < h) th *= 2;
}
if (!pad && (tw != w || th != h)) {
if (!have_ARB_texture_non_power_of_two()) {
cerr << "WARNING: trying to load texture of size " << w << " x " << h << ", but non-power-of-two textures not supported." << endl;
}
tw = w;
th = h;
}
if (png_get_color_type(png, info) == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb(png);
if (png_get_bit_depth(png, info) < 8)
png_set_packing(png);
if (png_get_bit_depth(png,info) == 16)
png_set_strip_16(png);
png_read_update_info(png, info);
unsigned int rowbytes = png_get_rowbytes(png, info);
//Make sure it's the format we think it is...
bool problem = false;
if (png_get_color_type(png, info) == PNG_COLOR_TYPE_GRAY) {
data_format = internal_format = GL_LUMINANCE;
if (rowbytes != w*1) problem = true;
} else if (png_get_color_type(png, info) == PNG_COLOR_TYPE_GRAY_ALPHA) {
data_format = internal_format = GL_LUMINANCE_ALPHA;
if (rowbytes != w*2) problem = true;
} else if (png_get_color_type(png, info) == PNG_COLOR_TYPE_PALETTE || png_get_color_type(png, info) == PNG_COLOR_TYPE_RGB) {
data_format = internal_format = GL_RGB;
if (rowbytes != w*3) problem = true;
} else if (png_get_color_type(png, info) == PNG_COLOR_TYPE_RGB_ALPHA) {
data_format = internal_format = GL_RGBA;
if (rowbytes != w*4) problem = true;
} else {
cerr << " unknown color format." << endl;
problem = true;
}
if (problem) {
cerr << " color format problem. (rowbytes: " << rowbytes << " w:" << w << ")" << endl;
png_destroy_read_struct(&png, &info, NULL);
fclose(fp);
return;
}
unsigned int pixelbytes = rowbytes / w;
assert(rowbytes == pixelbytes * w); //sanity check, should have bailed earlier if this was the case.
data = new uint8_t[th*tw*pixelbytes];
row_pointers = new png_bytep[th];
if (flip) {
//texture origin goes top-left, as in most images:
for (unsigned int r = 0; r < th; ++r) {
row_pointers[r] = (png_bytep)(data + r*pixelbytes*tw);
}
} else {
//texture origin goes bottom-left, as GL says:
for (unsigned int r = 0; r < th; ++r) {
row_pointers[th-1-r] = (png_bytep)(data + r*tw*pixelbytes);
}
}
png_read_image(png, row_pointers);
png_destroy_read_struct(&png, &info, NULL);
fclose(fp);
delete[] row_pointers;
if (pad && h != 0 && w != 0) {
//duplicate the last column accross the texture:
for (unsigned int r = 0; r < h; ++r) {
for (unsigned int c = w; c < tw; ++c) {
memcpy(&(data[(r*tw+c)*pixelbytes]), &(data[(r*tw+w-1)*pixelbytes]),pixelbytes);
}
}
//duplicate the last row down the texture:
for (unsigned int r = h; r < th; ++r) {
memcpy(&(data[r*pixelbytes*tw]), &(data[(h-1)*pixelbytes*tw]), pixelbytes*tw);
}
}
} else {
//well, not a supported image type I'm afraid.
cerr << " unknown image type." << endl;
return;
}
glGenTextures(1, &obj);
glBindTexture(GL_TEXTURE_2D, obj);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, internal_format, tw, th, 0, data_format, GL_UNSIGNED_BYTE, data);
glBindTexture(GL_TEXTURE_2D, 0);
glPopClientAttrib();
delete[] data;
loaded = true;
gl_errors("CachedTexture::reload()");
}
