Przyspieszenie wyświetlania na ekranie

[GrassHoppeR]

kombinuję z DirectDraw, porzuciłem Image.

odnoszę wrażenie, że autor wątku chce stworzyć jakiś program z wydajnością gry, a to wymaga użycia DirectX.

chcę stworzyć to: http://grasshopper.no-ip.info/Tjm.html tyle, że w C++ aby zwiększyć możliwości, i jak najlżejsze dla procesora.
(trzeba kliknąć zielony przycisk na początek, klonowanie klipów jest przy przytrzymaniu Ctrl i kliknięciu na klip)
wersję w C++ już mniej-więcej napisałem, tylko martwi mnie ta "wydajność".

dajcie cynk jak obejrzycie.

[Cyfrowy Baron]

No obejrzałem i gdyby dokładnie to samo stworzyć w C++Builder z wykorzystaniem np. TPainTBox jako powierzchni do rysowania zamiast TImage to byłoby równie wydajne. Pamiętaj, że skrypty uruchamiane są przez inne programy, ten podany przez Ciebie przez przeglądarkę, więc korzystają ze wsparcia przeglądarki, która korzysta ze wsparcia GDI, a Firefox 4 ma korzystać ze wsparcia Direct2D, ale tylko w Vista i Win 7, gdyż to wymaga DirectX 10.

Użycie TImage ma tą wadę, że ta klasa sama zarządza swoją zawartością, użycie innej powierzchni np. TPainBox daje większą kontrolę nad rysowaniem, ale wymaga też więcej pracy, gdyż trzeba wszystko zaprogramować. Nie da się po prostu wczytać do niego bitmapy, trzeba ją odrysować. Przeprowadzone testy z funkcją FillRect były u mnie siedmiokrotnie szybsze niż z Image.

[GrassHoppeR]

no właśnie z PaintBoxem też już kombinowałem, ale zniechęciło mnie dokładnie to, co piszesz. dlatego pozostałem przy Image, ale nie daje mi to jednak spokoju.
tu jest niezoptymalizowana wersja w C++, napisana identycznie jak "klocki" http://grasshopper.no-ip.info/Tjm0.1.zip
!ten program zapisuje na dysk C plik test.avs!

[Cyfrowy Baron]

Nie możesz tworzyć tej aplikacji tak jak tworzysz skrypt, gdyż w przypadku programu musisz zaprogramować obsługę GDI. Program działałby szybko gdybyś posłużył się zmianą stylu pędzla połączoną z wymazywanie. Już coś podobnego proponowałem kilku osobom na tym forum i działa idealnie. Podawałem zresztą wcześniej linki do tych postów. Twój program działa kiepsko. Kodu nie widziałem, ale jak sądzę, po każdym przesunięciu klocka zamazujesz tło, zamiast wymazywać klocek właśnie poprzez zmianę stylu pędzla.
W przypadku skryptu o obsługę GDI dba program, w którym skrypt jest uruchamiany, dlatego tworzenie skryptów jest prostsze.

[polymorphism]

Sprawdź u siebie program z załącznika i zobacz, ile zeżre % CPU. U mnie waha się w okolicach 2%.

____
p.s. nie zwracaj uwagi na migotanie, bo to akurat tu nie ma znaczenia.

[GrassHoppeR]

pięknie. bardzo szybko. obciążenie praktycznie niezauważalne. co to za mistrzowski sposób?

PS. choć mam pewne podejrzenia, bo aktywny klip po przesłonięciu przez inne okno znika i nie zamazuje klocka powyżej szerokości 1500.

[polymorphism]

Nie zamazuje, bo bitmapa jest na sztywno ustawiona. A co to za sztuczka? Banalna, po prostu przy przeciąganiu odświeżaj widok nie częściej niż co 10ms. Interwał ten w sumie zależy od czasu rysowania widoku. U mnie było to ~7ms, z czego jakieś 80% to narysowanie klocka przy użyciu GDI+ (reszta klocków szła z back-bufora).

[GrassHoppeR]

po prostu przy przeciąganiu odświeżaj widok nie częściej niż co 10ms.

no ba, wystarczy co 40ms, ale jak to się robi?

[polymorphism]

Na przykład tak:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

/*** w OnBeginDrag  ***/
m_last_repaint_time = timeGetTime();


/*** w OnDragging ***/
if(timeGetTime() - m_last_repaint_time > 10)
{
        /*
                tu logika OnDragging
        */
       
        RepaintView();
        m_last_repaint_time = timeGetTime();
}

[Cyfrowy Baron]

U mnie obraz migocze, a po rozciągnięciu okna na cały ekran, klocek już skacze, nie przesuwa się płynnie.

Nie zamazuje, bo bitmapa jest na sztywno ustawiona.

Nie widzę bitmapy.

---

Oto moje propozycje:

Bez bitmapy:

klocek.rar

Z bitmapą rysowaną w PaintBox daje nieprzewidziany efekt:

klocek_bitmapa.rar

Efekt można poprawić, ale to pokażę wieczorem, gdyż teraz muszę już kończyć.

[polymorphism]

U mnie obraz migocze

U mnie też, pisałem o tym. Pisałem też, żeby nie zwracać na to uwagi, bo nie to jest istotą problemu i nie to chciałem zaprezentować.

Nie widzę bitmapy.

A co chciałbyś widzieć, żeby uznać coś za bitmapę? Pisałem, że pozostałe klocki "idą z back-bufora", i ten bufor jest właśnie tą bitmapą.

[GrassHoppeR]

cieszę się, że Wam się udało. czy moglibyście się podzielić zatem kodem?

czy "nieprzewidziany efekt" odnosi się do negatywu pod klockiem? bo to akurat spodziewany efekt z użyciem tych trybów not, xor itp.

polymorphism, jak uzyskujesz półprzezroczystość? (czarne krawędzie pod klockiem nie robią się bledsze)

[polymorphism]

czy moglibyście się podzielić zatem kodem?

Mój kod na nic Ci się nie zda, bo pisałem to z wykorzystaniem wxWidgets, nie używam VCL-a. Tam zresztą nie ma czego pokazywać...


Co do półprzeźroczystości, to pisałem przecież, że wykorzystałem GDI+.

[GrassHoppeR]

Twój program działa kiepsko. Kodu nie widziałem, ale jak sądzę, po każdym przesunięciu klocka zamazujesz tło, zamiast wymazywać klocek właśnie poprzez zmianę stylu pędzla.

wiem, że działa kiepsko. od samego początku piszę, że działa kiepsko. ale działa równie kiepsko nawet BEZ wymazywania tła (w jednej z kompilacji, które dołączyłem). program się męczy nawet jeśli rysuje tylko jeden klocek jako Rectangle na pełnym ekranie, dlatego Was pytam. zmiana stylu pędzla nie wchodzi w grę, bo nie o taki rezultat wizualny mi chodzi. czy to ma bezpośredni wpływ na tą szybkość?
w jaki sposób uzyskałeś u siebie taką "lekkość"? najlepszy byłby dla mnie kod do analizy.

[Cyfrowy Baron]

Opracowałem kod wykorzystujący TPaintBox nie TImage, gdyż jest szybszy. Kod nie steruje stylem pędzla, gdyż w przypadku gdy tłem jest bitmapa daje to efekt maski, dlatego stworzyłem kod kopiujący fragment tła przesłoniętego klockiem z bufora zawierającego bitmapę. Program bazuje na GDI, jednak by uzyskać przeźroczystość klocka skorzystałem z GDI+, przez połączenie GDI z GDI+ udało mi się uzyskać szybki kod pozbawiony migotania i skokowego przesuwania prostokąta, a dzięki kopiowaniu tylko fragmentu bitmapy do przywrócenia, nie ma znaczenia jak duża jest ta bitmapa.

Kompletny kod:

plik nagłówkowy Unit1.h

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include "gdiplus.h"
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TPaintBox *PaintBox1;
        void __fastcall PaintBox1MouseMove(TObject *Sender, TShiftState Shift, int X,
          int Y);
        void __fastcall PaintBox1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y);
        void __fastcall PaintBox1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y);
        void __fastcall PaintBox1Paint(TObject *Sender);
        void __fastcall FormDestroy(TObject *Sender);
private:        // User declarations
        TWndMethod ResizeWindow;
        void __fastcall GetResizeWindow(TMessage &Msg);

        TRect graphRect;
        int gSize1, gSize2;

        Graphics::TBitmap *bitmapa;

        TPoint pbPoint;
        BOOL fDraw;

        void __fastcall DrawRect(TRect rDraw);
        void __fastcall DrawCopyRect(TRect rCopy);
        BOOL __fastcall FindRect(int X, int Y);

        /* GDI plus */
        Gdiplus::GdiplusStartupInput gdiplusStartupInput;
        ULONG_PTR gdiplusToken;

public:         // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

plik źródłowy Unit1.cpp

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------
#define STRICT

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

#pragma link "gdiplus.lib"


TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

 ResizeWindow = this->WindowProc;
 this->WindowProc = GetResizeWindow;

 bitmapa = new Graphics::TBitmap();
 bitmapa->LoadFromResourceName((int)HInstance, "PLIK");

 PaintBox1->Width = bitmapa->Width;
 PaintBox1->Height = bitmapa->Height;

 this->AutoScroll = true;
 this->DoubleBuffered = true;

 fDraw = false;
 gSize1 = 100;
 gSize2 = 25;

 graphRect = Rect(10, 10, 10 + gSize1, 10 + gSize2);
 DrawRect(graphRect);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
 Gdiplus::GdiplusShutdown(gdiplusToken);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::GetResizeWindow(TMessage &Msg)
{
 /* Przechwytywanie komunikatów o zmianie rorzmiaru okna */
 if(Msg.Msg == WM_SIZE)
 {
  if( Msg.WParam == SIZE_MAXIMIZED || Msg.WParam == SIZE_RESTORED )
  {
   fDraw = false;
   DrawCopyRect(graphRect);

   graphRect.Left   = 10;
   graphRect.Top    = 10;
   graphRect.Right  = 10 + gSize1;
   graphRect.Bottom = 10 + gSize2;

   this->VertScrollBar->Position = 0;
   this->HorzScrollBar->Position = 0;

   DrawRect(graphRect);
  }
 }

 ResizeWindow(Msg);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawRect(TRect rDraw)
{
 PaintBox1->Canvas->Pen->Color = clBlack;
 PaintBox1->Canvas->Pen->Width = 1;

 PaintBox1->Canvas->MoveTo(rDraw.Left, 0);
 PaintBox1->Canvas->LineTo(rDraw.Left, PaintBox1->Height);

 PaintBox1->Canvas->MoveTo(rDraw.Right, 0);
 PaintBox1->Canvas->LineTo(rDraw.Right, PaintBox1->Height);

 Gdiplus::Graphics grphxRect( PaintBox1->Canvas->Handle);
 Gdiplus::SolidBrush sBrush( Gdiplus::Color(175, 255, 0, 0) );  /* 175 stopień przeźroczystości 0-255 */
 Gdiplus::Pen blackPen( Gdiplus::Color(255, 0, 0, 0), 1 );

 grphxRect.DrawRectangle(&blackPen, rDraw.Left, rDraw.Top,
                                  rDraw.Width(), rDraw.Height() - 1);
 grphxRect.FillRectangle(&sBrush, rDraw.Left + 1, rDraw.Top + 1,
                                  rDraw.Width() - 1, rDraw.Height() - 2);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawCopyRect(TRect rCopy)
{
 TRect lineRect = Rect(rCopy.Left, 0, rCopy.Left + 1, PaintBox1->Height);
 PaintBox1->Canvas->CopyRect(lineRect, bitmapa->Canvas, lineRect);

 lineRect = Rect(rCopy.Right, 0, rCopy.Right + 1, PaintBox1->Height);
 PaintBox1->Canvas->CopyRect(lineRect, bitmapa->Canvas, lineRect);

 PaintBox1->Canvas->CopyRect(rCopy, bitmapa->Canvas, rCopy);
}
//---------------------------------------------------------------------------
BOOL __fastcall TForm1::FindRect(int X, int Y)
{
    if( (X >= graphRect.Left && X <= graphRect.Left + gSize1) &&
        (Y >= graphRect.Top && Y <= graphRect.Top + gSize2)
      )
    {
      return true;
    }

 return false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y)
{
 if(fDraw == true)
 {
  float Start = GetTickCount();

  DrawCopyRect(graphRect);

  int left = X - pbPoint.x;
  int top  = Y - pbPoint.y;


  graphRect.Left   = left;
  graphRect.Top    = top;
  graphRect.Right  =  left + gSize1;
  graphRect.Bottom =  top + gSize2;


  DrawRect(graphRect);

  float End = GetTickCount();

  Caption = "Draw Rectangle = " + FloatToStr(End - Start) + " ms";
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
 if( FindRect(X, Y) )
 {
  pbPoint.x = X - graphRect.Left;
  pbPoint.y = Y - graphRect.Top;

  fDraw = true;
 }
 else
 {
  fDraw = false;
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
  fDraw = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1Paint(TObject *Sender)
{
 PaintBox1->Canvas->Draw(0, 0, bitmapa);
 DrawRect(graphRect);
}
//---------------------------------------------------------------------------

---

Do pobrania: