void TLView::Draw( wxDC& dc )
{
long yoffset;
dc.SetBrush( *wxGREY_BRUSH );
SetBrushColour( dc, wxColour( 166, 166, 166 ) );
dc.SetPen( wxPen( wxColour( 100, 100, 100), 1, wxSOLID ) );
yoffset = TOP_OFFSET_TRACKS;
for ( TLTrackList::Node *node = m_TlData->GetFirst(); node; node = node->GetNext() ) {
TLTrack *track = node->GetData();
if (track->GetSelected()) {
SetBrushColour( dc, wxColour( 199, 199, 188 ) );
}
dc.DrawRectangle( VIEW_LEFT_BORDER,
yoffset - m_YscrollPosition,
m_width - VIEW_LEFT_BORDER - VIEW_RIGHT_BORDER,
track->GetHeight() );
yoffset += track->GetHeight() + m_TrackDrawDist;
if (track->GetSelected()) {
SetBrushColour( dc, wxColour( 166, 166, 166 ) );
}
}
yoffset = TOP_OFFSET_TRACKS;
for ( TLTrackList::Node *node = m_TlData->GetFirst(); node; node = node->GetNext() ) {
TLTrack *current = node->GetData();
yoffset = DrawTrack( dc, yoffset, current );
}
}
//#include "AmKernel/AmSelections.h"
void AmTrackDataView::DrawOrderedEvents(BRect clip, BView* view, const AmSong* song)
{
//printf("%s DrawOrderedEvents, selections:\n", Name() );
//AmSelections* sel = (AmSelections*)mTrackWinProps.Selections();
//if (sel) sel->Print();
/* Ordered events can draw themselves as translucent if they
* wish. So set that up.
*/
drawing_mode mode = view->DrawingMode();
if (mOrderedSaturation > 0 && mOrderedSaturation < 1 ) {
view->SetDrawingMode(B_OP_ALPHA);
view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
view->SetLowColor(mSecondaryBase);
}
uint32 count = mTrackWinProps.CountOrderedTracks();
for (uint32 k = 1; k < count; k++) {
const AmTrack* track = song->Track( mTrackWinProps.OrderedTrackAt(k).TrackId() );
if (track) {
DrawTrack(track, clip, view, ARPEVENT_ORDERED, mTrackWinProps.Selections() );
}
}
view->SetDrawingMode(mode);
}
void tcHookInfo::Draw()
{
static int nFrameCount = 0;
wxASSERT(mpSS);
//if ((nFrameCount++ % 4) != 0) return; // use to skip draw updates
StartDraw();
tcGameObject* pHookedObj;
mpSS->GetPlatformState(mnHookID, pHookedObj);
bool drawTruth = (pHookedObj != 0) && (pHookedObj->IsOwnAlliance() || pHookedObj->IsEditMode());
if (drawTruth)
{
DrawOwn(pHookedObj);
}
else
{
// attempt to draw track if either null pHookedObj or different alliance
DrawTrack(mnHookID);
}
FinishDraw();
}
void SphereDisplay::Draw(const Sensor& sensor,
VSSprite *frontSprite,
VSSprite *rearSprite)
{
assert(frontSprite || rearSprite); // There should be at least one radar display
radarTime += GetElapsedTime();
leftRadar.SetSprite(frontSprite);
rightRadar.SetSprite(rearSprite);
if (frontSprite)
frontSprite->Draw();
if (rearSprite)
rearSprite->Draw();
Sensor::TrackCollection tracks = sensor.FindTracksInRange();
// FIXME: Consider using std::sort instead of the z-buffer
GFXEnable(DEPTHTEST);
GFXEnable(DEPTHWRITE);
DrawBackground(sensor, leftRadar);
DrawBackground(sensor, rightRadar);
for (Sensor::TrackCollection::const_iterator it = tracks.begin(); it != tracks.end(); ++it)
{
static bool draw_both =
XMLSupport::parse_bool( vs_config->getVariable( "graphics", "hud", "draw_blips_on_both_radar", "false" ));
if (it->GetPosition().z < 0 || draw_both)
{
// Draw tracks behind the ship
DrawTrack(sensor, rightRadar, *it,true);
}
if (it->GetPosition().z >= 0 || draw_both)
{
// Draw tracks in front of the ship
DrawTrack(sensor, leftRadar, *it);
}
}
GFXPointSize(1);
GFXDisable(DEPTHTEST);
GFXDisable(DEPTHWRITE);
}
FX_BOOL CFWL_ScrollBarTP::DrawBackground(CFWL_ThemeBackground* pParams) {
if (!pParams)
return FALSE;
IFWL_Widget* pWidget = pParams->m_pWidget;
FWLTHEME_STATE eState = FWLTHEME_STATE_Normal;
if (pParams->m_dwStates & CFWL_PartState_Hovered)
eState = FWLTHEME_STATE_Hover;
else if (pParams->m_dwStates & CFWL_PartState_Pressed)
eState = FWLTHEME_STATE_Pressed;
else if (pParams->m_dwStates & CFWL_PartState_Disabled)
eState = FWLTHEME_STATE_Disabale;
CFX_Graphics* pGraphics = pParams->m_pGraphics;
CFX_RectF* pRect = &pParams->m_rtPart;
FX_BOOL bVert = pWidget->GetStylesEx();
switch (pParams->m_iPart) {
case CFWL_Part::ForeArrow: {
DrawMaxMinBtn(pGraphics, pRect,
bVert ? FWLTHEME_DIRECTION_Up : FWLTHEME_DIRECTION_Left,
eState, &pParams->m_matrix);
break;
}
case CFWL_Part::BackArrow: {
DrawMaxMinBtn(pGraphics, pRect,
bVert ? FWLTHEME_DIRECTION_Down : FWLTHEME_DIRECTION_Right,
eState, &pParams->m_matrix);
break;
}
case CFWL_Part::Thumb: {
DrawThumbBtn(pGraphics, pRect, bVert, eState, TRUE, &pParams->m_matrix);
break;
}
case CFWL_Part::LowerTrack: {
DrawTrack(pGraphics, pRect, bVert, eState, TRUE, &pParams->m_matrix);
break;
}
case CFWL_Part::UpperTrack: {
DrawTrack(pGraphics, pRect, bVert, eState, FALSE, &pParams->m_matrix);
break;
}
default: {}
}
return TRUE;
}
FWL_ERR CFWL_ScrollBarImp::DrawWidget(CFX_Graphics* pGraphics,
const CFX_Matrix* pMatrix) {
if (!pGraphics)
return FWL_ERR_Indefinite;
if (!m_pProperties->m_pThemeProvider)
return FWL_ERR_Indefinite;
IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
if (HasBorder()) {
DrawBorder(pGraphics, FWL_PART_SCB_Border, pTheme, pMatrix);
}
if (HasEdge()) {
DrawEdge(pGraphics, FWL_PART_SCB_Edge, pTheme, pMatrix);
}
DrawTrack(pGraphics, pTheme, TRUE, pMatrix);
DrawTrack(pGraphics, pTheme, FALSE, pMatrix);
DrawArrowBtn(pGraphics, pTheme, TRUE, pMatrix);
DrawArrowBtn(pGraphics, pTheme, FALSE, pMatrix);
DrawThumb(pGraphics, pTheme, pMatrix);
return FWL_ERR_Succeeded;
}
void CFWL_ScrollBarTP::DrawMaxMinBtn(CFX_Graphics* pGraphics,
const CFX_RectF* pRect,
FWLTHEME_DIRECTION eDict,
FWLTHEME_STATE eState,
CFX_Matrix* pMatrix) {
DrawTrack(pGraphics, pRect,
eDict == FWLTHEME_DIRECTION_Up || eDict == FWLTHEME_DIRECTION_Down,
eState, TRUE, pMatrix);
CFX_RectF rtArrowBtn(*pRect);
rtArrowBtn.Deflate(1, 1, 1, 1);
DrawArrowBtn(pGraphics, &rtArrowBtn, eDict, eState, pMatrix);
}
void SeqPhraseMatrixView::DrawOn( BRect clip, BView* view, const AmTrack* track,
AmPhraseRendererI* renderer)
{
mDrawMuted = false;
if ( track->ModeFlags()&track->MUTE_MODE && !(track->ModeFlags()&track->SOLO_MODE) )
mDrawMuted = true;
rgb_color bgC = Prefs().Color(AM_DATA_BACKDROP_C);
if (mDrawMuted) bgC = shade_color(bgC, BACKDROP_MUTE_SHADE);
view->SetHighColor(bgC);
if (!gPhraseBg) view->FillRect(clip);
float pipeTop = clip.top + ((clip.bottom - clip.top) / 2) - 3;
seq_draw_hrz_pipe(view, clip.left, pipeTop, clip.right);
drawing_mode mode = view->DrawingMode();
view->SetDrawingMode(B_OP_ALPHA);
view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
mLines.SetTarget(view);
mSelectionRange.MakeInvalid();
SeqSongWinPropertiesI* win = dynamic_cast<SeqSongWinPropertiesI*>( Window() );
bool drawSelection = false;
if (win) {
SeqSongSelections* selections = win->Selections();
if (selections && selections->IncludesTrack( track->Id() ) ) {
mSelectionRange = selections->TimeRange();
drawSelection = true;
}
}
if (drawSelection) {
BRect selectClip(clip);
if (mSelectionRange.IsValid() ) {
selectClip.left = mMtc.TickToPixel(mSelectionRange.start);
selectClip.right = mMtc.TickToPixel(mSelectionRange.end);
}
rgb_color bgC;
if (win && win->IsRecording() ) bgC = Prefs().Color(AM_SONG_RECORD_SELECTION_C);
else bgC = Prefs().Color(AM_SONG_SELECTION_C);
view->SetHighColor(bgC);
view->FillRect(selectClip);
}
view->SetDrawingMode(mode);
#if 0
_AmBgMeasureBackground bg( SongRef(), mTrackRef, *mMtc );
bg.SetLeftIndent( mLeftIndent );
bg.LockedDraw( view, clip, track->Signatures() );
#endif
DrawTrack(clip, view, track, renderer);
}
static void RemoveTracksFromPath(
track_p *Rtrk,
EPINX_T *Rep,
track_p trkEnd,
EPINX_T epEnd )
{
EPINX_T ep2;
track_p trk = *Rtrk, trkN;
EPINX_T ep = *Rep;
PASSERT( "removeTracksFromPath", trk, NOP );
PASSERT( "removeTracksFromPath", !PathListSingle(), NOP );
while (1) {
DrawTrack( trk, &mainD, drawColorWhite );
ClrTrkBits( trk, TB_PROFILEPATH );
DrawTrack( trk, &mainD, drawColorBlack );
if (trk == trkEnd) {
pathStartTrk = trkEnd;
pathStartEp = epEnd;
pathEndTrk = GetTrkEndTrk(pathStartTrk,pathStartEp);
if (pathEndTrk)
pathEndEp = GetEndPtConnectedToMe(pathEndTrk,pathStartTrk);
return;
}
ep2 = GetNextTrkOnPath( trk, ep );
PASSERT( "removeTracksFromPath", ep2 >= 0,NOP );
trkN = GetTrkEndTrk(trk,ep2);
PASSERT( "removeTracksFromPath", trkN != NULL, NOP );
ep = GetEndPtConnectedToMe(trkN,trk);
trk = trkN;
if (EndPtIsDefinedElev(trk,ep)) {
*Rtrk = trk;
*Rep = ep;
return;
}
}
}
void AmTrackDataView::DrawShadowEvents(BRect clip, BView* view, const AmSong* song)
{
/* Shadow events can draw themselves as translucent if they
* wish. So set that up.
*/
drawing_mode mode = view->DrawingMode();
if (mShadowSaturation > 0 && mShadowSaturation < 1 ) {
view->SetDrawingMode(B_OP_ALPHA);
view->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
view->SetLowColor(mSecondaryBase);
}
const AmTrack* track;
for (uint32 k=0; (track = song->Track(k)) != 0; k++) {
if (!IsOrdered(track->Id() )) DrawTrack(track, clip, view, ARPEVENT_SHADOW);
}
view->SetDrawingMode(mode);
}
// Constructor for range sample (includes motion track)
TrainingSample::TrainingSample(IplImage *frame, MotionTrack mt, HWND lc, HIMAGELIST il, int groupId) {
// this constructor should only be called for range sample type
assert(groupId == GROUPID_RANGESAMPLES);
hwndListControl = lc;
hImageList = il;
iGroupId = groupId;
iOrigId = groupId;
motionTrack = mt;
motionHistory = NULL;
fullImageCopy = cvCreateImage(cvSize(frame->width,frame->height),IPL_DEPTH_8U, 3);
cvZero(fullImageCopy);
cvAddWeighted(frame, 0.5, fullImageCopy, 0.5, 0.0, fullImageCopy);
// draw the trajectory in the sample image
Template t("", mt);
DrawTrack(fullImageCopy, t.m_points, CV_RGB(100,255,100), 3, GESTURE_SQUARE_SIZE);
resizedImage = cvCreateImage(cvSize(LISTVIEW_SAMPLE_X,LISTVIEW_SAMPLE_Y),IPL_DEPTH_8U, 3);
bmpImage = new Bitmap(LISTVIEW_SAMPLE_X, LISTVIEW_SAMPLE_Y, PixelFormat24bppRGB);
cvResize(fullImageCopy, resizedImage, CV_INTER_AREA);
IplToBitmap(resizedImage, bmpImage);
bmpImage->GetHBITMAP(NULL, &hbmImage);
// Add image to imagelist
int imgIndex = ImageList_Add(hImageList, hbmImage, NULL);
// Add item to list view
lvi.mask = LVIF_IMAGE | LVIF_STATE | LVIF_GROUPID;
lvi.state = 0;
lvi.stateMask = 0;
lvi.iGroupId = groupId;
lvi.iItem = imgIndex;
lvi.iImage = imgIndex;
lvi.iSubItem = 0;
int newListItemPos = ListView_InsertItem(hwndListControl, &lvi);
id = ListView_MapIndexToID(hwndListControl, newListItemPos);
}
int dRuntimeProfiler::Render (int mask, int lineNumber)
{
struct GLViewPort
{
int x;
int y;
int width;
int height;
} viewport;
//Retrieves the viewport and stores it in the variable
glGetIntegerv(GL_VIEWPORT, (GLint*) &viewport.x);
m_width = viewport.width;
m_height = viewport.height;
NewtonWorld* const world = m_scene->GetNewton();
for (int i = 0; i < MAX_TRACKS; i ++) {
m_perfomanceTracks[i][m_frameIndex] = NewtonReadPerformanceTicks (world, i);
}
glColor3f(1.0, 1.0, 1.0);
glDisable (GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, viewport.width, 0, viewport.height );
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
dFloat x0 = dFloat (m_oringin_x);
dFloat y0 = dFloat (m_oringin_y);
dFloat x1 = x0 + MAX_FRAMES * MAX_FRAMES_STEP;
dFloat y1 = y0 + CHART_HIEGHT;
glBegin(GL_LINES);
glVertex3f (x0, y0, 0.0f);
glVertex3f (x0, y1, 0.0f);
glVertex3f (x0, y0, 0.0f);
glVertex3f (x1, y0, 0.0f);
for (int i = 1; i < 4; i ++) {
dFloat y = y0 + (y1 - y0) * i / 4;
glVertex3f (x0 - 5, y, 0.0f);
glVertex3f (x0 + 5, y, 0.0f);
}
for (int i = 1; i < MAX_FRAMES; i += 16) {
dFloat x = x0 + (x1 - x0) * i / MAX_FRAMES;
glVertex3f (x , y0 - 5, 0.0f);
glVertex3f (x , y0 + 5, 0.0f);
}
glEnd();
DrawLabel (10, m_height - m_nextLine, "Profiler legend");
m_nextLine = lineNumber;
// total engine time
if (mask & 1) {
DrawLabel (10, m_height - m_nextLine, "white chart: world global update");
DrawTrack (x0, y0, dVector (1.0f, 1.0f, 1.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_WORLD_UPDATE][0]);
m_nextLine += 20;
}
// draw collision performance
if (mask & 2) {
DrawLabel (10, m_height - m_nextLine, "red chart: collision global update");
DrawTrack (x0, y0, dVector (1.0f, 0.0f, 0.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_COLLISION_UPDATE][0]);
m_nextLine += 20;
}
if (mask & 4) {
DrawLabel (10, m_height - m_nextLine, "green chart: collision broad phase update");
DrawTrack (x0, y0, dVector (0.0f, 1.0f, 0.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_COLLISION_UPDATE_BROAD_PHASE][0]);
m_nextLine += 20;
}
if (mask & 8) {
DrawLabel (10, m_height - m_nextLine, "blue chart: collision narrow phase update");
DrawTrack (x0, y0, dVector (0.0f, 0.0f, 1.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_COLLISION_UPDATE_NARROW_PHASE][0]);
m_nextLine += 20;
}
// draw dynamics performance
if (mask & 16) {
DrawLabel (10, m_height - m_nextLine, "cyan chart: dynamics global update");
DrawTrack (x0, y0, dVector (0.0f, 1.0f, 1.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_DYNAMICS_UPDATE][0]);
m_nextLine += 20;
}
if (mask & 32) {
DrawLabel (10, m_height - m_nextLine, "black chart: dynamics solver update");
DrawTrack (x0, y0, dVector (0.0f, 0.0f, 0.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_DYNAMICS_CONSTRAINT_GRAPH][0]);
m_nextLine += 20;
}
if (mask & 64) {
DrawLabel (10, m_height - m_nextLine, "yellow chart: dynamics solver update");
DrawTrack (x0, y0, dVector (1.0f, 1.0f, 0.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_DYNAMICS_SOLVE_CONSTRAINT_GRAPH][0]);
m_nextLine += 20;
}
// draw force Update performance
if (mask & 128) {
DrawLabel (10, m_height - m_nextLine, "magenta chart: force and torque callback update");
DrawTrack (x0, y0, dVector (1.0f, 0.0f, 1.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_FORCE_CALLBACK_UPDATE][0]);
m_nextLine += 20;
}
if (mask & 256) {
DrawLabel (10, m_height - m_nextLine, "magenta chart: pre simulation listener");
DrawTrack (x0, y0, dVector (1.0f, 0.0f, 1.0f), m_frameIndex, &m_perfomanceTracks[NEWTON_PROFILER_FORCE_CALLBACK_UPDATE][0]);
m_nextLine += 20;
}
if (mask & 256) {
DrawLabel (10, m_height - m_nextLine, "purple chart: pre simulation listener");
DrawTrack (x0, y0, dVector (0.64f, 0.29f, 0.64f), m_frameIndex, &m_perfomanceTracks[NEWTON_PRE_LISTERNER_CALLBACK_UPDATE][0]);
m_nextLine += 20;
}
if (mask & 512) {
DrawLabel (10, m_height - m_nextLine, "pink chart: post simulation listener");
DrawTrack (x0, y0, dVector (1.0f, 0.68f, 0.79f), m_frameIndex, &m_perfomanceTracks[NEWTON_POST_LISTERNER_CALLBACK_UPDATE][0]);
m_nextLine += 20;
}
{
int base_y = 0;
glColor3f(1.0, 1.0, 1.0);
DrawLabel (x0 - 30, y0 + (y1 - y0) * 0 / 4 + base_y, "0");
for (int i = 1; i < 5; i ++) {
char label[32];
sprintf (label, "%4.2f", (1000.0f / 60.0f) * (float)i / 4.0f );
DrawLabel (x0 - 55, y0 + (y1 - y0) * i / 4 + base_y, label);
}
}
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable( GL_DEPTH_TEST );
m_frameIndex = (m_frameIndex + 1) % MAX_FRAMES;
glColor3f(1.0, 1.0, 1.0);
return m_nextLine + 20;
}
LRESULT CVideoMarkup::OnPaint( UINT, WPARAM, LPARAM, BOOL& ) {
PAINTSTRUCT ps;
HDC hdc = BeginPaint(&ps);
Rect drawBounds(0,0,VIDEO_X,VIDEO_Y);
Rect videoBounds(0,0,m_videoLoader.videoX,m_videoLoader.videoY);
Rect videoBoundsExt(2,2,m_videoLoader.videoX-4,m_videoLoader.videoY-4);
if (m_videoLoader.videoLoaded) {
graphics->SetClip(drawBounds);
if (m_videoLoader.bmpVideo != NULL) {
if (showGuesses && !scrubbingVideo) { // highlight computer's guesses
graphics->DrawImage(m_videoLoader.GetMaskedBitmap(),drawBounds);
} else {
graphics->DrawImage(m_videoLoader.bmpVideo,drawBounds);
}
}
Rect selectRect;
selectRect.X = (INT) min(selectStart.X, selectCurrent.X);
selectRect.Y = (INT) min(selectStart.Y, selectCurrent.Y);
selectRect.Width = (INT) abs(selectStart.X - selectCurrent.X);
selectRect.Height = (INT) abs(selectStart.Y - selectCurrent.Y);
if (selectingRegion) {
if (currentGroupId == GROUPID_POSSAMPLES) {
graphics->FillRectangle(&posBrush, selectRect);
graphics->DrawRectangle(&posSelectPen, selectRect);
} else {
graphics->FillRectangle(&negBrush, selectRect);
graphics->DrawRectangle(&negSelectPen, selectRect);
}
}
graphics->ResetClip();
}
graphicsExamples->FillRectangle(<grayBrush, Rect(0,0,EXAMPLEWINDOW_WIDTH,EXAMPLEWINDOW_HEIGHT));
if (classifier->isTrained) {
graphicsExamples->DrawImage(classifier->GetFilterImage(),10,0);
graphicsExamples->DrawString(L"RECOGNIZER MODEL", 16, &labelFont, PointF(15,5), &whiteBrush);
}
if (showGuesses) {
graphicsExamples->DrawImage(classifier->GetApplyImage(),FILTERIMAGE_WIDTH+20, 0);
graphicsExamples->DrawString(L"RECOGNIZER OUTPUT", 17, &labelFont, PointF(FILTERIMAGE_WIDTH+25,5), &whiteBrush);
}
if (classifier->isOnDisk) {
LPWSTR name = classifier->GetName();
graphicsExamples->DrawString(L"Currently\nActive:", 17, &labelFont, PointF(2*FILTERIMAGE_WIDTH+30,10), &blackBrush);
graphicsExamples->DrawString(name, wcslen(name), &bigFont,
RectF(2*FILTERIMAGE_WIDTH+30,50,EXAMPLEWINDOW_WIDTH-(2*FILTERIMAGE_WIDTH+30),EXAMPLEWINDOW_HEIGHT-50),
&stringFormat, &blackBrush);
}
if (recognizerMode == GESTURE_FILTER) {
// draw the current gesture motion trajectory in this frame
MotionTrack mt = m_videoLoader.GetTrajectoryAtCurrentFrame();
mt = ScaleToSquare(mt, 3*VIDEO_Y/4);
mt = TranslateToOrigin(mt);
DrawTrack(graphics, mt, VIDEO_X, VIDEO_Y, VIDEO_X);
}
BitBlt(hdc,0,0,VIDEO_X,VIDEO_Y,hdcmem,0,0,SRCCOPY);
BitBlt(hdc,EXAMPLEWINDOW_X,EXAMPLEWINDOW_Y,EXAMPLEWINDOW_WIDTH,EXAMPLEWINDOW_HEIGHT,hdcmemExamples,0,0,SRCCOPY);
EndPaint(&ps);
return 0;
}
void display (void) {
movement();
for (int i=0; i<NUMENTITIES; i++) {
entitiesArray[i]->update(entitiesArray, NUMENTITIES);
}
glm::vec3 axis_y(0, 1, 0);
glm::mat4 anim;
glm::mat4 model;
glm::mat4 projection;
glm::mat4 current_mvp;
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//1st screen top
glViewport(0, SCREENHEIGHT/2+1, SCREENWIDTH, SCREENHEIGHT/2);
view = glm::lookAt(player1->viewSrc, player1->viewDest, player1->viewUp);
projection = glm::perspective(45.0f, 1.0f*SCREENWIDTH/SCREENHEIGHT, 0.1f, 100.0f);
//Map
DrawTrack();
//PLAYER1
anim = glm::rotate(glm::mat4(1.0f),degToRad(player1->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), player1->pos);
current_mvp = projection * view * model * anim;
drawObject(player1, current_mvp, model, view);
//PLAYER2
anim = glm::rotate(glm::mat4(1.0f), degToRad(player2->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), player2->pos);
current_mvp = projection * view * model * anim;
drawObject(player2, current_mvp, model, view);
//Weapon
if(WeaTimer < 5000){
anim = glm::rotate(glm::mat4(1.0f), degToRad(weapon->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), weapon->pos);
current_mvp = projection * view * model * anim;
drawObject(weapon, current_mvp, model, view);
}
if(WeaTimer2 < 5000){
anim = glm::rotate(glm::mat4(1.0f), degToRad(weapon2->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), weapon2->pos);
current_mvp = projection * view * model * anim;
drawObject(weapon2, current_mvp, model, view);
}
//---------------------------
//2ed screen, bottom
glViewport(0, 0, SCREENWIDTH, SCREENHEIGHT/2);
view = glm::lookAt(player2->viewSrc, player2->viewDest, player2->viewUp);
//Map
DrawTrack();
//PLAYER1
anim = glm::rotate(glm::mat4(1.0f),degToRad(player1->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), player1->pos);
current_mvp = projection * view * model * anim;
drawObject(player1, current_mvp, model, view);
//PLAYER2
anim = glm::rotate(glm::mat4(1.0f),degToRad(player2->angle) , axis_y);
model = glm::translate(glm::mat4(1.0f), player2->pos);
current_mvp = projection * view * model * anim;
drawObject(player2, current_mvp, model, view);
if(WeaTimer < 5000){
anim = glm::rotate(glm::mat4(1.0f), degToRad(weapon->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), weapon->pos);
current_mvp = projection * view * model * anim;
drawObject(weapon, current_mvp, model, view);
}
if(WeaTimer2 < 5000){
anim = glm::rotate(glm::mat4(1.0f), degToRad(weapon2->angle), axis_y);
model = glm::translate(glm::mat4(1.0f), weapon2->pos);
current_mvp = projection * view * model * anim;
drawObject(weapon2, current_mvp, model, view);
}
glutSwapBuffers();
}
//+---------------------------------------------------------------------------
//
// Member: CScrollbar::Draw
//
// Synopsis: Draw the scroll bar in the given direction.
//
// Arguments: direction 0 for horizontal, 1 for vertical
// rcScrollbar bounds of entire scroll bar
// rcRedraw bounds to be redrawn
// contentSize size of content controlled by scroll bar
// containerSize size of area to scroll within
// scrollAmount amount that the content is scrolled
// partPressed which part, if any, is pressed
// hdc DC to draw into
// params customizable scroll bar parameters
// pDI draw info
// dwFlags rendering flags
//
// Notes:
//
//----------------------------------------------------------------------------
void CScrollbar::Draw(
int direction,
const CRect& rcScrollbar,
const CRect& rcRedraw,
long contentSize,
long containerSize,
long scrollAmount,
SCROLLBARPART partPressed,
HDC hdc,
const CScrollbarParams& params,
CDrawInfo* pDI,
DWORD dwFlags)
{
Assert(hdc != NULL);
// for now, we're using CDrawInfo, which should have the same hdc
Assert(pDI->_hdc == hdc);
// trivial rejection if nothing to draw
if(!rcScrollbar.Intersects(rcRedraw))
{
return;
}
BOOL fDisabled = (params._fForceDisabled) || (containerSize>=contentSize);
long scaledButtonWidth =
GetScaledButtonWidth(direction, rcScrollbar, params._buttonWidth);
// compute rects for buttons and track
CRect rcTrack(rcScrollbar);
rcTrack[direction] += scaledButtonWidth;
rcTrack[direction+2] -= scaledButtonWidth;
// draw buttons unless requested not to (it's expensive to draw these!)
if((dwFlags & DISPSCROLLBARHINT_NOBUTTONDRAW) == 0)
{
CRect rcButton[2];
rcButton[0] = rcScrollbar;
rcButton[0][direction+2] = rcTrack[direction];
rcButton[1] = rcScrollbar;
rcButton[1][direction] = rcTrack[direction+2];
// draw buttons
CSize sizeButton;
pDI->DocumentFromWindow(
&sizeButton, rcButton[0].Width(), rcButton[0].Height());
for(int i=0; i<2; i++)
{
if(rcRedraw.Intersects(rcButton[i]))
{
BOOL fButtonPressed = (i==0 && partPressed==SBP_PREVBUTTON) ||
(i==1 && partPressed==SBP_NEXTBUTTON);
CScrollButton scrollButton(params._pColors, params._fFlat);
scrollButton.DrawButton(
pDI,
NULL, // no hwnd, we don't want to invalidate
(direction==0?(i==0?BG_LEFT:BG_RIGHT):(i==0?BG_UP:BG_DOWN)),
fButtonPressed,
!fDisabled,
FALSE, // never focused
rcButton[i],
sizeButton,
0); // assume both button glyphs are the same size
}
}
}
// draw track
if(rcRedraw.Intersects(rcTrack))
{
if(fDisabled)
{
// no thumb, so draw non-pressed track
DrawTrack(rcTrack, FALSE, fDisabled, hdc, params);
}
else
{
// calculate thumb rect
CRect rcThumb;
GetPartRect(
&rcThumb,
SBP_THUMB,
direction,
rcScrollbar,
contentSize,
containerSize,
scrollAmount,
params._buttonWidth,
pDI,
FALSE);
// can track contain the thumb?
if(!rcTrack.Contains(rcThumb))
{
DrawTrack(rcTrack, FALSE, fDisabled, hdc, params);
}
else
{
// draw previous track
CRect rcTrackPart(rcTrack);
rcTrackPart[direction+2] = rcThumb[direction];
if(rcRedraw.Intersects(rcTrackPart))
{
DrawTrack(rcTrackPart, partPressed==SBP_PREVTRACK, fDisabled, hdc, params);
}
// draw thumb
if(rcRedraw.Intersects(rcThumb))
{
DrawThumb(rcThumb, partPressed==SBP_THUMB, hdc, params, pDI );
}
// draw next track
rcTrackPart = rcTrack;
rcTrackPart[direction] = rcThumb[direction+2];
if(rcRedraw.Intersects(rcTrackPart))
{
DrawTrack(rcTrackPart, partPressed==SBP_NEXTTRACK, fDisabled, hdc, params);
}
}
}
}
}
void AmTrackDataView::DrawPrimaryEvents(BRect clip, BView* view, const AmTrack* track)
{
DrawTrack(track, clip, view, ARPEVENT_PRIMARY, mTrackWinProps.Selections() );
}
static int ProfileShortestPathFunc(
SPTF_CMD cmd,
track_p trk,
EPINX_T ep,
EPINX_T ep0,
DIST_T dist,
void * data )
{
track_p trkN;
EPINX_T epN;
int rc0=0;
int pathMatch;
switch (cmd) {
case SPTC_TERMINATE:
rc0 = 1;
break;
case SPTC_MATCH:
if ( EndPtIsIgnoredElev(trk,ep) )
break;
if ( PathListSingle() ) {
if ( trk == pathStartTrk && ep == pathStartEp ) {
pathMatch = 2;
} else if ( trk == pathEndTrk && ep == pathEndEp ) {
pathMatch = 3;
} else {
break;
}
} else if ( ( trkN = GetTrkEndTrk(trk,ep) ) == NULL ) {
break;
} else {
epN = GetEndPtConnectedToMe( trkN, trk );
if ( trkN == pathStartTrk && epN == pathStartEp ) {
pathMatch = 1;
} else if ( trkN == pathEndTrk && epN == pathEndEp ) {
pathMatch = 2;
} else if ( trkN == pathStartTrk && trkN == pathEndTrk ) {
pathMatch = 2;
} else if ( trkN == pathStartTrk ) {
pathMatch = 1;
} else if ( trkN == pathEndTrk ) {
pathMatch = 2;
} else {
break;
}
}
if ( profileShortestPathMatch < 0 || profileShortestPathDist > dist ) {
LOG( log_shortPath, 4, ( " Match=%d", pathMatch ) )
profileShortestPathMatch = pathMatch;
profileShortestPathDist = dist;
}
rc0 = 1;
break;
case SPTC_MATCHANY:
rc0 = -1;
break;
case SPTC_IGNNXTTRK:
if ( EndPtIsIgnoredElev(trk,ep) )
rc0 = 1;
else if ( (GetTrkBits(trk)&TB_PROFILEPATH)!=0 )
rc0 = 1;
else if ( (!EndPtIsDefinedElev(trk,ep)) && GetTrkEndTrk(trk,ep)==NULL )
rc0 = 1;
else
rc0 = 0;
break;
case SPTC_ADD_TRK:
if (log_shortPath<=0||logTable(log_shortPath).level<4) LOG( log_profile, 4, ( " ADD_TRK T%d:%d", GetTrkIndex(trk), ep ) )
SetTrkBits( trk, TB_PROFILEPATH );
DrawTrack( trk, &mainD, profilePathColor );
rc0 = 0;
break;
case SPTC_VALID:
rc0 = 1;
break;
default:
break;
}
return rc0;
}
//画面描画
void TimelineEditorView::DrawTimelineEditorView(const CDC& dcDC)
{
CRect rcRect;
GetClientRect(&rcRect);
int iHeight = rcRect.Height();
CString strPoint;
// プレビューエリア枠線描画
m_pDebugInfoPanelRect->DrawMyBorderRect(3.0f);
// タイムラインヘッダーコントロールパネル描画
DrawTimelineControlPanel();
// シークバーエリア描画
DrawSeekBar(dcDC, iHeight);
// 静止クリップ描画
DrawClip(dcDC, iHeight);
// 操作イメージ描画
if ((m_pTimelineDataOperator->IsSingleInTrim() || m_pTimelineDataOperator->IsSingleOutTrim() || m_pTimelineDataOperator->IsMove())
&& (!(m_pOperatingClipData->GetOperatingRect()->IsRectEmpty())))
{
DrawOperatingClip(dcDC, iHeight);
}
if (m_pTimelineDataOperator->IsDragAndDrop())
{
DrawDragAndDropClip(dcDC, iHeight);
}
// トラックヘッダー描画
DrawTrackHeader();
// タイムラインデータエリア描画
DrawTimelineDataRect();
// トラック枠描画
DrawTrack(dcDC, iHeight);
// タイムラインカーソル／シャトル操作補助線描画
DrawTimelineCursor(dcDC, iHeight);
#ifdef _DEBUG
CString strFrameNumber;
double dPointX, dPointY;
HFONT hfDrawFont;
CreateDrawFont(13, 0, DEFAULT_FONTFACE, hfDrawFont);
strFrameNumber.Format(_T("TLCursor %d"), m_pTimelineDataOperator->GetTimelineCursorFramePosition());
ChangeScreenPointToOpenGLPoint(5, 15, iHeight, dPointX, dPointY);
DrawTextOnGL(static_cast<PCTSTR>(strFrameNumber), dcDC.GetSafeHdc(), hfDrawFont, BLACKCOLOR_BRUSH_FLOAT,
static_cast<float>(dPointX), static_cast<float>(dPointY), TIMELINE_DEFAULTZ, 1.0f);
strFrameNumber.Format(_T("Frame Left %d Right %d"), m_pTimelineDataOperator->GetLeftFrameNumber(), m_pTimelineDataOperator->GetRightFrameNumber());
ChangeScreenPointToOpenGLPoint(5, 30, iHeight, dPointX, dPointY);
DrawTextOnGL(static_cast<PCTSTR>(strFrameNumber), dcDC.GetSafeHdc(), hfDrawFont, BLACKCOLOR_BRUSH_FLOAT,
static_cast<float>(dPointX), static_cast<float>(dPointY), TIMELINE_DEFAULTZ, 1.0f);
strFrameNumber.Format(_T("Operating TLCursor %d"), m_pTimelineDataOperator->GetOperatingTimelineCursorFramePosition());
ChangeScreenPointToOpenGLPoint(5, 45, iHeight, dPointX, dPointY);
DrawTextOnGL(static_cast<PCTSTR>(strFrameNumber), dcDC.GetSafeHdc(), hfDrawFont, BLACKCOLOR_BRUSH_FLOAT,
static_cast<float>(dPointX), static_cast<float>(dPointY), TIMELINE_DEFAULTZ, 1.0f);
strFrameNumber.Format(_T("Operating Left %d Right %d"), m_pTimelineDataOperator->GetOperatingLeftFrameNumber(), m_pTimelineDataOperator->GetOperatingRightFrameNumber());
ChangeScreenPointToOpenGLPoint(5, 60, iHeight, dPointX, dPointY);
DrawTextOnGL(static_cast<PCTSTR>(strFrameNumber), dcDC.GetSafeHdc(), hfDrawFont, BLACKCOLOR_BRUSH_FLOAT,
static_cast<float>(dPointX), static_cast<float>(dPointY), TIMELINE_DEFAULTZ, 1.0f);
strFrameNumber.Format(_T("CursorLine Point %d"), m_iTimelineCursorPoint);
ChangeScreenPointToOpenGLPoint(5, 75, iHeight, dPointX, dPointY);
DrawTextOnGL(static_cast<PCTSTR>(strFrameNumber), dcDC.GetSafeHdc(), hfDrawFont, BLACKCOLOR_BRUSH_FLOAT,
static_cast<float>(dPointX), static_cast<float>(dPointY), TIMELINE_DEFAULTZ, 1.0f);
strFrameNumber.Format(_T("f/p %d p/f %d"), m_pTimelineDataOperator->GetFramePerPoint(), m_pTimelineDataOperator->GetPointPerFrame());
ChangeScreenPointToOpenGLPoint(5, 90, iHeight, dPointX, dPointY);
DrawTextOnGL(static_cast<PCTSTR>(strFrameNumber), dcDC.GetSafeHdc(), hfDrawFont, BLACKCOLOR_BRUSH_FLOAT,
static_cast<float>(dPointX), static_cast<float>(dPointY), TIMELINE_DEFAULTZ, 1.0f);
DeleteObject(hfDrawFont);
#endif
}
