ich habe eine funktion in WM_PAINT geschrieben die gezeichnet wird, jedesmal wenn das fenster neu aktiviert wird, beginnt es wieder alles neu zu berechnen und zu zeichnen.
gibt es eine möglichkeit zu verhinder das alles immer neu berechnet werden muss, so dass einfach das schonmal berechnete angezeigt wird?

vielen dank!

// Pseudocode
if(mussNeuBerechnetWerden)
{
// berechnen
}
// zeichnen

wen ich diese in einer anderen funktion berechnen lasse stürtzt das programm sofort ab!
das passiert auch wenn ich dieses point-array global mache

Zeig doch mal deinen Code

Es ist kein Problem ein Array vorher zu befüllen und dann zu Zeichnen.

Hier wird als Beispiel ein 2D array befüllt und dann gezeichnet, dabei bediene ich mich eines Timers: (aus Coneway's Life)

case WM_TIMER:
      {
 //calulating next_generation
         bool next_gen[width][height];
         bool area[3][3];
         //first the four corners

         //0,0 corner
               //mid of area has to be set false
               area[1][1]=false;
               //right bottom
               area[0][0]=field[width-1][height-1];
               //left bottom
               area[1][0]=field[0][height-1];
               area[2][0]=field[1][height-1];
               //right top
               area[0][1]=field[width-1][0];
               area[0][2]=field[width-1][1];
               //rest
               area[2][1]=field[1][0];
               area[1][2]=field[0][1];
               area[2][2]=field[1][1];
         next_gen[0][0]=deadORalive(field[0][0],area);
         //width,0 corner
               //mid of area has to be set false
               area[1][1]=false;
               //right bottom
               area[0][0]=field[width-2][height-1];
               area[1][0]=field[width-1][height-1];
               //left bottom
               area[0][2]=field[0][height-1];
               //left top
               area[1][2]=field[0][0];
               area[2][2]=field[0][1];
               //rest
               area[0][1]=field[width-2][0];
               area[0][2]=field[width-2][1];
               area[1][2]=field[width-1][1];
         next_gen[width-1][0]=deadORalive(field[width-1][0],area);
         //width,height corner
               //mid of area has to be set false
               area[1][1]=false;
               //left bottom
               area[2][0]=field[0][height-2];
               area[2][1]=field[0][height-1];
               //left top
               area[2][2]=field[0][0];
               //right top
               area[1][2]=field[width-1][0];
               area[0][2]=field[width-2][0];
               //rest
               area[0][0]=field[width-2][height-2];
               area[1][0]=field[width-1][height-2];
               area[0][1]=field[width-2][height-1];
         next_gen[width-1][height-1]=deadORalive(field[width-1][height-1],area);
         //0,height corner
               //mid of area has to be set false
               area[1][1]=false;
               //right top
               area[0][2]=field[width-1][0];
               //right bottom
               area[0][0]=field[width-1][height-2];
               area[0][1]=field[width-1][height-1];
               //left top
               area[1][2]=field[0][0];
               area[2][2]=field[0][1];
               //rest
               area[1][0]=field[0][height-2];
               area[2][0]=field[1][height-2];
               area[2][1]=field[1][height-1];
         next_gen[0][height-1]=deadORalive(field[0][height-1],area);

         //H line
         area[1][1]=false;       
         for(int i=1;i<(width-1);i++)
         { 
          //calculating rest of top line
          //bottom
          area[0][0]=field[i-1][height-1];
          area[1][0]=field[i][height-1];
          area[2][0]=field[i+1][height-1];
          //rest
          area[0][1]=field[i-1][0];
          area[0][2]=field[i-1][1];
          area[2][1]=field[i+1][0];
          area[2][2]=field[i+1][1];
          area[1][2]=field[i][1];
         next_gen[i][0]=deadORalive(field[i][0],area);

         //calculating for bottom line
         //top
          area[0][2]=field[i-1][0];
          area[1][2]=field[i][0];
          area[2][2]=field[i+1][0];
          //rest                    
          area[0][0]=field[i-1][height-2];
          area[0][1]=field[i-1][height-1];
          area[1][0]=field[i][height-2];
          area[2][0]=field[i+1][height-2];
          area[2][1]=field[i+1][height-1];

         next_gen[i][height-1]=deadORalive(field[i][height-1],area);
         }
         //V line
         area[1][1]=false;       
         for(int i=1;i<(height-1);i++)
         { //calculating rest of left line
           //left
           area[0][0]=field[width-1][i-1];
           area[0][1]=field[width-1][i];
           area[0][2]=field[width-1][i+1];
           //rest
           area[1][0]=field[0][i-1];
           area[2][0]=field[1][i-1];
           area[2][1]=field[1][i];
           area[1][2]=field[0][i+1];
           area[2][2]=field[1][i+1];
         next_gen[0][i]=deadORalive(field[0][i],area);  
          //calulating rest of right line
          //right
          area[2][0]=field[0][i-1];
          area[2][1]=field[0][i];
          area[2][2]=field[0][i+1];
          //rest
          area[0][0]=field[width-2][i-1];
          area[0][1]=field[width-2][i];
          area[0][2]=field[width-2][i+1];
          area[1][0]=field[width-1][i-1];
          area[1][2]=field[width-1][i+1];
         next_gen[width-1][i]=deadORalive(field[width-1][i],area);   
         }
         //calculating rest of next_gen field
         area[1][1]=false;
         for(int i=1;i<(width-1);i++)
         {for(int j=1;j<(height-1);j++)
         {
         area[0][0]=field[i-1][j-1];
         area[0][1]=field[i-1][j];
         area[0][2]=field[i-1][j+1];
         area[2][0]=field[i+1][j-1];
         area[2][1]=field[i+1][j];
         area[2][2]=field[i+1][j+1];
         area[1][0]=field[i][j-1];
         area[1][2]=field[i][j+1];
         next_gen[i][j]=deadORalive(field[i][j],area);        
         }}
         //copy to actually field;
         for(int i=0;i<width;i++)
         for(int j=0;j<height;j++)
         {field[i][j]=next_gen[i][j];};
         InvalidateRect(hwnd, NULL, FALSE);
         return 0;
      }

         case WM_ERASEBKGND: {return 1;}

das field array ist als static int array innerhalb der callback fkt angelegt, kann aber auch global sein.
Das zeichnen läuft dann per double puffer:

case WM_PAINT:
        {

         PAINTSTRUCT ps;
         HDC hDC=BeginPaint(hwnd,&ps);
         int bkgCol=0;//0x00d8e9ec;
         int frmCol=0x00b99d7f;
         HDC hMemDC=CreateCompatibleDC(hDC);
         HBITMAP hBm = CreateCompatibleBitmap(hDC, width, height); 
         SelectObject(hMemDC, hBm); 
         //SetBkColor(hMemDC,bkgCol);

         for(int i=0;i<width;i++){
         for(int j=0;j<height;j++){
               if(field[i][j]==true)
               {SetPixel(hMemDC,i,j,frmCol);}
               else{SetPixel(hMemDC,i,j,bkgCol);};
         }}                         

       BitBlt(hDC, 0, 0, width, height, hMemDC, 0, 0, SRCCOPY); 
       DeleteDC(hMemDC);
       DeleteObject(hBm);  
       EndPaint(hwnd,&ps);

        return 0;
        }

Ich hoffe das das Beispiel hilfreich ist, denkt an das (c) muhahaha

greetz

Wo kracht es denn.
Der Debugger sollte Dir doch helfen, wenn Du Dir die Variablen und die Lokation des Crash ansiehst.

@Martin: derfer ist der Thread opener,.. ich habe nur ein beispiel wie es funktioniert gegeben,...
greetz

Upps! Sorry, das habe ich übersehen!