Matrix rot(double w, double axis[], double point[])
{
////
double theta = w * 180 / M_PI; //needed as glRotate* takes degrees
double matrix[16];
glPushMatrix();
glLoadIdentity();
glTranslated(point[0], point[1], point[2]);
glRotated(theta, axis[0], axis[1], axis[2]);
glTranslated(-point[0], -point[1], -point[2]);
glGetDoublev(GL_MODELVIEW_MATRIX, matrix);
glPopMatrix();
Matrix C(4, 4, matrix);
return C.traspose();
}
void FGLRenderBuffers::ClearFrameBuffer(bool stencil, bool depth)
{
GLboolean scissorEnabled;
GLint stencilValue;
GLdouble depthValue;
glGetBooleanv(GL_SCISSOR_TEST, &scissorEnabled);
glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &stencilValue);
glGetDoublev(GL_DEPTH_CLEAR_VALUE, &depthValue);
glDisable(GL_SCISSOR_TEST);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClearDepth(0.0);
glClearStencil(0);
GLenum flags = GL_COLOR_BUFFER_BIT;
if (stencil)
flags |= GL_STENCIL_BUFFER_BIT;
if (depth)
flags |= GL_DEPTH_BUFFER_BIT;
glClear(flags);
glClearStencil(stencilValue);
glClearDepth(depthValue);
if (scissorEnabled)
glEnable(GL_SCISSOR_TEST);
}
void C3dCamera::SetNearClipPlane(GLdouble fNear)
{
m_fNear = fNear;
// Reset the projection matrix (coordinate system)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(m_bPerspective)
// Perspective transformations.
gluPerspective(m_fFovY, m_fAspect, m_fNear, m_fFar);
else
// Orthographic transformations.
glOrtho(m_fLeft, m_fRight, m_fBottom, m_fTop, m_fNear, m_fFar);
// Save the Projection matrix. This is used later for
// conversion of mouse coordinates to world coordinates.
glGetDoublev(GL_PROJECTION_MATRIX, m_dProjectionMatrix);
// Reset the ModelView matrix
glMatrixMode(GL_MODELVIEW);
}
void output(int x, int y, float r, float g, float b, int font, std::string string)
{
glMatrixMode(GL_PROJECTION); // change the current matrix to PROJECTION
double matrix[16]; // 16 doubles in stack memory
glGetDoublev(GL_PROJECTION_MATRIX, matrix); // get the values from PROJECTION matrix to local variable
glLoadIdentity(); // reset PROJECTION matrix to identity matrix
glOrtho(0, 800, 0, 600, -5, 5); // orthographic perspective
glMatrixMode(GL_MODELVIEW); // change current matrix to MODELVIEW matrix again
glLoadIdentity(); // reset it to identity matrix
glPushMatrix(); // push current state of MODELVIEW matrix to stack
//glLoadIdentity();
glRasterPos2d(10, 10); // raster position in 2D
int len, i;
len = (int)string.size();
for (i = 0; i < len; i++) {
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, string[i]);
}
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glLoadMatrixd(matrix);
glMatrixMode(GL_MODELVIEW);
}
void CBall::Init()
{
static float dif_orange[4] = {0.75,0.4,0.2,1.0};
static float amb_orange[4] = {0.5,0.2,0.1,1.0};
static float spec[4] = {1.0,1.0,1.0,1.0};
glPushMatrix();
glLoadIdentity();
glTranslatef(0.000, 0.000, 1.100);
glGetDoublev(GL_MODELVIEW_MATRIX, position);
glPopMatrix();
material.SetDiffuse(dif_orange);
material.SetAmbient(amb_orange);
material.SetSpecular(spec);
material.SetShininess(300);
radius = 0.040;
//body設定
bBall = dBodyCreate(world);
dBodySetAutoDisableFlag(bBall,0);
dBodySetPosition(bBall, position[12+0], position[12+1], position[12+2]);
dMass mass;
dMassSetSphereTotal(&(mass),0.010,0.040);
dBodySetMass (bBall ,&(mass));
//geom設定
transBall = dCreateGeomTransform(space);
gBall = dCreateSphere (0,0.040);
dGeomSetPosition(gBall, 0 ,0, 0.002);//重心が3mmずれてる
dGeomTransformSetGeom(transBall, gBall);
dGeomSetBody(transBall, bBall);
}
void MapPreview::onMouseMotion(GtkWidget* widget, GdkEventMotion* ev, MapPreview* self) {
if (ev->state & GDK_BUTTON1_MASK) { // dragging with mouse button
static gdouble _lastX = ev->x;
static gdouble _lastY = ev->y;
// Calculate the mouse delta as a vector in the XY plane, and store the
// current position for the next event.
Vector3 deltaPos(ev->x - _lastX,
_lastY - ev->y,
0);
_lastX = ev->x;
_lastY = ev->y;
// Calculate the axis of rotation. This is the mouse vector crossed with the Z axis,
// to give a rotation axis in the XY plane at right-angles to the mouse delta.
static Vector3 _zAxis(0, 0, 1);
Vector3 axisRot = deltaPos.crossProduct(_zAxis);
// Grab the GL widget, and update the modelview matrix with the
// additional rotation
if (gtkutil::GLWidget::makeCurrent(widget)) {
// Premultiply the current modelview matrix with the rotation,
// in order to achieve rotations in eye space rather than object
// space. At this stage we are only calculating and storing the
// matrix for the GLDraw callback to use.
glLoadIdentity();
glRotated(-2, axisRot.x(), axisRot.y(), axisRot.z());
glMultMatrixd(self->_rotation);
// Save the new GL matrix for GL draw
glGetDoublev(GL_MODELVIEW_MATRIX, self->_rotation);
gtk_widget_queue_draw(widget); // trigger the GLDraw method to draw the actual model
}
}
}
void LightPosition::prepare()
{
if (!_lightIsInWorldCoords)
{
glGetLightfv(GL_LIGHT0, GL_POSITION, _lightPositionf);
gmVector4 eyeLP;
for(size_t i = 0; i < 4; i++)
eyeLP[i] = _lightPositionf[i];
GLdouble modelview[16];
glGetDoublev(GL_MODELVIEW_MATRIX,modelview);
gmMatrix4 _m(modelview[0], modelview[4], modelview[8], modelview[12],
modelview[1], modelview[5], modelview[9], modelview[13],
modelview[2], modelview[6], modelview[10], modelview[14],
modelview[3], modelview[7], modelview[11], modelview[15]);
gmMatrix4 _m_inv = _m.inverse();
_lightPosition = _m_inv * eyeLP;
}
else
{
_lightPosition = _lightPositionInput;
}
}
void drawText(const char *text, int length, int x, int y)
{
double *matrix = new double[16];
glMatrixMode(GL_PROJECTION);
glGetDoublev(GL_PROJECTION_MATRIX, matrix);
glLoadIdentity();
glOrtho(0, 800, 0, 600, -5, 5);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glLoadIdentity();
glRasterPos2i(x, y);
for (int i = 0; i < length; i++) {
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, (int) text[i]);
}
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glLoadMatrixd(matrix);
glMatrixMode(GL_MODELVIEW);
}
void CScanLineZBufferView::OnMouseMove(UINT nFlags, CPoint point)
{
// std::cout << logTime() << " 当前屏幕坐标点:" << point.x << " " << point.y << std::endl;
// 没有导入模型
if ( GetDocument()->m_mesh.n_vertices() <= 0) return;
// 处理模型旋转事件
// 保存上一次点击位置
static CPoint prevPointPos(-1, -1);
if (nFlags & MK_LBUTTON)
{
// std::cout << logTime() << " " << "Model Move" << std::endl;
// std::cout << "(" << prevPointPos.x << ", " << prevPointPos.y << ")" << " " << "(" << point.x << ", " << point.y << ")" << std::endl;
if (prevPointPos.x < 0 || prevPointPos.y < 0) prevPointPos = point; // 处理一次点击
// 旋转模型
double x = prevPointPos.x - point.x;
double y = prevPointPos.y - point.y;
double modelview_matrix[16];
glGetDoublev(GL_MODELVIEW_MATRIX, modelview_matrix);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(0., 0., m_z_delta); // 移动到原点
glRotated(sqrt((double)(x*x + y*y)), y, x, 0.0); // 旋转
glTranslated(0., 0., -m_z_delta); // 移回原处
glMultMatrixd(modelview_matrix);
prevPointPos = point;
RedrawWindow();
}
else
{
prevPointPos.x = prevPointPos.y = -1;
}
// CView::OnMouseMove(nFlags, point);
}
//------------------------------------------------------------------------------
// drawFunc() --
//------------------------------------------------------------------------------
void DspRwr::drawFunc()
{
// Need a RWR to draw; if not, just draw a big X
if (rwr == 0) {
glBegin(GL_LINES);
glVertex3d(-1.0, -1.0, 0.0);
glVertex3d( 1.0, 1.0, 0.0);
glVertex3d(-1.0, 1.0, 0.0);
glVertex3d( 1.0, -1.0, 0.0);
glEnd();
return;
}
// ---
// Draw the RWR signal rays
// ---
GLdouble ocolor[4];
glGetDoublev(GL_CURRENT_COLOR,ocolor);
glColor3d(0.0, 1.0, 0.0);
unsigned int n = rwr->getNumberOfRays();
for (unsigned int i = 0; i < n; i++) {
GLdouble azr = (Basic::Angle::D2RCC * rwr->getRayAzimuth(i) );
GLdouble pwr = rwr->getRay(i);
GLdouble up = cos(azr) * pwr;
GLdouble right = sin(azr) * pwr;
glBegin(GL_LINES);
glVertex3d( 0.0, 0.0, 0.0);
glVertex3d( right, up, 0.0);
glEnd();
}
glColor4dv(ocolor);
}
void zprReset() {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(_left,_right,_bottom,_top,_zNear,_zFar);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glGetDoublev(GL_MODELVIEW_MATRIX,_matrix);
double initscale = 1.5/display_r->boxsize_max;
glScalef(initscale,initscale,initscale);
switch(resetOrientation){
case 1:
glRotatef(90,1.,0.,0.);
break;
case 2:
glRotatef(90,1.,0.,0.);
glRotatef(90,0.,0.,1.);
break;
}
glscale = 1.0;
resetOrientation++;
if (resetOrientation>2){
resetOrientation=0;
}
}
// makes sure that the axis aligned box is visible in the camera (and y is up)
void Camera::makeVisible(float xMin, float xMax,
float yMin, float yMax, float zMin, float zMax) {
// float yPos = (yMax + yMin) / 2; // just the average
float yPos = (1.0/5.0) * yMin + (4.0/5.0) * yMax; // lift it up a bit
float xPos, zPos;
// find position (x, z) st when camera is facing along one of these axes
// the box is fully in the view but and as big as possible
float distX = xMax - xMin, distZ = zMax - zMin;
float xAvr = ( xMax + xMin ) / 2;
float zAvr = ( zMax + zMin ) / 2;
if (distX > distZ) {
xPos = xAvr;
zPos = zMin - distX/2;
// TODO check if y fits? --not--> move z more negative
while (distX/2 + distZ > far) { far += 10; } // make sure it's in the picture
// add a little extra so we can see the man from an angle
xPos += 20;
zPos -= 20;
} else {
zPos = zAvr;
xPos = xMin - distZ/2;
// TODO check if y fits? --not--> move x more negative
while (distZ/2 + distX > far) { far += 10; } // make sure it's in the picture
// add a little extra so we can see the man from an angle
zPos += 20;
xPos -= 20;
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
gluLookAt(xPos, yPos, zPos, xAvr, yPos, zAvr, 0, 1.0, 0);
glGetDoublev(GL_MODELVIEW_MATRIX, cameraTrans); // initialize it to identity --> move to resetScene()
glPopMatrix();
}
vector3 RawDataVisualization::Unprojection(vector2 _2Dpos){
float Depth;
int viewport[4];
//double ModelViewMatrix[16]; //Model_view matrix
double ProjectionMatrix[16]; //Projection matrix
glPushMatrix();
glGetIntegerv(GL_VIEWPORT, viewport);
//glGetDoublev(GL_MODELVIEW_MATRIX, ModelViewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, ProjectionMatrix);
glPopMatrix();
glReadPixels((int)_2Dpos.x , viewport[3] - (int)_2Dpos.y , 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &Depth);
double X = _2Dpos.x;
double Y = _2Dpos.y;
double wpos[3] = {0.0 , 0.0 , 0.0};
gluUnProject(X , ((double)viewport[3] - Y) , (double)Depth , ModelViewMatrix2 , ProjectionMatrix , viewport, &wpos[0] , &wpos[1] , &wpos[2]);
return vector3(wpos[0] , wpos[1] , wpos[2]);
}
vec3 Project(const vec3 &p)
{
GLdouble modelMat[16], projMat[16];
GLint viewport[4];
GLdouble winx = 0, winy = 0, winz = 0;
GLdouble objx = p.x, objy = p.y, objz = p.z;
glPushAttrib(GL_ALL_ATTRIB_BITS);
viewport[0] = 0;
viewport[1] = 0;
viewport[2] = 1024;
viewport[3] = 800;
// Use the game camera's modelview matrix
const mat4 &modl = g_Camera.getTransformation();
for(int i=0; i<16; ++i)
{
modelMat[i] = modl[i];
}
// Use the perspective transformation for the projection matrix
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(45, 1024.0f / 768.0f, 0.01f, 5000.0f);
glGetDoublev(GL_PROJECTION_MATRIX, projMat);
glPopMatrix();
// Now project the point to window coords
gluProject(objx, objy, objz, modelMat, projMat, viewport, &winx, &winy, &winz);
glPopAttrib();
return vec3((float)winx, (float)winy, (float)winz);
}
void VisualSceneOCCGeometry :: MouseDblClick (int px, int py)
{
int hits;
// select surface triangle by mouse click
GLuint selbuf[10000];
glSelectBuffer (10000, selbuf);
glRenderMode (GL_SELECT);
GLint viewport[4];
glGetIntegerv (GL_VIEWPORT, viewport);
glMatrixMode (GL_PROJECTION);
glPushMatrix();
GLdouble projmat[16];
glGetDoublev (GL_PROJECTION_MATRIX, projmat);
glLoadIdentity();
gluPickMatrix (px, viewport[3] - py, 1, 1, viewport);
glMultMatrixd (projmat);
glClearColor(backcolor, backcolor, backcolor, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glMultMatrixf (transformationmat);
glInitNames();
glPushName (1);
glPolygonOffset (1, 1);
glEnable (GL_POLYGON_OFFSET_FILL);
glDisable(GL_CLIP_PLANE0);
// Philippose - 30/01/2009
// Enable clipping planes for Selection mode in OCC Geometry
if (vispar.clipenable)
{
Vec<3> n(clipplane[0], clipplane[1], clipplane[2]);
double len = Abs(n);
double mu = -clipplane[3] / (len*len);
Point<3> p (mu * n);
n /= len;
Vec<3> t1 = n.GetNormal ();
Vec<3> t2 = Cross (n, t1);
double xi1mid = (center - p) * t1;
double xi2mid = (center - p) * t2;
glLoadName (0);
glBegin (GL_QUADS);
glVertex3dv (p + (xi1mid-rad) * t1 + (xi2mid-rad) * t2);
glVertex3dv (p + (xi1mid+rad) * t1 + (xi2mid-rad) * t2);
glVertex3dv (p + (xi1mid+rad) * t1 + (xi2mid+rad) * t2);
glVertex3dv (p + (xi1mid-rad) * t1 + (xi2mid+rad) * t2);
glEnd ();
}
glCallList (trilists.Get(1));
glDisable (GL_POLYGON_OFFSET_FILL);
glPopName();
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
glFlush();
hits = glRenderMode (GL_RENDER);
int minname = 0;
GLuint mindepth = 0;
// find clippingplane
GLuint clipdepth = 0; // GLuint(-1);
for (int i = 0; i < hits; i++)
{
int curname = selbuf[4*i+3];
if (!curname) clipdepth = selbuf[4*i+1];
}
for (int i = 0; i < hits; i++)
{
int curname = selbuf[4*i+3];
GLuint curdepth = selbuf[4*i+1];
if (curname && (curdepth> clipdepth) &&
(curdepth < mindepth || !minname))
{
mindepth = curdepth;
minname = curname;
}
}
occgeometry->LowLightAll();
if (minname)
{
occgeometry->fvispar[minname-1].Highlight();
if (vispar.occzoomtohighlightedentity)
occgeometry->changed = OCCGEOMETRYVISUALIZATIONFULLCHANGE;
else
occgeometry->changed = OCCGEOMETRYVISUALIZATIONHALFCHANGE;
cout << "Selected face: " << minname << endl;
}
else
{
occgeometry->changed = OCCGEOMETRYVISUALIZATIONHALFCHANGE;
}
glDisable(GL_CLIP_PLANE0);
SelectFaceInOCCDialogTree (minname);
// Philippose - 30/01/2009
// Set the currently selected face in the array
// for local face mesh size definition
occgeometry->SetSelectedFace(minname);
// selecttimestamp = NextTimeStamp();
}
void Scarry::drawtra(wardraw_t *wd){
st::drawtra(wd);
Scarry *p = this;
Scarry *pt = this;
Mat4d mat;
Vec3d pa, pb, pa0(.01, 0, 0), pb0(-.01, 0, 0);
double scale;
/* if(scarry_cull(pt, wd))
return;*/
if(wd->vw->gc->cullFrustum(pos, getHitRadius()))
return;
scale = fabs(wd->vw->gc->scale(this->pos));
transform(mat);
const double blastscale = .04;
drawCapitalBlast(wd, Vec3d(0, 0, .55), blastscale);
drawCapitalBlast(wd, Vec3d(.08, .08, .55), blastscale);
drawCapitalBlast(wd, Vec3d(-.08, .08, .55), blastscale);
drawCapitalBlast(wd, Vec3d(-.08, -.08, .55), blastscale);
drawCapitalBlast(wd, Vec3d(.08, -.08, .55), blastscale);
pa = pt->rot.trans(pa0);
pa += pt->pos;
pb = pt->rot.trans(pb0);
pb += pt->pos;
glColor4ub(255,255,9,255);
glBegin(GL_LINES);
glVertex3dv(pa);
glVertex3dv(pb);
glEnd();
{
int i;
static const avec3_t lights[] = {
{0, 520 * SCARRY_SCALE, 220 * SCARRY_SCALE},
{0, -520 * SCARRY_SCALE, 220 * SCARRY_SCALE},
{140 * SCARRY_SCALE, 370 * SCARRY_SCALE, 220 * SCARRY_SCALE},
{-140 * SCARRY_SCALE, 370 * SCARRY_SCALE, 220 * SCARRY_SCALE},
{140 * SCARRY_SCALE, -370 * SCARRY_SCALE, 220 * SCARRY_SCALE},
{-140 * SCARRY_SCALE, -370 * SCARRY_SCALE, 220 * SCARRY_SCALE},
{100 * SCARRY_SCALE, -360 * SCARRY_SCALE, -600 * SCARRY_SCALE},
{100 * SCARRY_SCALE, 360 * SCARRY_SCALE, -600 * SCARRY_SCALE},
{ 280 * SCARRY_SCALE, 20 * SCARRY_SCALE, 520 * SCARRY_SCALE},
{ 280 * SCARRY_SCALE, -20 * SCARRY_SCALE, 520 * SCARRY_SCALE},
{-280 * SCARRY_SCALE, 20 * SCARRY_SCALE, 520 * SCARRY_SCALE},
{-280 * SCARRY_SCALE, -20 * SCARRY_SCALE, 520 * SCARRY_SCALE},
{-280 * SCARRY_SCALE, 20 * SCARRY_SCALE, -300 * SCARRY_SCALE},
{-280 * SCARRY_SCALE, -20 * SCARRY_SCALE, -300 * SCARRY_SCALE},
{ 280 * SCARRY_SCALE, 20 * SCARRY_SCALE, -480 * SCARRY_SCALE},
{ 280 * SCARRY_SCALE, -20 * SCARRY_SCALE, -480 * SCARRY_SCALE},
};
avec3_t pos;
double rad = .01;
double t;
GLubyte col[4] = {255, 31, 31, 255};
random_sequence rs;
init_rseq(&rs, (unsigned long)this);
/* color calculation of static navlights */
t = fmod(wd->vw->viewtime + drseq(&rs) * 2., 2.);
if(t < 1.){
rad *= (t + 1.) / 2.;
col[3] *= t;
}
else{
rad *= (2. - t + 1.) / 2.;
col[3] *= 2. - t;
}
for(i = 0 ; i < numof(lights); i++){
mat4vp3(pos, mat, lights[i]);
gldSpriteGlow(pos, rad, col, wd->vw->irot);
}
/* runway lights */
if(1 < scale * .01){
col[0] = 0;
col[1] = 191;
col[2] = 255;
for(i = 0 ; i <= 10; i++){
avec3_t pos0;
pos0[0] = -160 * SCARRY_SCALE;
pos0[1] = 20 * SCARRY_SCALE + .0025;
pos0[2] = (i * -460 + (10 - i) * -960) * SCARRY_SCALE / 10;
rad = .005 * (1. - fmod(i / 10. + t / 2., 1.));
col[3] = 255/*rad * 255 / .01*/;
mat4vp3(pos, mat, pos0);
gldSpriteGlow(pos, rad, col, wd->vw->irot);
pos0[0] = -40 * SCARRY_SCALE;
mat4vp3(pos, mat, pos0);
gldSpriteGlow(pos, rad, col, wd->vw->irot);
pos0[1] = -20 * SCARRY_SCALE - .0025;
mat4vp3(pos, mat, pos0);
gldSpriteGlow(pos, rad, col, wd->vw->irot);
pos0[0] = -160 * SCARRY_SCALE;
mat4vp3(pos, mat, pos0);
gldSpriteGlow(pos, rad, col, wd->vw->irot);
}
}
/* for(i = 0; i < numof(p->turrets); i++)
mturret_drawtra(&p->turrets[i], pt, wd);*/
}
static int init = 0;
static suftex_t *pst;
static suf_t *sufbase = NULL;
if(init == 0) do{
init = 1;
sufbase = CallLoadSUF("models/spacecarrier.bin");
} while(0);
if(sufbase){
static const double normal[3] = {0., 1., 0.};
double scale = SCARRY_SCALE;
static const GLdouble rotaxis[16] = {
-1,0,0,0,
0,1,0,0,
0,0,-1,0,
0,0,0,1,
};
Mat4d mat;
glPushAttrib(GL_TEXTURE_BIT | GL_LIGHTING_BIT | GL_CURRENT_BIT | GL_ENABLE_BIT);
glEnable(GL_CULL_FACE);
glPushMatrix();
transform(mat);
glMultMatrixd(mat);
extern GLuint screentex;
glBindTexture(GL_TEXTURE_2D, screentex);
glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glColor4f(1.,1.,1.,1.);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
Mat4d modelview, proj;
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, proj);
Mat4d trans = proj * modelview;
texture((glPushMatrix(),
glScaled(1./2., 1./2., 1.),
glTranslated(1, 1, 0),
glMultMatrixd(trans)
));
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGendv(GL_S, GL_EYE_PLANE, Vec4d(.9,0,0,0));
glEnable(GL_TEXTURE_GEN_S);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGendv(GL_T, GL_EYE_PLANE, Vec4d(0,.9,0,0));
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGendv(GL_R, GL_EYE_PLANE, Vec4d(0,0,.9,0));
glEnable(GL_TEXTURE_GEN_R);
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeniv(GL_Q, GL_EYE_PLANE, Vec4<int>(0,0,0,1));
glEnable(GL_TEXTURE_GEN_Q);
glPushMatrix();
glScaled(-scale, scale, -scale);
DrawSUF(sufbase, 0, NULL);
glPopMatrix();
texture((glPopMatrix()));
glPopMatrix();
glPopAttrib();
}
}
void Scarry::draw(wardraw_t *wd){
Scarry *const p = this;
static int init = 0;
static suftex_t *pst;
static suf_t *sufbase = NULL;
if(!w)
return;
/* cull object */
/* if(beamer_cull(this, wd))
return;*/
// wd->lightdraws++;
draw_healthbar(this, wd, health / getMaxHealth(), getHitRadius(), -1., capacitor / maxenergy());
if(wd->vw->gc->cullFrustum(pos, getHitRadius()))
return;
#if 0
if(init == 0) do{
init = 1;
sufbase = CallLoadSUF("models/spacecarrier.bin");
if(!sufbase) break;
CallCacheBitmap("bridge.bmp", "bridge.bmp", NULL, NULL);
CallCacheBitmap("beamer_panel.bmp", "beamer_panel.bmp", NULL, NULL);
CallCacheBitmap("bricks.bmp", "bricks.bmp", NULL, NULL);
CallCacheBitmap("runway.bmp", "runway.bmp", NULL, NULL);
suftexparam_t stp;
stp.flags = STP_MAGFIL | STP_MINFIL | STP_ENV;
stp.magfil = GL_LINEAR;
stp.minfil = GL_LINEAR;
stp.env = GL_ADD;
stp.mipmap = 0;
CallCacheBitmap5("engine2.bmp", "engine2br.bmp", &stp, "engine2.bmp", NULL);
pst = AllocSUFTex(sufbase);
extern GLuint screentex;
glNewList(pst->a[0].list, GL_COMPILE);
glBindTexture(GL_TEXTURE_2D, screentex);
glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDisable(GL_LIGHTING);
glEndList();
} while(0);
if(sufbase){
static const double normal[3] = {0., 1., 0.};
double scale = SCARRY_SCALE;
static const GLdouble rotaxis[16] = {
-1,0,0,0,
0,1,0,0,
0,0,-1,0,
0,0,0,1,
};
Mat4d mat;
glPushAttrib(GL_TEXTURE_BIT | GL_LIGHTING_BIT | GL_CURRENT_BIT | GL_ENABLE_BIT);
glPushMatrix();
transform(mat);
glMultMatrixd(mat);
#if 1
for(int i = 0; i < nhitboxes; i++){
Mat4d rot;
glPushMatrix();
gldTranslate3dv(hitboxes[i].org);
rot = hitboxes[i].rot.tomat4();
glMultMatrixd(rot);
hitbox_draw(this, hitboxes[i].sc);
glPopMatrix();
}
#endif
Mat4d modelview, proj;
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
glGetDoublev(GL_PROJECTION_MATRIX, proj);
Mat4d trans = proj * modelview;
texture((glPushMatrix(),
glScaled(1./2., 1./2., 1.),
glTranslated(1, 1, 0),
glMultMatrixd(trans)
));
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGendv(GL_S, GL_EYE_PLANE, Vec4d(1,0,0,0));
glEnable(GL_TEXTURE_GEN_S);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGendv(GL_T, GL_EYE_PLANE, Vec4d(0,1,0,0));
glEnable(GL_TEXTURE_GEN_T);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeniv(GL_R, GL_EYE_PLANE, Vec4<int>(0,0,1,0));
glEnable(GL_TEXTURE_GEN_R);
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeniv(GL_Q, GL_EYE_PLANE, Vec4<int>(0,0,0,1));
glEnable(GL_TEXTURE_GEN_Q);
glPushMatrix();
glScaled(scale, scale, scale);
glMultMatrixd(rotaxis);
DecalDrawSUF(sufbase, SUF_ATR, NULL, pst, NULL, NULL);
glPopMatrix();
texture((glPopMatrix()));
glPopMatrix();
glPopAttrib();
}
#endif
}
int main(int /*argc*/, char** /*argv*/)
{
// Init SDL
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
printf("Could not initialise SDL\n");
return -1;
}
// Center window
char env[] = "SDL_VIDEO_CENTERED=1";
putenv(env);
// Init OpenGL
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
//#ifndef WIN32
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
//#endif
const SDL_VideoInfo* vi = SDL_GetVideoInfo();
bool presentationMode = false;
int width, height;
SDL_Surface* screen = 0;
if (presentationMode)
{
width = 1700;
height = 1000;
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL|SDL_FULLSCREEN);
}
else
{
width = 1700;
height = 1000;
screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL);
}
if (!screen)
{
printf("Could not initialise SDL opengl\n");
return -1;
}
glEnable(GL_MULTISAMPLE);
SDL_WM_SetCaption("Recast Demo", 0);
if (!imguiRenderGLInit("DroidSans.ttf"))
{
printf("Could not init GUI renderer.\n");
SDL_Quit();
return -1;
}
float t = 0.0f;
float timeAcc = 0.0f;
Uint32 lastTime = SDL_GetTicks();
int mx = 0, my = 0;
float rx = 45;
float ry = -45;
float moveW = 0, moveS = 0, moveA = 0, moveD = 0;
float camx = 0, camy = 0, camz = 0, camr = 1000;
float origrx = 0, origry = 0;
int origx = 0, origy = 0;
float scrollZoom = 0;
bool rotate = false;
bool movedDuringRotate = false;
float rays[3], raye[3];
bool mouseOverMenu = false;
bool showMenu = !presentationMode;
bool showLog = false;
bool showTools = true;
bool showLevels = false;
bool showSample = false;
bool showTestCases = false;
int propScroll = 0;
int logScroll = 0;
int toolsScroll = 0;
char sampleName[64] = "Choose Sample...";
FileList files;
char meshName[128] = "Choose Mesh...";
float mpos[3] = {0,0,0};
bool mposSet = false;
SlideShow slideShow;
slideShow.init("slides/");
InputGeom* geom = 0;
Sample* sample = 0;
TestCase* test = 0;
BuildContext ctx;
glEnable(GL_CULL_FACE);
float fogCol[4] = { 0.32f, 0.31f, 0.30f, 1.0f };
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, camr*0.1f);
glFogf(GL_FOG_END, camr*1.25f);
glFogfv(GL_FOG_COLOR, fogCol);
glDepthFunc(GL_LEQUAL);
bool done = false;
while(!done)
{
// Handle input events.
int mscroll = 0;
bool processHitTest = false;
bool processHitTestShift = false;
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
// Handle any key presses here.
if (event.key.keysym.sym == SDLK_ESCAPE)
{
done = true;
}
else if (event.key.keysym.sym == SDLK_t)
{
showLevels = false;
showSample = false;
showTestCases = true;
scanDirectory("Tests", ".txt", files);
}
else if (event.key.keysym.sym == SDLK_TAB)
{
showMenu = !showMenu;
}
else if (event.key.keysym.sym == SDLK_SPACE)
{
if (sample)
sample->handleToggle();
}
else if (event.key.keysym.sym == SDLK_1)
{
if (sample)
sample->handleStep();
}
else if (event.key.keysym.sym == SDLK_9)
{
if (geom)
geom->save("geomset.txt");
}
else if (event.key.keysym.sym == SDLK_0)
{
delete geom;
geom = new InputGeom;
if (!geom || !geom->load(&ctx, "geomset.txt"))
{
delete geom;
geom = 0;
showLog = true;
logScroll = 0;
ctx.dumpLog("Geom load log %s:", meshName);
}
if (sample && geom)
{
sample->handleMeshChanged(geom);
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.2f);
glFogf(GL_FOG_END, camr*1.25f);
}
}
else if (event.key.keysym.sym == SDLK_RIGHT)
{
slideShow.nextSlide();
}
else if (event.key.keysym.sym == SDLK_LEFT)
{
slideShow.prevSlide();
}
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_RIGHT)
{
if (!mouseOverMenu)
{
// Rotate view
rotate = true;
movedDuringRotate = false;
origx = mx;
origy = my;
origrx = rx;
origry = ry;
}
}
else if (event.button.button == SDL_BUTTON_WHEELUP)
{
if (mouseOverMenu)
mscroll--;
else
scrollZoom -= 1.0f;
}
else if (event.button.button == SDL_BUTTON_WHEELDOWN)
{
if (mouseOverMenu)
mscroll++;
else
scrollZoom += 1.0f;
}
break;
case SDL_MOUSEBUTTONUP:
// Handle mouse clicks here.
if (event.button.button == SDL_BUTTON_RIGHT)
{
rotate = false;
if (!mouseOverMenu)
{
if (!movedDuringRotate)
{
processHitTest = true;
processHitTestShift = true;
}
}
}
else if (event.button.button == SDL_BUTTON_LEFT)
{
if (!mouseOverMenu)
{
processHitTest = true;
processHitTestShift = (SDL_GetModState() & KMOD_SHIFT) ? true : false;
}
}
break;
case SDL_MOUSEMOTION:
mx = event.motion.x;
my = height-1 - event.motion.y;
if (rotate)
{
int dx = mx - origx;
int dy = my - origy;
rx = origrx - dy*0.25f;
ry = origry + dx*0.25f;
if (dx*dx+dy*dy > 3*3)
movedDuringRotate = true;
}
break;
case SDL_QUIT:
done = true;
break;
default:
break;
}
}
unsigned char mbut = 0;
if (SDL_GetMouseState(0,0) & SDL_BUTTON_LMASK)
mbut |= IMGUI_MBUT_LEFT;
if (SDL_GetMouseState(0,0) & SDL_BUTTON_RMASK)
mbut |= IMGUI_MBUT_RIGHT;
Uint32 time = SDL_GetTicks();
float dt = (time - lastTime) / 1000.0f;
lastTime = time;
t += dt;
// Hit test mesh.
if (processHitTest && geom && sample)
{
float hitt;
bool hit = geom->raycastMesh(rays, raye, hitt);
if (hit)
{
if (SDL_GetModState() & KMOD_CTRL)
{
// Marker
mposSet = true;
mpos[0] = rays[0] + (raye[0] - rays[0])*hitt;
mpos[1] = rays[1] + (raye[1] - rays[1])*hitt;
mpos[2] = rays[2] + (raye[2] - rays[2])*hitt;
}
else
{
float pos[3];
pos[0] = rays[0] + (raye[0] - rays[0])*hitt;
pos[1] = rays[1] + (raye[1] - rays[1])*hitt;
pos[2] = rays[2] + (raye[2] - rays[2])*hitt;
sample->handleClick(rays, pos, processHitTestShift);
}
}
else
{
if (SDL_GetModState() & KMOD_CTRL)
{
// Marker
mposSet = false;
}
}
}
// Update sample simulation.
const float SIM_RATE = 20;
const float DELTA_TIME = 1.0f/SIM_RATE;
timeAcc = rcClamp(timeAcc+dt, -1.0f, 1.0f);
int simIter = 0;
while (timeAcc > DELTA_TIME)
{
timeAcc -= DELTA_TIME;
if (simIter < 5)
{
if (sample)
sample->handleUpdate(DELTA_TIME);
}
simIter++;
}
// Clamp the framerate so that we do not hog all the CPU.
const float MIN_FRAME_TIME = 1.0f/40.0f;
if (dt < MIN_FRAME_TIME)
{
int ms = (int)((MIN_FRAME_TIME - dt)*1000.0f);
if (ms > 10) ms = 10;
if (ms >= 0)
SDL_Delay(ms);
}
// Update and render
glViewport(0, 0, width, height);
glClearColor(0.3f, 0.3f, 0.32f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_TEXTURE_2D);
// Render 3d
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0f, (float)width/(float)height, 1.0f, camr);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(rx,1,0,0);
glRotatef(ry,0,1,0);
glTranslatef(-camx, -camy, -camz);
// Get hit ray position and direction.
GLdouble proj[16];
GLdouble model[16];
GLint view[4];
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetIntegerv(GL_VIEWPORT, view);
GLdouble x, y, z;
gluUnProject(mx, my, 0.0f, model, proj, view, &x, &y, &z);
rays[0] = (float)x; rays[1] = (float)y; rays[2] = (float)z;
gluUnProject(mx, my, 1.0f, model, proj, view, &x, &y, &z);
raye[0] = (float)x; raye[1] = (float)y; raye[2] = (float)z;
// Handle keyboard movement.
Uint8* keystate = SDL_GetKeyState(NULL);
moveW = rcClamp(moveW + dt * 4 * (keystate[SDLK_w] ? 1 : -1), 0.0f, 1.0f);
moveS = rcClamp(moveS + dt * 4 * (keystate[SDLK_s] ? 1 : -1), 0.0f, 1.0f);
moveA = rcClamp(moveA + dt * 4 * (keystate[SDLK_a] ? 1 : -1), 0.0f, 1.0f);
moveD = rcClamp(moveD + dt * 4 * (keystate[SDLK_d] ? 1 : -1), 0.0f, 1.0f);
float keybSpeed = 22.0f;
if (SDL_GetModState() & KMOD_SHIFT)
keybSpeed *= 4.0f;
float movex = (moveD - moveA) * keybSpeed * dt;
float movey = (moveS - moveW) * keybSpeed * dt;
movey += scrollZoom * 2.0f;
scrollZoom = 0;
camx += movex * (float)model[0];
camy += movex * (float)model[4];
camz += movex * (float)model[8];
camx += movey * (float)model[2];
camy += movey * (float)model[6];
camz += movey * (float)model[10];
glEnable(GL_FOG);
if (sample)
sample->handleRender();
if (test)
test->handleRender();
glDisable(GL_FOG);
// Render GUI
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
mouseOverMenu = false;
imguiBeginFrame(mx,my,mbut,mscroll);
if (sample)
{
sample->handleRenderOverlay((double*)proj, (double*)model, (int*)view);
}
if (test)
{
if (test->handleRenderOverlay((double*)proj, (double*)model, (int*)view))
mouseOverMenu = true;
}
// Help text.
if (showMenu)
{
const char msg[] = "W/S/A/D: Move RMB: Rotate";
imguiDrawText(280, height-20, IMGUI_ALIGN_LEFT, msg, imguiRGBA(255,255,255,128));
}
if (showMenu)
{
if (imguiBeginScrollArea("Properties", width-250-10, 10, 250, height-20, &propScroll))
mouseOverMenu = true;
if (imguiCheck("Show Log", showLog))
showLog = !showLog;
if (imguiCheck("Show Tools", showTools))
showTools = !showTools;
imguiSeparator();
imguiLabel("Sample");
if (imguiButton(sampleName))
{
if (showSample)
{
showSample = false;
}
else
{
showSample = true;
showLevels = false;
showTestCases = false;
}
}
imguiSeparator();
imguiLabel("Input Mesh");
if (imguiButton(meshName))
{
if (showLevels)
{
showLevels = false;
}
else
{
showSample = false;
showTestCases = false;
showLevels = true;
scanDirectory("Meshes", ".obj", files);
}
}
if (geom)
{
char text[64];
snprintf(text, 64, "Verts: %.1fk Tris: %.1fk",
geom->getMesh()->getVertCount()/1000.0f,
geom->getMesh()->getTriCount()/1000.0f);
imguiValue(text);
}
imguiSeparator();
if (geom && sample)
{
imguiSeparatorLine();
sample->handleSettings();
if (imguiButton("Build"))
{
ctx.resetLog();
if (!sample->handleBuild())
{
showLog = true;
logScroll = 0;
}
ctx.dumpLog("Build log %s:", meshName);
// Clear test.
delete test;
test = 0;
}
imguiSeparator();
}
if (sample)
{
imguiSeparatorLine();
sample->handleDebugMode();
}
imguiEndScrollArea();
}
// Sample selection dialog.
if (showSample)
{
static int levelScroll = 0;
if (imguiBeginScrollArea("Choose Sample", width-10-250-10-200, height-10-250, 200, 250, &levelScroll))
mouseOverMenu = true;
Sample* newSample = 0;
for (int i = 0; i < g_nsamples; ++i)
{
if (imguiItem(g_samples[i].name))
{
newSample = g_samples[i].create();
if (newSample)
strcpy(sampleName, g_samples[i].name);
}
}
if (newSample)
{
delete sample;
sample = newSample;
sample->setContext(&ctx);
if (geom && sample)
{
sample->handleMeshChanged(geom);
}
showSample = false;
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.1f);
glFogf(GL_FOG_END, camr*1.25f);
}
imguiEndScrollArea();
}
// Level selection dialog.
if (showLevels)
{
static int levelScroll = 0;
if (imguiBeginScrollArea("Choose Level", width-10-250-10-200, height-10-450, 200, 450, &levelScroll))
mouseOverMenu = true;
int levelToLoad = -1;
for (int i = 0; i < files.size; ++i)
{
if (imguiItem(files.files[i]))
levelToLoad = i;
}
if (levelToLoad != -1)
{
strncpy(meshName, files.files[levelToLoad], sizeof(meshName));
meshName[sizeof(meshName)-1] = '\0';
showLevels = false;
delete geom;
geom = 0;
char path[256];
strcpy(path, "Meshes/");
strcat(path, meshName);
geom = new InputGeom;
if (!geom || !geom->loadMesh(&ctx, path))
{
delete geom;
geom = 0;
showLog = true;
logScroll = 0;
ctx.dumpLog("Geom load log %s:", meshName);
}
if (sample && geom)
{
sample->handleMeshChanged(geom);
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.1f);
glFogf(GL_FOG_END, camr*1.25f);
}
}
imguiEndScrollArea();
}
// Test cases
if (showTestCases)
{
static int testScroll = 0;
if (imguiBeginScrollArea("Choose Test To Run", width-10-250-10-200, height-10-450, 200, 450, &testScroll))
mouseOverMenu = true;
int testToLoad = -1;
for (int i = 0; i < files.size; ++i)
{
if (imguiItem(files.files[i]))
testToLoad = i;
}
if (testToLoad != -1)
{
char path[256];
strcpy(path, "Tests/");
strcat(path, files.files[testToLoad]);
test = new TestCase;
if (test)
{
// Load the test.
if (!test->load(path))
{
delete test;
test = 0;
}
// Create sample
Sample* newSample = 0;
for (int i = 0; i < g_nsamples; ++i)
{
if (strcmp(g_samples[i].name, test->getSampleName()) == 0)
{
newSample = g_samples[i].create();
if (newSample) strcpy(sampleName, g_samples[i].name);
}
}
if (newSample)
{
delete sample;
sample = newSample;
sample->setContext(&ctx);
showSample = false;
}
// Load geom.
strcpy(meshName, test->getGeomFileName());
meshName[sizeof(meshName)-1] = '\0';
delete geom;
geom = 0;
strcpy(path, "Meshes/");
strcat(path, meshName);
geom = new InputGeom;
if (!geom || !geom->loadMesh(&ctx, path))
{
delete geom;
geom = 0;
showLog = true;
logScroll = 0;
ctx.dumpLog("Geom load log %s:", meshName);
}
if (sample && geom)
{
sample->handleMeshChanged(geom);
}
// This will ensure that tile & poly bits are updated in tiled sample.
if (sample)
sample->handleSettings();
ctx.resetLog();
if (sample && !sample->handleBuild())
{
ctx.dumpLog("Build log %s:", meshName);
}
if (geom || sample)
{
const float* bmin = 0;
const float* bmax = 0;
if (sample)
{
bmin = sample->getBoundsMin();
bmax = sample->getBoundsMax();
}
else if (geom)
{
bmin = geom->getMeshBoundsMin();
bmax = geom->getMeshBoundsMax();
}
// Reset camera and fog to match the mesh bounds.
if (bmin && bmax)
{
camr = sqrtf(rcSqr(bmax[0]-bmin[0]) +
rcSqr(bmax[1]-bmin[1]) +
rcSqr(bmax[2]-bmin[2])) / 2;
camx = (bmax[0] + bmin[0]) / 2 + camr;
camy = (bmax[1] + bmin[1]) / 2 + camr;
camz = (bmax[2] + bmin[2]) / 2 + camr;
camr *= 3;
}
rx = 45;
ry = -45;
glFogf(GL_FOG_START, camr*0.2f);
glFogf(GL_FOG_END, camr*1.25f);
}
// Do the tests.
if (sample)
test->doTests(sample->getNavMesh(), sample->getNavMeshQuery());
}
}
imguiEndScrollArea();
}
// Log
if (showLog && showMenu)
{
if (imguiBeginScrollArea("Log", 250+20, 10, width - 300 - 250, 200, &logScroll))
mouseOverMenu = true;
for (int i = 0; i < ctx.getLogCount(); ++i)
imguiLabel(ctx.getLogText(i));
imguiEndScrollArea();
}
// Tools
if (!showTestCases && showTools && showMenu) // && geom && sample)
{
if (imguiBeginScrollArea("Tools", 10, 10, 250, height-20, &toolsScroll))
mouseOverMenu = true;
if (sample)
sample->handleTools();
imguiEndScrollArea();
}
slideShow.updateAndDraw(dt, (float)width, (float)height);
// Marker
if (mposSet && gluProject((GLdouble)mpos[0], (GLdouble)mpos[1], (GLdouble)mpos[2],
model, proj, view, &x, &y, &z))
{
// Draw marker circle
glLineWidth(5.0f);
glColor4ub(240,220,0,196);
glBegin(GL_LINE_LOOP);
const float r = 25.0f;
for (int i = 0; i < 20; ++i)
{
const float a = (float)i / 20.0f * RC_PI*2;
const float fx = (float)x + cosf(a)*r;
const float fy = (float)y + sinf(a)*r;
glVertex2f(fx,fy);
}
glEnd();
glLineWidth(1.0f);
}
imguiEndFrame();
imguiRenderGLDraw();
glEnable(GL_DEPTH_TEST);
SDL_GL_SwapBuffers();
}
imguiRenderGLDestroy();
SDL_Quit();
delete sample;
delete geom;
return 0;
}
inline void updateProjectionState() {
glGetDoublev(GL_MODELVIEW_MATRIX, modelviewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projectionMatrix);
glGetIntegerv(GL_VIEWPORT, viewport);
}
void draw_arrow(
float ax, float ay, float az,
float bx, float by, float bz,
float ah, float bh,
char const * const annotation,
float annot_size )
{
int i;
GLdouble mv[16];
glGetDoublev(GL_MODELVIEW_MATRIX, mv);
/* We're assuming the modelview RS part is (isotropically scaled)
* orthonormal, so the inverse is the transpose.
* The local view direction vector is the 3rd column of the matrix;
* assuming the view direction to be the normal on the arrows tangent
* space taking the cross product of this with the arrow direction
* yields the binormal to be used as the orthonormal base to the
* arrow direction to be used for drawing the arrowheads */
double d[3] = {
bx - ax,
by - ay,
bz - az
};
normalize_v(d);
double r[3] = { mv[0], mv[4], mv[8] };
int rev = scalarproduct_v(d, r) < 0.;
double n[3] = { mv[2], mv[6], mv[10] };
{
double const s = scalarproduct_v(d,n);
for(int i = 0; i < 3; i++)
n[i] -= d[i]*s;
}
normalize_v(n);
double b[3];
crossproduct_v(n, d, b);
GLfloat const pos[][3] = {
{ax, ay, az},
{bx, by, bz},
{ ax + (0.866*d[0] + 0.5*b[0])*ah,
ay + (0.866*d[1] + 0.5*b[1])*ah,
az + (0.866*d[2] + 0.5*b[2])*ah },
{ ax + (0.866*d[0] - 0.5*b[0])*ah,
ay + (0.866*d[1] - 0.5*b[1])*ah,
az + (0.866*d[2] - 0.5*b[2])*ah },
{ bx + (-0.866*d[0] + 0.5*b[0])*bh,
by + (-0.866*d[1] + 0.5*b[1])*bh,
bz + (-0.866*d[2] + 0.5*b[2])*bh },
{ bx + (-0.866*d[0] - 0.5*b[0])*bh,
by + (-0.866*d[1] - 0.5*b[1])*bh,
bz + (-0.866*d[2] - 0.5*b[2])*bh }
};
GLushort const idx_line[][2] = {
{0, 1},
};
GLushort const idx_heads[][3] = {
{0, 2, 3},
{1, 4, 5}
};
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, pos);
glDrawElements(GL_LINES, 2, GL_UNSIGNED_SHORT, idx_line);
glDrawElements(GL_TRIANGLES, 2*3, GL_UNSIGNED_SHORT, idx_heads);
glDisableClientState(GL_VERTEX_ARRAY);
if(annotation) {
float w = 0;
for(char const *c = annotation; *c; c++)
w += glutStrokeWidth(GLUT_STROKE_ROMAN, *c);
w *= annot_size / 100.;
float tx = (ax + bx)/2.;
float ty = (ay + by)/2.;
float tz = (az + bz)/2.;
GLdouble r[16] = {
d[0], d[1], d[2], 0,
b[0], b[1], b[2], 0,
n[0], n[1], n[2], 0,
0, 0, 0, 1
};
glPushMatrix();
glTranslatef(tx, ty, tz);
glMultMatrixd(r);
if(rev)
glScalef(-1, -1, 1);
glTranslatef(-w/2., annot_size*0.1, 0);
draw_strokestring(GLUT_STROKE_ROMAN, annot_size, annotation);
glPopMatrix();
}
}
void LineBuilderState::mousePressEvent(QMouseEvent *pe)
{
if (log)
Logger::getLogger()->infoLog() << "LineBuilderState::mousePressEvent(QMouseEvent *pe)\n";
ptrMousePosition = pe->pos();
switch (pe->button())
{
case Qt::LeftButton:
{
leftButtonIsPressed = true;
if (lineBroken == NULL)
{
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLfloat winX, winY, winZ;
GLdouble posX = 0.0, posY = 0.0, posZ = 0.0;
glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
glGetDoublev( GL_PROJECTION_MATRIX, projection );
glGetIntegerv( GL_VIEWPORT, viewport );
winX = (float)pe->pos().x();
winY = (float)viewport[3] - (float)pe->pos().y();
glReadPixels( int(winX), int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ);
float x = posX / scene->nSca + scene->xDelta;
float y = posY / scene->nSca + scene->yDelta;
float axis[6];
axis[0] = x - 2.5f;
axis[1] = y;
axis[2] = 0.02f;
axis[3] = x + 2.5f;
axis[4] = y;
axis[5] = 0.02f;
lineBroken = new LineBroken(0.1f, axis, 6, QString("LineBroken"), 1);
model->getGroup(1).push_back(lineBroken);
groupIndex = 1;
elementIndex = model->getGroup(1).size() - 1;
lineBroken->setSelectedStatus(true);
lineBroken->getProperties(properties, scene);
lineBroken->setFixed(false);
model->setModified(true);
}
else
{
if (this->tryToSelectControlsInSelectedFigure(ptrMousePosition) == true)
{
controlIsSelected = true;
switch (key)
{
case Qt::Key_Control:
{
if (controlIndex == lineBroken->getNumberOfControls() - 1)
{
//lineBroken->addBreak(false);
RoadElement::undoStack->push(new AddLineBrokenBreakCommand(lineBroken, false, scene));
controlIndex = lineBroken->getNumberOfControls() - 1;
}
else
if (controlIndex == 0)
{
//lineBroken->addBreak(true);
RoadElement::undoStack->push(new AddLineBrokenBreakCommand(lineBroken, true, scene));
controlIndex = 0;
}
}
break;
default:
break;
}
if (resizeByControlCommand == NULL)
resizeByControlCommand = new ResizeByControlCommand(lineBroken,controlIndex, scene);
scene->setCursor(lineBroken->getCursorForControlElement(controlIndex));
scene->updateGL();
}
else
{
if (this->tryToSelectFigures(ptrMousePosition) == true)
{
// oldX = (GLdouble)ptrMousePosition.x()/
// scene->width()/(scene->nSca * scene->ratio) * 2.0;
// oldY = (GLdouble)(scene->height() - ptrMousePosition.y())/
// scene->width()/(scene->nSca * scene->ratio) * 2.0;
scene->getWorldCoord(ptrMousePosition, oldX, oldY);
scene->setCursor(Qt::SizeAllCursor);
scene->updateGL();
}
else
{
// Переключить в состояние по умолчанию
clear();
scene->setMouseTracking(false);
scene->setCursor(Qt::ArrowCursor);
scene->updateGL();
stateManager->setState(stateManager->defaultState);
}
}
}
scene->updateGL();
}
break;
case Qt::RightButton:
rightButtonIsPressed = true;
break;
default:
break;
}
scene->updateGL();
}
//*********************************
// OnButtonRun
//*********************************
void CDialogWmf::OnButtonRun()
{
BeginWaitCursor();
UpdateData(TRUE);
// Get DC
CDC *pDC = m_pDoc->GetView()->GetDC();
ASSERT(pDC);
// Get view rect
CRect rect;
m_pDoc->GetView()->GetClientRect(&rect);
rect.InflateRect(5,5);
// Create metafile device context
HDC hMetaDC = CreateEnhMetaFile(pDC->m_hDC,"metafile.emf",NULL,NULL);
if(!hMetaDC)
{
AfxMessageBox("Unable to create MetaFile");
ReleaseDC(pDC);
return;
}
// Get DC from handle
CDC *pMetaDC = CDC::FromHandle(hMetaDC);
ASSERT(pMetaDC);
pMetaDC->SetMapMode(MM_TEXT);
// Position / translation / scale
glPushMatrix();
CMeshView *pView = (CMeshView *)m_pDoc->GetView();
glTranslated(pView->m_xTranslation,pView->m_yTranslation,pView->m_zTranslation);
glRotatef(pView->m_xRotation, 1.0, 0.0, 0.0);
glRotatef(pView->m_yRotation, 0.0, 1.0, 0.0);
glRotatef(pView->m_zRotation, 0.0, 0.0, 1.0);
glScalef(pView->m_xScaling,pView->m_yScaling,pView->m_zScaling);
// Get OpenGL parameters
GLdouble modelMatrix[16];
GLdouble projMatrix[16];
GLint viewport[4];
glGetDoublev(GL_MODELVIEW_MATRIX,modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX,projMatrix);
glGetIntegerv(GL_VIEWPORT,viewport);
// Start rendering via std GDI 2D drawing functions
CSceneGraph3d *pScene = &m_pDoc->m_SceneGraph;
for(int i=0;i<pScene->NbObject();i++)
{
CObject3d *pObject = pScene->GetAt(i);
if(pObject->GetType() == TYPE_MESH3D) // meshes only
// The line mode (no sort)
if(m_Mode == MODE_LINE)
((CMesh3d *)pObject)->glDrawProjectLine(pMetaDC,
modelMatrix,
projMatrix,
viewport,
m_ColorLine,
m_Ratio,
rect.Height());
else
// The face mode (faces are z-sorted
// according to their barycenter)
((CMesh3d *)pObject)->glDrawProjectFace(pMetaDC,
modelMatrix,
projMatrix,
viewport,
m_ColorLine,
m_ColorFace,
m_Ratio,
rect.Height(),
m_RatioNbFaces);
}
glPopMatrix();
// Close metafile
HENHMETAFILE hMetaFile = CloseEnhMetaFile(hMetaDC);
// Fill the clipboard (direct sent to wmf2eps or
// any windows app such as Powerpoint)
OpenClipboard();
EmptyClipboard();
SetClipboardData(CF_ENHMETAFILE,CopyEnhMetaFile(hMetaFile,NULL));
CloseClipboard();
// Cleanup
DeleteEnhMetaFile(hMetaFile);
ReleaseDC(pDC);
EndWaitCursor();
}
void
screen_display(void)
{
GLfloat pos[4], lKa[4], lKd[4], lKs[4];
GLfloat dir[3], mKa[4], mKd[4], mKs[4], mKe[4];
GLfloat lmKa[4];
cell_vector(pos, light_pos, 4);
cell_vector(lKa, light_Ka, 4);
cell_vector(lKd, light_Kd, 4);
cell_vector(lKs, light_Ks, 4);
cell_vector(dir, spot_direction, 3);
cell_vector(mKa, material_Ka, 4);
cell_vector(mKd, material_Kd, 4);
cell_vector(mKs, material_Ks, 4);
cell_vector(mKe, material_Ke, 4);
cell_vector(lmKa, lmodel_Ka, 4);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, local_viewer.value);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, two_side.value);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmKa);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, lKa);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lKd);
glLightfv(GL_LIGHT0, GL_SPECULAR, lKs);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);
glLighti(GL_LIGHT0, GL_SPOT_EXPONENT, (int)spot_exponent.value);
if (spot_cutoff.value > 90)
glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, 180);
else
glLighti(GL_LIGHT0, GL_SPOT_CUTOFF, (int)spot_cutoff.value);
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, Kc.value);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, Kl.value);
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, Kq.value);
glMaterialfv(GL_FRONT, GL_AMBIENT, mKa);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mKd);
glMaterialfv(GL_FRONT, GL_SPECULAR, mKs);
glMaterialfv(GL_FRONT, GL_EMISSION, mKe);
glMaterialf(GL_FRONT, GL_SHININESS, material_Se.value);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(spin_y, 1.0, 0.0, 0.0);
glRotatef(spin_x, 0.0, 1.0, 0.0);
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
if (pmodel)
drawmodel();
else
glutSolidTorus(0.25, 0.75, 28, 28);
glPopMatrix();
#if 0
#define TESS 20
glNormal3f(0.0, 1.0, 0.0);
for (i = 0; i < TESS; i++) {
glBegin(GL_TRIANGLE_STRIP);
for (j = 0; j <= TESS; j++) {
glVertex3f(-1+(float)i/TESS*2, -1.0, -1+(float)j/TESS*2);
glVertex3f(-1+(float)(i+1)/TESS*2, -1.0, -1+(float)j/TESS*2);
}
glEnd();
}
#endif
glutSwapBuffers();
}
void Frame::select(int mouse_x, int mouse_y)
{
GLuint buffer[512];
GLint hits;
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
glSelectBuffer(512, buffer);
mouse_y = (viewport[3]-mouse_y);
glRenderMode(GL_SELECT);
glInitNames();
glPushName(0);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPickMatrix((GLdouble) mouse_x, (GLdouble) mouse_y, 1.0f, 1.0f, viewport);
gluPerspective(m_fov, (GLfloat) (viewport[2]-viewport[0])/(GLfloat) (viewport[3]-viewport[1]), 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
DrawGLScene();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
hits=glRenderMode(GL_RENDER);
if (hits > 0)
{
int choose = buffer[3];
int depth = buffer[1];
for (int loop = 1; loop < hits; loop++)
{
if (buffer[loop*4+1] < GLuint(depth))
{
choose = buffer[loop*4+3];
depth = buffer[loop*4+1];
}
}
// ray 구해서 가장 가까운점 찾음.
GLdouble modelViewMatrix[16];
GLdouble projectionMatrix[16];
int viewport[4];
glGetDoublev(GL_MODELVIEW_MATRIX, modelViewMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projectionMatrix);
glGetIntegerv(GL_VIEWPORT, viewport);
GLdouble nearPlaneLocation[3];
gluUnProject(mouse_x, mouse_y, 0.0, modelViewMatrix, projectionMatrix,
viewport, &nearPlaneLocation[0], &nearPlaneLocation[1],
&nearPlaneLocation[2]);
GLdouble farPlaneLocation[3];
gluUnProject(mouse_x, mouse_y, 1.0, modelViewMatrix, projectionMatrix,
viewport, &farPlaneLocation[0], &farPlaneLocation[1],
&farPlaneLocation[2]);
Vector3F ray;
Vector3F pos;
for(int i = 0; i < 3; i++)
{
ray[i] = farPlaneLocation[i] - nearPlaneLocation[i];
pos[i] = nearPlaneLocation[i];
}
m_mesh.select_vertex(choose,pos,ray);
}
}
void SeedGLWidget::selectRegion()
{
/*if (_seedRegions.empty())
{
return;
}*/
glViewport (0, 0, 1024, 1024);
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fboId);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
glClear (GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, _widgetWidth-_planeWidth, _widgetHeight, 0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor3f(1, 1, 1);
gluTessBeginPolygon(tessObj, NULL);
gluTessBeginContour(tessObj);
for (int i=0; i<_penTrack.size(); ++i)
{
gluTessVertex(tessObj, _penTrack[i], _penTrack[i]);
}
gluTessEndContour(tessObj);
gluTessEndPolygon(tessObj);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
GLubyte * tempBuffer = new GLubyte [1024*1024];
glBindTexture(GL_TEXTURE_2D, _texId);
glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, tempBuffer);
GLdouble modelMatrix[16];
GLdouble projMatrix[16];
int viewport[4];
int viewportWidth = _viewportHeight*(_widgetWidth-_planeWidth)*1.0/_widgetHeight;
glViewport (0, 0, 1024, 1024);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, viewportWidth, 0, _viewportHeight, -2000, 2000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(_translateX, _translateY, 0);
glTranslatef(viewportWidth/2.0, _viewportHeight/2.0, 0);
setRotationMatrix();
_volumeData->setTransformMatrix();
glGetIntegerv(GL_VIEWPORT, viewport);
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
int minX = floor(_minDrawX*1023.0/(_widgetWidth-_planeWidth-1));
int maxX = ceil(_maxDrawX*1023.0/(_widgetWidth-_planeWidth-1));
int minY = floor((_widgetHeight-_maxDrawY)*1023.0/(_widgetHeight-1));
int maxY = ceil((_widgetHeight-_minDrawY)*1023.0/(_widgetHeight-1));
for (int i=minX; i<=maxX; ++i)
{
for (int j=minY; j<maxY; ++j)
{
if (tempBuffer[j*1024+i]>0)
{
double x, y, z;
gluUnProject(i, j, 0, modelMatrix, projMatrix, viewport, &x, &y, &z);
//add to seed region list
switch (_viewpoint)
{
case 1: //AXIAL
z = _seedData->_aSliceIdx;
break;
case 2: //CORONAL
y = _seedData->_cSliceIdx;
break;
case 3: //SAGITTAL
x = _seedData->_pSliceIdx;
break;
}
if (_bAddRegion)
{
_seedData->addSeedPoint(x,y,z, _currentSeedIndex);
} else
{
_seedData->removeSeedPoint(x,y,z,_currentSeedIndex);
}
}
}
}
delete tempBuffer;
_seedData->setASlice(_aSlicePos);
_seedData->setPSlice(_pSlicePos);
_seedData->setCSlice(_cSlicePos);
}
//---------------------------------------------------------------------------
// Draw the major and minor tick marks
//----------------------------------------------------------------------------
void VisusBorderAxis::renderTickMarks(const float borderWidth, const float borderLength,
const BBAxis axis, const BBTickLine tickLineType)
{
// If drawing ticks is disabled, return
if(!mDrawTicks)
return;
float low,high,minor_low,minor_high;
float dimensions[2] = { borderLength, borderWidth };
int other = (axis+1) % 2;
float width = dimensions[other];
float length = dimensions[axis];
// Get the current viewport
GLdouble model[16];
GLdouble projection[16];
GLint viewport[4]; // x, y, width, height
glGetDoublev(GL_PROJECTION_MATRIX, projection);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetIntegerv(GL_VIEWPORT,viewport);
// Determine number of pixels per tick mark based on thickness (smallest 1)
float minval = numPixels(model, projection, viewport, length, axis);
const int numPixelPerMajorTick = std::max(1, (int)floor(minval*mMajorTickThickness));
const int numPixelPerMinorTick = std::max(1, (int)floor(minval*mMinorTickThickness));
float majorDelta = length / (mMajorTicks-1);
float minorDelta = majorDelta / mMinorTicks;
// Determine Tick Up/Down Positions
low = minor_low = 0;
high = minor_high = width;
// If we need to draw tick on the normal side (below or right)
if ((mTickPosition == AXIS_LOW) || (mTickPosition == AXIS_BOTH))
{
low -= mMajorTickLength * width; // it needs to start this much below 0
minor_low -= mMinorTickLength * mMajorTickLength * width;
}
// If we need to draw tick on the opposite side (above or left)
if ((mTickPosition == AXIS_HIGH) || (mTickPosition == AXIS_BOTH))
{
high += mMajorTickLength * width; // it needs to end this much above the bar
minor_high += mMinorTickLength * mMajorTickLength * width;
}
// Set the bounding box
if (axis == BB_X_AXIS) {
mDrawBox[0] = 0;
mDrawBox[1] = low;
mDrawBox[3] = length;
mDrawBox[4] = high;
}
else {
mDrawBox[0] = low;
mDrawBox[1] = 0;
mDrawBox[3] = high;
mDrawBox[4] = length;
}
mWidth = width;
mLength= length;
mDrawAxis = axis;
mDrawOther = other;
if (! mDrawTicks)
return;
mTickColor.glColor();
// We can't change the thickness between a glBegin() and
// glEnd(). Therefore, we first draw the major ticks then the minor
// ones
glLineWidth(numPixelPerMajorTick);
glBegin(GL_LINES);
float axisPosition = 0;
for (int i=0;i<mMajorTicks; ++i, axisPosition+=majorDelta) {
if (i==0 || i==(mMajorTicks-1))
drawTick(low, 0, axisPosition, BB_SOLID);
else
drawTick(low, high, axisPosition, tickLineType);
}
glEnd();
// Now draw the minor ticks
glLineWidth(numPixelPerMinorTick);
glBegin(GL_LINES);
axisPosition = 0;
for (int i=0;i<mMajorTicks-1; ++i, axisPosition+=majorDelta)
{
for (int j=0;j<mMinorTicks; ++j)
{
float position = axisPosition + (minorDelta*j);
drawTick(minor_low, minor_high, position, tickLineType);
}
}
glEnd();
}
void GLLUTWidget::paintGL()
{
m.lock();
if (gl_ready && needs_init && _lut!=0) {
init();
}
m.unlock();
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
setupProjection();
//setup lens:
//switch to modelview mode
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
//cam.apply();
if (view_mode==VIEW_SINGLE || view_mode==VIEW_GRID) {
gluLookAt(0.0,0.0,100.0, 0.0, 0.0, 0.0,0.0,1.0,0.0);
} else {
cam.apply();
}
if (_lut==0) return;
//store matrices for reverse mouse-lookup
for (int i=0;i<(int)slices.size();i++) {
Slice * s=slices[i];
if (s->bg_update_pending) {
if (s->bg->update()==false) printf("draw-slice texture update failed\n");
s->bg_update_pending=false;
}
if (s->selection_update_pending) {
if (s->selection->update(GL_CLAMP,GL_CLAMP,GL_NEAREST,GL_NEAREST)==false) printf("draw-slice texture update failed\n");
s->selection_update_pending=false;
}
if (s->sampler_update_pending) {
if (s->sampler->update(GL_CLAMP,GL_CLAMP,GL_LINEAR,GL_NEAREST)==false) printf("draw-slice texture update failed\n");
s->sampler_update_pending=false;
}
}
//let's draw a slice
//glColor3f(0.0,0.0,0.0);
if (view_mode==VIEW_SINGLE) {
glGetIntegerv(GL_VIEWPORT,viewport);
glGetDoublev(GL_PROJECTION_MATRIX,projMatrix);
glGetDoublev(GL_MODELVIEW_MATRIX,modelMatrix);
glDrawSlice(slices[state.slice_idx]);
} else if (view_mode==VIEW_GRID) {
int cols=(int)(sqrt(slices.size()));
int rows=slices.size()/cols;
int c=0;
int r=0;
for (int i=0;i<(int)slices.size();i++) {
glPushMatrix();
glTranslatef((1.0/(float)cols)*(float)c,(1.0/(float)rows)*(float)r,0.0);
c++;
if (c >= cols) { c=0; r++; }
glScalef((1.0/(float)cols)*0.98,(1.0/(float)rows)*0.98,1.0);
glTranslatef(0.01,0.01,0.0);
if (i==state.slice_idx) {
glGetIntegerv(GL_VIEWPORT,viewport);
glGetDoublev(GL_PROJECTION_MATRIX,projMatrix);
glGetDoublev(GL_MODELVIEW_MATRIX,modelMatrix);
}
glDrawSlice(slices[i]);
glBindTexture(GL_TEXTURE_2D,0);
glColor3f(1.0,1.0,1.0);
if (i==state.slice_idx) {
glPushMatrix();
glLineWidth(2.0);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.01);
glVertex3f(1.0,0.0,0.01);
glVertex3f(1.0,0.0,0.01);
glVertex3f(1.0,1.0,0.01);
glVertex3f(1.0,1.0,0.01);
glVertex3f(0.0,1.0,0.01);
glVertex3f(0.0,1.0,0.01);
glVertex3f(0.0,0.0,0.01);
glEnd();
glPopMatrix();
}
glPopMatrix();
}
} else if (view_mode==VIEW_CUBE) {
glTranslatef(-0.5,-0.5,-0.5);
glColor3f(0.7,0.7,0.7);
glPushMatrix();
glLineWidth(1.0);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(1.0,0.0,0.0);
glVertex3f(0.0,1.0,0.0);
glVertex3f(1.0,1.0,0.0);
glVertex3f(0.0,0.0,1.0);
glVertex3f(1.0,0.0,1.0);
glVertex3f(0.0,1.0,1.0);
glVertex3f(1.0,1.0,1.0);
glVertex3f(0.0,0.0,0.0);
glVertex3f(0.0,1.0,0.0);
glVertex3f(1.0,0.0,0.0);
glVertex3f(1.0,1.0,0.0);
glVertex3f(0.0,0.0,1.0);
glVertex3f(0.0,1.0,1.0);
glVertex3f(1.0,0.0,1.0);
glVertex3f(1.0,1.0,1.0);
glVertex3f(0.0,0.0,0.0);
glVertex3f(0.0,0.0,1.0);
glVertex3f(0.0,1.0,0.0);
glVertex3f(0.0,1.0,1.0);
glVertex3f(1.0,0.0,0.0);
glVertex3f(1.0,0.0,1.0);
glVertex3f(1.0,1.0,0.0);
glVertex3f(1.0,1.0,1.0);
glEnd();
glPopMatrix();
for (int i=0;i<(int)slices.size();i++) {
glPushMatrix();
glTranslatef(0.0,0.0,(1.0 / (float)slices.size()) * (float)i);
//glScalef((1.0/(float)cols)*0.98,(1.0/(float)rows)*0.98,1.0);
//glTranslatef(0.01,0.01,0.0);
/*if (i==state.slice_idx) {
glGetIntegerv(GL_VIEWPORT,viewport);
glGetDoublev(GL_PROJECTION_MATRIX,projMatrix);
glGetDoublev(GL_MODELVIEW_MATRIX,modelMatrix);
}*/
glDrawSlice(slices[i]);
glBindTexture(GL_TEXTURE_2D,0);
glColor3f(1.0,1.0,1.0);
if (i==state.slice_idx) {
glPushMatrix();
glLineWidth(2.0);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.01);
glVertex3f(1.0,0.0,0.01);
glVertex3f(1.0,0.0,0.01);
glVertex3f(1.0,1.0,0.01);
glVertex3f(1.0,1.0,0.01);
glVertex3f(0.0,1.0,0.01);
glVertex3f(0.0,1.0,0.01);
glVertex3f(0.0,0.0,0.01);
glEnd();
glPopMatrix();
}
glPopMatrix();
}
}
c_draw.count();
//updateVideoStats(stats);
}
void GlStateSnapshot::log(std::string id, unsigned key, int type) {
GLint ival[4];
GLboolean bval[4];
GLdouble dval[4];
GLfloat fval[16];
ival[0] = ival[1] = ival[2] = ival[3] = 0;
fval[0] = fval[1] = fval[2] = fval[3] = 0;
dval[0] = dval[1] = dval[2] = dval[3] = 0;
bval[0] = bval[1] = bval[2] = bval[3] = false;
std::ostringstream os;
switch (type) {
case INTv:
glGetIntegerv(key, ival);
os << "GL state: " << id << " " << ival[0];
break;
case BOOLv:
glGetBooleanv(key, bval);
os << "GL state: " << id << " " << (bval[0] ? "yes" : "no");
break;
case FLOATv:
glGetFloatv(key, fval);
os << "GL state: " << id << " " << fval[0];
break;
case DOUBLEv:
glGetDoublev(key, dval);
os << "GL state: " << id << " " << dval[0];
break;
case INTv2:
glGetIntegerv(key, ival);
os << "GL state: " << id << " " << ival[0] << " " << ival[1];
break;
case INTv4:
glGetIntegerv(key, ival);
os << "GL state: " << id << " " << ival[0] << " " << ival[1] << " " << ival[2] << " " << ival[3];
break;
case BOOLv4:
glGetBooleanv(key, bval);
os << "GL state: " << id << " " << (bval[0] ? 'y':'n') << " " << (bval[1] ? 'y':'n') << " " << (bval[2] ? 'y':'n') << " " << (bval[3] ? 'y':'n');
break;
case FLOATv4:
glGetFloatv(key, fval);
os << "GL state: " << id << " " << fval[0] << " " << fval[1] << " " << fval[2] << " " << fval[3];
break;
case FLOATv16:
glGetFloatv(key, fval);
os << "GL state: " << id << "0 " << fval[0] << " " << fval[1] << " " << fval[2] << " " << fval[3] << "\n";
os << "GL state: " << id << "1 " << fval[4] << " " << fval[5] << " " << fval[6] << " " << fval[7] << "\n";
os << "GL state: " << id << "2 " << fval[8] << " " << fval[9] << " " << fval[10] << " " << fval[11] << "\n";
os << "GL state: " << id << "3 " << fval[12] << " " << fval[13] << " " << fval[14] << " " << fval[15];
break;
case TEXENViv:
glGetTexEnviv(GL_TEXTURE_ENV, key, ival);
os << "GL state: " << id << " " << ival[0];
break;
case TEXENVfv4:
glGetTexEnvfv(GL_TEXTURE_ENV, key, fval);
os << "GL state: " << id << " " << fval[0] << " " << fval[1] << " " << fval[2] << " " << fval[3];
break;
case TEXGENiv:
glGetTexGeniv(GL_Q, key, ival); ival[3] = ival[0];
glGetTexGeniv(GL_R, key, ival); ival[2] = ival[0];
glGetTexGeniv(GL_T, key, ival); ival[1] = ival[0];
glGetTexGeniv(GL_S, key, ival);
os << "GL state: " << id << " " << ival[0] << " " << ival[1] << " " << ival[2] << " " << ival[3];
break;
}
m_StateLog.push_back(os.str());
}
void CGraphicsReaction::Draw( CDC* pDC, const CWindowFilter& filter, double scale, CGLText* text, double length )
{
ASSERT( m_pN && m_pRC );
if( !m_pN || !m_pRC || m_pN->isFree() )
return;
float w = (float)ini.size().reactionWidth;
float l = length;
const CResult* cR = m_pRC->result( *m_pN );
double xi = m_pN->x();
double yi = m_pN->y();
double zi = m_pN->z();
if( cR )
{
xi += scale*cR->displacement( DX );
yi += scale*cR->displacement( DY );
zi += scale*cR->displacement( DZ );
}
COLORREF c = ini.color().nodes;
ApplyAmbientGLMaterialiv( c );
glPushMatrix();
glTranslatef( float( xi ), float( yi ), float( zi ) );
double mv[16];
glGetDoublev( GL_MODELVIEW_MATRIX, mv );
for( int i=0; i<3; i++ ){
for( int j=0; j<3; j++ ) {
if ( i==j )
mv[i*4+j] = 1.0;
else
mv[i*4+j] = 0.0;
}
}
CPoint p2D;
CVector3D mvz( mv[8], mv[9], mv[10] );
CPoint3D p3D( 0., -l, 0. );
if( m_pN->isFixed( DX ) && !zero(cR->force( DX )) && filter.node.fx )
{
CString label = "FX = ";
label += Units::show( FORCE_UNIT, cR->force( DX ));
text->ClearText();
text->AddLine( label );
glPushMatrix();
if( cR->force( DX ) < 0. )
glRotatef( 180.f, 0.f, 0.f, 1.f );
DrawLineArrow( l, w, pDC, text,
ini.font().graphWindow.name,
ini.font().graphWindow.size,
ini.color().nodalLoads);
glPopMatrix();
}
if( m_pN->isFixed( DY ) && !zero(cR->force( DY )) && filter.node.fy )
{
CString label = "FY = ";
label += Units::show( FORCE_UNIT, cR->force( DY ));
text->ClearText();
text->AddLine( label );
glPushMatrix();
glRotatef( 90.f, 0.f, 0.f, 1.f );
if( cR->force( DY ) < 0. )
glRotatef( 180.f, 0.f, 0.f, 1.f );
DrawLineArrow( l, w, pDC, text,
ini.font().graphWindow.name,
ini.font().graphWindow.size,
ini.color().nodalLoads);
glPopMatrix();
}
if( m_pN->isFixed( DZ ) && !zero(cR->force( DZ )) && filter.node.fz )
{
CString label = "FZ = ";
label += Units::show( FORCE_UNIT, cR->force( DZ ));
text->ClearText();
text->AddLine( label );
glPushMatrix();
glRotatef( 90.f, 0.f, 1.f, 0.f );
if( cR->force( DZ ) < 0. )
glRotatef( 180.f, 0.f, 0.f, 1.f );
DrawLineArrow( l, w, pDC, text,
ini.font().graphWindow.name,
ini.font().graphWindow.size,
ini.color().nodalLoads);
glPopMatrix();
}
if( m_pN->isFixed( RX ) && !zero(cR->force( RX )) && filter.node.mx )
{
CString label = "MX = ";
label += Units::show( MOMENT_UNIT, cR->force( RX ));
text->ClearText();
text->AddLine( label );
glPushMatrix();
glRotatef( 90.f, 0.f, 1.f, 0.f );
if( cR->force( RX ) < 0. )
glRotatef( 180.f, 0.f, 0.f, 1.f );
DrawSolidMomentArrow( l, w, pDC, text,
ini.font().graphWindow.name,
ini.font().graphWindow.size,
ini.color().nodalLoads);
glPopMatrix();
text->AddLine( label );
}
if( m_pN->isFixed( RY ) && !zero(cR->force( RY )) && filter.node.my )
{
CString label = "MY = ";
label += Units::show( MOMENT_UNIT, cR->force( RY ));
text->ClearText();
text->AddLine( label );
glPushMatrix();
glRotatef( 90.f, 1.f, 0.f, 0.f );
if( cR->force( RY ) > 0. )
glRotatef( 180.f, 0.f, 0.f, 1.f );
DrawSolidMomentArrow( l, w, pDC, text,
ini.font().graphWindow.name,
ini.font().graphWindow.size,
ini.color().nodalLoads);
glPopMatrix();
}
if( m_pN->isFixed( RZ ) && !zero(cR->force( RZ )) && filter.node.mz )
{
CString label = "MZ = ";
label += Units::show( MOMENT_UNIT, cR->force( RZ ));
text->ClearText();
text->AddLine( label );
glPushMatrix();
if( cR->force( RZ ) < 0. )
glRotatef( 180.f, 0.f, 1.f, 0.f );
DrawSolidMomentArrow( l, w, pDC, text,
ini.font().graphWindow.name,
ini.font().graphWindow.size,
ini.color().nodalLoads);
glPopMatrix();
}
glPopMatrix();
}
void render(void)
{
static GLint iFrames = 0;
static GLfloat fps = 0.0f, DeltaT;
static char cBuffer[64];
struct timeval tv;
GLuint model_id;
// Update timer
gettimeofday(&tv, NULL);
etime = (double)tv.tv_sec + tv.tv_usec / 1000000.0f;
dt = etime - t0;
t0 = etime;
/*
* Make the shadow pass
*
*/
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, FBO );
glPushMatrix();
//Compute light position
sinE = sinf(eLit);
cosE = cosf(eLit);
sinA = sinf(aLit);
cosA = cosf(aLit);
lightPos[0] = lightRadius * cosE * sinA;
lightPos[1] = lightRadius * sinE;
lightPos[2] = lightRadius * cosE * cosA;
lightPos[3] = 1.0f;
//Set light position
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
//Set up camera to light location
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective( 70.0f, 1.0f, 75.0f, 350.0f );
glGetDoublev(GL_PROJECTION_MATRIX, lightProjection );
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt( lightPos[0], lightPos[1], lightPos[2],
0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f );
glGetDoublev(GL_MODELVIEW_MATRIX, lightModelview );
glViewport( 0, 0, shadow_sz, shadow_sz );
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_POLYGON_OFFSET_FILL);
glShadeModel(GL_FLAT);
//Rotate scene, if required
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
//Disable shaders
glUseProgramObjectARB(0);
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
// Draw dynamic objects
for (model_id = 0; model_id < NUM_MODELS; model_id++ )
{
//Update the kinematic's state
UpdateMD2(md2_model[model_id], dt);
//Animate the MD2 models
AnimateMD2(md2_model[model_id], dt);
//Draw the geometry
glPushMatrix();
glTranslatef( md2_model[model_id]->position.x,
md2_model[model_id]->position.y,
md2_model[model_id]->position.z );
glRotatef( md2_model[model_id]->rotation, 0.0f, 1.0f, 0.0f );
DrawMD2(md2_model[model_id]);
glPopMatrix();
}
glPopMatrix();
glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
/*
* And now the normal pass
*
*/
//Back to normal settings
glDisable(GL_POLYGON_OFFSET_FILL);
glShadeModel(GL_SMOOTH);
change_size( width, height );
// Clear the window with current clearing color
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
//Set up camera location and parameters
setup_camera((float)dt);
//Retrieve modelview matrix and invert it
glGetDoublev(GL_MODELVIEW_MATRIX, cameraModelview );
FastInvert4( cameraModelview, cameraModelviewInverse );
//Set up depth texture
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, shadow_tx);
//Set up texture matrix for shadow map projection
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glTranslatef(0.5f, 0.5f, 0.5f);
glScalef(0.5f, 0.5f, 0.5f);
glMultMatrixd(lightProjection);
glMultMatrixd(lightModelview);
glMultMatrixd(cameraModelviewInverse);
glMatrixMode(GL_MODELVIEW);
//Rotate scene
glRotatef(xRot, 1.0f, 0.0f, 0.0f);
glRotatef(yRot, 0.0f, 1.0f, 0.0f);
//Re-enable shaders
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
if (GLSLshader)
glUseProgramObjectARB(progObj);
else
glUseProgramObjectARB(0);
//Floor
//Color
glColor3f(0.64f, 0.63f, 0.65f);
//Set textures
glActiveTexture(GL_TEXTURE0); //Diffuse map
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-2]);
glActiveTexture(GL_TEXTURE1); //Normal map
glBindTexture(GL_TEXTURE_2D, texture_id[NUM_TEXTURES-1]);
//Set Tangent vector
glVertexAttrib3fv( tangent, floorT );
//Set Binormal vector
glVertexAttrib3fv( binormal, floorB );
//Set Normal vector
glNormal3fv( floorN );
//Call Display List to draw
glCallList(FList);
// Draw dynamic objects
for (model_id = 0; model_id < NUM_MODELS; model_id++ )
{
//Set color
glColor3f( md2_model[model_id]->color.x,
md2_model[model_id]->color.y,
md2_model[model_id]->color.z );
//Set texture
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture_id[2*model_id+1]);
//Draw the geometry
glPushMatrix();
glTranslatef( md2_model[model_id]->position.x,
md2_model[model_id]->position.y,
md2_model[model_id]->position.z );
glRotatef( md2_model[model_id]->rotation, 0.0f, 1.0f, 0.0f );
DrawMD2(md2_model[model_id]);
glPopMatrix();
}
glPopMatrix();
iFrames++;
DeltaT = (GLfloat)(etime-t1);
if( DeltaT >= Timed )
{
fps = (GLfloat)(iFrames)/DeltaT;
fps_count++;
fps_mean = ((fps_count - 1.0f) * fps_mean + fps ) / fps_count;
iFrames = 0;
t1 = etime;
sprintf(cBuffer,"FPS: %.1f Mean FPS: %.1f Poly Scale: %.1f Bias: %.1f", fps, fps_mean, scalePoly, biasPoly);
}
if (print_fps)
{
if (windowpos)
{
glColor3f(1.0f, 1.0f, 1.0f);
glPushAttrib(GL_LIST_BIT);
glListBase(fps_font - ' ');
glWindowPos2i(0,2);
glCallLists(strlen(cBuffer), GL_UNSIGNED_BYTE, cBuffer);
glPopAttrib();
}
if( iFrames == 0 )
printf("FPS: %.1f Mean FPS: %.1f\n", fps, fps_mean);
}
lCam = 0.0f;
vCam = 0.0f;
dCam = 0.0f;
}