bool PisteInput_Hae_Ohjaimet() { bool ok = false; for(int ohjain=0; ohjain < PI_MAX_PELIOHJAIMIA; ohjain++) { if (PI_joysticks[ohjain].available) { if (FAILED(PI_joysticks[ohjain].lpdijoy->Poll())) { PisteLog_Kirjoita("[Warning] Piste Input: Lost control of game pad! \n"); PI_joysticks[ohjain].available = false; } if (FAILED(PI_joysticks[ohjain].lpdijoy->GetDeviceState(sizeof(DIJOYSTATE),(LPVOID)&PI_joysticks[ohjain].joystick_state))) { PisteLog_Kirjoita("[Warning] Piste Input: Lost control of game pad! \n"); PI_joysticks[ohjain].available = false; } if (PI_joysticks[ohjain].available) ok = true; } } return ok; }
bool PisteInput_Alusta_Keyboard() { if (FAILED(PI_lpdi->CreateDevice(GUID_SysKeyboard, &PI_lpdikey, NULL))) { PisteLog_Kirjoita("[Error] Piste Input: Keyboard - Create Device failed! \n"); return false; } if (FAILED(PI_lpdikey->SetCooperativeLevel(PI_main_window_handle, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE /* | DISCL_FOREGROUND*/))) { PisteLog_Kirjoita("[Error] Piste Input: Keyboard - Set cooperative level failed! \n"); return false; } if (FAILED(PI_lpdikey->SetDataFormat(&c_dfDIKeyboard))) { PisteLog_Kirjoita("[Error] Piste Input: Keyboard - Set data format failed! \n"); return false; } if (FAILED(PI_lpdikey->Acquire())) { PisteLog_Kirjoita("[Error] Piste Input: Keyboard - Acquire failed! \n"); return false; } return true; }
int PisteDraw_Paletti_Pyorita(UCHAR eka_vari, UCHAR vika_vari) { UCHAR i; if (FAILED(PD_lpddpal->GetEntries(0,0,255,PD_paletti_nyt))) { PisteLog_Kirjoita("[Error] Piste Draw: Palette get entries failed!\n"); return PD_VIRHE; } PALETTEENTRY temp_vari; temp_vari.peRed = PD_paletti_nyt[vika_vari].peRed; temp_vari.peGreen = PD_paletti_nyt[vika_vari].peGreen; temp_vari.peBlue = PD_paletti_nyt[vika_vari].peBlue; for (i=vika_vari;i>eka_vari;i--) { PD_paletti_nyt[i].peRed = PD_paletti_nyt[i-1].peRed; PD_paletti_nyt[i].peGreen = PD_paletti_nyt[i-1].peGreen; PD_paletti_nyt[i].peBlue = PD_paletti_nyt[i-1].peBlue; } PD_paletti_nyt[eka_vari].peRed = temp_vari.peRed; PD_paletti_nyt[eka_vari].peGreen = temp_vari.peGreen; PD_paletti_nyt[eka_vari].peBlue = temp_vari.peBlue; if (FAILED(PD_lpddpal->SetEntries(0,0,255,PD_paletti_nyt))) { PisteLog_Kirjoita("[Error] Piste Draw: Palette set entries failed!\n"); return PD_VIRHE; } return 0; }
bool PisteInput_Alusta_Mouse() { if (FAILED(PI_lpdi->CreateDevice(GUID_SysMouse, &PI_lpdimouse, NULL))) { PisteLog_Kirjoita("[Warning] Piste Input: No mouse available! \n"); PI_mouse_available = false; } if (PI_mouse_available) { if (FAILED(PI_lpdimouse->SetCooperativeLevel(PI_main_window_handle, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE))) { PisteLog_Kirjoita("[Error] Piste Input: Mouse - Set cooperative level failed! \n"); PI_mouse_available = false; } if (FAILED(PI_lpdimouse->SetDataFormat(&c_dfDIMouse))) { PisteLog_Kirjoita("[Error] Piste Input: Mouse - Set data format failed! \n"); PI_mouse_available = false; } if (FAILED(PI_lpdimouse->Acquire())) { PisteLog_Kirjoita("[Error] Piste Input: Mouse - Acquire failed! \n"); PI_mouse_available = false; } } return PI_mouse_available; }
int PisteInput_Alusta(HWND &main_window_handle, HINSTANCE &hinstance_app) { if (PI_unload) { PI_main_window_handle = (HWND &) main_window_handle; PI_hinstance_app = (HINSTANCE &) hinstance_app; if (FAILED(DirectInputCreate(PI_hinstance_app, DIRECTINPUT_VERSION, &PI_lpdi, NULL))) { PisteLog_Kirjoita("[Error] Piste Input: DirectInputCreate failed! \n"); return PI_VIRHE; } /* Näppäimistön asennus */ if (!PisteInput_Alusta_Keyboard()) return PI_VIRHE; /* Hiiren asennus */ if (!PisteInput_Alusta_Mouse()) PI_mouse_available = false; //return PI_VIRHE; /* Ohjainten asennus */ PisteInput_Alusta_Ohjaimet(); PI_unload = false; } return 0; }
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; }
int PisteDraw_Paletti_Set(void) { if (FAILED(PD_lpddpal->SetEntries(0,0,255,PD_paletti_nyt))) { PisteLog_Kirjoita("[Error] Piste Draw: Palette set failed!\n"); return PD_VIRHE; } return 0; }
int PisteDraw_Paletti_Get(PALETTEENTRY *&paletti) { if (FAILED(PD_lpddpal->GetEntries(0,0,255,PD_paletti_nyt))) { PisteLog_Kirjoita("[Error] Piste Draw: Palette get failed!\n"); return PD_VIRHE; } paletti = (PALETTEENTRY *)PD_paletti_nyt; return 0; }
int PisteDraw_Aseta_Videomode(int leveys, int korkeus, int bpp, int max_colors) { 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; } return 0; }
bool PisteInput_Hae_Hiiri() { if (PI_mouse_available) { if (FAILED(PI_lpdimouse->GetDeviceState(sizeof(DIMOUSESTATE), (LPVOID)&PI_mouse_state))) { PisteLog_Kirjoita("[Warning] Piste Input: Lost control of mouse! \n"); PI_mouse_available = false; } } return PI_mouse_available; }
int PisteDraw_Fade_Paletti_Do(int pros) { UCHAR i; if (FAILED(PD_lpddpal->GetEntries(0,0,255,PD_paletti_nyt))) { PisteLog_Kirjoita("[Error] Piste Draw: Palette get entries failed!\n"); return PD_VIRHE; } for (i=0;i<255;i++) { PD_paletti_nyt[i].peRed = (PD_paletti[i].peRed * pros / 100); PD_paletti_nyt[i].peGreen = (PD_paletti[i].peGreen * pros / 100); PD_paletti_nyt[i].peBlue = (PD_paletti[i].peBlue * pros / 100); } if (FAILED(PD_lpddpal->SetEntries(0,0,255,PD_paletti_nyt))) { PisteLog_Kirjoita("[Error] Piste Draw: Palette set entries failed!\n"); return PD_VIRHE; } return 0; }
/* int PisteDraw_Paletti_Pyorita(UCHAR eka_vari, UCHAR vika_vari) { UCHAR i; if (FAILED(PD_lpddpal->GetEntries(0,0,255,PD_paletti_nyt))) return PD_VIRHE; PALETTEENTRY temp_vari; temp_vari.peRed = PD_paletti_nyt[eka_vari].peRed; temp_vari.peGreen = PD_paletti_nyt[eka_vari].peGreen; temp_vari.peBlue = PD_paletti_nyt[eka_vari].peBlue; for (i=eka_vari;i<vika_vari;i++) { PD_paletti_nyt[i].peRed = PD_paletti_nyt[i+1].peRed; PD_paletti_nyt[i].peGreen = PD_paletti_nyt[i+1].peGreen; PD_paletti_nyt[i].peBlue = PD_paletti_nyt[i+1].peBlue; } PD_paletti_nyt[vika_vari].peRed = temp_vari.peRed; PD_paletti_nyt[vika_vari].peGreen = temp_vari.peGreen; PD_paletti_nyt[vika_vari].peBlue = temp_vari.peBlue; if (FAILED(PD_lpddpal->SetEntries(0,0,255,PD_paletti_nyt))) return PD_VIRHE; return 0; } */ int PisteDraw_Fade_Paletti(void) { if ((PD_paletti_fade_pros < 100 && PD_paletti_fade_laskuri > 0) || (PD_paletti_fade_pros > 0 && PD_paletti_fade_laskuri < 0)) { PD_paletti_fade_pros += PD_paletti_fade_laskuri; if (PisteDraw_Fade_Paletti_Do(PD_paletti_fade_pros)==PD_VIRHE) { PisteLog_Kirjoita("[Error] Piste Draw: Palette fade failed!\n"); return PD_VIRHE; } } return 0; }
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_Piirto_Lopeta(int i) { if (PD_buffers[i].lukittu) { if (FAILED(PD_buffers[i].lpdds->Unlock(NULL))) { PisteLog_Kirjoita("[Error] Piste Draw: Free draw - surface unlock failed!\n"); return PD_VIRHE; } PD_buffers[i].lukittu = false; } return 0; }
int PisteDraw_Font_Uusi(char *polku, char *tiedosto) { int index = 0; bool found = false; PD_Loki_Kirjoita("PisteDraw_Font_Uusi\n"); PD_Loki_Kirjoita(polku); PD_Loki_Kirjoita(tiedosto); PisteLog_Kirjoita("- PisteDraw: Loading a font from file: "); PisteLog_Kirjoita(polku);PisteLog_Kirjoita(tiedosto); PisteLog_Kirjoita("\n"); while (index<MAX_FONTTEJA && !found) { if (PD_fontit[index] == NULL) { PD_Loki_Kirjoita("Tyhja fontti\n"); PD_fontit[index] = new PisteFont(); if (PD_fontit[index]->LataaTiedostosta(polku,tiedosto) == -1){ strcpy(virhe,"PisteEngine can't load a font from file!"); PisteLog_Kirjoita("[Error] Piste Draw: Loading font failed!\n"); PD_Loki_Kirjoita("Lataus epäonnistui\n"); return PD_VIRHE; } PD_Loki_Kirjoita("Lataus onnistui\n"); found = true; if (PD_fontit[index]->Korkeus() > PD_font_korkein) { PD_font_korkein = PD_fontit[index]->Korkeus(); PisteDraw_Buffer_Tuhoa(PD_fontbuffer); PD_fontbuffer = PisteDraw_Buffer_Uusi(PD_ruudun_leveys,PD_font_korkein,true,255); } } else index++; } if (!found) { strcpy(virhe,"PisteEngine has run out of free fonts!"); PisteLog_Kirjoita("[Error] Piste Draw: PisteDraw has run out of free fonts!\n"); index = PD_VIRHE; } PD_Loki_Kirjoita("Kaikki ok.\n"); return index; }
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; }
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; }
bool PisteInput_Hae_Nappaimet() { HRESULT result; bool ok = true; while (result = PI_lpdikey->GetDeviceState(sizeof(PI_keyboard_state), (LPVOID) PI_keyboard_state) == DIERR_INPUTLOST) { if (FAILED(result = PI_lpdikey->Acquire())) { PisteLog_Kirjoita("[Warning] Piste Input: Lost control of keyboard! \n"); ok = false; } } return ok; }
int PisteDraw_Piirto_Lopeta(void) { int i = 0; while (i<MAX_BUFFEREITA /*PD_buffereita_varattu*/) { if (PD_buffers[i].lpdds != NULL) if (PD_buffers[i].lukittu) { if (FAILED(PD_buffers[i].lpdds->Unlock(NULL))) { PisteLog_Kirjoita("[Error] Piste Draw: Free draw - surface unlock failed!\n"); return PD_VIRHE; } PD_buffers[i].lukittu = false; } } return 0; }
int PisteDraw_Font_Uusi(int buffer_index, int buffer_x, int buffer_y, int leveys, int korkeus, int lkm) { int index = 0; bool found = false; while (index<MAX_FONTTEJA && !found) { if (PD_fontit[index] == NULL) { PD_fontit[index] = new PisteFont(korkeus,leveys,lkm); UCHAR *buffer = NULL; DWORD ruudun_leveys; PisteDraw_Piirto_Aloita(buffer_index, *&buffer, (DWORD &) ruudun_leveys); PD_fontit[index]->Get_bitmap(buffer_x,buffer_y,ruudun_leveys,buffer); PisteDraw_Piirto_Lopeta(buffer_index); found = true; if (korkeus > PD_font_korkein) { PD_font_korkein = korkeus; PisteDraw_Buffer_Tuhoa(PD_fontbuffer); PD_fontbuffer = PisteDraw_Buffer_Uusi(PD_ruudun_leveys,korkeus,true,255); } } else index++; } if (!found) { strcpy(virhe,"PisteEngine has run out of free fonts!"); PisteLog_Kirjoita("[Error] Piste Draw: PisteDraw has run out of free fonts!\n"); index = PD_VIRHE; } return index; }
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; }
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_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; }
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_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; }
bool PisteInput_Alusta_Ohjaimet() { //LPDIRECTINPUTDEVICE temp; if (FAILED(PI_lpdi->EnumDevices(DIDEVTYPE_JOYSTICK, PisteInput_Enum_Ohjaimet, /*&PI_joystickGUID*/NULL, DIEDFL_ATTACHEDONLY))) { PisteLog_Kirjoita("[Error] Piste Input: Gamepads - Enumerating failed! \n"); return false; } for (int i=0; i < PI_MAX_PELIOHJAIMIA; i++) { if (PI_joysticks[i].nimi != NULL) { if (PisteInput_Alusta_Ohjain(i)) { PI_joysticks[i].available = true; } else { PI_joysticks[i].available = false; } } else PI_joysticks[i].available = false; } /* if (FAILED(PI_lpdi->CreateDevice(PI_joystickGUID, &temp, NULL))) return false; if (FAILED(temp->QueryInterface(IID_IDirectInputDevice2,(void**) &PI_lpdijoy))) return false; if (FAILED(temp->Release())) return false; if (FAILED(PI_lpdijoy->SetCooperativeLevel(PI_main_window_handle, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE ))) return false; if (FAILED(PI_lpdijoy->SetDataFormat(&c_dfDIJoystick))) return false; DIPROPRANGE joy_axis_range; //Määritellään x-akseli joy_axis_range.lMin = -PI_OHJAIN_XY; joy_axis_range.lMax = PI_OHJAIN_XY; joy_axis_range.diph.dwSize = sizeof(DIPROPRANGE); joy_axis_range.diph.dwHeaderSize = sizeof(DIPROPHEADER); joy_axis_range.diph.dwObj = DIJOFS_X; joy_axis_range.diph.dwHow = DIPH_BYOFFSET; PI_lpdijoy->SetProperty(DIPROP_RANGE, &joy_axis_range.diph); //Määritellään y-akseli joy_axis_range.lMin = -PI_OHJAIN_XY; joy_axis_range.lMax = PI_OHJAIN_XY; joy_axis_range.diph.dwSize = sizeof(DIPROPRANGE); joy_axis_range.diph.dwHeaderSize = sizeof(DIPROPHEADER); joy_axis_range.diph.dwObj = DIJOFS_Y; joy_axis_range.diph.dwHow = DIPH_BYOFFSET; PI_lpdijoy->SetProperty(DIPROP_RANGE, &joy_axis_range.diph); DIPROPDWORD dead_angle; dead_angle.diph.dwSize = sizeof(dead_angle); dead_angle.diph.dwHeaderSize = sizeof(dead_angle.diph); dead_angle.diph.dwObj = DIJOFS_X; dead_angle.diph.dwHow = DIPH_BYOFFSET; dead_angle.dwData = 5000; //= 10% PI_lpdijoy->SetProperty(DIPROP_DEADZONE, &dead_angle.diph); dead_angle.diph.dwSize = sizeof(dead_angle); dead_angle.diph.dwHeaderSize = sizeof(dead_angle.diph); dead_angle.diph.dwObj = DIJOFS_Y; dead_angle.diph.dwHow = DIPH_BYOFFSET; dead_angle.dwData = 5000; //= 10% PI_lpdijoy->SetProperty(DIPROP_DEADZONE, &dead_angle.diph); if (FAILED(PI_lpdijoy->Acquire())) return false; */ return true; }
bool PisteInput_Alusta_Ohjain(int index) { LPDIRECTINPUTDEVICE temp; if (FAILED(PI_lpdi->CreateDevice(PI_joysticks[index].joystickGUID, &temp, NULL))) { PisteLog_Kirjoita("[Error] Piste Input: Gamepad - Create device failed! \n"); return false; } if (FAILED(temp->QueryInterface(IID_IDirectInputDevice2,(void**) &PI_joysticks[index].lpdijoy))) { PisteLog_Kirjoita("[Error] Piste Input: Gamepad - Create device failed! \n"); return false; } if (FAILED(temp->Release())) { PisteLog_Kirjoita("[Error] Piste Input: Gamepad - Releasing DirectInputDevice 1 failed! \n"); return false; } if (FAILED(PI_joysticks[index].lpdijoy->SetCooperativeLevel(PI_main_window_handle, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE ))) { PisteLog_Kirjoita("[Error] Piste Input: Gamepad - Releasing DirectInputDevice 1 failed! \n"); return false; } if (FAILED(PI_joysticks[index].lpdijoy->SetDataFormat(&c_dfDIJoystick))) { PisteLog_Kirjoita("[Error] Piste Input: Gamepad - Set dataformat failed! \n"); return false; } DIPROPRANGE joy_axis_range; //Määritellään x-akseli joy_axis_range.lMin = -PI_OHJAIN_XY; joy_axis_range.lMax = PI_OHJAIN_XY; joy_axis_range.diph.dwSize = sizeof(DIPROPRANGE); joy_axis_range.diph.dwHeaderSize = sizeof(DIPROPHEADER); joy_axis_range.diph.dwObj = DIJOFS_X; joy_axis_range.diph.dwHow = DIPH_BYOFFSET; PI_joysticks[index].lpdijoy->SetProperty(DIPROP_RANGE, &joy_axis_range.diph); //Määritellään y-akseli joy_axis_range.lMin = -PI_OHJAIN_XY; joy_axis_range.lMax = PI_OHJAIN_XY; joy_axis_range.diph.dwSize = sizeof(DIPROPRANGE); joy_axis_range.diph.dwHeaderSize = sizeof(DIPROPHEADER); joy_axis_range.diph.dwObj = DIJOFS_Y; joy_axis_range.diph.dwHow = DIPH_BYOFFSET; PI_joysticks[index].lpdijoy->SetProperty(DIPROP_RANGE, &joy_axis_range.diph); DIPROPDWORD dead_angle; dead_angle.diph.dwSize = sizeof(dead_angle); dead_angle.diph.dwHeaderSize = sizeof(dead_angle.diph); dead_angle.diph.dwObj = DIJOFS_X; dead_angle.diph.dwHow = DIPH_BYOFFSET; dead_angle.dwData = 5000; //= 10% PI_joysticks[index].lpdijoy->SetProperty(DIPROP_DEADZONE, &dead_angle.diph); dead_angle.diph.dwSize = sizeof(dead_angle); dead_angle.diph.dwHeaderSize = sizeof(dead_angle.diph); dead_angle.diph.dwObj = DIJOFS_Y; dead_angle.diph.dwHow = DIPH_BYOFFSET; dead_angle.dwData = 5000; //= 10% PI_joysticks[index].lpdijoy->SetProperty(DIPROP_DEADZONE, &dead_angle.diph); if (FAILED(PI_joysticks[index].lpdijoy->Acquire())) { PisteLog_Kirjoita("[Error] Piste Input: Gamepad - Acquiring device failed! \n"); return false; } return true; }
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; }