DWORD PisteDraw_Videomuistia() { DDCAPS hel_caps, hal_caps; DD_INIT_STRUCT(hel_caps); DD_INIT_STRUCT(hal_caps); if (FAILED(PD_lpdd->GetCaps(&hal_caps,&hel_caps))) { strcpy(virhe,"Cannot aquire system information!"); return PD_VIRHE; } return hal_caps.dwVidMemFree; }
int PisteDraw_Buffer_Tayta(int i, UCHAR color) { DD_INIT_STRUCT(PD_ddbltfx); PD_ddbltfx.dwFillColor = color; IDirectDrawSurface4 *buffer; if (i >= MAX_BUFFEREITA) return PD_VIRHE; if (PD_buffers[i].lpdds == NULL) return PD_VIRHE; buffer = PD_buffers[i].lpdds; RECT dest_rect; dest_rect.left = 0; dest_rect.right = PD_buffers[i].leveys; dest_rect.top = 0; dest_rect.bottom = PD_buffers[i].korkeus; if (FAILED(buffer->Blt(&dest_rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &PD_ddbltfx))) { PisteLog_Kirjoita("[Error] Piste Draw: Buffer fill failed!\n"); return PD_VIRHE; } return 0; }
DWORD PisteDraw_Videomuistia_Max() { DDCAPS hel_caps, hal_caps; DD_INIT_STRUCT(hel_caps); DD_INIT_STRUCT(hal_caps); if (FAILED(PD_lpdd->GetCaps(&hal_caps,&hel_caps))) { strcpy(virhe,"Cannot aquire system information!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot aquire system information! \n"); return PD_VIRHE; } return hal_caps.dwVidMemTotal; }
LPDIRECTDRAWSURFACE4 PisteDraw_Create_Surface(int width, int height, int mem_flags, UCHAR color) { LPDIRECTDRAWSURFACE4 lpdds; DD_INIT_STRUCT(PD_ddsd); PD_ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; PD_ddsd.dwWidth = width; PD_ddsd.dwHeight = height; PD_ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | mem_flags; if (FAILED(PD_lpdd->CreateSurface(&PD_ddsd, &lpdds, NULL))) return(NULL); DDCOLORKEY color_key; color_key.dwColorSpaceLowValue = color; color_key.dwColorSpaceHighValue = color; if(FAILED(lpdds->SetColorKey(DDCKEY_SRCBLT, &color_key))) return(NULL); return(lpdds); }
int Draw_Rectangle(int x1, int y1, int x2, int y2, int color, LPDIRECTDRAWSURFACE7 lpdds) { // this function uses directdraw to draw a filled rectangle DDBLTFX ddbltfx; // this contains the DDBLTFX structure RECT fill_area; // this contains the destination rectangle // clear out the structure and set the size field DD_INIT_STRUCT(ddbltfx); // set the dwfillcolor field to the desired color ddbltfx.dwFillColor = color; // fill in the destination rectangle data (your data) fill_area.top = y1; fill_area.left = x1; fill_area.bottom = y2+1; fill_area.right = x2+1; // ready to blt to surface, in this case blt to primary lpdds->Blt(&fill_area, // ptr to dest rectangle NULL, // ptr to source surface, NA NULL, // ptr to source rectangle, NA DDBLT_COLORFILL | DDBLT_WAIT | DDBLT_ASYNC, // fill and wait &ddbltfx); // ptr to DDBLTFX structure // return success return(1); } // end Draw_Rectangle
/* * DD_Lock_Surface: * Locks a specified surface */ WORD *DDLockSurface(LPDIRECTDRAWSURFACE lpdds, int *lpitch) { // lock the surface DD_INIT_STRUCT(ddsd); lpdds->Lock(NULL, &ddsd, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, NULL); // set the memory pitch *lpitch = ddsd.lPitch >> 1; // return pointer to surface return((WORD *)ddsd.lpSurface); }
int PisteDraw_Buffer_Tayta(int i, int vasen, int yla, int oikea, int ala, UCHAR color) { DD_INIT_STRUCT(PD_ddbltfx); PD_ddbltfx.dwFillColor = color; IDirectDrawSurface4 *buffer; if (i >= MAX_BUFFEREITA) return PD_VIRHE; if (PD_buffers[i].lpdds == NULL) return PD_VIRHE; buffer = PD_buffers[i].lpdds; vasen += vasen_marginaali; oikea += vasen_marginaali; yla += yla_marginaali; ala += yla_marginaali; RECT dest_rect; dest_rect.left = (long)vasen; dest_rect.right = (long)oikea; dest_rect.top = (long)yla; dest_rect.bottom = (long)ala; if (dest_rect.left < PD_buffers[i].klipperi.left) dest_rect.left = PD_buffers[i].klipperi.left; if (dest_rect.right > PD_buffers[i].klipperi.right) dest_rect.right = PD_buffers[i].klipperi.right; if (dest_rect.top < PD_buffers[i].klipperi.top) dest_rect.top = PD_buffers[i].klipperi.top; if (dest_rect.bottom > PD_buffers[i].klipperi.bottom) dest_rect.bottom = PD_buffers[i].klipperi.bottom; if (FAILED(buffer->Blt(&dest_rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &PD_ddbltfx))) { PisteLog_Kirjoita("[Error] Piste Draw: Buffer fill area failed!\n"); return PD_VIRHE; } return 0; }
int PisteDraw_Buffer_Flip(int i) { DD_INIT_STRUCT(PD_ddsd); DD_INIT_STRUCT(PD_ddbltfx); RECT dest_rect; dest_rect.left = 0; dest_rect.right = PD_ruudun_leveys; dest_rect.top = 0; dest_rect.bottom = PD_ruudun_korkeus; if (FAILED(PD_buffers[PD_TAUSTABUFFER].lpdds->Blt(&dest_rect, PD_buffers[i].lpdds, &dest_rect, (DDBLT_WAIT | DDBLT_KEYSRC), NULL))) { strcpy(virhe,"Unable to flip surface!"); PisteLog_Kirjoita("[Error] Piste Draw: Unable to flip surface!\n"); return PD_VIRHE; } return 0; }
void DDFillSurface(LPDIRECTDRAWSURFACE lpdds, WORD color) { DDBLTFX ddbltfx; // this contains the DDBLTFX structure // clear out the structure and set the size field DD_INIT_STRUCT(ddbltfx); // set the dwfillcolor field to the desired color ddbltfx.dwFillColor = color; // ready to blt to surface lpdds->Blt(NULL, // ptr to dest rectangle NULL, // ptr to source surface, NA NULL, // ptr to source rectangle, NA DDBLT_COLORFILL | DDBLT_WAIT, // fill and wait &ddbltfx); // ptr to DDBLTFX structure }
int PisteDraw_Piirto_Aloita(int i, UCHAR *&back_buffer, DWORD &lPitch) { if (PD_buffers[i].lukittu) if (PisteDraw_Piirto_Lopeta(i)==PD_VIRHE) { PisteLog_Kirjoita("[Error] Piste Draw: Can't start free draw: Surface unlock failed!\n"); return PD_VIRHE; } DD_INIT_STRUCT(PD_ddsd); //PD_piirto_buffer_index = i; if (FAILED(PD_buffers[i].lpdds->Lock(NULL, &PD_ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL))) { PisteLog_Kirjoita("[Error] Piste Draw: Can't start free draw: Surface lock failed!\n"); return PD_VIRHE; } back_buffer = (UCHAR *)PD_ddsd.lpSurface; lPitch = (DWORD &)PD_ddsd.lPitch; PD_buffers[i].lukittu = true; return 0; }
int DMusic_Load_MIDI(char *filename) { // this function loads a midi segment DMUS_OBJECTDESC ObjDesc; HRESULT hr; IDirectMusicSegment* pSegment = NULL; // look for open slot for midi segment int id = -1; int index; for (index = 0; index < DM_NUM_SEGMENTS; index++) { // is this one open if (dm_midi[index].state == MIDI_NULL) { // validate id, but don't validate object until loaded id = index; break; } } // found good id? if (id==-1) return(-1); // get current working directory char szDir[_MAX_PATH]; WCHAR wszDir[_MAX_PATH]; if(_getcwd( szDir, _MAX_PATH ) == NULL) return(-1); MULTI_TO_WIDE(wszDir, szDir); // tell the loader were to look for files hr = dm_loader->SetSearchDirectory(GUID_DirectMusicAllTypes,wszDir, FALSE); if (FAILED(hr)) return (-1); // convert filename to wide string WCHAR wfilename[_MAX_PATH]; MULTI_TO_WIDE(wfilename, filename); // setup object description DD_INIT_STRUCT(ObjDesc); ObjDesc.guidClass = CLSID_DirectMusicSegment; wcscpy(ObjDesc.wszFileName, wfilename ); ObjDesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FILENAME; // load the object and query it for the IDirectMusicSegment interface // This is done in a single call to IDirectMusicLoader::GetObject // note that loading the object also initializes the tracks and does // everything else necessary to get the MIDI data ready for playback. hr = dm_loader->GetObject(&ObjDesc,IID_IDirectMusicSegment, (void**) &pSegment); if (FAILED(hr)) return(-1); // ensure that the segment plays as a standard MIDI file // you now need to set a parameter on the band track // Use the IDirectMusicSegment::SetParam method and let // DirectMusic find the trackby passing -1 (or 0xFFFFFFFF) in the dwGroupBits method parameter. hr = pSegment->SetParam(GUID_StandardMIDIFile,-1, 0, 0, (void*)dm_perf); if (FAILED(hr)) return(-1); // This step is necessary because DirectMusic handles program changes and // bank selects differently for standard MIDI files than it does for MIDI // content authored specifically for DirectMusic. // The GUID_StandardMIDIFile parameter must be set before the instruments are downloaded. // The next step is to download the instruments. // This is necessary even for playing a simple MIDI file // because the default software synthesizer needs the DLS data // for the General MIDI instrument set // If you skip this step, the MIDI file will play silently. // Again, you call SetParam on the segment, this time specifying the GUID_Download parameter: hr = pSegment->SetParam(GUID_Download, -1, 0, 0, (void*)dm_perf); if (FAILED(hr)) return(-1); // at this point we have MIDI loaded and a valid object dm_midi[id].dm_segment = pSegment; dm_midi[id].dm_segstate = NULL; dm_midi[id].state = MIDI_LOADED; return(id); }
int PisteDraw_Buffer_Flip_Nopea(int lahde_index, int kohde_index, int x, int y) { DD_INIT_STRUCT(PD_ddsd); //Alustetaan DirectX pintakuvaus DD_INIT_STRUCT(PD_ddbltfx); //Alustetaan Blittaus tehosteet int leveys; //Apumuuttuja int korkeus; //Apumuuttuja RECT source_rect; //Alue lähdebufferista josta kopioidaan kohdebufferiin RECT *klipperi_kohde; //Pointteri kohdebufferin leikkuriin RECT *klipperi_lahde; //Pointteri lähdebufferin leikkuriin x += vasen_marginaali; y += yla_marginaali; klipperi_kohde = &PD_buffers[kohde_index].klipperi; klipperi_lahde = &PD_buffers[lahde_index].klipperi; int vasen = klipperi_lahde->left; int oikea = klipperi_lahde->right; int yla = klipperi_lahde->top; int ala = klipperi_lahde->bottom; leveys = oikea - vasen; // lasketaan apuja korkeus = ala - yla; if (x+leveys > klipperi_kohde->right) //Varmistetaan että ei piirretä kohdebufferin { //rajojen ulkopuolelle oikea = vasen + klipperi_kohde->right - x; } if (x < klipperi_kohde->left) { vasen = vasen - x + klipperi_kohde->left; x = klipperi_kohde->left; } if (y+korkeus > klipperi_kohde->bottom) { ala = yla + klipperi_kohde->bottom - y; } if (y < klipperi_kohde->top) { yla = yla - y + klipperi_kohde->top; y = klipperi_kohde->top; } if (oikea>vasen && ala>yla) { source_rect.left = vasen; source_rect.right = oikea; source_rect.top = yla; source_rect.bottom = ala; if (FAILED(PD_buffers[kohde_index].lpdds->BltFast(x, y, PD_buffers[lahde_index].lpdds, &source_rect, (DDBLTFAST_WAIT | DDBLTFAST_SRCCOLORKEY)))) { PisteLog_Kirjoita("[Error] Piste Draw: BlitFast failed!\n"); return PD_VIRHE; // blitataan kaikki paitsi läpinäkyvyysväri } } return 0; }
int PisteDraw_Buffer_Flip(int lahde_index, int kohde_index, int x, int y, bool peilaa_x, bool peilaa_y) { DD_INIT_STRUCT(PD_ddsd); //Alustetaan DirectX pintakuvaus DD_INIT_STRUCT(PD_ddbltfx); //Alustetaan Blittaus tehosteet int leveys; //Apumuuttuja int korkeus; //Apumuuttuja RECT dest_rect; //Alue kohdebufferista josta kopioidaan lähdebufferiin RECT source_rect; //Alue lähdebufferista josta kopioidaan kohdebufferiin RECT *klipperi_kohde; //Pointteri kohdebufferin leikkuriin RECT *klipperi_lahde; //Pointteri lähdebufferin leikkuriin x += vasen_marginaali; y += yla_marginaali; if (peilaa_x) PD_ddbltfx.dwDDFX = DDBLTFX_MIRRORLEFTRIGHT; if (peilaa_y) PD_ddbltfx.dwDDFX = DDBLTFX_MIRRORUPDOWN; if (peilaa_x && peilaa_y) PD_ddbltfx.dwDDFX = DDBLTFX_MIRRORLEFTRIGHT | DDBLTFX_MIRRORUPDOWN; klipperi_kohde = &PD_buffers[kohde_index].klipperi; klipperi_lahde = &PD_buffers[lahde_index].klipperi; int vasen = klipperi_lahde->left; int oikea = klipperi_lahde->right; int yla = klipperi_lahde->top; int ala = klipperi_lahde->bottom; leveys = oikea - vasen; // lasketaan apuja korkeus = ala - yla; if (x+leveys > klipperi_kohde->right) //Varmistetaan että ei piirretä kohdebufferin { //rajojen ulkopuolelle oikea = vasen + klipperi_kohde->right - x; } if (x < klipperi_kohde->left) { vasen = vasen - x + klipperi_kohde->left; } if (y+korkeus > klipperi_kohde->bottom) { ala = yla + klipperi_kohde->bottom - y; } if (y < klipperi_kohde->top) { yla = yla - y + klipperi_kohde->top; } if (oikea>vasen && ala>yla) { dest_rect.left = vasen+x; dest_rect.right = oikea+x; dest_rect.top = yla+y; dest_rect.bottom = ala+y; source_rect.left = vasen; source_rect.right = oikea; source_rect.top = yla; source_rect.bottom = ala; if (peilaa_x) { if (x<klipperi_kohde->left) { source_rect.left = klipperi_lahde->left; source_rect.right = klipperi_lahde->right - (vasen - klipperi_lahde->left); } else { source_rect.left = klipperi_lahde->left + (klipperi_lahde->right - oikea); source_rect.right = klipperi_lahde->right; } } if (peilaa_y) { if (y < klipperi_kohde->top) { source_rect.top = klipperi_lahde->top; source_rect.bottom = klipperi_lahde->bottom - (yla - klipperi_lahde->top); } else { source_rect.top = klipperi_lahde->top + (klipperi_lahde->bottom - ala); source_rect.bottom = klipperi_lahde->bottom; } } if (FAILED(PD_buffers[kohde_index].lpdds->Blt(&dest_rect, PD_buffers[lahde_index].lpdds, &source_rect, (DDBLT_WAIT | DDBLT_KEYSRC | DDBLT_DDFX), &PD_ddbltfx))){ PisteLog_Kirjoita("[Error] Piste Draw: Unable to flip surface!\n"); return PD_VIRHE; } } return 0; }
int PisteDraw_Lataa_Kuva(int index, char *filename, bool lataa_paletti) { BITMAP_FILE bitmap; bool ok = false; char paate[4]; for (int i=0;i<4;i++) paate[i] = toupper(filename[strlen(filename)-3+i]); paate[4] = '\0'; if (strcmp(paate,"BMP")==0) { ok = true; if (PD_buffers[index].lpdds) { if (PisteDraw_Load_Bitmap(&bitmap, filename) != 0) { strcpy(virhe,"Could not load picture "); strcat(virhe,filename); strcat(virhe,"!"); PisteLog_Kirjoita("[Error] Piste Draw: "); PisteLog_Kirjoita(virhe); PisteLog_Kirjoita("\n"); return PD_VIRHE; } DD_INIT_STRUCT(PD_ddsd); if (FAILED(PD_buffers[index].lpdds->Lock(NULL,&PD_ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL))) { strcpy(virhe,"Could not lock surface after loading a picture!"); PisteLog_Kirjoita("[Error] Piste Draw: Could not lock surface after loading a picture! \n"); return PD_VIRHE; } UCHAR *back_buffer = (UCHAR *)PD_ddsd.lpSurface; int x; int y; int leveys, korkeus; if (bitmap.bitmapinfoheader.biWidth > PD_buffers[index].leveys) leveys = PD_buffers[index].leveys; else leveys = bitmap.bitmapinfoheader.biWidth; if (bitmap.bitmapinfoheader.biHeight > PD_buffers[index].korkeus) korkeus = PD_buffers[index].korkeus; else korkeus = bitmap.bitmapinfoheader.biHeight; for (y=0; y<korkeus; y++) { for (x=0; x<leveys; x++) { back_buffer[x+y*PD_ddsd.lPitch] = bitmap.buffer[x+y*bitmap.bitmapinfoheader.biWidth]; } } if (FAILED(PD_buffers[index].lpdds->Unlock(NULL))) { strcpy(virhe,"Could not unlock surface after loading a picture!"); PisteLog_Kirjoita("[Error] Piste Draw: Could not unlock surface after loading a picture! \n"); return PD_VIRHE; } PisteDraw_Unload_Bitmap_File(&bitmap); if (lataa_paletti) { if (FAILED(PD_lpddpal->SetEntries(0,0,PD_max_varit, bitmap.paletti))) { strcpy(virhe,"Could not set palette after loading a picture!"); PisteLog_Kirjoita("[Error] Piste Draw: Could not set palette after loading a picture! \n"); return PD_VIRHE; } for (int pi=0;pi<256;pi++) { PD_paletti[pi].peBlue = bitmap.paletti[pi].peBlue; PD_paletti[pi].peRed = bitmap.paletti[pi].peRed; PD_paletti[pi].peGreen = bitmap.paletti[pi].peGreen; PD_paletti[pi].peFlags = bitmap.paletti[pi].peFlags; } } } else return PD_VIRHE; } if (strcmp(paate,"PCX")==0) { ok = true; if (PisteDraw_Lataa_PCX(filename, index, lataa_paletti) == PD_VIRHE) { strcpy(virhe,"Could not load picture "); strcat(virhe,filename); strcat(virhe,"!"); PisteLog_Kirjoita("[Error] Piste Draw: "); PisteLog_Kirjoita(virhe); PisteLog_Kirjoita("\n"); return PD_VIRHE; } } if (!ok) { strcpy(virhe,"Could not load bitmap file of type "); strcat(virhe,paate); return PD_VIRHE; } return 0; }
int PisteDraw_Buffer_Uusi(int leveys, int korkeus, bool video_muisti, UCHAR color) { int i = 0, varaus; bool find = false; DDCAPS hel_caps, hal_caps; DD_INIT_STRUCT(hel_caps); DD_INIT_STRUCT(hal_caps); if (FAILED(PD_lpdd->GetCaps(&hal_caps,&hel_caps))) { strcpy(virhe,"Cannot aquire system information!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot aquire system information to create a new buffer! \n"); return PD_VIRHE; } if ((unsigned long)(leveys*korkeus) > hal_caps.dwVidMemFree) { //tarkastetaan riittääkö videomuistia video_muisti = false; PisteLog_Kirjoita("[Warning] Piste Draw: Out of video memory - creating a new buffer in system memory! \n"); } if (video_muisti) { varaus = DDSCAPS_VIDEOMEMORY; } else { varaus = DDSCAPS_SYSTEMMEMORY; } while ((i < MAX_BUFFEREITA) && !find) { if (PD_buffers[i].lpdds == NULL) // Onko puskurin pinta jo varattu? { if ((PD_buffers[i].lpdds = PisteDraw_Create_Surface(leveys, korkeus, varaus, color)) != NULL) { PD_buffers[i].leveys = leveys; PD_buffers[i].korkeus = korkeus; PD_buffers[i].klipperi.left = 0; PD_buffers[i].klipperi.top = 0; PD_buffers[i].klipperi.right = leveys; PD_buffers[i].klipperi.bottom = korkeus; PD_buffers[i].video_muisti = video_muisti; PD_buffers[i].lukittu = false; find = true; PD_buffereita_varattu++; } else { i = PD_VIRHE; strcpy(virhe,"Cannot create a new DirectDraw surface!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot create a new DirectDraw surface! \n"); } } else { i++; } } if (!find) { strcpy(virhe,"PisteEngine has run out of buffers!"); PisteLog_Kirjoita("[Error] Piste Draw: PisteDraw has run out of buffers! \n"); i = PD_VIRHE; } return i; }
int PisteDraw_Alusta(HWND &main_window_handle, HINSTANCE &hinstance_app, int leveys, int korkeus, int bpp, int max_colors) { if (PD_unload) { strcpy(virhe,"Uh, oh, I think we have a bug..."); PD_main_window_handle = (HWND &)main_window_handle; PD_hinstance_app = (HINSTANCE &)hinstance_app; PD_ruudun_leveys = leveys; PD_ruudun_korkeus = korkeus; PD_ruudun_bpp = bpp; PD_max_varit = max_colors; LPDIRECTDRAW temp = NULL; // väliaikainen rajapinta jolla haetaan uusin versio int i; if (FAILED(DirectDrawCreate(NULL, &temp, NULL))) // luo rajapintaosoitin versioon 1.0 { strcpy(virhe,"Cannot initialize DirectDraw!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot initialize DirectDraw! \n"); return PD_VIRHE; } if (FAILED(temp->QueryInterface(IID_IDirectDraw4,(LPVOID *)&PD_lpdd))) // osoitin v 4.0 { strcpy(virhe,"Cannot initialize DirectDraw4!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot initialize DirectDraw4! \n"); return PD_VIRHE; } temp->Release(); // tuhotaan väliaikainen rajapinta temp = NULL; if (FAILED(PD_lpdd->SetCooperativeLevel(PD_main_window_handle, // Yhteistyö Windowsin kanssa.. DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT))) { strcpy(virhe,"Failed to cooperate with Windows!"); PisteLog_Kirjoita("[Error] Piste Draw: Failed to cooperate with Windows! \n"); return PD_VIRHE; } if (FAILED(PD_lpdd->SetDisplayMode(PD_ruudun_leveys, PD_ruudun_korkeus, PD_ruudun_bpp,0,0))) { strcpy(virhe,"Unable to change video mode!"); PisteLog_Kirjoita("[Error] Piste Draw: Unable to change video mode! \n"); return PD_VIRHE; } DD_INIT_STRUCT(PD_ddsd); PD_ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; PD_ddsd.dwBackBufferCount = 2; //Kolmoispuskurointi = primary + 2 taustapuskuria PD_ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; if (FAILED(PD_lpdd->CreateSurface(&PD_ddsd, &PD_lpddsprimary, NULL))) { strcpy(virhe,"Cannot create primary surface!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot create primary surface! \n"); return PD_VIRHE; } PD_buffers[PD_TAUSTABUFFER].leveys = leveys; PD_buffers[PD_TAUSTABUFFER].korkeus = korkeus; PisteDraw_Aseta_Klipperi(PD_TAUSTABUFFER,0,0,leveys,korkeus); PD_ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER; if (FAILED(PD_lpddsprimary->GetAttachedSurface(&PD_ddsd.ddsCaps, &PD_buffers[PD_TAUSTABUFFER].lpdds))) { strcpy(virhe,"Cannot attach back buffer to primary surface!"); PisteLog_Kirjoita("[Error] Piste Draw: Cannot attach back buffer to primary surface! \n"); return PD_VIRHE; } PD_buffers[PD_TAUSTABUFFER2].leveys = leveys; PD_buffers[PD_TAUSTABUFFER2].korkeus = korkeus; PisteDraw_Aseta_Klipperi(PD_TAUSTABUFFER2,0,0,leveys,korkeus); for (i=1;i<255;i++) //Luodaan 8-bittinen paletti { PD_paletti[i].peRed = 0; PD_paletti[i].peGreen = 0; PD_paletti[i].peBlue = 0; PD_paletti[i].peFlags = PC_NOCOLLAPSE; } if (FAILED(PD_lpdd->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256 | DDPCAPS_INITIALIZE, PD_paletti, &PD_lpddpal, NULL))) { PisteLog_Kirjoita("[Error] Piste Draw: Cannot create 8-bit palette! \n"); strcpy(virhe,"Cannot create 8-bit palette!"); return PD_VIRHE; } if (FAILED(PD_lpddsprimary->SetPalette(PD_lpddpal))) { PisteLog_Kirjoita("[Error] Piste Draw: Cannot set palette! \n"); strcpy(virhe,"Cannot set palette!"); return PD_VIRHE; } /*LIITETÄÄN KLIPPERI KUVAN REUNOJEN YLIKIRJOITUSTA ESTÄMÄÄN*/ PD_fontbuffer = PisteDraw_Buffer_Uusi(PD_ruudun_leveys,10,true,255); for (i=2;i<MAX_BUFFEREITA;i++) // alustetaan kuvabufferi taulukko. PD_buffers[i].lpdds = NULL; // 0 ja 1 on varattu taustapuskureille vasen_marginaali = 0; yla_marginaali = 0; PD_unload = false; } return 0; }