3dpcp/include/show/viewcull.h

171 lines
4.3 KiB
C
Raw Normal View History

2012-09-16 12:33:11 +00:00
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#ifdef _MSC_VER
#include <windows.h>
#include <GL/glu.h>
#include <GL/glut.h>
2012-10-24 09:22:27 +00:00
#elif __APPLE__
#include <GLUT/glut.h>
#include <OpenGl/glu.h>
#include <stdbool.h>
2012-09-16 12:33:11 +00:00
#else
2012-10-24 09:22:27 +00:00
#include <GL/glut.h>
#include <GL/glu.h>
2012-09-16 12:33:11 +00:00
#include <stdbool.h>
#endif
#ifndef __VIEWCULL_H__
#define __VIEWCULL_H__
2012-10-24 09:22:27 +00:00
namespace show{
2012-09-16 12:33:11 +00:00
///////////////////////// Variable declarations...
/** The 6 planes of the viewing frustum */
extern float frustum[6][4];
/** the modelview * projection matrix to map a model point to an onscreen coordinate */
extern float matrix[16];
/** some useful variables for faster calculation of the pixel coordinates */
extern short VP[4];
/** a unit vector pointing to the right of the screen */
extern float right[3];
/** how much detail is shown, 0 means everything is plotted */
extern short DETAIL;
extern double SX, SY, SZ, EX, EY, EZ;
extern float origin[3], dir[3]; /*ray */
extern float dist;
extern int rayX,rayY;
extern float rayVP[4];
#define NUMDIM 3
#define RIGHT 0
#define LEFT 1
#define MIDDLE 2
extern float minB[NUMDIM], maxB[NUMDIM]; /*box */
extern float coord[NUMDIM]; /* hit point */
template <class T> bool HitBoundingBox(const T center[3], T size )
{
minB[0] = center[0] - size;
minB[1] = center[1] - size;
minB[2] = center[2] - size;
maxB[0] = center[0] + size;
maxB[1] = center[1] + size;
maxB[2] = center[2] + size;
bool inside = true;
char quadrant[NUMDIM];
register int i;
int whichPlane;
float maxT[NUMDIM];
float candidatePlane[NUMDIM];
// Find candidate planes; this loop can be avoided if
// rays cast all from the eye(assume perpsective view)
for (i=0; i<NUMDIM; i++)
if(origin[i] < minB[i]) {
quadrant[i] = LEFT;
candidatePlane[i] = minB[i];
inside = false;
}else if (origin[i] > maxB[i]) {
quadrant[i] = RIGHT;
candidatePlane[i] = maxB[i];
inside = false;
}else {
candidatePlane[i] = 0.0;
quadrant[i] = MIDDLE;
}
// Ray origin inside bounding box
if(inside) {
return (true);
}
// Calculate T distances to candidate planes
for (i = 0; i < NUMDIM; i++)
if (quadrant[i] != MIDDLE && dir[i] !=0.)
maxT[i] = (candidatePlane[i]-origin[i]) / dir[i];
else
maxT[i] = -1.;
// Get largest of the maxT's for final choice of intersection
whichPlane = 0;
for (i = 1; i < NUMDIM; i++)
if (maxT[whichPlane] < maxT[i])
whichPlane = i;
// Check final candidate actually inside box
if (maxT[whichPlane] < 0.) return (false);
for (i = 0; i < NUMDIM; i++)
if (whichPlane != i) {
coord[i] = origin[i] + maxT[whichPlane] *dir[i];
if (coord[i] < minB[i] || coord[i] > maxB[i])
return (false);
} else {
coord[i] = candidatePlane[i];
}
return (true); // ray hits box
}
void calcRay(int x, int y, double znear, double zfar);
#include <float.h>
template <class T>
float RayDist(T *point)
{
return point[0] * dir[0] + point[1] * dir[1] + point[2] * dir[2] - dist;
}
template <class T>
short ScreenDist(T *point) {
float pn[3];
// x coordinate on screen, not normalized
pn[0] = point[0] * matrix[0] + point[1] * matrix[4] + point[2] * matrix[8] + matrix[12];
pn[1] = point[0] * matrix[1] + point[1] * matrix[5] + point[2] * matrix[9] + matrix[13];
// normalization
pn[2] = point[0] * matrix[3] + point[1] * matrix[7] + point[2] * matrix[11] + matrix[15];
// normalized x coordinate on screen
pn[0] /= pn[2];
pn[1] /= pn[2];
// true x coordinate in viewport coordinate system
//Xi = pn[0]*VP[0] + VP[1];
//fTempo[4]*0.5+0.5)*viewport[2]+viewport[0];
float XX = ( (pn[0])*rayVP[0] + rayVP[1]);
float YY = ( (pn[1])*rayVP[2] + rayVP[3]);
short dx, dy;
if (XX > rayX) dx = XX-rayX;
else dx = rayX-XX;
if (YY > rayY) dy = YY-rayY;
else dy = rayY-YY;
// for the benefit of visual studio's compiler cast to float
return sqrt((float)(dx*dx + dy*dy));
}
void ExtractFrustum(short detail);
void ExtractFrustum(float *frust[6]);
bool CubeInFrustum( float x, float y, float z, float size );
int CubeInFrustum2( float x, float y, float z, float size );
char PlaneAABB( float x, float y, float z, float size, float *plane );
void remViewport();
bool LOD(float x, float y, float z, float size);
int LOD2(float x, float y, float z, float size);
2012-10-24 09:22:27 +00:00
}
2012-09-16 12:33:11 +00:00
#endif