void G_initializeGame() { window.initialize(); scene_rect = ScreenRect(0,0,window.videoModes[0].width,window.videoModes[0].height); client_rect = ScreenRect(0,0,window.currentWidth(),window.currentHeight()); lmenuRect = ScreenRect(0,0,lmenuw,client_rect.h); rmenuRect = ScreenRect(client_rect.w - rmenuw,0,rmenuw,client_rect.h); aspect_ratio = client_rect.w / client_rect.h; camera.initialize(-(256 + 16) * (scene_rect.w/client_rect.w), -16, scene_rect.w , scene_rect.h ); atlas_tile.initialize(&texture_sprite, 16, 16, 16, 16); atlas_collision.initialize(&texture_bga, 4, 4, 64, 64); atlas_font.initialize(&texture_bg, 16, 16, 8, 8); tilethumbsize = atlas_tile.imageFrameSize*2.0f; initializeTileAnimations(); world_constraints = WorldRect(-10000, -10000,81000, 81000); smallfont.initialize(16, 16, 8, 8, 1.0f, &camera, &client_rect, &atlas_font); bigfont.initialize(16, 16, 8, 8, 2.0f, &camera, &client_rect, &atlas_font); InitSpacings(); }
bool MenuBar::EventMouse(cevent_mouse* pEvent) { int n; if (pEvent->Type() == EV_MOUSE_PRESS) { n = GetPointItem(pEvent->Point()); if (n>=0) { SetSelect(n); OpenSub(); return true; } if (sub.ptr()) { crect rect = ScreenRect(); crect sr = sub->ScreenRect(); pEvent->Point().x += rect.left - sr.left; pEvent->Point().y += rect.top - sr.top; if (sub->EventMouse(pEvent)) return true; SetSelect(-1); if (Parent()) Parent()->Command(CMD_MENU_INFO, SCMD_MENU_CANCEL, this, 0); } return true; } else if (pEvent->Type() == EV_MOUSE_MOVE) { n = GetPointItem(pEvent->Point()); if (n>=0) { if (lastMouseSelect != n) { lastMouseSelect = n; SetSelect(n); } return true; } if (!sub.ptr() && !InFocus()) { lastMouseSelect = -1; SetSelect(-1); return true; } if (sub.ptr()) { crect rect = ScreenRect(); crect sr = sub->ScreenRect(); pEvent->Point().x += rect.left - sr.left; pEvent->Point().y += rect.top - sr.top; return sub->EventMouse(pEvent); } return true; } return false; }
VideoEngine::VideoEngine(): _fps_display(false), _fps_sum(0), _current_sample(0), _number_samples(0), _FPS_textimage(NULL), _gl_error_code(GL_NO_ERROR), _gl_blend_is_active(false), _gl_texture_2d_is_active(false), _gl_alpha_test_is_active(false), _gl_stencil_test_is_active(false), _gl_scissor_test_is_active(false), _gl_vertex_array_is_activated(false), _gl_color_array_is_activated(false), _gl_texture_coord_array_is_activated(false), _viewport_x_offset(0), _viewport_y_offset(0), _viewport_width(0), _viewport_height(0), _screen_width(0), _screen_height(0), _fullscreen(false), _x_cursor(0), _y_cursor(0), _debug_info(false), _x_shake(0), _y_shake(0), _brightness_value(1.0f), _temp_fullscreen(false), _temp_width(0), _temp_height(0), _smooth_pixel_art(true), _initialized(false) { _current_context.blend = 0; _current_context.x_align = -1; _current_context.y_align = -1; _current_context.x_flip = 0; _current_context.y_flip = 0; _current_context.coordinate_system = CoordSys(0.0f, VIDEO_STANDARD_RES_WIDTH, 0.0f, VIDEO_STANDARD_RES_HEIGHT); _current_context.viewport = ScreenRect(0, 0, VIDEO_STANDARD_RES_WIDTH, VIDEO_STANDARD_RES_HEIGHT); _current_context.scissor_rectangle = ScreenRect(0, 0, VIDEO_STANDARD_RES_WIDTH, VIDEO_STANDARD_RES_HEIGHT); _current_context.scissoring_enabled = false; for(uint32 sample = 0; sample < FPS_SAMPLES; sample++) _fps_samples[sample] = 0; }
void R_resize(int w, int h) { client_rect.w = (float) w; client_rect.h = (float) h; aspect_ratio = client_rect.w / client_rect.h; camera.aspect = aspect_ratio; camera.size.y = camera.size.x / aspect_ratio; lmenuRect = ScreenRect(0,0,lmenuw,client_rect.h); rmenuRect = ScreenRect(client_rect.w - rmenuw,0,rmenuw,client_rect.h); debug_rendertarget.Resize(client_rect.w, client_rect.h); rt_temp0.Resize(client_rect.w, client_rect.h); rt_temp1.Resize(client_rect.w, client_rect.h); }
void ui_core::PushScissor(const Frect& r_tgt, bool overlapped) { //. return; Frect r_top = ScreenRect(); Frect result = r_tgt; if (!m_Scissors.empty()&&!overlapped){ r_top = m_Scissors.top(); } if (!result.intersection(r_top,r_tgt)) result.set (0.0f,0.0f,0.0f,0.0f); if (!(result.x1>=0&&result.y1>=0&&result.x2<=UI_BASE_WIDTH&&result.y2<=UI_BASE_HEIGHT) ) { Msg("! r_tgt [%.3f][%.3f][%.3f][%.3f]", r_tgt.x1, r_tgt.y1, r_tgt.x2, r_tgt.y2); Msg("! result [%.3f][%.3f][%.3f][%.3f]", result.x1, result.y1, result.x2, result.y2); VERIFY(result.x1>=0&&result.y1>=0&&result.x2<=UI_BASE_WIDTH&&result.y2<=UI_BASE_HEIGHT); } m_Scissors.push (result); result.lt.x = ClientToScreenScaledX(result.lt.x); result.lt.y = ClientToScreenScaledY(result.lt.y); result.rb.x = ClientToScreenScaledX(result.rb.x); result.rb.y = ClientToScreenScaledY(result.rb.y); Irect r; r.x1 = iFloor(result.x1); r.x2 = iFloor(result.x2+0.5f); r.y1 = iFloor(result.y1); r.y2 = iFloor(result.y2+0.5f); RCache.set_Scissor (&r); }
void R_draw(HDC hDC) { glGetUniformLocation(NULL,NULL); rt_back.Clear(0.2941f, 0.2941f, 0.2941f, 1.0f); rt_scene.Clear(0.3921f, 0.3921f, 0.3921f, 1.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBindFramebuffer(GL_FRAMEBUFFER, rt_scene.fbo); glViewport(0, 0, rt_scene.width, rt_scene.height); camera.setOrthoMatrix(); if(bdrawbglayer01) tilemap_back.draw(&camera); if(bdrawbglayer02) tilemap_front.draw(&camera); if(bdrawbglayer03 && tilemap_back.has_c_Map) DrawCollisionMap(); R_drawWorldDebug(); glViewport(0, 0, client_rect.w, client_rect.h); R_setScreenOrtho(); s_srcRect = ScreenRect(lmenuw/client_rect.w,0,1.0 - ((lmenuw + rmenuw)/client_rect.w),1); s_dstRect = ScreenRect(lmenuw, 0, client_rect.w - (lmenuw + rmenuw), client_rect.h); DrawQuadDS(rt_back, rt_scene,&s_dstRect,&s_srcRect, NULL); glViewport(0, 0, client_rect.w, client_rect.h); glBindFramebuffer(GL_FRAMEBUFFER, debug_rendertarget.fbo); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); R_setScreenOrtho(); DrawLeftPanel(); DrawRightPanel(); DrawClientBorder(); R_setPostProcessingOrtho(); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); DrawFullscreenQuad(rt_back, debug_rendertarget, NULL); glFlush(); bdoublebuffer ? SwapBuffers( hDC ) : glDrawBuffer(GL_FRONT); }
void VideoEngine::Clear(const Color &c) { _current_context.viewport = ScreenRect(0, 0, _screen_width, _screen_height); glViewport(0, 0, _screen_width, _screen_height); glClearColor(c[0], c[1], c[2], c[3]); glClear(GL_COLOR_BUFFER_BIT); TextureManager->_debug_num_tex_switches = 0; }
void Font::initialize( int charsWide, int charsHigh, int charWidth, int charHeight, float Scale, Camera* pCamera, ScreenRect* pScreen, TileAtlas* ptexatlas) { atlas = ptexatlas; pcamera = pCamera; pscreen = pScreen; scaleValue = Scale; charsXYWH = ScreenRect(charsWide, charsHigh, charWidth, charHeight); }
bool PapercraftBulletBehaviorDefault::IsBulletOffScreen(const Bullet& TestBullet) const { HGE& HGEEngine = CheezePizzaEngine::Instance().GetHGE(); const float ScreenWidth = static_cast<float>(HGEEngine.System_GetState(HGE_SCREENWIDTH)); const float ScreenHeight = static_cast<float>(HGEEngine.System_GetState(HGE_SCREENHEIGHT)); hgeRect ScreenRect(0.0f, 0.0f, ScreenWidth, ScreenHeight); hgeRect BulletRect; BulletAnim->GetBoundingBox(TestBullet.Position.X, TestBullet.Position.Y, &BulletRect); // A bullet is fully-off-screen when its collision rect is outside the screen rect return !ScreenRect.Intersect(&BulletRect); }
bool CWinSystemWin32::ResizeInternal(bool forceRefresh) { DWORD dwStyle = WS_CLIPCHILDREN; HWND windowAfter; RECT rc; if(m_bFullScreen) { dwStyle |= WS_POPUP; windowAfter = HWND_TOP; rc = ScreenRect(m_nScreen); } else { dwStyle |= WS_OVERLAPPEDWINDOW; windowAfter = g_advancedSettings.m_alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST; if(m_nTop <= 0 || m_nLeft <= 0) CenterWindow(); rc.left = m_nLeft; rc.right = m_nLeft + m_nWidth; rc.top = m_nTop; rc.bottom = m_nTop + m_nHeight; AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, false ); } WINDOWINFO wi; GetWindowInfo(m_hWnd, &wi); RECT wr = wi.rcWindow; if (forceRefresh || wr.bottom - wr.top != rc.bottom - rc.top || wr.right - wr.left != rc.right - rc.left || (wi.dwStyle & WS_CAPTION) != (dwStyle & WS_CAPTION)) { CLog::Log(LOGDEBUG, "%s - resizing due to size change (%d,%d,%d,%d%s)->(%d,%d,%d,%d%s)",__FUNCTION__,wr.left, wr.top, wr.right, wr.bottom, (wi.dwStyle & WS_CAPTION) ? "" : " fullscreen", rc.left, rc.top, rc.right, rc.bottom, (dwStyle & WS_CAPTION) ? "" : " fullscreen"); SetWindowRgn(m_hWnd, 0, false); SetWindowLong(m_hWnd, GWL_STYLE, dwStyle); // The SWP_DRAWFRAME is here because, perversely, without it win7 draws a // white frame plus titlebar around the xbmc splash SetWindowPos(m_hWnd, windowAfter, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_SHOWWINDOW|SWP_DRAWFRAME); // TODO: Probably only need this if switching screens ValidateRect(NULL, NULL); } return true; }
void MenuBar::OpenSub() { ReleaseCapture(); sub = 0; if (select>=0 && select<list.count()) { crect rect = ScreenRect(); crect itemRect = ItemRect(select); int x = rect.left+itemRect.left; int y = rect.top+itemRect.bottom; sub = new PopupMenu(0, this, list[select].data, x, y, this ); //Parent() ? Parent() : 0); sub->Show(Win::SHOW_INACTIVE); sub->Enable(true); SetCapture(); } }
void CreditsWindow::Draw() { _window.Draw(); // Don't draw any contents of the window until the window is fully shown if (_window.GetState() != VIDEO_MENU_STATE_SHOWN) return; // Set clip region for the text and draw the visible part of it VideoManager->SetDrawFlags(VIDEO_X_CENTER, VIDEO_Y_TOP, 0); VideoManager->Move(512.0f, 384.0f + _scroll_offset); VideoManager->EnableScissoring(); // TODO: This returns a bad scissor rect due to a known bug in the GUI code // VideoManager->SetScissorRect(_window.GetScissorRect()); VideoManager->SetScissorRect(ScreenRect(0.0f, 80.0f, 1024.0f, 610.0f)); // Initially fade in the text from completely transparent to fully opaque float color_alpha = _scroll_offset * 0.025f; if (color_alpha >= 1.0f) _credits_text.Draw(); else _credits_text.Draw(Color(1.0f, 1.0f, 1.0f, color_alpha)); VideoManager->DisableScissoring(); }
bool CWinSystemWin32::BlankNonActiveMonitors(bool bBlank) { if(m_hBlankWindows.size() == 0) return false; if(bBlank == false) { for (unsigned int i=0; i < m_hBlankWindows.size(); i++) ShowWindow(m_hBlankWindows[i], SW_HIDE); return true; } // Move a blank window in front of every screen, except the current XBMC screen. int screen = 0; if (screen == m_nScreen) screen++; for (unsigned int i=0; i < m_hBlankWindows.size(); i++) { RECT rBounds = ScreenRect(screen); // move and resize the window SetWindowPos(m_hBlankWindows[i], NULL, rBounds.left, rBounds.top, rBounds.right - rBounds.left, rBounds.bottom - rBounds.top, SWP_NOACTIVATE); ShowWindow(m_hBlankWindows[i], SW_SHOW | SW_SHOWNOACTIVATE); screen++; if (screen == m_nScreen) screen++; } if(m_hWnd) SetForegroundWindow(m_hWnd); return true; }
bool CWinSystemWin32::ResizeInternal(bool forceRefresh) { if (m_hWnd == NULL) return false; DWORD dwStyle = WS_CLIPCHILDREN; HWND windowAfter; RECT rc; if(m_bFullScreen) { dwStyle |= WS_POPUP; windowAfter = HWND_TOP; rc = ScreenRect(m_nScreen); } else { dwStyle |= WS_OVERLAPPEDWINDOW; windowAfter = g_advancedSettings.m_alwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST; rc.left = m_nLeft; rc.right = m_nLeft + m_nWidth; rc.top = m_nTop; rc.bottom = m_nTop + m_nHeight; HMONITOR hMon = MonitorFromRect(&rc, MONITOR_DEFAULTTONULL); HMONITOR hMon2 = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTOPRIMARY); // hasn't been windowed yet, or windowed position would not fullscreen to the same screen we were fullscreen on? // -> center on the screen that we were fullscreen on if(!m_ValidWindowedPosition || hMon == NULL || hMon != hMon2) { RECT newScreenRect = ScreenRect(GetCurrentScreen()); rc.left = m_nLeft = newScreenRect.left + ((newScreenRect.right - newScreenRect.left) / 2) - (m_nWidth / 2); rc.top = m_nTop = newScreenRect.top + ((newScreenRect.bottom - newScreenRect.top) / 2) - (m_nHeight / 2); rc.right = m_nLeft + m_nWidth; rc.bottom = m_nTop + m_nHeight; } AdjustWindowRect( &rc, WS_OVERLAPPEDWINDOW, false ); } WINDOWINFO wi; wi.cbSize = sizeof (WINDOWINFO); GetWindowInfo(m_hWnd, &wi); RECT wr = wi.rcWindow; if (forceRefresh || wr.bottom - wr.top != rc.bottom - rc.top || wr.right - wr.left != rc.right - rc.left || (wi.dwStyle & WS_CAPTION) != (dwStyle & WS_CAPTION)) { CLog::Log(LOGDEBUG, "%s - resizing due to size change (%d,%d,%d,%d%s)->(%d,%d,%d,%d%s)",__FUNCTION__,wr.left, wr.top, wr.right, wr.bottom, (wi.dwStyle & WS_CAPTION) ? "" : " fullscreen", rc.left, rc.top, rc.right, rc.bottom, (dwStyle & WS_CAPTION) ? "" : " fullscreen"); SetWindowRgn(m_hWnd, 0, false); SetWindowLong(m_hWnd, GWL_STYLE, dwStyle); // The SWP_DRAWFRAME is here because, perversely, without it win7 draws a // white frame plus titlebar around the xbmc splash SetWindowPos(m_hWnd, windowAfter, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_SHOWWINDOW|SWP_DRAWFRAME); // TODO: Probably only need this if switching screens ValidateRect(NULL, NULL); } return true; }
void DrawRightPanel() { float x,y,w,h; float border = 2.0f; x = rmenuRect.x + border; y = rmenuRect.y + border - 1; w = rmenuRect.w - 2*border; h = rmenuRect.h - 2*border + 1; glDisable(GL_TEXTURE_2D); glColor4f(0.5882f, 0.5882f, 0.5882f, 1.0f); glBegin(GL_QUADS); { glVertex2f(x, y); glVertex2f(x + w, y); glVertex2f(x + w, y + h); glVertex2f(x, y + h); } glEnd(); glEnable(GL_TEXTURE_2D); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glBindTexture(GL_TEXTURE_2D, *(atlas_tile.texture)); w = tilethumbsize.x; h = tilethumbsize.y; x = rmenuRect.x + border + 8.0f; y = (rmenuRect.y + border - 1 + 2.0f) + rmenuyoffset + h; ScreenRect srcRect,dstRect,hl_dstRect,sel_dstRect; for(int i=0;i<atlas_tile.totalFrames;) { glBegin(GL_QUADS); { srcRect = atlas_tile.sourceRectangles[i]; dstRect = ScreenRect(x,y,w,h); glTexCoord2d(srcRect.fLeft(), srcRect.fTop()); glVertex2f(dstRect.fLeft(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fTop()); glVertex2f(dstRect.fRight(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fBottom()); glVertex2f(dstRect.fRight(), dstRect.fBottom()); glTexCoord2d(srcRect.fLeft(), srcRect.fBottom()); glVertex2f(dstRect.fLeft(), dstRect.fBottom()); } glEnd(); if(i == highlightedBrush) hl_dstRect = dstRect; if(i == selectedBrush) sel_dstRect = dstRect; x += w + 2.0f; i++; if(!fmod(i,tilesperrow)) { x = rmenuRect.x + border + 8.0f; y += h + 2.0f; } } //highlightedBrush float lw = 1.0f; glDisable(GL_TEXTURE_2D); //selected glColor4f(0.5f, 1.0f, 0.5f, 1.0f); R_DrawHorizontalLine(sel_dstRect.x - lw, sel_dstRect.y, sel_dstRect.w + 2*lw, lw); R_DrawVerticalLine(sel_dstRect.x, sel_dstRect.y , sel_dstRect.h, lw); R_DrawHorizontalLine(sel_dstRect.x - lw, sel_dstRect.y + sel_dstRect.h, sel_dstRect.w + 2*lw, lw); R_DrawVerticalLine(sel_dstRect.x + sel_dstRect.w, sel_dstRect.y + sel_dstRect.h, -sel_dstRect.h, lw); if(PointinRect(Point(input.mouse.lX,input.mouse.lY),rmenuRect)) { x = rmenuRect.x + border + 8.0f; y = (rmenuRect.y + border - 1 + 2.0f) + rmenuyoffset + h; Point cursor(CLAMP(input.mouse.lX,rmenuw,client_rect.w),input.mouse.lY); cursor.x -= x; cursor.y -= y; highlightedBrush = ((int)(cursor.x/(w + 2.0f)) + tilesperrow*((int)((cursor.y)/(h + 2.0f)))); highlightedBrush = CLAMP(highlightedBrush,0,atlas_tile.totalFrames-1); glColor4f(1.0f, 1.0f, 0.0f, 1.0f); R_DrawHorizontalLine(hl_dstRect.x - lw, hl_dstRect.y, hl_dstRect.w + 2*lw, lw); R_DrawVerticalLine(hl_dstRect.x, hl_dstRect.y , hl_dstRect.h, lw); R_DrawHorizontalLine(hl_dstRect.x - lw, hl_dstRect.y + hl_dstRect.h, hl_dstRect.w + 2*lw, lw); R_DrawVerticalLine(hl_dstRect.x + hl_dstRect.w, hl_dstRect.y + hl_dstRect.h, -hl_dstRect.h, lw); } glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glEnable(GL_TEXTURE_2D); x = rmenuRect.x + border; y = rmenuRect.y + border - 1; w = rmenuRect.w - 2*border; h = smallfont.charsXYWH.h * smallfont.scaleValue * 3; glDisable(GL_TEXTURE_2D); glColor4f(0.4882f, 0.4882f, 0.4882f, 1.0f); glBegin(GL_QUADS); { glVertex2f(x, y); glVertex2f(x + w, y); glVertex2f(x + w, y + h); glVertex2f(x, y + h); glColor4f(0.2941f, 0.2941f, 0.2941f, 1.0f); glVertex2f(x, y - 1); glVertex2f(x + w, y - 1); glVertex2f(x + w, y); glVertex2f(x, y); glVertex2f(x, y + h - 2); glVertex2f(x + w, y + h - 2); glVertex2f(x + w, y + h); glVertex2f(x, y + h); } glEnd(); glEnable(GL_TEXTURE_2D); char buffer[128]; Vector4 color; int ty = y + 8; int dy = smallfont.charsXYWH.h * smallfont.scaleValue; color = Vector4(0.0f,0.0f,0.0f,1.0f); sprintf (buffer, "Tile Set = %s", "tiles03.bmp"); ty += dy; smallfont.displayScreenTextSpacing(x + 8,ty,color.x,color.y,color.z,buffer); }
void ClientTiledThebesLayer::BeginPaint() { if (ClientManager()->IsRepeatTransaction()) { return; } mPaintData.mLowPrecisionPaintCount = 0; mPaintData.mPaintFinished = false; // Get the metrics of the nearest scroll container. ContainerLayer* scrollParent = nullptr; for (ContainerLayer* parent = GetParent(); parent; parent = parent->GetParent()) { const FrameMetrics& metrics = parent->GetFrameMetrics(); if (metrics.mScrollId != FrameMetrics::NULL_SCROLL_ID) { scrollParent = parent; break; } } if (!scrollParent) { // XXX I don't think this can happen, but if it does, warn and set the // composition bounds to empty so that progressive updates are disabled. NS_WARNING("Tiled Thebes layer with no scrollable container parent"); mPaintData.mCompositionBounds.SetEmpty(); return; } const FrameMetrics& metrics = scrollParent->GetFrameMetrics(); // Calculate the transform required to convert screen space into transformed // layout device space. gfx::Matrix4x4 effectiveTransform = GetEffectiveTransform(); for (ContainerLayer* parent = GetParent(); parent; parent = parent->GetParent()) { if (parent->UseIntermediateSurface()) { effectiveTransform = effectiveTransform * parent->GetEffectiveTransform(); } } gfx3DMatrix layoutToScreen; gfx::To3DMatrix(effectiveTransform, layoutToScreen); layoutToScreen.ScalePost(metrics.mCumulativeResolution.scale, metrics.mCumulativeResolution.scale, 1.f); mPaintData.mTransformScreenToLayout = layoutToScreen.Inverse(); // Compute the critical display port in layer space. mPaintData.mLayoutCriticalDisplayPort.SetEmpty(); if (!metrics.mCriticalDisplayPort.IsEmpty()) { // Convert the display port to screen space first so that we can transform // it into layout device space. const ScreenRect& criticalDisplayPort = metrics.mCriticalDisplayPort * metrics.mZoom; LayoutDeviceRect transformedCriticalDisplayPort = ApplyScreenToLayoutTransform(mPaintData.mTransformScreenToLayout, criticalDisplayPort); mPaintData.mLayoutCriticalDisplayPort = LayoutDeviceIntRect::ToUntyped(RoundedOut(transformedCriticalDisplayPort)); } // Calculate the frame resolution. Because this is Gecko-side, before any // async transforms have occurred, we can use mZoom for this. mPaintData.mResolution = metrics.mZoom; // Calculate the scroll offset since the last transaction, and the // composition bounds. mPaintData.mCompositionBounds.SetEmpty(); mPaintData.mScrollOffset.MoveTo(0, 0); Layer* primaryScrollable = ClientManager()->GetPrimaryScrollableLayer(); if (primaryScrollable) { const FrameMetrics& metrics = primaryScrollable->AsContainerLayer()->GetFrameMetrics(); mPaintData.mScrollOffset = metrics.mScrollOffset * metrics.mZoom; mPaintData.mCompositionBounds = ApplyScreenToLayoutTransform(mPaintData.mTransformScreenToLayout, ScreenRect(metrics.mCompositionBounds)); } }
void DrawLeftPanel() { float x,y,w,h; float border = 2.0f; x = lmenuRect.x + border; y = lmenuRect.y + border - 1; w = lmenuRect.w - 2*border; h = lmenuRect.h - 2*border + 1; glDisable(GL_TEXTURE_2D); glColor4f(0.5882f, 0.5882f, 0.5882f, 1.0f); glBegin(GL_QUADS); { glVertex2f(x, y); glVertex2f(x + w, y); glVertex2f(x + w, y + h); glVertex2f(x, y + h); } glEnd(); glEnable(GL_TEXTURE_2D); ScreenRect srcRect,dstRect; float top = 210; float dx = 32; float dw = 120; float dh = 128; w = tilethumbsize.x*2; h = tilethumbsize.y*2; x = lmenuRect.x + border + dx; y = lmenuRect.y + border - 1 + top; glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glBindTexture(GL_TEXTURE_2D, *(atlas_tile.texture)); glBegin(GL_QUADS); { //brush srcRect = atlas_tile.sourceRectangles[selectedBrush]; dstRect = ScreenRect(x,y,w,h); glTexCoord2d(srcRect.fLeft(), srcRect.fTop()); glVertex2f(dstRect.fLeft(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fTop()); glVertex2f(dstRect.fRight(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fBottom()); glVertex2f(dstRect.fRight(), dstRect.fBottom()); glTexCoord2d(srcRect.fLeft(), srcRect.fBottom()); glVertex2f(dstRect.fLeft(), dstRect.fBottom()); } glEnd(); //cbrush glBindTexture(GL_TEXTURE_2D, *(atlas_collision.texture)); glBegin(GL_QUADS); { srcRect = atlas_collision.sourceRectangles[selectedCBrush]; dstRect = ScreenRect(x + dw, y ,w,h); glTexCoord2d(srcRect.fLeft(), srcRect.fTop()); glVertex2f(dstRect.fLeft(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fTop()); glVertex2f(dstRect.fRight(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fBottom()); glVertex2f(dstRect.fRight(), dstRect.fBottom()); glTexCoord2d(srcRect.fLeft(), srcRect.fBottom()); glVertex2f(dstRect.fLeft(), dstRect.fBottom()); } glEnd(); float lw = 4.0f; glDisable(GL_TEXTURE_2D); x += -8.0f; w += 16.0f; y += -8.0f; h += 16.0f; //tile outline glColor4f(0.0f, 0.4f, 0.9f, 1.0f); R_DrawHorizontalLine(x - lw, y, w + 2*lw,lw); R_DrawVerticalLine(x, y , h, lw); R_DrawHorizontalLine(x - lw, y + h, w + 2*lw, lw); R_DrawVerticalLine(x + w, y + h, -h, lw); //brush outline glColor4f(0.0f, 0.9f, 0.4f, 1.0f); x += dw; R_DrawHorizontalLine(x - lw, y, w + 2*lw,lw); R_DrawVerticalLine(x, y , h, lw); R_DrawHorizontalLine(x - lw, y + h, w + 2*lw, lw); R_DrawVerticalLine(x + w, y + h, -h, lw); x -= dw; glEnable(GL_TEXTURE_2D); char buffer[128]; Vector4 color; int ty = lmenuRect.y + border - 1 + top - 32; int dy = smallfont.charsXYWH.h * smallfont.scaleValue; color = Vector4(0.0f,0.0f,0.0f,1.0f); sprintf (buffer, "%s", "Image Brush"); smallfont.displayScreenTextSpacing(x - 16,ty,color.x,color.y,color.z,buffer); sprintf (buffer, "index = %d", selectedBrush); smallfont.displayScreenTextSpacing(x - 16,ty +dy,color.x,color.y,color.z,buffer); sprintf (buffer, "%s", "Collision Brush"); smallfont.displayScreenTextSpacing(x - 16 + dw, ty,color.x,color.y,color.z,buffer); sprintf (buffer, "index = %d", selectedCBrush); smallfont.displayScreenTextSpacing(x - 16 + dw, ty + dy,color.x,color.y,color.z,buffer); //CBrush icons glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glBindTexture(GL_TEXTURE_2D, *(atlas_collision.texture)); w = 48.0f; h = 48.0f; x = lmenuRect.x + border + 8.0f; y = lmenuRect.y + border - 1 + top + dh; ScreenRect hl_dstRect,sel_dstRect; for(int i=0;i<atlas_collision.totalFrames;) { glBegin(GL_QUADS); { srcRect = atlas_collision.sourceRectangles[i]; dstRect = ScreenRect(x,y,w,h); glTexCoord2d(srcRect.fLeft(), srcRect.fTop()); glVertex2f(dstRect.fLeft(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fTop()); glVertex2f(dstRect.fRight(), dstRect.fTop()); glTexCoord2d(srcRect.fRight(), srcRect.fBottom()); glVertex2f(dstRect.fRight(), dstRect.fBottom()); glTexCoord2d(srcRect.fLeft(), srcRect.fBottom()); glVertex2f(dstRect.fLeft(), dstRect.fBottom()); } glEnd(); if(i == highlightedCBrush) hl_dstRect = dstRect; if(i == selectedCBrush) sel_dstRect = dstRect; x += w + 8.0f; i++; if(!fmod(i,4)) { x = lmenuRect.x + border + 8.0f; y += h + 8.0f; } } //highlightedCBrush lw = 1.0f; glDisable(GL_TEXTURE_2D); //selected glColor4f(0.5f, 1.0f, 0.5f, 1.0f); R_DrawHorizontalLine(sel_dstRect.x - lw, sel_dstRect.y, sel_dstRect.w + 2*lw, lw); R_DrawVerticalLine(sel_dstRect.x, sel_dstRect.y , sel_dstRect.h, lw); R_DrawHorizontalLine(sel_dstRect.x - lw, sel_dstRect.y + sel_dstRect.h, sel_dstRect.w + 2*lw, lw); R_DrawVerticalLine(sel_dstRect.x + sel_dstRect.w, sel_dstRect.y + sel_dstRect.h, -sel_dstRect.h, lw); if(PointinRect(Point(input.mouse.lX,input.mouse.lY),lmenuRect)) { x = lmenuRect.x + border + 8.0f; y = lmenuRect.y + border - 1 + top + dh; Point cursor(CLAMP(input.mouse.lX,0,lmenuRect.fRight()),input.mouse.lY); cursor.x -= x; cursor.y -= y; highlightedCBrush = ((int)(cursor.x/(w + 8.0f)) + 4*((int)((cursor.y)/(h + 8.0f)))); highlightedCBrush = CLAMP(highlightedCBrush,0,atlas_collision.totalFrames-1); glColor4f(1.0f, 1.0f, 0.0f, 1.0f); R_DrawHorizontalLine(hl_dstRect.x - lw, hl_dstRect.y, hl_dstRect.w + 2*lw, lw); R_DrawVerticalLine(hl_dstRect.x, hl_dstRect.y , hl_dstRect.h, lw); R_DrawHorizontalLine(hl_dstRect.x - lw, hl_dstRect.y + hl_dstRect.h, hl_dstRect.w + 2*lw, lw); R_DrawVerticalLine(hl_dstRect.x + hl_dstRect.w, hl_dstRect.y + hl_dstRect.h, -hl_dstRect.h, lw); } glEnable(GL_TEXTURE_2D); R_drawScreenDebug(); }
bool PopupMenu::EventMouse( cevent_mouse* pEvent ) { int N = -1; cpoint point = pEvent->Point(); for ( int i = 0; i < list.count(); i++ ) { crect* pr = &( list[i].rect ); if ( point.x >= pr->left && point.x < pr->right && point.y >= pr->top && point.y < pr->bottom ) { N = i; break; } } switch ( pEvent->Type() ) { case EV_MOUSE_MOVE: if ( N < 0 ) { if ( !sub.ptr() ) { return false; } crect rect = ScreenRect(); crect sr = sub->ScreenRect(); pEvent->Point().x += rect.left - sr.left; pEvent->Point().y += rect.top - sr.top; return sub->EventMouse( pEvent ); } if ( SetSelected( N ) ) { if ( this->IsSub( selected ) && IsEnabled( selected ) ) { OpenSubmenu(); } } return true; case EV_MOUSE_PRESS: if ( N < 0 ) { if ( sub.ptr() ) { crect rect = ScreenRect(); crect sr = sub->ScreenRect(); pEvent->Point().x += rect.left - sr.left; pEvent->Point().y += rect.top - sr.top; if ( sub->EventMouse( pEvent ) ) { return true; } } if ( IsModal() ) { EndModal( 0 ); } else if ( Parent() ) { Parent()->Command( CMD_MENU_INFO, SCMD_MENU_CANCEL, this, 0 ); } return true; } if ( SetSelected( N ) ) { if ( IsCmd( selected ) && IsEnabled( selected ) ) { int id = list[N].data->id; if ( IsModal() ) { EndModal( id ); } else if ( Parent() ) { Parent()->Command( id, 0, this, 0 ); } } else { OpenSubmenu(); } } return true; } return false; }
template<class ContainerT> void ContainerRender(ContainerT* aContainer, LayerManagerComposite* aManager, const nsIntRect& aClipRect) { /** * Setup our temporary surface for rendering the contents of this container. */ RefPtr<CompositingRenderTarget> surface; Compositor* compositor = aManager->GetCompositor(); RefPtr<CompositingRenderTarget> previousTarget = compositor->GetCurrentRenderTarget(); nsIntRect visibleRect = aContainer->GetEffectiveVisibleRegion().GetBounds(); aContainer->mSupportsComponentAlphaChildren = false; float opacity = aContainer->GetEffectiveOpacity(); bool needsSurface = aContainer->UseIntermediateSurface(); if (needsSurface) { SurfaceInitMode mode = INIT_MODE_CLEAR; bool surfaceCopyNeeded = false; gfx::IntRect surfaceRect = gfx::IntRect(visibleRect.x, visibleRect.y, visibleRect.width, visibleRect.height); gfx::IntPoint sourcePoint = gfx::IntPoint(visibleRect.x, visibleRect.y); // we're about to create a framebuffer backed by textures to use as an intermediate // surface. What to do if its size (as given by framebufferRect) would exceed the // maximum texture size supported by the GL? The present code chooses the compromise // of just clamping the framebuffer's size to the max supported size. // This gives us a lower resolution rendering of the intermediate surface (children layers). // See bug 827170 for a discussion. int32_t maxTextureSize = compositor->GetMaxTextureSize(); surfaceRect.width = std::min(maxTextureSize, surfaceRect.width); surfaceRect.height = std::min(maxTextureSize, surfaceRect.height); if (aContainer->GetEffectiveVisibleRegion().GetNumRects() == 1 && (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE)) { // don't need a background, we're going to paint all opaque stuff aContainer->mSupportsComponentAlphaChildren = true; mode = INIT_MODE_NONE; } else { const gfx3DMatrix& transform3D = aContainer->GetEffectiveTransform(); gfxMatrix transform; // If we have an opaque ancestor layer, then we can be sure that // all the pixels we draw into are either opaque already or will be // covered by something opaque. Otherwise copying up the background is // not safe. if (HasOpaqueAncestorLayer(aContainer) && transform3D.Is2D(&transform) && !transform.HasNonIntegerTranslation()) { surfaceCopyNeeded = gfxPlatform::ComponentAlphaEnabled(); sourcePoint.x += transform.x0; sourcePoint.y += transform.y0; aContainer->mSupportsComponentAlphaChildren = gfxPlatform::ComponentAlphaEnabled(); } } sourcePoint -= compositor->GetCurrentRenderTarget()->GetOrigin(); if (surfaceCopyNeeded) { surface = compositor->CreateRenderTargetFromSource(surfaceRect, previousTarget, sourcePoint); } else { surface = compositor->CreateRenderTarget(surfaceRect, mode); } if (!surface) { return; } compositor->SetRenderTarget(surface); } else { surface = previousTarget; aContainer->mSupportsComponentAlphaChildren = (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE) || (aContainer->GetParent() && aContainer->GetParent()->SupportsComponentAlphaChildren()); } nsAutoTArray<Layer*, 12> children; aContainer->SortChildrenBy3DZOrder(children); /** * Render this container's contents. */ for (uint32_t i = 0; i < children.Length(); i++) { LayerComposite* layerToRender = static_cast<LayerComposite*>(children.ElementAt(i)->ImplData()); if (layerToRender->GetLayer()->GetEffectiveVisibleRegion().IsEmpty() && !layerToRender->GetLayer()->AsContainerLayer()) { continue; } if (i + 1 < children.Length() && layerToRender->GetLayer()->GetEffectiveTransform().IsIdentity()) { LayerComposite* nextLayer = static_cast<LayerComposite*>(children.ElementAt(i + 1)->ImplData()); nsIntRect nextLayerOpaqueRect; if (nextLayer && nextLayer->GetLayer()) { nextLayerOpaqueRect = GetOpaqueRect(nextLayer->GetLayer()); } if (!nextLayerOpaqueRect.IsEmpty()) { nsIntRegion visibleRegion; visibleRegion.Sub(layerToRender->GetShadowVisibleRegion(), nextLayerOpaqueRect); layerToRender->SetShadowVisibleRegion(visibleRegion); if (visibleRegion.IsEmpty()) { continue; } } } nsIntRect clipRect = layerToRender->GetLayer()-> CalculateScissorRect(aClipRect, &aManager->GetWorldTransform()); if (clipRect.IsEmpty()) { continue; } if (layerToRender->HasLayerBeenComposited()) { // Composer2D will compose this layer so skip GPU composition // this time & reset composition flag for next composition phase layerToRender->SetLayerComposited(false); } else { layerToRender->RenderLayer(clipRect); } // invariant: our GL context should be current here, I don't think we can // assert it though } if (needsSurface) { // Unbind the current surface and rebind the previous one. #ifdef MOZ_DUMP_PAINTING if (gfxUtils::sDumpPainting) { nsRefPtr<gfxImageSurface> surf = surface->Dump(aManager->GetCompositor()); WriteSnapshotToDumpFile(aContainer, surf); } #endif compositor->SetRenderTarget(previousTarget); EffectChain effectChain; LayerManagerComposite::AutoAddMaskEffect autoMaskEffect(aContainer->GetMaskLayer(), effectChain, !aContainer->GetTransform().CanDraw2D()); effectChain.mPrimaryEffect = new EffectRenderTarget(surface); gfx::Matrix4x4 transform; ToMatrix4x4(aContainer->GetEffectiveTransform(), transform); gfx::Rect rect(visibleRect.x, visibleRect.y, visibleRect.width, visibleRect.height); gfx::Rect clipRect(aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height); aManager->GetCompositor()->DrawQuad(rect, clipRect, effectChain, opacity, transform); } if (aContainer->GetFrameMetrics().IsScrollable()) { gfx::Matrix4x4 transform; ToMatrix4x4(aContainer->GetEffectiveTransform(), transform); const FrameMetrics& frame = aContainer->GetFrameMetrics(); LayerRect layerBounds = ScreenRect(frame.mCompositionBounds) * ScreenToLayerScale(1.0); gfx::Rect rect(layerBounds.x, layerBounds.y, layerBounds.width, layerBounds.height); gfx::Rect clipRect(aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height); aManager->GetCompositor()->DrawDiagnostics(DIAGNOSTIC_CONTAINER, rect, clipRect, transform); } }
void R_drawWorldDebug() { glUseProgramObjectARB(NULL); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glDisable(GL_TEXTURE_2D); float x0,y0,x1,y1,w,h; //axis glLineWidth(4.0f); glBegin(GL_LINES); { glColor4f(1.0f, 0.0f, 0.0f, 1.0f); x0 = max(-10000,camera.position.x); x1 = min(10000,camera.position.x+camera.size.x); glVertex2f(x0, 0); glVertex2f(x1, 0); glColor4f(0.0f, 1.0f, 0.0f, 1.0f); y0 = max(-10000,camera.position.y); y1 = min(10000,camera.position.y+camera.size.y); glVertex2f(0, y0); glVertex2f(0, y1); } glEnd(); //grid glLineWidth(4.0f); glBegin(GL_LINES); { w = tilemap_back.w_tileSize.x; h = tilemap_back.w_tileSize.y; for (int y = tilemap_back.Min.y; y < tilemap_back.Max.y; y++) { for (int x = tilemap_back.Min.x; x < tilemap_back.Max.x; x++) { x0 = tilemap_back.position.x + x * w; y0 = tilemap_back.position.y + y * h; glColor4f(0.0f, 0.0f, 0.0f, 0.75f); glVertex2f(x0, y0); glVertex2f(x0, y0 + h); glVertex2f(x0, y0); glVertex2f(x0 + w, y0); glColor4f(1.0f, 0.0f, 1.0f, 0.5f); if(y == tilemap_back.Max.y-1) { glVertex2f(x0, y0 + h); glVertex2f(x0 + w, y0 + h); } glColor4f(0.0f, 0.0f, 1.0f, 0.5f); if(x == tilemap_back.Max.x-1) { glVertex2f(x0 + w, y0); glVertex2f(x0 + w, y0 + h); } } } } glEnd(); //highlightedTile if(PointinRect(Point(input.mouse.lX,input.mouse.lY),s_dstRect)) { Point cursor(CLAMP(input.mouse.lX,lmenuw,client_rect.w - rmenuw),input.mouse.lY); Vector2 worldcursor = screenToWorld(cursor,camera,client_rect); highlightedTile = worldToTile(worldcursor - pselected_tilemap->position, pselected_tilemap->w_tileSize); highlightedTile.x = CLAMP(highlightedTile.x,0,pselected_tilemap->t_mapSize.x-1); highlightedTile.y = CLAMP(highlightedTile.y,0,pselected_tilemap->t_mapSize.y-1); } float lw = 2.0f; ScreenRect srcRect,dstRect; w = pselected_tilemap->w_tileSize.x; h = pselected_tilemap->w_tileSize.y; x0 = pselected_tilemap->position.x + highlightedTile.x * w; y0 = pselected_tilemap->position.y + highlightedTile.y * h; glColor4f(1.0f, 1.0f, 1.0f, 1.0f); srcRect = atlas_tile.sourceRectangles[selectedBrush]; dstRect = ScreenRect(x0,y0,w,h); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, *(atlas_tile.texture)); glBegin(GL_QUADS); { glTexCoord2d(srcRect.fLeft(), srcRect.fTop()); glVertex2f(dstRect.fLeft(), dstRect.fBottom()); glTexCoord2d(srcRect.fRight(), srcRect.fTop()); glVertex2f(dstRect.fRight(), dstRect.fBottom()); glTexCoord2d(srcRect.fRight(), srcRect.fBottom()); glVertex2f(dstRect.fRight(), dstRect.fTop()); glTexCoord2d(srcRect.fLeft(), srcRect.fBottom()); glVertex2f(dstRect.fLeft(), dstRect.fTop()); } glEnd(); glDisable(GL_TEXTURE_2D); //image map if(blayer01loaded) { glColor4f(0.0f, 0.5f, 1.0f, 1.0f); x0 = pselected_tilemap->position.x + selectedTile.x * w; y0 = pselected_tilemap->position.y + selectedTile.y * h; R_DrawHorizontalLine(x0 - lw, y0, w + 2*lw, lw); R_DrawVerticalLine(x0, y0 , h, lw); R_DrawHorizontalLine(x0 - lw, y0 + h, w + 2*lw, lw); R_DrawVerticalLine(x0 + w, y0 + h, -h, lw); glColor4f(1.0f, 1.0f, 0.0f, 1.0f); x0 = pselected_tilemap->position.x + highlightedTile.x * w; y0 = pselected_tilemap->position.y + highlightedTile.y * h; R_DrawHorizontalLine(x0 - lw, y0, w + 2*lw, lw); R_DrawVerticalLine(x0, y0 , h, lw); R_DrawHorizontalLine(x0 - lw, y0 + h, w + 2*lw, lw); R_DrawVerticalLine(x0 + w, y0 + h, -h, lw); } glEnable(GL_TEXTURE_2D); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); }
void main(int argc, char *argv[]) { double r, g, b; uint rows, cols; char fname[256]; double colormag; time_t tstart, tend; int nrgbr = 63, nrgbg = 63, nrgbb = 63; OctreeType *octree; RGBType color; FILE *f; char title[40]; char description[128]; ulong i; uint j; int n; RGBType palette[256]; ulong image_start; union REGS regs; int resx, resy; int px, py; int ii; int cols2, rows2; int k; int cli; int maxr=0, maxg=0, maxb=0; #if defined METAWINDO rect screen; #endif printf("Image file : "); scanf("%s",fname); if ((f = fopen(fname,"rb")) == NULL) { printf("%s not found.\n",fname); exit(1); } /* ** Read the image file header */ fgets(title,40,f); fgets(description,128,f); fscanf(f,"%d %d",&cols,&rows); fscanf(f,"%lf",&colormag); image_start = ftell(f); cols2 = cols/2; rows2 = rows/2; time(&tstart); /* ** Initialize the color octree */ octree = CreateOctNode(0); /* ** Loop through the image and store each unique color. */ for (i = 0L; i < (ulong)rows*(ulong)cols; i++) { /* ** Show progress... */ if ((i % (ulong)cols) == 0L) printf("%ld\r",i/cols); fscanf(f,"%lf %lf %lf",&r,&g,&b); /* ** Convert input floating point values to bytes. NOTE: We assume that ** all input values are between 0..1.0 */ color.r = (unsigned char)(r * nrgbr); color.g = (unsigned char)(g * nrgbg); color.b = (unsigned char)(b * nrgbb); if (color.r > nrgbr) color.r = nrgbr; if (color.g > nrgbg) color.g = nrgbg; if (color.b > nrgbb) color.b = nrgbb; /* ** Insert this color into the octree */ InsertTree(&octree, &color, 0); /* ** If there are too many colors in the tree as a result of this ** insert, reduce the octree */ while (TotalLeafNodes() > npal) { ReduceTree(); } } /* ** Make a pass through the completed octree to average down the ** rgb components. When done, 'n' contains the actual number of ** colors in the palette table. */ n = 0; MakePaletteTable(octree, palette, &n); /* ** How long did it take? */ time(&tend); printf("Processed %ld pixels per second\ninto %d quantized colors\n", ((long)rows*(long)cols)/(tend-tstart), n); j = 0; while (j != 3) { printf("Output to (1)monitor or (2).PCX file or (3) quit: "); scanf("%s",title); j = atoi(title); if (j == 2) { fseek(f,image_start,0); SaveAsPCX(f, octree, cols, rows, nrgbr, nrgbg, nrgbb, npal, palette); } else if (j == 1) { #if defined METAWINDO /* ** NOTE: This section requires MetaWINDOW graphics lib ** ** Let the user choose his graphics device and resolution */ MetQuery(argc,argv); if (InitGraphics(GrafixCard) != 0) { printf("\n---Error initializing graphics device---\n"); exit(1); } SetDisplay(GrafPg0); BackColor(0); /* ** Set the VGA palette */ for (j = 0; j < n; j++) { regs.h.al = 0x10; regs.h.ah = 0x10; regs.h.bl = j; regs.h.bh = 0; regs.h.ch = (int)(palette[j].g); regs.h.cl = (int)(palette[j].b); regs.h.dh = (int)(palette[j].r); int86(0x10,®s,®s); } /* ** Center the image on the screen */ ScreenRect(&screen); resx = screen.Xmax; resy = screen.Ymax; px = resx/2 - npal; /* ** Display a color bar at the top of the screen */ for (ii = 0; ii < npal; ii++){ PenColor(ii); SetPixel(ii*2+px,1); SetPixel(ii*2+px+1,1); SetPixel(ii*2+px,2); SetPixel(ii*2+px+1,2); SetPixel(ii*2+px,3); SetPixel(ii*2+px+1,3); SetPixel(ii*2+px,4); SetPixel(ii*2+px+1,4); } fseek(f,image_start,0); py = resy/2 - rows2 - 1; for (ii = 0; ii < rows ; ii++) { px = resx/2 - cols2; for (k = 0; k < cols; k++) { if (fscanf(f,"%f %f %f",&r,&g,&b) == EOF) { goto pdone; } color.r = (byte)(nrgbr * r); color.g = (byte)(nrgbg * g); color.b = (byte)(nrgbb * b); cli = QuantizeColor(octree, &color); PenColor(cli); SetPixel(px,py); px++; } py++; } pdone: getch(); SetDisplay(TextPg0); StopGraphics(); #endif } } }