solid.cxx from gzz at Krugle
Show solid.cxx syntax highlighted
/*
solid.cxx
*
* Copyright (c) 2003, Janne Kujala and Tuomas J. Lukka
*
* This file is part of Gzz.
*
* Gzz is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Gzz is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
* Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with Gzz; if not, write to the Free
* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
*/
/*
* Written by Janne Kujala and Tuomas J. Lukka
*/
#include <math.h>
#include <iostream>
#include <vector>
#include <GL/glut.h>
#include <unistd.h>
#include <sys/time.h>
namespace Perlin {
#include "perlin.c"
}
#include <GummiBasic.hxx>
enum { POLY, DRAWPIX, NVTEX, NVTEX2 } mode = NVTEX2;
int local_light = 1;
typedef Gummi::Point<float> Pt;
typedef Gummi::Point3<float> ZPt;
typedef Gummi::Vector<float> Vec;
typedef Gummi::Vector3<float> ZVec;
#define GLERR { int er = glGetError(); if(er != GL_NO_ERROR) {\
cout << "ERROR "<<__FILE__<<" "<<__LINE__ \
<<gluErrorString(er)<<"\n"; \
abort();\
} \
}
using std::cout;
double offs;
#define ND 512
float func[ND+30][ND+30];
int normals[ND*ND]; // int 0..65535
float fnormals[ND*ND][2];
#define CMAPSIZE 16
GLushort cmap[CMAPSIZE*CMAPSIZE];
GLushort img[ND*ND];
void initf() {
for(int x=0; x<ND+30; x++) {
for(int y=0; y<ND+30; y++) {
double dx = x / (double)ND - 0.5;
double dy = y / (double)ND - 0.5;
#define SCA 10
float vec[3] = { SCA * dx, SCA * dy, 0.5 };
double n1 = 0.1 * Perlin::noise3(vec) / SCA;
vec[0] /= 2;
vec[1] *= 2; vec[1] += 200 * n1;
vec[2] += 3; vec[1] += 5.5;
double n2 = 0.1 * Perlin::noise3(vec) / SCA;
vec[2] += 3;
vec[0] = 120 * (dx+dy) * n1 * 200;
vec[1] = 1 * (dx-dy);
double n3 = 0.01 * Perlin::noise3(vec) / SCA;
vec[0] = 200 * (dx+dy);
vec[1] = 200 * (dx-dy);
double n4 = 0.01 * Perlin::noise3(vec) / SCA;
func[x][y] = (n1 > n2 ? n1 + n4 : n2) >? n3;
}
}
for(int cx=0; cx<ND; cx++) {
for(int cy=0; cy<ND; cy++) {
int x = cx + 1;
int y = cy + 1;
float nx = (func[x+1][y]-func[x-1][y]) * (double)ND;
float ny = (func[x][y+1]-func[x][y-1]) * (double)ND;
normals[cx+cy*ND] = (int)((nx+1)*CMAPSIZE/2) + ((((int)((ny+1)*CMAPSIZE/2 *
CMAPSIZE)) / CMAPSIZE ) * CMAPSIZE);
fnormals[cx+cy*ND][0] = nx;
fnormals[cx+cy*ND][1] = ny;
}
}
}
void vert(int x, int y) {
x = x + 1;
y = y + 1;
float f = func[x][y];
float nx = (func[x+1][y]-func[x-1][y]) * (double)ND;
float ny = (func[x][y+1]-func[x][y-1]) * (double)ND;
float dx = (x / (double)ND - 0.5) * 2.0;
float dy = (y / (double)ND - 0.5) * 2.0;
double nz = sqrt(1-nx*nx-ny*ny);
glNormal3f(nx,ny,nz);
glVertex3f(dx, dy, 0.0);
}
void pla() {
for(int x=0; x<ND; x++) {
glBegin(GL_QUAD_STRIP);
for(int y=0; y<ND+1; y++) {
vert(x, y);
vert(x+1, y);
}
glEnd();
}
}
#define NN 32
#define NSIZ 256
#define WINDOWSIZ 1200
void nvert(int x, int y) {
double dx = x * NSIZ / (WINDOWSIZ/2.0) / NN;
double dy = y * NSIZ / (WINDOWSIZ/2.0) / NN;
float nx = x / (double)NN * 2 - 1;
float ny = y / (double)NN * 2 - 1;
float det = 1-nx*nx-ny*ny;
float nz = (det >= 0 ? sqrt(det) : -10);
glNormal3f(nx, ny, nz);
glVertex3f(dx, dy, 0.0);
cout << nx <<" " <<ny<<" "<<nz<<" "<<dx<< " "<<dy<<"\n";
}
void nors() {
for(int x=0; x<NN; x++) {
glBegin(GL_QUAD_STRIP);
for(int y=0; y<NN+1; y++) {
nvert(x, y);
nvert(x+1, y);
}
glEnd();
}
}
void addlight(float *pos, float *color) {
float posl = sqrt(pos[0] * pos[0] + pos[1] * pos[1] + pos[2] * pos[2]);
for(int i=0; i<CMAPSIZE * CMAPSIZE; i++) {
float nx = (i / CMAPSIZE) / (double)(CMAPSIZE/2) - 1;
float ny = (i % CMAPSIZE) / (double)(CMAPSIZE/2) - 1;
float nz = sqrt(1-nx*nx-ny*ny);
float spec = pow((pos[0] * nx + pos[1] * ny + pos[2] * nz)/posl, 4);
int s = (int)(255 * spec);
cmap[i] = (s >> 3 ) + ((s << 3) & (0x3f << 5)) + ((s << 8) & (0x1f << 13));
// cmap[i] = s + (s<<8) + (s<<16) + (255<<24);
}
}
/* #define POLY */
void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1, 1, 1);
float noiseparam[11] = {
offs, 3 + offs, 2.5, 1-offs, 3.1,
2 + offs, 15 - offs, 3.6, 4 + 2*offs, 5 + 4 * offs,
6*offs
};
#define PNOI(i) { 3 * Perlin::noise3(noiseparam+i), 3 * Perlin::noise3(noiseparam + i + 1), \
Perlin::noise3(noiseparam + i + 2) * 0.5 + 0.5, local_light }
float pos0[4] = PNOI(0);
float col0[4] = { 0.8, 0, 0, 1};
float pos1[4] = PNOI(3);
float pos2[4] = PNOI(8);
glLightfv(GL_LIGHT0, GL_POSITION, pos0);
glLightfv(GL_LIGHT1, GL_POSITION, pos1);
glLightfv(GL_LIGHT2, GL_POSITION, pos2);
glPointSize(20);
glDisable(GL_LIGHTING);
glBegin(GL_POINTS);
glVertex4fv(pos0);
glVertex4fv(pos1);
glVertex4fv(pos2);
glEnd();
glEnable(GL_LIGHTING);
if(mode == POLY) {
glCallList(1);
} else if(mode == DRAWPIX) {
for(int i=0; i<CMAPSIZE*CMAPSIZE; i++) {
cmap[i] = 0;
}
addlight(pos0, col0);
for(int i=0; i<ND*ND; i++) {
img[i] = cmap[normals[i]];
}
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
glDisable(GL_LIGHT1);
glDisable(GL_LIGHT2);
glDisable(GL_BLEND);
glColor3f(1,1,1);
glRasterPos2f(-1,-1);
glDrawPixels(ND, ND, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, img);
glPopAttrib();
// glDrawPixels(ND, ND, GL_RGB, GL_UNSIGNED_BYTE, img);
#ifdef GL_DSDT_NV
} else if(mode == NVTEX) {
glEnable(GL_TEXTURE_SHADER_NV);
glActiveTexture(GL_TEXTURE2);
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, WINDOWSIZ/2, WINDOWSIZ/2,
NSIZ, NSIZ, 0);
// glutSwapBuffers();
// glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
// CMAPSIZE, CMAPSIZE, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, cmap);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glBegin(GL_QUADS);
glMultiTexCoord2f(1, 0.5, 0.5);
// glMultiTexCoord2f(1, 0, 0);
glTexCoord2f(0,0);
glVertex2f(-1,-1);
// glMultiTexCoord2f(1, 1, 1);
glTexCoord2f(0,1);
glVertex2f(-1,0.9);
// glMultiTexCoord2f(1, 0, 1);
glTexCoord2f(1,1);
glVertex2f(1,1);
// glMultiTexCoord2f(1, 1, 0);
glTexCoord2f(1,0);
glVertex2f(1,-1);
glEnd();
glPopAttrib();
} else if(mode == NVTEX2) {
#endif
}
// glDisable(GL_LIGHTING);
glutSwapBuffers();
offs += 0.01;
GLERR
}
void idle() {
glutPostRedisplay();
}
void keypress(unsigned char key, int x, int y) {
cout << key << " pressed\n";
switch (key) {
}
}
void init() {
initf();
glClearColor(0, 0, 0, 1);
glEnable(GL_BLEND);
// glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHT2);
glNewList(1, GL_COMPILE);
pla();
glEndList();
glNewList(2, GL_COMPILE);
nors();
glEndList();
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, 0.0);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
// float diffu[4] = { 0.1, 0.1, 0.1, 1 };
float specu[4] = { 0.8, 0, 0 , 1 };
glLightfv(GL_LIGHT0, GL_DIFFUSE, specu);
glLightfv(GL_LIGHT0, GL_SPECULAR, specu);
glLightfv(GL_LIGHT0, GL_AMBIENT, specu);
specu[1] = 0.8;
glLightfv(GL_LIGHT1, GL_DIFFUSE, specu);
glLightfv(GL_LIGHT1, GL_SPECULAR, specu);
glLightfv(GL_LIGHT1, GL_AMBIENT, specu);
specu[2] = 0.8; specu[0] = 0;
glLightfv(GL_LIGHT2, GL_DIFFUSE, specu);
glLightfv(GL_LIGHT2, GL_SPECULAR, specu);
glLightfv(GL_LIGHT2, GL_AMBIENT, specu);
float mat[4] = { 0.4, 0.4, 0.4, 0.4};
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat);
float amb = 0.15;
float amat[4] = { amb, amb, amb, amb};
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, amat);
float diffumat[4] = { 0.1, 0.1, 0.2, 0.1 };
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffumat);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 2);
GLERR
if(mode == NVTEX) {
//
// ---------------
#ifdef GL_DSDT_NV
glEnable(GL_TEXTURE_SHADER_NV);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 1);
glEnable(GL_TEXTURE_2D);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
GLERR
int c;
#define SHCONST(a) \
glGetTexEnviv(GL_TEXTURE_SHADER_NV, GL_SHADER_CONSISTENT_NV, &c); \
cout << "SCONSISTENT: "<<a<<" "<<c<<"\n";
glTexImage2D(GL_TEXTURE_2D, 0, GL_DSDT_NV,
ND, ND, 0, GL_DSDT_NV, GL_FLOAT, fnormals);
SHCONST("")
GLERR
// ---------------
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,2);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
GLERR
// gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8,
// NOISEW, NOISEH, GL_RGBA, GL_FLOAT, sinetex);
SHCONST("Teximaged")
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
SHCONST("")
GLERR
{
float disp = 1;
GLfloat mat[4] = {disp, 0, 0, disp};
// GLfloat mat[4] = {0.15, 0, 0, 0.15};
// GLfloat mat[4] = {1.2, 0, 0, 1.2};
glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat);
SHCONST("")
}
#endif
} else if(mode == NVTEX2) {
#ifdef GL_DSDT_NV
glEnable(GL_TEXTURE_SHADER_NV);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 1);
glEnable(GL_TEXTURE_2D);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
GLERR
int c;
#define SHCONST(a) \
glGetTexEnviv(GL_TEXTURE_SHADER_NV, GL_SHADER_CONSISTENT_NV, &c); \
cout << "SCONSISTENT: "<<a<<" "<<c<<"\n";
glTexImage2D(GL_TEXTURE_2D, 0, GL_SIGNED_HILO_NV,
ND, ND, 0, GL_HILO_NV, GL_FLOAT, fnormals);
SHCONST("")
GLERR
// ---------------
glActiveTexture(GL_TEXTURE1);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
GLERR
// gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA8,
// NOISEW, NOISEH, GL_RGBA, GL_FLOAT, sinetex);
SHCONST("Teximaged")
// glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
SHCONST("")
GLERR
// ---------------
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP,3);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, 0);
GLERR
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
SHCONST("")
GLERR
// ---------------
glActiveTexture(GL_TEXTURE3);
glEnable(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP,4);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV);
glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, 0);
GLERR
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
SHCONST("")
GLERR
#endif
} else {
#ifdef GL_DSDT_NV
glDisable(GL_TEXTURE_SHADER_NV);
#endif
}
}
void reshape(int w, int h) {
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// glOrtho(0, w, 0, h, -100, 100);
// glTranslatef(0, h, 0);
// glScalef(1, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char **argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
// glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(WINDOWSIZ,WINDOWSIZ);
glutInitWindowPosition(0,0);
glutCreateWindow("fontTest");
init();
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutKeyboardFunc(keypress);
//timer(0);
glutIdleFunc(idle);
glutMainLoop();
return 0;
}
See more files for this project here