void draw (int picking)
{
if(picking==2)return;
gle();
glPushAttrib(GL_ALL_ATTRIB_BITS);
gle();
if(!picking)
{
CameraUpdate ();
gle();
EntityUpdate ();
gle();
WorldUpdate ();
gle();
TextureUpdate ();
gle();
VisibleUpdate ();
gle();
CarUpdate ();
}
gle();
RenderResize();
gle();
RenderUpdate (picking);
resetviewport();
gle();
glPopAttrib();
gle();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
//-------------------------------------------------------------------------
void mafViewOrthoSlice::ResetSlicesPosition( mafNode *node )
//-------------------------------------------------------------------------
{
// workaround... :(
// maybe we need some mechanism to execute view code from op?
this->VmeShow(node, false);
this->VmeShow(node, true);
CameraUpdate();
}
void AppUpdate ()
{
CameraUpdate ();
EntityUpdate ();
WorldUpdate ();
TextureUpdate ();
VisibleUpdate ();
CarUpdate ();
RenderUpdate ();
}
/**
* @brief All render will be here
*/
void Game::Render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
CameraUpdate();
if(isWireframe)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
hmk::ShaderManager::getInstance()->use("basic");
renderer->render();
hmk::ShaderManager::getInstance()->use("");
sky->render();
}
//----------------------------------------------------------------------------
void mafViewRXCT::OnEventRangeModified(mafEventBase *maf_event)
//----------------------------------------------------------------------------
{
// is the volume visible?
if(((mafViewSlice *)m_ChildViewList[RX_FRONT_VIEW])->VolumeIsVisible())
{
double low, hi;
// from which lut slider the event is coming?
if (maf_event->GetSender() == m_LutSliders[RX_FRONT_VIEW])
{
m_LutSliders[RX_FRONT_VIEW]->GetSubRange(&low,&hi);
((mafViewRX *)m_ChildViewList[RX_FRONT_VIEW])->SetLutRange(low,hi);
}
else if (maf_event->GetSender() == m_LutSliders[RX_SIDE_VIEW])
{
m_LutSliders[RX_SIDE_VIEW]->GetSubRange(&low,&hi);
((mafViewRX *)m_ChildViewList[RX_SIDE_VIEW])->SetLutRange(low,hi);
}
else if (maf_event->GetSender() == m_LutSliders[CT_COMPOUND_VIEW])
{
m_LutSliders[CT_COMPOUND_VIEW]->GetSubRange(&low,&hi);
//m_vtkLUT[CT_COMPOUND_VIEW]->SetRange(low,hi);
m_Lut->SetRange(low,hi);
for(int i=0; i<CT_CHILD_VIEWS_NUMBER; i++)
{
mafPipeVolumeSlice_BES *p = NULL;
p = mafPipeVolumeSlice_BES::SafeDownCast(((mafViewSlice *)((mafViewCompound *)m_ChildViewList[CT_COMPOUND_VIEW])->GetSubView(i))->GetNodePipe(m_CurrentVolume));
//p->SetColorLookupTable(m_vtkLUT[CT_COMPOUND_VIEW]);
p->SetColorLookupTable(m_Lut);
}
}
CameraUpdate();
}
}
void GameDoLogic(bool* Continue, bool* Error, Uint32 Milliseconds)
{
(void)Continue;
(void)Error;
if (Pause) return;
cpSpaceStep(space.Space, Milliseconds * 0.001);
CameraUpdate(&camera, PlayerMiddleY(), Milliseconds);
bool hasPlayers = false;
for (int i = 0; i < MAX_PLAYERS; i++)
{
Player *p = &players[i];
if (!p->Enabled) continue;
PlayerUpdate(p, Milliseconds);
// Check if the player needs to be respawned
if (p->RespawnCounter == 0 && !p->Alive && space.Gaps.size > 0)
{
SpaceRespawnPlayer(&space, p);
}
if (!p->Alive)
{
// Check if any players are past ones that await reenabling
if (p->RespawnCounter == -1 && PlayerMinY() < p->y)
{
PlayerRevive(p);
}
else
{
continue;
}
}
hasPlayers = true;
// Check player pickups
if (PickupsCollide(p->x, p->y, PLAYER_RADIUS))
{
PlayerScore(p, false);
}
// Players that hit the top of the screen die
if (cpBodyGetPosition(p->Body).y + PLAYER_RADIUS >=
camera.Y + FIELD_HEIGHT / 2)
{
PlayerKill(p);
}
}
// If no players left alive, end the game
if (!hasPlayers)
{
ToTitleScreen(false);
}
SpaceUpdate(&space, PlayerMinY(), camera.Y, PlayerMaxY(), &players[0]);
ParticlesUpdate(Milliseconds);
// Players that hit the top of the screen die
if (PlayerMaxY() + PLAYER_RADIUS >= camera.Y + FIELD_HEIGHT / 2)
{
ToTitleScreen(false);
}
}
void V_CalcRefdef (void) {
vec3_t forward;
float bob;
float height_adjustment;
V_DriftPitch ();
bob = V_CalcBob ();
height_adjustment = v_viewheight.value ? bound (-7, v_viewheight.value, 4) : V_CalcBob ();
// set up the refresh position
VectorCopy (cl.simorg, r_refdef.vieworg);
// never let it sit exactly on a node line, because a water plane can
// dissapear when viewed with the eye exactly on it.
// the server protocol only specifies to 1/8 pixel, so add 1/16 in each axis
r_refdef.vieworg[0] += 1.0/16;
r_refdef.vieworg[1] += 1.0/16;
r_refdef.vieworg[2] += 1.0/16;
// add view height
if (view_message.flags & PF_GIB) {
r_refdef.vieworg[2] += 8; // gib view height
} else if (view_message.flags & PF_DEAD && (cl.stats[STAT_HEALTH] <= 0)) {
r_refdef.vieworg[2] -= 16; // corpse view height
} else {
// normal view height
// Use STAT_VIEWHEIGHT in case of server support it or NQ demoplayback, if not then use default viewheight.
r_refdef.vieworg[2] += ((cl.z_ext & Z_EXT_VIEWHEIGHT) || cls.nqdemoplayback) ? cl.stats[STAT_VIEWHEIGHT] : DEFAULT_VIEWHEIGHT;
r_refdef.vieworg[2] += height_adjustment;
r_refdef.vieworg[2] += bob;
// smooth out stair step ups
r_refdef.vieworg[2] += cl.crouch;
}
// set up refresh view angles
VectorCopy (cl.simangles, r_refdef.viewangles);
V_CalcViewRoll ();
V_AddIdle ();
if (v_gunkick.value) {
// add weapon kick offset
AngleVectors (r_refdef.viewangles, forward, NULL, NULL);
VectorMA (r_refdef.vieworg, cl.punchangle, forward, r_refdef.vieworg);
// add weapon kick angle
r_refdef.viewangles[PITCH] += cl.punchangle * 0.5;
}
if (view_message.flags & PF_DEAD && (cl.stats[STAT_HEALTH] <= 0))
r_refdef.viewangles[ROLL] = 80; // dead view angle
//VULT CAMERAS
CameraUpdate(view_message.flags & PF_DEAD);
V_AddViewWeapon (height_adjustment);
}
//----------------------------------------------------------------------------
void mafViewOrthoSlice::OnEvent(mafEventBase *maf_event)
//----------------------------------------------------------------------------
{
if (mafEvent *e = mafEvent::SafeDownCast(maf_event))
{
switch(e->GetId())
{
/* case ID_SIDE_ORTHO:
{
if (m_Side == 1)
{
((mafViewSlice *)m_ChildViewList[CHILD_XN_VIEW])->CameraSet(CAMERA_RX_RIGHT);
((mafViewSlice*)m_ChildViewList[CHILD_XN_VIEW])->CameraUpdate();
}
else
{
((mafViewSlice *)m_ChildViewList[CHILD_XN_VIEW])->CameraSet(CAMERA_RX_LEFT);
((mafViewSlice*)m_ChildViewList[CHILD_XN_VIEW])->CameraUpdate();
}
}
break;*/
case ID_BORDER_CHANGE:
{
OnEventSetThickness();
}
break;
case ID_ALL_SURFACE:
{
if(m_AllSurface)
{
mafNode* node=GetSceneGraph()->GetSelectedVme();
mafVME* vme=(mafVME*)node;
mafNode* root=vme->GetRoot();
SetThicknessForAllSurfaceSlices(root);
}
}
break;
case ID_LUT_CHOOSER:
{
mmaVolumeMaterial *currentVolumeMaterial = ((mafVMEOutputVolume *)m_CurrentVolume->GetOutput())->GetMaterial();
currentVolumeMaterial->UpdateFromTables();
for(int i=0; i<m_NumOfChildView; i++)
{
mafPipeVolumeSlice_BES *p = (mafPipeVolumeSlice_BES *)((mafViewSlice *)m_ChildViewList[i])->GetNodePipe(m_CurrentVolume);
p->SetColorLookupTable(m_ColorLUT);
}
double *sr;
sr = m_ColorLUT->GetRange();
m_LutSlider->SetSubRange((long)sr[0],(long)sr[1]);
CameraUpdate();
}
break;
case ID_RANGE_MODIFIED:
{
if(((mafViewSlice *)m_ChildViewList[0])->VolumeIsVisible())
{
double low, hi;
m_LutSlider->GetSubRange(&low,&hi);
m_ColorLUT->SetTableRange(low,hi);
mmaVolumeMaterial *currentVolumeMaterial = ((mafVMEOutputVolume *)m_CurrentVolume->GetOutput())->GetMaterial();
currentVolumeMaterial->UpdateFromTables();
CameraUpdate();
}
}
break;
case MOUSE_UP:
case MOUSE_MOVE:
{
// get the gizmo that is being moved
long gizmoId = e->GetArg();
double pos[3];
vtkPoints *p = (vtkPoints *)e->GetVtkObj();
if(p == NULL) return;
p->GetPoint(0,pos);
this->SetSlicePosition(gizmoId, p);
}
break;
case ID_SNAP:
{
if(this->m_CurrentVolume==NULL && m_Snap)
{
wxMessageBox("You can't switch to snap modality!");
m_Snap=0;
m_Gui->Update();
}
else
{
for(int i=GIZMO_XN; i<GIZMOS_NUMBER; i++)
{
if(m_Snap==1)
m_Gizmo[i]->SetGizmoMovingModalityToSnap();
else
m_Gizmo[i]->SetGizmoMovingModalityToBound();
}
}
}
break;
case ID_RESET_SLICES:
{
assert(m_CurrentVolume);
this->ResetSlicesPosition(m_CurrentVolume);
}
break;
// Added by Losi 11.25.2009
case ID_ENABLE_GPU:
{
if (m_CurrentVolume)
{
for(int i=0; i<m_NumOfChildView; i++)
{
mafPipeVolumeSlice_BES *p = NULL;
p = mafPipeVolumeSlice_BES::SafeDownCast(((mafViewSlice *)m_ChildViewList[i])->GetNodePipe(m_CurrentVolume));
if (p)
{
p->SetEnableGPU(m_EnableGPU);
}
}
this->CameraUpdate();
}
}
break;
case ID_TRILINEAR_INTERPOLATION:
{
if (m_CurrentVolume)
{
for(int i=0; i<m_NumOfChildView; i++)
{
mafPipeVolumeSlice_BES *p = NULL;
p = mafPipeVolumeSlice_BES::SafeDownCast(((mafViewSlice *)m_ChildViewList[i])->GetNodePipe(m_CurrentVolume));
if (p)
{
p->SetTrilinearInterpolation(m_TrilinearInterpolationOn);
}
}
this->CameraUpdate();
}
}
break;
default:
mafViewCompound::OnEvent(maf_event);
}
}
}
void hack_draw (xstuff_t * XStuff, double currentTime, float frameTime)
{
GLvector pos;
GLvector angle;
GLrgba color;
int elapsed;
incrementTickCount(frameTime * 1000);
CameraUpdate ();
EntityUpdate ();
WorldUpdate ();
TextureUpdate ();
VisibleUpdate ();
CarUpdate ();
glViewport (0, 0, render_width, render_height);
glDepthMask (true);
glClearColor (0.0f, 0.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (letterbox)
glViewport (0, letterbox_offset, render_width, render_height);
if (LOADING_SCREEN && TextureReady () && !EntityReady ()) {
do_effects (EFFECT_NONE);
return;
}
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glShadeModel(GL_SMOOTH);
glFogi (GL_FOG_MODE, GL_LINEAR);
glDepthFunc(GL_LEQUAL);
glEnable (GL_CULL_FACE);
glCullFace (GL_BACK);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode (GL_TEXTURE);
glLoadIdentity();
glMatrixMode (GL_MODELVIEW);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glLoadIdentity();
glLineWidth (1.0f);
pos = CameraPosition ();
angle = CameraAngle ();
glRotatef (angle.x, 1.0f, 0.0f, 0.0f);
glRotatef (angle.y, 0.0f, 1.0f, 0.0f);
glRotatef (angle.z, 0.0f, 0.0f, 1.0f);
glTranslatef (-pos.x, -pos.y, -pos.z);
glEnable (GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//Render all the stuff in the whole entire world.
glDisable (GL_FOG);
SkyRender ();
if (show_fog) {
glEnable (GL_FOG);
glFogf (GL_FOG_START, fog_distance - 100);
glFogf (GL_FOG_END, fog_distance);
color = glRgba (0.0f);
glFogfv (GL_FOG_COLOR, &color.red);
}
WorldRender ();
if (effect == EFFECT_GLASS_CITY) {
glDisable (GL_CULL_FACE);
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthFunc (false);
glDisable(GL_DEPTH_TEST);
glMatrixMode (GL_TEXTURE);
glTranslatef ((pos.x + pos.z) / SEGMENTS_PER_TEXTURE, 0, 0);
glMatrixMode (GL_MODELVIEW);
} else {
glEnable (GL_CULL_FACE);
glDisable (GL_BLEND);
}
EntityRender ();
if (!LOADING_SCREEN) {
elapsed = 3000 - WorldSceneElapsed ();
if (elapsed >= 0 && elapsed <= 3000) {
RenderFogFX ((float)elapsed / 3000.0f);
glDisable (GL_TEXTURE_2D);
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
EntityRender ();
}
}
if (EntityReady ())
LightRender ();
CarRender ();
if (show_wireframe) {
glDisable (GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
EntityRender ();
}
do_effects (effect);
}
