See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  VoxEd Source Code
  Submitted by



Hey guys this is the source of my Voxel Engine. It doesn't include the data files, so you may not compile a working program with it, but you can look at it and send me feedback.

Currently browsing [VoxEd.zip] (61,511 bytes) - [RESOURCE.H] - (1,267 bytes)

//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by LandEd.rc
//
#define IDI_ICON                        101
#define IDI_CURSOR                      102
#define IDI_CROSS                       103
#define IDI_FINGER                      108
#define IDI_STOP                        108
#define IDI_PINPET                      109
#define IDR_ACCELERATOR1                110
#define IDI_UP                          113
#define IDI_DOWN                        114
#define IDI_RIGHT                       115
#define IDI_LEFT                        116
#define IDI_UPLEFT                      118
#define IDI_UPRIGHT                     119
#define IDI_DOWNRIGHT                   120
#define IDI_DOWNLEFT                    121
#define IDI_CLOCK                       122
#define IDI_LEFTRIGHT                   123
#define IDI_UPDOWN                      124
#define ID_ACCEL40001                   40001

// Next default values for new objects // #ifdef APSTUDIO_INVOKED #ifndef APSTUDIO_READONLY_SYMBOLS #define _APS_NEXT_RESOURCE_VALUE 128 #define _APS_NEXT_COMMAND_VALUE 40002 #define _APS_NEXT_CONTROL_VALUE 1001 #define _APS_NEXT_SYMED_VALUE 101 #endif #endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CCheckBox.cpp] - (1,493 bytes)

// CCheckBox.cpp
// by Comanche

#include "CCheckBox.h"
#include "CMain.h"
#include "CGraphics.h"

extern CMain GameMain; extern CGraphics Graphics;

////////////////////////////////////////////////////////////////////////////////// CCheckBox::CCheckBox(int x,int y,char *string) { Cx=x; Cy=y; redraw=TRUE; sprintf(caption,"%s",string); State=FALSE; }

////////////////////////////////////////////////////////////////////////////////// BOOL CCheckBox::RedrawCheckBox() { redraw=TRUE; return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CCheckBox::TestIfPressed() { Graphics.logfont.lfHeight = CHECKBOXFONTHEIGHT;

if(GameMain.CheckMouseRange(Cx,Cy,Cx+11,Cy+11,TRUE)) { if(State) { State=FALSE; Graphics.Lock(); Graphics.DrawCheckBoxOff(Cx,Cy); Graphics.UnLock(); } else { State=TRUE; Graphics.Lock(); Graphics.DrawCheckBoxOn(Cx,Cy); Graphics.UnLock(); } while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); }

if(redraw) { redraw=FALSE; Graphics.Lock(); if(State) Graphics.DrawCheckBoxOn(Cx,Cy); else Graphics.DrawCheckBoxOff(Cx,Cy); Graphics.UnLock(); Graphics.OSGetLaDC(); Graphics.Text(Cx+16,Cy-2,caption); Graphics.OSReleaseDC(); }

Graphics.logfont.lfHeight = STANDARTFONTHEIGHT;

return(TRUE); }

//////////////////////////////////////////////////////////////////////////////////

Currently browsing [VoxEd.zip] (61,511 bytes) - [CColor.cpp] - (1,993 bytes)

// CColor.cpp
// by Comanche

#include "CColor.h"
#include "CMain.h"
#include "CLog.h"
#include "CGraphics.h"

extern CMain GameMain; extern CLog Log; extern CGraphics Graphics;

////////////////////////////////////////////////////////////////////////////////// CColor::CColor() { redpos=100; greenpos=100; bluepos=100; }

////////////////////////////////////////////////////////////////////////////////// void CColor::DrawColors() { Graphics.Lock(); Graphics.Quader(2,72,32,143,100,100,100); Graphics.Quader(35,72,65,143,100,100,100); Graphics.Quader(68,72,98,143,100,100,100); for(int i=0;i<=6;i++) { Graphics.FullQuader(3,72+(i*10),31,82+(i*10),redpos+i,0,0); Graphics.FullQuader(36,72+(i*10),64,82+(i*10),0,greenpos+i,0); Graphics.FullQuader(69,72+(i*10),97,82+(i*10),0,0,bluepos+i); } Graphics.Quader(3,168,97,208,0,0,0); Graphics.FullQuader(4,169,96,207,color.rgbtRed,color.rgbtGreen,color.rgbtBlue); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// void CColor::TestIfPressed() { Graphics.Lock();

if(GameMain.MouseX>=3 && GameMain.MouseX<=32 && GameMain.MouseY>=72 && GameMain.MouseY<=142 && GameMain.MouseB[0]) { int y=GameMain.MouseY-72; color.rgbtRed=redpos+(y/10); Graphics.FullQuader(4,169,96,207,color.rgbtRed,color.rgbtGreen,color.rgbtBlue); }

if(GameMain.MouseX>=36 && GameMain.MouseX<=64 && GameMain.MouseY>=72 && GameMain.MouseY<=142 && GameMain.MouseB[0]) { int y=GameMain.MouseY-72; color.rgbtGreen=greenpos+(y/10); Graphics.FullQuader(4,169,96,207,color.rgbtRed,color.rgbtGreen,color.rgbtBlue); }

if(GameMain.MouseX>=69 && GameMain.MouseX<=97 && GameMain.MouseY>=72 && GameMain.MouseY<=142 && GameMain.MouseB[0]) { int y=GameMain.MouseY-72; color.rgbtBlue=bluepos+(y/10); Graphics.FullQuader(4,169,96,207,color.rgbtRed,color.rgbtGreen,color.rgbtBlue); }

Graphics.UnLock(); }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CGraphics.cpp] - (17,959 bytes)

// CGraphics.cpp
// by Comanche

#include "CGraphics.h"
#include "CMain.h"
#include "CLog.h"
#include "CTime.h"
#include "CLandScape.h"
#include "CVoxel.h"
#include "CCheckBox.h"
#include "CLiquid.h"

extern CMain GameMain; extern CLog Log; extern CTime Time; extern CLandScape Land; extern CVoxel Voxel; extern CCheckBox *CheckBoxes[20]; extern CLiquid *Liquids[128];

////////////////////////////////////////////////////////////////////////////////// void CGraphics::Lock() { GameMain.lpddsos1->Lock(NULL,&GameMain.ddsd,DDLOCK_WAIT,NULL); video_buffer = (BYTE*)GameMain.ddsd.lpSurface; WordsPerLine = (GameMain.ddsd.lPitch); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::UnLock() { GameMain.lpddsos1->Unlock(NULL); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::LockBackBuffer() { GameMain.lpddsback->Lock(NULL,&GameMain.ddsd,DDLOCK_WAIT,NULL); video_buffer = (BYTE*)GameMain.ddsd.lpSurface; WordsPerLine = (GameMain.ddsd.lPitch); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::UnLockBackBuffer() { GameMain.lpddsback->Unlock(NULL); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::Flip() { GetDC(); if(!CheckBoxes[1]->State) sprintf(buffer,"%d FPS",Time.GetFPS(Time.GetFrameTime())); else sprintf(buffer,"%d VPF",Land.vps); Text(50,237,buffer); if(GameMain.Editor==0) { if(!CheckBoxes[2]->State) sprintf(buffer,"%d,%d",Land.ScreenPosX,Land.ScreenPosY); else { if(GameMain.ActiveLiquid<0) { sprintf(buffer,"%d",GameMain.ActiveLiquid); } else { sprintf(buffer,"%d,%d",GameMain.ActiveLiquid, Liquids[GameMain.ActiveLiquid]->height); } } Text(50,217,buffer); } if(GameMain.Editor==1) { sprintf(buffer,"%d,%d",Voxel.ViewX,Voxel.ViewY); Text(50,217,buffer); } ReleaseDC();

GameMain.lpddsprimary->Flip(GameMain.lpddsback, DDFLIP_WAIT); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::BltToBackBuffer() { GameMain.lpddsback->BltFast(0,0,GameMain.lpddsos1,NULL,DDBLTFAST_WAIT|DDBLTFAST_NOCOLORKEY); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::GetDC() { GameMain.lpddsback->GetDC(&xdc); Arial=CreateFontIndirect(&logfont); if(DrawFont) SelectObject(xdc,Arial); SetTextColor(xdc,RGB(textcolor.rgbtGreen,textcolor.rgbtGreen,textcolor.rgbtBlue)); SetBkMode(xdc, TRANSPARENT); SetTextAlign(xdc,TA_CENTER); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::GetLaDC() { GameMain.lpddsback->GetDC(&xdc); Arial=CreateFontIndirect(&logfont); if(DrawFont) SelectObject(xdc,Arial); SetTextColor(xdc,RGB(textcolor.rgbtGreen,textcolor.rgbtGreen,textcolor.rgbtBlue)); SetBkMode(xdc, TRANSPARENT); SetTextAlign(xdc,TA_LEFT); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::ReleaseDC() { GameMain.lpddsback->ReleaseDC(xdc); DeleteObject(Arial); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::OSGetDC() { GameMain.lpddsos1->GetDC(&xdc); Arial=CreateFontIndirect(&logfont); if(DrawFont) SelectObject(xdc,Arial); SetTextColor(xdc,RGB(textcolor.rgbtGreen,textcolor.rgbtGreen,textcolor.rgbtBlue)); SetBkMode(xdc, TRANSPARENT); SetTextAlign(xdc,TA_CENTER); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::OSGetLaDC() { GameMain.lpddsos1->GetDC(&xdc); Arial=CreateFontIndirect(&logfont); if(DrawFont) SelectObject(xdc,Arial); SetTextColor(xdc,RGB(textcolor.rgbtGreen,textcolor.rgbtGreen,textcolor.rgbtBlue)); SetBkMode(xdc, TRANSPARENT); SetTextAlign(xdc,TA_LEFT); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::OSReleaseDC() { GameMain.lpddsos1->ReleaseDC(xdc); DeleteObject(Arial); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::RestorePrimarySurface() { if (GameMain.lpddsos1->IsLost()!=DD_OK) GameMain.lpddsos1->Restore(); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::RestoreOffScreenSurface() { if (GameMain.lpddsprimary->IsLost()!=DD_OK) GameMain.lpddsprimary->Restore(); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::Blt(int x,int y,int x2,int y2,int vx, int vy) { RECT source;

source.left=x; source.right=x2; source.top=y; source.bottom=y2;

GameMain.lpddsos1->BltFast(x+vx,y+vy,GameMain.lpddsos1,&source,NULL); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::Text(int x,int y,char *string) { int len=strlen(string); TextOut(xdc,x,y,string,len); }

////////////////////////////////////////////////////////////////////////////////// __declspec(naked) void CGraphics::PutPixel(int x,int y,BYTE red,BYTE green,BYTE blue) { __asm { push ebp mov ebp,esp push eax push ebx mov eax,y mov ebx,x mul WordsPerLine lea eax,[eax+ebx*4] add eax,video_buffer mov bl,blue mov BYTE PTR [eax],bl inc eax mov bl,green mov BYTE PTR [eax],bl inc eax mov bl,red mov BYTE PTR [eax],bl pop ebx pop eax mov esp,ebp pop ebp ret 14h } }

////////////////////////////////////////////////////////////////////////////////// __declspec(naked) void CGraphics::PutSafePixel(int x,int y,BYTE red,BYTE green,BYTE blue) { __asm { push ebp mov ebp,esp push eax push ebx mov ebx,x mov eax,y cmp eax,0 jl end cmp eax,479 jg end cmp ebx,101 jl end cmp ebx,559 jg end mul WordsPerLine lea eax,[eax+ebx*4] add eax,video_buffer mov bl,blue mov BYTE PTR [eax],bl inc eax mov bl,green mov BYTE PTR [eax],bl inc eax mov bl,red mov BYTE PTR [eax],bl end: pop ebx pop eax mov esp,ebp pop ebp ret 14h } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::Quader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue) { int i; for (i=x;i<=x2;i++) { PutPixel(i,y,red,green,blue); PutPixel(i,y2,red,green,blue); } for (i=y;i<=y2;i++) { PutPixel(x,i,red,green,blue); PutPixel(x2,i,red,green,blue); } }

//////////////////////////////////////////////////////////////////////////////////

void CGraphics::FullQuader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue) { __asm { push eax push ebx push ecx push edx mov eax,x mov ebx,x2 cmp eax,ebx jg end mov eax,y mov ebx,y2 cmp eax,ebx jg end mov eax,y mov ebx,x mul WordsPerLine lea eax,[eax+ebx*4] add eax,video_buffer mov edx,x2 sub edx,x mov ecx,y2 sub ecx,y jmp1: push ecx push eax mov ecx,edx jmp2: mov bl,blue mov BYTE PTR [eax],bl inc eax mov bl,green mov BYTE PTR [eax],bl inc eax mov bl,red mov BYTE PTR [eax],bl add eax,2 loop jmp2 pop eax pop ecx add eax,WordsPerLine loop jmp1 end: pop eax pop ebx pop edx pop ecx } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::BlackQuader(int x,int y,int x2,int y2) { DDBLTFX ddbltfx; RECT rect;

ddbltfx.dwSize = sizeof(ddbltfx); ddbltfx.dwFillColor = 0;

rect.left=x; rect.right=x2; rect.top=y; rect.bottom=y2;

GameMain.lpddsos1->Blt(&rect,NULL,NULL,DDBLT_COLORFILL,&ddbltfx); }

////////////////////////////////////////////////////////////////////////////////// __declspec(naked) void CGraphics::PutTransPixel(int x,int y,BYTE red,BYTE green,BYTE blue) { __asm { push ebp mov ebp,esp push eax push ebx push ecx mov ebx,x mov eax,y mul WordsPerLine lea eax,[eax+ebx*4] add eax,video_buffer movzx ebx,BYTE PTR [eax] movzx ecx,blue add ebx,ecx shr ebx,1 mov BYTE PTR [eax],bl inc eax movzx ebx,BYTE PTR [eax] movzx ecx,green add ebx,ecx shr ebx,1 mov BYTE PTR [eax],bl inc eax movzx ebx,BYTE PTR [eax] movzx ecx,red add ebx,ecx shr ebx,1 mov BYTE PTR [eax],bl pop ecx pop ebx pop eax mov esp,ebp pop ebp ret 14h } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::FullTransQuader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue) { BYTE color[8]; __asm { push eax push ebx push ecx push edx mov eax,x mov ebx,x2 cmp eax,ebx jg end mov eax,y mov ebx,y2 cmp eax,ebx jg end mov al,blue mov bl,green mov cl,red mov BYTE PTR [color],al mov BYTE PTR [color+1],bl mov BYTE PTR [color+2],cl mov BYTE PTR [color+3],0 mov BYTE PTR [color+4],al mov BYTE PTR [color+5],bl mov BYTE PTR [color+6],cl mov BYTE PTR [color+7],0 pxor mm4,mm4 mov eax,y mov ebx,x mul WordsPerLine lea eax,[eax+ebx*4] add eax,video_buffer mov edx,x2 sub edx,x mov ecx,y2 sub ecx,y movq mm5,color jmp1: push ecx push eax mov ecx,edx jmp2: dec ecx jz jmp3 movq mm0,BYTE PTR [eax] movq mm1,mm0 movq mm2,mm5 movq mm3,mm5 punpckhbw mm0,mm4 punpcklbw mm1,mm4 punpckhbw mm2,mm4 punpcklbw mm3,mm4 paddw mm0,mm2 paddw mm1,mm3 psrlw mm0,1 psrlw mm1,1 packuswb mm1,mm0 movq BYTE PTR [eax],mm1 add eax,8 loop jmp2 pop eax pop ecx add eax,WordsPerLine loop jmp1 jmp end jmp3: movd mm0,BYTE PTR [eax] movd mm1,BYTE PTR [eax] movd mm2,color movd mm3,color punpckhbw mm0,mm4 punpcklbw mm1,mm4 punpckhbw mm2,mm4 punpcklbw mm3,mm4 paddw mm0,mm2 paddw mm1,mm3 psrlw mm0,1 psrlw mm1,1 packuswb mm1,mm0 movd BYTE PTR [eax],mm1 pop eax pop ecx add eax,WordsPerLine loop jmp1 end: pop eax pop ebx pop edx pop ecx emms } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::FullBrightQuader(int x,int y,int x2,int y2,BYTE red,BYTE green,BYTE blue) { BYTE color[8]; __asm { push eax push ebx push ecx push edx mov eax,x mov ebx,x2 cmp eax,ebx jg end mov eax,y mov ebx,y2 cmp eax,ebx jg end mov al,blue mov bl,green mov cl,red mov BYTE PTR [color],al mov BYTE PTR [color+1],bl mov BYTE PTR [color+2],cl mov BYTE PTR [color+3],0 mov BYTE PTR [color+4],al mov BYTE PTR [color+5],bl mov BYTE PTR [color+6],cl mov BYTE PTR [color+7],0 mov eax,y mov ebx,x mul WordsPerLine lea eax,[eax+ebx*4] add eax,video_buffer mov edx,x2 sub edx,x mov ecx,y2 sub ecx,y movq mm2,color jmp1: push ecx push eax mov ecx,edx jmp2: dec ecx jz jmp3 movq mm0,BYTE PTR [eax] movq mm1,mm2 paddusb mm0,mm1 movq BYTE PTR [eax],mm0 add eax,8 loop jmp2 pop eax pop ecx add eax,WordsPerLine loop jmp1 jmp end jmp3: movd mm0,BYTE PTR [eax] movd mm1,mm2 paddusb mm0,mm1 movq BYTE PTR [eax],mm0 pop eax pop ecx add eax,WordsPerLine loop jmp1 end: pop eax pop ebx pop edx pop ecx emms } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::Line(int x,int y,int x2,int y2,BYTE red,BYTE green,BYTE blue) { int lenx,leny; if(x>x2) lenx=x-x2; else lenx=x2-x; if(y>y2) leny=y-y2; else leny=y2-y; if (lenx>leny) { float c=(float)(lenx)/(float)(leny); int i=0; while(y<=y2) { i++;y++; for(int i2=0;i2<=((i+1)*c)-(i*c);i2++) PutPixel((x+(float)(i*c))+i2,y,red,green,blue); } return; } else { float c=(float)(leny)/(float)(lenx); int i=0; while(x<=x2) { i++;x++; for(int i2=0;i2<=c;i2++) PutPixel(x,(y+(float)(i*c))-i2,red,green,blue); } } }

////////////////////////////////////////////////////////////////////////////////// /*void CGraphics::Line(int x,int y,int x2,int y2,BYTE red,BYTE green,BYTE blue) { if(x2>x) int len=x2-x; if(x2==x) int len=0; if(x2<x) int len=x-x2;

if(y2>y) int len2=y2-y; if(y2==y) int len2=0; if(y2<y) int len2=y-y2;

if(len==len2) return();

if(len>len2) { if(y>y2) c=y2; if(y<y2) c=y;

for(int i=1; i<=len; i++) { float b=len2/i; PutPixel(i,b,red,green,blue); } }

}*/


////////////////////////////////////////////////////////////////////////////////// void CGraphics::HLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue) { __asm { push eax push ebx push ecx mov ebx,x mov eax,y shl ebx,2 mul WordsPerLine add eax,ebx add eax,video_buffer mov ecx,p inc ecx jmp1: mov bl,blue mov BYTE PTR [eax],bl inc eax mov bl,green mov BYTE PTR [eax],bl inc eax mov bl,red mov BYTE PTR [eax],bl sub eax,2 add eax,WordsPerLine loop jmp1 pop ecx pop ebx pop eax } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::VLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue) { __asm { push eax push ebx push ecx mov ebx,x mov eax,y shl ebx,2 mul WordsPerLine add eax,ebx add eax,video_buffer mov ecx,p jmp1: mov bl,blue mov BYTE PTR [eax],bl inc eax mov bl,green mov BYTE PTR [eax],bl inc eax mov bl,red mov BYTE PTR [eax],bl add eax,2 loop jmp1 pop ecx pop ebx pop eax } }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::TransHLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue) { for(int i=0;i<=p;i++) PutTransPixel(x,y+i,red,green,blue); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::TransVLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue) { for(int i=0;i<=p;i++) PutTransPixel(x+i,y,red,green,blue); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::DrawButton(int x,int y,int x2,int y2) { FullQuader(x,y,x2,y2,150,150,150); VLine(x,y,x2-x,200,200,200); VLine(x+1,y+1,x2-x-2,170,170,170); HLine(x,y,y2-y-1,200,200,200); HLine(x+1,y+1,y2-y-3,170,170,170); VLine(x,y2,x2-x,10,10,10); VLine(x+1,y2-1,x2-x-2,80,80,80); HLine(x2,y,y2-y,10,10,10); HLine(x2-1,y+1,y2-y-2,80,80,80); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::DrawPushedButton(int x,int y,int x2,int y2) { FullQuader(x+1,y+1,x2-1,y2-1,150,150,150); VLine(x,y,x2-x,10,10,10); VLine(x+1,y+1,x2-x-1,80,80,80); HLine(x,y,y2-y,10,10,10); HLine(x+1,y+1,y2-y-2,80,80,80); VLine(x,y2,x2-x,200,200,200); VLine(x+1,y2-1,x2-x-2,170,170,170); HLine(x2,y,y2-y,200,200,200); HLine(x2-1,y+1,y2-y-2,190,170,170); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::DrawCheckBoxOff(int x,int y) { FullQuader(x+1,y+1,x+10,y+10,220,220,220); VLine(x,y,11,10,10,10); VLine(x+1,y+1,10,80,80,80); HLine(x,y,11,10,10,10); HLine(x+1,y+1,9,80,80,80); VLine(x,y+11,11,200,200,200); VLine(x+1,y+10,9,170,170,170); HLine(x+11,y,11,200,200,200); HLine(x+10,y+1,9,190,170,170); }

////////////////////////////////////////////////////////////////////////////////// void CGraphics::DrawCheckBoxOn(int x,int y) { FullQuader(x+1,y+1,x+10,y+10,220,220,220); VLine(x,y,11,10,10,10); VLine(x+1,y+1,10,80,80,80); HLine(x,y,11,10,10,10); HLine(x+1,y+1,9,80,80,80); VLine(x,y+11,11,200,200,200); VLine(x+1,y+10,9,170,170,170); HLine(x+11,y,11,200,200,200); HLine(x+10,y+1,9,190,170,170); for(int i=0;i<5;i++) { PutPixel(x+3+i,y+4+i,75,75,75); PutPixel(x+4+i,y+3+i,75,75,75); PutPixel(x+8-i,y+4+i,75,75,75); PutPixel(x+7-i,y+3+i,75,75,75); } PutPixel(x+3,y+3,75,75,75); PutPixel(x+3,y+8,75,75,75); PutPixel(x+8,y+3,75,75,75); PutPixel(x+8,y+8,75,75,75); for(i=0;i<4;i++) { PutPixel(x+4+i,y+4+i,0,0,0); PutPixel(x+7-i,y+4+i,0,0,0); } }

////////////////////////////////////////////////////////////////////////////////// BOOL CGraphics::StoreScreenArea(int x,int y,int x2,int y2) { x2++;y2++; Sx=x;Sy=y;Sx2=x2;Sy2=y2;

memset(&GameMain.ddsd,0,sizeof(GameMain.ddsd)); GameMain.ddsd.dwSize = sizeof(GameMain.ddsd); GameMain.ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; GameMain.ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; GameMain.ddsd.dwWidth = x2-x; GameMain.ddsd.dwHeight = y2-y;

if(GameMain.lpdd2->CreateSurface(&GameMain.ddsd,&lpddsos2,NULL)!=DD_OK) { Log.WriteErrorToLogFile("> Error: Store Screen Area"); return(FALSE); }

RECT source;

source.left=x; source.right=x2; source.top=y; source.bottom=y2;

if(lpddsos2->BltFast(0,0,GameMain.lpddsos1,&source,NULL)!=DD_OK) { lpddsos2->Release(); Log.WriteErrorToLogFile("> Error: Store Screen Area"); return(FALSE); }

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CGraphics::RestoreScreenArea() { if(GameMain.lpddsos1->BltFast(Sx,Sy,lpddsos2,NULL,NULL)!=DD_OK) { Log.WriteErrorToLogFile("> Error: Restore Screen Area"); lpddsos2->Release(); return(FALSE); }

if(lpddsos2!=NULL) { lpddsos2->Release(); lpddsos2=NULL; }

return(TRUE); }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CLandScape.cpp] - (41,281 bytes)

// CLandScape.cpp
// by Comanche

#include "CLandScape.h"
#include "CMain.h"
#include "CGraphics.h"
#include "CLog.h"
#include "CTexture.h"
#include "CMenu.h"
#include "CCheckBox.h"

extern CLandScape Land; extern CMain GameMain; extern CGraphics Graphics; extern CLog Log; extern CTexture *Masks[3]; extern CTexture *Textures[1024]; extern CCheckBox *CheckBoxes[20]; extern CMenu Menu;

////////////////////////////////////////////////////////////////////////////////// CLandScape::CLandScape() { ScreenPosX=0; ScreenPosY=0; }

////////////////////////////////////////////////////////////////////////////////// BOOL CLandScape::InitScreen() { FillScreen(101,0,559,479); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// void CLandScape::PutVoxel(int x,int y,int x2,int y2) { int red,green,blue; float multi; //////////////////////////////////////////////////////////// // Algorithmus // //////////////////////////////////////////////////////////// // // // for(int i=64;i>=0;i--) // // { // // pointer=(BYTE*)&Landscape[x][y+i]; // // if((y+i)>1999) continue; // // height=*(pointer+3); // // if(height>=i) // // { // // float shadow=GetShadow(x,y+i,i); // // blue=(*pointer)*shadow; // // if(blue>255) blue=255; // // green=(*(++pointer))*shadow; // // if(green>255) green=255; // // red=(*(++pointer))*shadow; // // if(red>255) red=255; // // Graphics.PutPixel(x2,y2,red,green,blue); // // break; // // } // // } // // // //////////////////////////////////////////////////////////// __asm { mov eax,x // Adresse berechnen imul eax,8000 // 2000*4 Bytes pro Zeile mov ebx,y lea eax,[eax+ebx*4+Land.Landscape+3] // 3 Bytes dazu weil Höhe Byte 4 im DWORD ist mov ecx,64 // Counter auf 64 (max-Höhe = 64) jmp1: mov dl,BYTE PTR [eax+ecx*4] // Höhe laden cmp dl,cl // und mit Counter vergleichen jae jmp2 // wenn gleich oder höher jmp2 loop jmp1 // loop (ecx-1) jmp2: lea eax,[eax+ecx*4-3] // auf Farben gehen (minus 3 Bytes) xor ebx,ebx // Farben 32-Bit breit speichern wegen FILD mov bl,BYTE PTR [eax] // Blau mov blue,ebx inc eax // Grün mov bl,BYTE PTR [eax] mov green,ebx inc eax // Rot mov bl,BYTE PTR [eax] mov red,ebx // auf Höhe gehen cmp x,1998 ja equal add eax,7997 // +1, -1 (+8000-4+1) mov bl,BYTE PTR [eax] // dl old, bl new cmp cl,bl ja above // höher jb below // niedriger equal: jmp jmp4 // gleich, nicht zu tun ! above: inc bl cmp cl,bl // testen ob nur 1 höher jne above1 mov multi,03F4CCCCDh // ja x0.8 jmp jmp3 above1: inc bl // testen ob nur 2 höher cmp cl,bl jne above2 mov multi,03F19999Ah // ja x0.6 jmp jmp3 above2: inc bl // testen ob nur 3 höher cmp cl,bl jne above3 mov multi,03ECCCCCDh // ja x0.4 jmp jmp3 above3: mov multi,03E4CCCCDh // x0.2 jmp jmp3

below: dec bl // testen ob nur 1 niedriger cmp cl,bl jne below1 mov multi,03F99999Ah // ja x1.2 jmp jmp3 below1: dec bl // testen ob nur 2 niedriger cmp cl,bl jne below2 mov multi,03FB33333h // ja x1.4 jmp jmp3 below2: dec bl // testen ob nur 3 niedriger cmp cl,bl jne below3 mov multi,03FCCCCCDh // ja x1.6 jmp jmp3 below3: mov multi,03FE66666h // x1.8 jmp3: fld multi fild red fmul st,st(1) fistp red fild green fmul st,st(1) fistp green fild blue fmul st,st(1) fistp blue ffree st mov eax,red cmp eax,0FFh jbe okr mov red,0FFh okr: mov eax,green cmp eax,0FFh jbe okg mov green,0FFh okg: mov eax,blue cmp eax,0FFh jbe jmp4 mov blue,0FFh jmp4: mov eax,y2 // Grafikspeicher Koordinaten rechnen mov ebx,x2 mul WordsPerLine lea eax,[eax+ebx*4] // 32-Bit Farbtiefe add eax,video_buffer

mov ebx,blue // Und Pixel speichern mov BYTE PTR [eax],bl inc eax mov ebx,green mov BYTE PTR [eax],bl inc eax mov ebx,red mov BYTE PTR [eax],bl

end: inc Land.vps } }

////////////////////////////////////////////////////////////////////////////////// void CLandScape::FillScreen(int x,int y,int x2,int y2) { /* __asm { mov edx,x2 sub edx,x loop1: mov ecx,y2 sub ecx,y loop2: push edx push ecx add edx,Land.ScreenPosX sub edx,100 push edx add ecx,Land.ScreenPosY push ecx call Land.PutVoxel loop loop2 dec edx jnz loop1 }*/ for(int i=x;i<=x2;i++) { for(int i2=y;i2<=y2;i2++) { int posx=ScreenPosX+i-100; int posy=ScreenPosY+i2; PutVoxel(posx,posy,i,i2); } } }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::PutBrightVoxel(int x,int y,int x2,int y2) { int red,green,blue; float multi;

__asm { mov eax,x // Adresse berechnen imul eax,8000 // 2000*4 Bytes pro Zeile mov ebx,y lea eax,[eax+ebx*4+Land.Landscape+3] // 3 Bytes dazu weil Höhe Byte 4 im DWORD ist mov ecx,64 // Counter auf 64 (max-Höhe = 64) jmp1: mov dl,BYTE PTR [eax+ecx*4] // Höhe laden cmp dl,cl // und mit Counter vergleichen jae jmp2 // wenn gleich oder höher jmp2 loop jmp1 // loop (ecx-1) jmp2: lea eax,[eax+ecx*4-3] // auf Farben gehen (minus 3 Bytes) xor ebx,ebx // Farben 32-Bit breit speichern wegen FILD mov bl,BYTE PTR [eax] // Blau mov blue,ebx mov bl,BYTE PTR [eax+1] // Grün mov green,ebx mov bl,BYTE PTR [eax+2] // Rot mov red,ebx // auf Höhe gehen mov bl,BYTE PTR [eax+7999] // dl old, bl new; +1, -1 (+8000-4+1) cmp cl,bl ja above // höher jb below // niedriger equal: jmp jmp4 // gleich, nicht zu tun ! above: inc bl cmp cl,bl // testen ob nur 1 höher jne above1 mov multi,03F4CCCCDh // ja x0.8 jmp jmp3 above1: inc bl // testen ob nur 2 höher cmp cl,bl jne above2 mov multi,03F19999Ah // ja x0.6 jmp jmp3 above2: inc bl // testen ob nur 3 höher cmp cl,bl jne above3 mov multi,03ECCCCCDh // ja x0.4 jmp jmp3 above3: mov multi,03E4CCCCDh // x0.2 jmp jmp3

below: dec bl // testen ob nur 1 niedriger cmp cl,bl jne below1 mov multi,03F99999Ah // ja x1.2 jmp jmp3 below1: dec bl // testen ob nur 2 niedriger cmp cl,bl jne below2 mov multi,03FB33333h // ja x1.4 jmp jmp3 below2: dec bl // testen ob nur 3 niedriger cmp cl,bl jne below3 mov multi,03FCCCCCDh // ja x1.6 jmp jmp3 below3: mov multi,03FE66666h // x1.8 jmp3: fld multi fild red fmul st,st(1) fistp red fild green fmul st,st(1) fistp green fild blue fmul st,st(1) fistp blue ffree st

jmp4: mov eax,red cmp eax,0D7h // rot +20 (<=255!) jbe rjmp mov eax,0FFh jmp rjmp2 rjmp: add eax,028h rjmp2: mov red,eax mov ebx,green cmp ebx,0D7h // grün +20 (<=255!) jbe gjmp mov ebx,0FFh jmp gjmp2 gjmp: add ebx,028h gjmp2: mov green,ebx

mov ecx,blue cmp ecx,0D7h // blau +20 (<=255!) jbe bjmp mov ecx,0FFh jmp bjmp2 bjmp: add ecx,028h bjmp2: mov blue,ecx

mov eax,y2 // Grafikspeicher Koordinaten rechnen mov ebx,x2 mul WordsPerLine lea eax,[eax+ebx*4] // 32-Bit Farbtiefe add eax,video_buffer

mov ebx,blue // Und Pixel speichern mov BYTE PTR [eax],bl inc eax mov ebx,green mov BYTE PTR [eax],bl inc eax mov ebx,red mov BYTE PTR [eax],bl

end: inc Land.vps } }

////////////////////////////////////////////////////////////////////////////////// // RIP // ////////////////////////////////////////////////////////////////////////////////// // inline float CLandScape::GetShadow(int x,int y,int height) // // { // // if((x+1)>1999) return(1.0); // // if((y-1)<0) return(1.0); // // // // BYTE *pointer; // // // // pointer=(BYTE*)&Landscape[++x][--y]; // // pointer+=3; // // // // if(*pointer+1==height) return(0.8); // // if(*pointer+2==height) return(0.6); // // if(*pointer+3==height) return(0.4); // // if(*pointer<height) return(0.2); // // if(*pointer-1==height) return(1.2); // // if(*pointer-2==height) return(1.4); // // if(*pointer-3==height) return(1.6); // // if(*pointer>height) return(1.8); // // return(1.0); // // } // ////////////////////////////////////////////////////////////////////////////////// void CLandScape::DrawBrush() { RGBTRIPLE color; BYTE height; BYTE *pointer;

if(GameMain.Status2==7) return;

if(GameMain.MouseX>100 && GameMain.MouseX<560) { if(GameMain.Status==0) { Graphics.LockBackBuffer(); for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; height=*pointer; if(posy2-height<0) continue; if(posy2-height>639) continue;

color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) PutBrightVoxel(posx,posy-height,posx2,posy2-height); } Graphics.UnLockBackBuffer(); }

if(GameMain.Status==1) { Graphics.LockBackBuffer(); for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; height=*pointer; if(posy2-height<0) continue; if(posy2-height>639) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) PutBrightVoxel(posx,posy-height,posx2,posy2-height); } Graphics.UnLockBackBuffer(); }

if(GameMain.Status==2) { Graphics.LockBackBuffer(); for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; height=*pointer; if(posy2-height<0) continue; if(posy2-height>639) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) PutBrightVoxel(posx,posy-height,posx2,posy2-height); } Graphics.UnLockBackBuffer(); } } }

////////////////////////////////////////////////////////////////////////////////// void CLandScape::UseBrush() { if(GameMain.Status2==0) Higher(); if(GameMain.Status2==1) Lower(); if(GameMain.Status2==2) Brush(); if(GameMain.Status2==3) Smoth(); if(GameMain.Status2==4) Level(); if(GameMain.Status2==5) Spray(); if(GameMain.Status2==6) Transparent(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Higher() { RGBTRIPLE color; BYTE *pointer; BYTE oldheight;

if(GameMain.Status==0) { for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; *pointer+=1; if(*pointer>64) *pointer=64; } }

Graphics.Lock(); for(i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; PutVoxel(posx,posy-*pointer,posx2,posy2-*pointer); } } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; *pointer+=1; if(*pointer>64) *pointer=64; } }

Graphics.Lock(); for(i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; PutVoxel(posx,posy-*pointer,posx2,posy2-*pointer); } } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; *pointer+=1; if(*pointer>64) *pointer=64; PutVoxel(posx,posy-*pointer,posx2,posy2-*pointer); } }

Graphics.Lock(); for(i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; PutVoxel(posx,posy-*pointer,posx2,posy2-*pointer); } } Graphics.UnLock(); } }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Lower() { RGBTRIPLE color; BYTE *pointer;

if(GameMain.Status==0) { Graphics.Lock(); for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; if(*pointer!=0) *pointer-=1; PutVoxel(posx,posy,posx2,posy2); } } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { Graphics.Lock(); for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; if(*pointer!=0) *pointer-=1; PutVoxel(posx,posy,posx2,posy2); } Graphics.UnLock(); } }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { Graphics.Lock(); for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; if(*pointer!=0) *pointer-=1; PutVoxel(posx,posy,posx2,posy2); } } Graphics.UnLock(); } }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Brush() { if(Menu.Selection==-1) return;

DWORD buffer2; int TexPos=Menu.ScrolPos+Menu.Selection; int x,y,x2,y2; int a,b; RGBTRIPLE color; float red,green,blue; float ored,ogreen,oblue; BYTE *pointer; BYTE height;

if(GameMain.Status==0) { Graphics.Lock(); for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { a=255-color.rgbtRed;

x=posx/Textures[TexPos]->width; y=posy/Textures[TexPos]->height; x2=posx-(x*Textures[TexPos]->width); y2=posy-(y*Textures[TexPos]->height); pointer=(BYTE*)&Landscape[posx][posy]; oblue=*pointer;ogreen=*(++pointer);ored=*(++pointer);

color=Textures[TexPos]->GetPixel(x2,y2); red=color.rgbtRed;green=color.rgbtGreen;blue=color.rgbtBlue;

red=GetAlpha(red,ored,a); blue=GetAlpha(blue,oblue,a); green=GetAlpha(green,ogreen,a); pointer=(BYTE*)&Landscape[posx][posy]; *pointer=blue; *(++pointer)=green; *(++pointer)=red;

height=*(++pointer); for(int i3=0;i3<=height;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } } Graphics.UnLock();

}

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { Graphics.Lock(); for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { a=255-color.rgbtRed;

x=posx/Textures[TexPos]->width; y=posy/Textures[TexPos]->height; x2=posx-(x*Textures[TexPos]->width); y2=posy-(y*Textures[TexPos]->height); pointer=(BYTE*)&Landscape[posx][posy]; oblue=*pointer;ogreen=*(++pointer);ored=*(++pointer);

color=Textures[TexPos]->GetPixel(x2,y2); red=color.rgbtRed;green=color.rgbtGreen;blue=color.rgbtBlue;

red=GetAlpha(red,ored,a); blue=GetAlpha(blue,oblue,a); green=GetAlpha(green,ogreen,a); pointer=(BYTE*)&Landscape[posx][posy]; *pointer=blue; *(++pointer)=green; *(++pointer)=red;

height=*(++pointer); for(int i3=0;i3<=height;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { Graphics.Lock(); for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { a=255-color.rgbtRed;

x=posx/Textures[TexPos]->width; y=posy/Textures[TexPos]->height; x2=posx-(x*Textures[TexPos]->width); y2=posy-(y*Textures[TexPos]->height); pointer=(BYTE*)&Landscape[posx][posy]; oblue=*pointer;ogreen=*(++pointer);ored=*(++pointer);

color=Textures[TexPos]->GetPixel(x2,y2); red=color.rgbtRed;green=color.rgbtGreen;blue=color.rgbtBlue;

red=GetAlpha(red,ored,a); blue=GetAlpha(blue,oblue,a); green=GetAlpha(green,ogreen,a);; pointer=(BYTE*)&Landscape[posx][posy]; *pointer=blue; *(++pointer)=green; *(++pointer)=red;

height=*(++pointer); for(int i3=0;i3<=height;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } } Graphics.UnLock(); } }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Smoth() { BYTE cache[128][128]; BYTE *pointer; RGBTRIPLE color;

ZeroMemory(&cache,sizeof(cache));

if(GameMain.Status==0) { for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16;

if(posx2<101 || posx2>559) { cache[i][i2]=255; continue; } if(posy2<0 || posy2>479) { cache[i][i2]=255; continue; }

pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; cache[i][i2]=*pointer; }

for(i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { int z=0; int z2=0;

for(int i3=-1;i3<2;i3++) for(int i4=-1;i4<2;i4++) { if(i+i3<0) continue; if(i2+i4<0) continue; if(cache[i+i3][i2+i4]==255) continue;

z2++; z+=cache[i+i3][i2+i4]; } z=z/z2; pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

*pointer=z; } }

Graphics.Lock(); for(i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue;

pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

for(int i3=0;i3<=*pointer;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) { cache[i][i2]=255; continue; } if(posy2<0 || posy2>479) { cache[i][i2]=255; continue; } pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

cache[i][i2]=*pointer; }

for(i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { int z=0; int z2=0;

for(int i3=-1;i3<2;i3++) for(int i4=-1;i4<2;i4++) { if(i+i3<0) continue; if(i2+i4<0) continue; if(cache[i+i3][i2+i4]==255) continue;

z2++; z+=cache[i+i3][i2+i4]; } z=z/z2; pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

*pointer=z; } }

Graphics.Lock(); for(i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue;

pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

for(int i3=0;i3<=*pointer;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) { cache[i][i2]=255; continue; } if(posy2<0 || posy2>479) { cache[i][i2]=255; continue; } pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

cache[i][i2]=*pointer; }

for(i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { int z=0; int z2=0;

for(int i3=-1;i3<2;i3++) for(int i4=-1;i4<2;i4++) { if(i+i3<0) continue; if(i2+i4<0) continue; if(cache[i+i3][i2+i4]==255) continue;

z2++; z+=cache[i+i3][i2+i4]; } z=z/z2; pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

*pointer=z; } }

Graphics.Lock(); for(i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue;

pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

for(int i3=0;i3<=*pointer;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } Graphics.UnLock(); } }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Level() { BYTE *pointer; RGBTRIPLE color;

if(GameMain.Status==0) { for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

if(*pointer==32) continue; if(*pointer<32) ++*pointer; if(*pointer>32) --*pointer; } } }

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

if(*pointer==32) continue; if(*pointer<32) ++*pointer; if(*pointer>32) --*pointer; } } }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

if(*pointer==32) continue; if(*pointer<32) ++*pointer; if(*pointer>32) --*pointer; } } } }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Spray() { BYTE *pointer; RGBTRIPLE color; srand((unsigned)time(NULL)); int r=0;

if(GameMain.Status==0) { for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3; r=rand()%4; if(r==1 && *pointer<64) ++*pointer; if(r==2 && *pointer<64) ++*pointer; } } }

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

r=rand()%4; if(r==1 && *pointer<64) ++*pointer; if(r==2 && *pointer<64) ++*pointer; } } }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { pointer=(BYTE*)&Landscape[posx][posy]; pointer+=3;

r=rand()%4; if(r==1 && *pointer<64) ++*pointer; if(r==2 && *pointer<64) ++*pointer; } } }

}

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::Transparent() { if(Menu.Selection==-1) return;

DWORD buffer2; int TexPos=Menu.ScrolPos+Menu.Selection; int x,y,x2,y2; int a,b; RGBTRIPLE color; float red,green,blue; float ored,ogreen,oblue; BYTE *pointer; BYTE height;

if(GameMain.Status==0) { Graphics.Lock(); for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-16; int posy=ScreenPosY+GameMain.MouseY+i2-16; int posx2=GameMain.MouseX+i-16; int posy2=GameMain.MouseY+i2-16; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[2]->GetPixel(i,i2); if(color.rgbtRed) { a=255-color.rgbtRed;

x=posx/Textures[TexPos]->width; y=posy/Textures[TexPos]->height; x2=posx-(x*Textures[TexPos]->width); y2=posy-(y*Textures[TexPos]->height); pointer=(BYTE*)&Landscape[posx][posy]; oblue=*pointer;ogreen=*(++pointer);ored=*(++pointer);

color=Textures[TexPos]->GetPixel(x2,y2); red=color.rgbtRed;green=color.rgbtGreen;blue=color.rgbtBlue;

if(a<192) a=192; red=GetAlpha(red,ored,a); blue=GetAlpha(blue,oblue,a); green=GetAlpha(green,ogreen,a); pointer=(BYTE*)&Landscape[posx][posy]; *pointer=blue; *(++pointer)=green; *(++pointer)=red;

height=*(++pointer); for(int i3=0;i3<=height;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } } Graphics.UnLock();

}

/////////////////////////////////////////////////////////// if(GameMain.Status==1) { Graphics.Lock(); for(int i=0;i<64;i++) for(int i2=0;i2<64;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-32; int posy=ScreenPosY+GameMain.MouseY+i2-32; int posx2=GameMain.MouseX+i-32; int posy2=GameMain.MouseY+i2-32; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[1]->GetPixel(i,i2); if(color.rgbtRed) { a=255-color.rgbtRed;

x=posx/Textures[TexPos]->width; y=posy/Textures[TexPos]->height; x2=posx-(x*Textures[TexPos]->width); y2=posy-(y*Textures[TexPos]->height); pointer=(BYTE*)&Landscape[posx][posy]; oblue=*pointer;ogreen=*(++pointer);ored=*(++pointer);

color=Textures[TexPos]->GetPixel(x2,y2); red=color.rgbtRed;green=color.rgbtGreen;blue=color.rgbtBlue;

if(a<192) a=192; red=GetAlpha(red,ored,a); blue=GetAlpha(blue,oblue,a); green=GetAlpha(green,ogreen,a); pointer=(BYTE*)&Landscape[posx][posy]; *pointer=blue; *(++pointer)=green; *(++pointer)=red;

height=*(++pointer); for(int i3=0;i3<=height;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } } Graphics.UnLock(); }

/////////////////////////////////////////////////////////// if(GameMain.Status==2) { Graphics.Lock(); for(int i=0;i<96;i++) for(int i2=0;i2<96;i2++) { int posx=ScreenPosX+GameMain.MouseX-100+i-48; int posy=ScreenPosY+GameMain.MouseY+i2-48; int posx2=GameMain.MouseX+i-48; int posy2=GameMain.MouseY+i2-48; if(posx2<101 || posx2>559) continue; if(posy2<0 || posy2>479) continue; color=Masks[0]->GetPixel(i,i2); if(color.rgbtRed) { a=255-color.rgbtRed;

x=posx/Textures[TexPos]->width; y=posy/Textures[TexPos]->height; x2=posx-(x*Textures[TexPos]->width); y2=posy-(y*Textures[TexPos]->height); pointer=(BYTE*)&Landscape[posx][posy]; oblue=*pointer;ogreen=*(++pointer);ored=*(++pointer);

color=Textures[TexPos]->GetPixel(x2,y2); red=color.rgbtRed;green=color.rgbtGreen;blue=color.rgbtBlue;

if(a<192) a=192; red=GetAlpha(red,ored,a); blue=GetAlpha(blue,oblue,a); green=GetAlpha(green,ogreen,a);; pointer=(BYTE*)&Landscape[posx][posy]; *pointer=blue; *(++pointer)=green; *(++pointer)=red;

height=*(++pointer); for(int i3=0;i3<=height;i3++) PutVoxel(posx,posy-i3,posx2,posy2-i3); } } Graphics.UnLock(); } }

////////////////////////////////////////////////////////////////////////////////// inline BYTE CLandScape::GetAlpha(BYTE a,BYTE b,float alpha) { float diff=a-b;

if(diff<0) { //diff=diff*(-1); diff=diff*(alpha/-255); return(a+diff); } else { diff=diff*(alpha/255); return(a-diff); } }

////////////////////////////////////////////////////////////////////////////////// // Move operations // ////////////////////////////////////////////////////////////////////////////////// HICON CLandScape::CheckMouseCursor() { if(CheckBoxes[0]->State) return(GameMain.Cursor);

if(GameMain.KeyboardB[0]==129 && GameMain.KeyboardB[1]==132) { MoveLeftDown(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==129 && GameMain.KeyboardB[1]==131) { MoveLeftUp(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==130 && GameMain.KeyboardB[1]==132) { MoveRightDown(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==130 && GameMain.KeyboardB[1]==131) { MoveRightUp(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==132) { MoveDown(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==131) { MoveUp(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==130) { MoveRight(); return(GameMain.Cursor); }

if(GameMain.KeyboardB[0]==129) { MoveLeft(); return(GameMain.Cursor); }

if(GameMain.MouseX>=636 && GameMain.MouseY>=476) { MoveRightDown(); GameMain.CursorRegX=-16; GameMain.CursorRegY=-14; return(GameMain.RightDown); } if(GameMain.MouseX>=636 && GameMain.MouseY<=3) { MoveRightUp(); GameMain.CursorRegX=-14; GameMain.CursorRegY=0; return(GameMain.RightUp); } if(GameMain.MouseX<=3 && GameMain.MouseY<=3) { MoveLeftUp(); GameMain.CursorRegX=0; GameMain.CursorRegY=0; return(GameMain.LeftUp); } if(GameMain.MouseX<=3 && GameMain.MouseY>=476) { MoveLeftDown(); GameMain.CursorRegX=0; GameMain.CursorRegY=-15; return(GameMain.LeftDown); } if(GameMain.MouseX>=636) { MoveRight(); GameMain.CursorRegX=-19; GameMain.CursorRegY=0; return(GameMain.Right); } if(GameMain.MouseX<=3) { MoveLeft(); GameMain.CursorRegX=0; GameMain.CursorRegY=0; return(GameMain.Left); } if(GameMain.MouseY<=3) { MoveUp(); GameMain.CursorRegX=0; GameMain.CursorRegY=0; return(GameMain.Up); } if(GameMain.MouseY>=476) { MoveDown(); GameMain.CursorRegX=0; GameMain.CursorRegY=-19; return(GameMain.Down); } GameMain.CursorRegX=0; GameMain.CursorRegY=0; return(GameMain.Cursor); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveRight() { if(ScreenPosX>1530) return;

ScreenPosX+=10; Graphics.Blt(111,0,559,480,-10,0); Graphics.Lock(); FillScreen(549,0,559,479); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveLeft() { if(ScreenPosX==0) return; ScreenPosX-=10; Graphics.Blt(100,0,550,480,10,0); Graphics.Lock(); FillScreen(101,0,111,479); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveUp() { if(ScreenPosY==0) return; ScreenPosY-=10; Graphics.Blt(101,0,560,470,0,10); Graphics.Lock(); FillScreen(101,0,559,10); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveDown() { if(ScreenPosY==1450) return; ScreenPosY+=10; Graphics.Blt(101,10,560,480,0,-10); Graphics.Lock(); FillScreen(101,469,559,479); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveRightUp() { if(ScreenPosX>=1540) { MoveUp(); return; } if(ScreenPosY==0) { MoveRight(); return; } ScreenPosY-=10; ScreenPosX+=10; Graphics.Blt(111,0,560,470,-10,10); Graphics.Lock(); FillScreen(549,0,559,479); FillScreen(101,0,548,10); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveRightDown() { if(ScreenPosX>=1540) { MoveDown(); return; } if(ScreenPosY==1450) { MoveRight(); return; } ScreenPosY+=10; ScreenPosX+=10; Graphics.Blt(111,10,559,480,-10,-10); Graphics.Lock(); FillScreen(549,0,559,470); FillScreen(101,470,559,479); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveLeftUp() { if(ScreenPosX==0) { MoveUp(); return; } if(ScreenPosY==0) { MoveLeft(); return; } ScreenPosX-=10; ScreenPosY-=10; Graphics.Blt(101,0,549,470,10,10); Graphics.Lock(); FillScreen(101,0,559,10); FillScreen(101,10,110,479); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// inline void CLandScape::MoveLeftDown() { if(ScreenPosX==0) { MoveDown(); return; } if(ScreenPosY==1450) { MoveLeft(); return; } ScreenPosX-=10; ScreenPosY+=10; Graphics.Blt(101,10,549,480,10,-10), Graphics.Lock(); FillScreen(101,469,559,479); FillScreen(101,10,111,479); Graphics.UnLock(); }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CLiquid.cpp] - (6,830 bytes)

// CLiquid.cpp
// by Comanche

#include "CMain.h"
#include "CGraphics.h"
#include "CLog.h"
#include "CLiquid.h"
#include "CLandScape.h"
#include "CTexture.h"

extern CMain GameMain; extern CGraphics Graphics; extern CLog Log; extern CLandScape Land; extern CTexture *Textures[1024];

////////////////////////////////////////////////////////////////////////////////// CLiquid::CLiquid(int Texture) { int i=0; int TempX,TempY,TempX2,TempY2; height=0;

strcpy(TextureName,Textures[Texture]->Name); TexId = Texture;

while(i<2) { GameMain.GetMouseInfo(); if(GameMain.MouseX<101) GameMain.MouseX=101; if(GameMain.MouseX>559) GameMain.MouseX=559; Graphics.BltToBackBuffer();

Graphics.LockBackBuffer(); if(GameMain.CheckMouseRange(101,0,559,479,FALSE) && i==0) { if(GameMain.MouseB[0]) { TempX=GameMain.MouseX; TempY=GameMain.MouseY; i++; } } if(GameMain.CheckMouseRange(101,0,559,479,FALSE) && i==1) { if(GameMain.MouseX>TempX && GameMain.MouseY>TempY) { Graphics.Quader(TempX,TempY,GameMain.MouseX,GameMain.MouseY,0,0,150); if(GameMain.MouseB[0]) { TempX2=GameMain.MouseX; TempY2=GameMain.MouseY; i++; } } } Graphics.UnLockBackBuffer();

GameMain.RenderLiquids();

x=TempX+Land.ScreenPosX-100; y=TempY+Land.ScreenPosY; x2=TempX2+Land.ScreenPosX-100; y2=TempY2+Land.ScreenPosY; Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX-7,GameMain.MouseY-7,GameMain.Cross); Graphics.ReleaseDC(); Graphics.Flip(); }

while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); }

////////////////////////////////////////////////////////////////////////////////// CLiquid::~CLiquid() { }

////////////////////////////////////////////////////////////////////////////////// void CLiquid::Render() { }

////////////////////////////////////////////////////////////////////////////////// void CLiquid::RenderOutline(BOOL Marked) { int TempX,TempY,TempX2,TempY2;

Graphics.LockBackBuffer(); TempX=x-Land.ScreenPosX+100; TempY=y-Land.ScreenPosY-height; TempX2=x2-Land.ScreenPosX+100; TempY2=y2-Land.ScreenPosY-height; if(Marked) { for (int i=TempX;i<=TempX2;i++) { Graphics.PutSafePixel(i,TempY,0,0,220); Graphics.PutSafePixel(i,TempY2,0,0,220); } for (int i2=TempY;i2<=TempY2;i2++) { Graphics.PutSafePixel(TempX,i2,0,0,220); Graphics.PutSafePixel(TempX2,i2,0,0,220); } } else { for (int i=TempX;i<=TempX2;i++) { Graphics.PutSafePixel(i,TempY,0,0,150); Graphics.PutSafePixel(i,TempY2,0,0,150); } for (int i2=TempY;i2<=TempY2;i2++) { Graphics.PutSafePixel(TempX,i2,0,0,150); Graphics.PutSafePixel(TempX2,i2,0,0,150); } } int Temp=TempY+((TempY2-TempY)/2)-1; int Temp2=TempX+((TempX2-TempX)/2)-1; for(int i=0;i<4;i++) { for(int i2=0;i2<4;i2++) { Graphics.PutSafePixel(i+TempX-2,i2+Temp,0,0,255); Graphics.PutSafePixel(i+TempX2-1,i2+Temp,0,0,255); Graphics.PutSafePixel(i+Temp2,i2+TempY-2,0,0,255); Graphics.PutSafePixel(i+Temp2,i2+TempY2-1,0,0,255); } }

Graphics.UnLockBackBuffer(); }

////////////////////////////////////////////////////////////////////////////////// void CLiquid::CheckMouse(int Liquid) { int TempX = x-Land.ScreenPosX+100; int TempY = y-Land.ScreenPosY; int TempX2 = x2-Land.ScreenPosX+100; int TempY2 = y2-Land.ScreenPosY; int TempX3 = (x2-x)/2; int TempY3 = (y2-y)/2;

if(GameMain.CheckMouseRange(TempX-4,TempY-height,TempX+4,TempY2-height,FALSE)) { GameMain.ActiveLiquid=Liquid; } if(GameMain.CheckMouseRange(TempX2-4,TempY-height,TempX2+4,TempY2-height,FALSE)) { GameMain.ActiveLiquid=Liquid; } if(GameMain.CheckMouseRange(TempX,TempY-4-height,TempX2,TempY+4-height,FALSE)) { GameMain.ActiveLiquid=Liquid; } if(GameMain.CheckMouseRange(TempX,TempY2-4,TempX2,TempY2+4-height,FALSE)) { GameMain.ActiveLiquid=Liquid; }

if(GameMain.CheckMouseRange(TempX-4,TempY+TempY3-4-height, TempX+4,TempY+TempY3+4-height,FALSE)) { GameMain.Icon=GameMain.LeftRight; if(GameMain.MouseB[0]) { while(GameMain.MouseB[0]) { GameMain.GetMouseInfo(); if(GameMain.MouseX>=TempX2) GameMain.MouseX=TempX2-1; if(GameMain.MouseX>559) GameMain.MouseX=559; if(GameMain.MouseX<101) GameMain.MouseX=101; x=GameMain.MouseX+Land.ScreenPosX-100; Graphics.BltToBackBuffer(); GameMain.RenderLiquids(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX-7,GameMain.MouseY-7,GameMain.LeftRight); Graphics.ReleaseDC(); Graphics.Flip(); } } while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); return; } if(GameMain.CheckMouseRange(TempX2-4,TempY+TempY3-4-height, TempX2+4,TempY+TempY3+4-height,FALSE)) { GameMain.Icon=GameMain.LeftRight; if(GameMain.MouseB[0]) { while(GameMain.MouseB[0]) { GameMain.GetMouseInfo(); if(GameMain.MouseX<=TempX) GameMain.MouseX=TempX+1; if(GameMain.MouseX>559) GameMain.MouseX=559; if(GameMain.MouseX<101) GameMain.MouseX=101; x2=GameMain.MouseX+Land.ScreenPosX-100; Graphics.BltToBackBuffer(); GameMain.RenderLiquids(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX-7,GameMain.MouseY-7,GameMain.LeftRight); Graphics.ReleaseDC(); Graphics.Flip(); } } while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); return; } if(GameMain.CheckMouseRange(TempX+TempX3-4,TempY-4-height, TempX+TempX3+4,TempY+4-height,FALSE)) { GameMain.Icon=GameMain.UpDown; if(GameMain.MouseB[0]) { while(GameMain.MouseB[0]) { GameMain.GetMouseInfo(); if(GameMain.MouseY>=TempY2) GameMain.MouseY=TempY2-1; y=GameMain.MouseY+Land.ScreenPosY; Graphics.BltToBackBuffer(); GameMain.RenderLiquids(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX-7,GameMain.MouseY-7,GameMain.UpDown); Graphics.ReleaseDC(); Graphics.Flip(); } } while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); return; } if(GameMain.CheckMouseRange(TempX+TempX3-4,TempY2-4-height, TempX+TempX3+4,TempY2+4-height,FALSE)) { GameMain.Icon=GameMain.UpDown; if(GameMain.MouseB[0]) { while(GameMain.MouseB[0]) { GameMain.GetMouseInfo(); if(GameMain.MouseY<=TempY) GameMain.MouseY=TempY+1; y2=GameMain.MouseY+Land.ScreenPosY; Graphics.BltToBackBuffer(); GameMain.RenderLiquids(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX-7,GameMain.MouseY-7,GameMain.UpDown); Graphics.ReleaseDC(); Graphics.Flip(); } } while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); return; } }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CLog.cpp] - (2,590 bytes)

// Clog.cpp
// by Comanche

#include "CLog.h"

////////////////////////////////////////////////////////////////////////////////// CLog::CLog() { MEMORYSTATUS mem; GlobalMemoryStatus(&mem);

int memoryfree = mem.dwAvailPhys / 1024; int memory = mem.dwTotalPhys / 1024;

lfh = OpenFile("VoxEd Log.html",&log_file_data,OF_CREATE); WriteCodeToLogFile("<html>"); WriteCodeToLogFile("<body>"); WriteCodeToLogFile("<p> <font size=5 color=#000080 face=Arial>"); WriteToLogFile("Pulsar Entertainment LogFile Version 3.0"); WriteCodeToLogFile("</p> </font>"); WriteCodeToLogFile("<p> <font size=2 color=#000000 face=Arial>"); WriteToLogFile("> Voxel Editor: Version alpha 0.53 MMX"); _strtime(buffer); sprintf(buffer2,"> Time: %s",buffer); WriteToLogFile(buffer2); _strdate(buffer); sprintf(buffer2,"> Date: %s (month/day/year)",buffer); WriteToLogFile(buffer2); sprintf(buffer2,"> Total physical memory: %d KB",memory); WriteToLogFile(buffer2); sprintf(buffer2,"> Physical memory free: %d KB",memoryfree); WriteToLogFile(buffer2); }

////////////////////////////////////////////////////////////////////////////////// BOOL CLog::CloseLogFile() { WriteCodeToLogFile("</p> </font>"); WriteCodeToLogFile("</body>"); WriteCodeToLogFile("</html>"); _close(lfh); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CLog::WriteToLogFile(char *string) { _lwrite(lfh,"<BR> ",strlen("<BR> ")); _lwrite(lfh,string,strlen(string)); _lwrite(lfh,"\r\n",strlen("\r\n")); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CLog::WriteCodeToLogFile(char *string) { _lwrite(lfh,string,strlen(string)); _lwrite(lfh,"\r\n",strlen("\r\n")); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CLog::WriteErrorToLogFile(char *string) { WriteCodeToLogFile("</font>"); WriteCodeToLogFile("<font size=2 color=#FF0000 face=Arial>"); WriteToLogFile(string); WriteCodeToLogFile("</font>"); WriteCodeToLogFile("<font size=2 color=#000000 face=Arial>"); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CLog::WriteStatusToLogFile(char *string) { WriteCodeToLogFile("</font>"); WriteCodeToLogFile("<font size=2 color=#008000 face=Arial>"); WriteToLogFile(string); WriteCodeToLogFile("</font>"); WriteCodeToLogFile("<font size=2 color=#000000 face=Arial>"); return(TRUE); }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CMain.cpp] - (42,136 bytes)

// CMain.cpp
// by Comanche

#include "CLog.h"
#include "CButton.h"
#include "CGraphics.h"
#include "CMain.h"
#include "CLandScape.h"
#include "CMenu.h"
#include "CTexture.h"
#include "CTime.h"
#include "CViewport.h"
#include "CColor.h"
#include "CVoxel.h"
#include "CLiquid.h"
#include "CCheckBox.h"

extern CMain GameMain; extern CLog Log; extern CLandScape Land; extern CGraphics Graphics; extern CMenu Menu; extern CTime Time; extern CColor Color; extern CVoxel Voxel; extern CButton *Buttons[60]; extern CCheckBox *CheckBoxes[20]; extern CViewport *Viewports[4]; extern CTexture *Textures[1024]; extern CLiquid *Liquids[128]; extern CTexture *Masks[3]; extern HINSTANCE main_instance; extern HWND main_window_handle;

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GameInit(HWND main_window_handle) { Log.WriteToLogFile("> Checking DirectX"); if(!CheckDirectX()) { Log.WriteErrorToLogFile("> Cannot find DirectX"); return(FALSE); }

switch(DXVersion) { case 0x100: Log.WriteToLogFile("> DirectX 1.0 found"); break;

case 0x200: Log.WriteToLogFile("> DirectX 2.0 found"); break;

case 0x300: Log.WriteToLogFile("> DirectX 3.0 found"); break;

case 0x500: Log.WriteToLogFile("> DirectX 5.0 found"); break;

case 0x600: Log.WriteToLogFile("> DirectX 6.0 found"); break;

case 0x601: Log.WriteToLogFile("> DirectX 6.1 found"); break;

case 0x700: Log.WriteToLogFile("> DirectX 7.0 or better found"); break; }

if(DXVersion<0x700) { Log.WriteErrorToLogFile("> This Program cannot run on older Version than DirectX 7.0"); return(FALSE); }

if(DXPlatform==VER_PLATFORM_WIN32_WINDOWS) { Log.WriteToLogFile("> Running under Win 9x"); }

if(DXPlatform==VER_PLATFORM_WIN32_NT) { Log.WriteToLogFile("> Running under Win NT"); }

CheckProzessor();

Log.WriteToLogFile("> Checking Prozessor");

sprintf(buffer,"> Vendor String: %s",VendorString); Log.WriteToLogFile(buffer);

if(CPUID=TRUE) { sprintf(buffer,"> Prozessor class: %d86, Model: %d, Stepping ID: %d", CpuFamily,CpuModel,CpuStepId); Log.WriteToLogFile(buffer); }

if(AMD) Log.WriteToLogFile("> Yeah, AMD!");

if(INTEL) Log.WriteToLogFile("> I HATE Intel!"); char features[80]; ZeroMemory(&features,sizeof(features)); if (CPUID) sprintf(features,"%s CPUID", features); else sprintf(features,"%s Unknown",features); if (FPU) sprintf(features,"%s FPU", features); if (MMX) sprintf(features,"%s MMX", features); if (CMOV) sprintf(features,"%s CMOV", features); if (TSC) sprintf(features,"%s TSC",features); if (MCA) sprintf(features,"%s MCA",features); sprintf(buffer, "> CPU Features:%s", features); Log.WriteToLogFile(buffer);

if (!CPUID) { Log.WriteErrorToLogFile("> Sorry, no MMX found!"); return(FALSE); }

if (!MMX) { Log.WriteErrorToLogFile("> Sorry, no MMX found!"); return(FALSE); } if (DirectDrawCreate(NULL,&lpdd,NULL)!=DD_OK) { Log.WriteErrorToLogFile("> Error: Create main DirectDraw object"); return(FALSE); } Log.WriteToLogFile("> Create main DirectDraw object: OK");

if (lpdd->QueryInterface(IID_IDirectDraw2,(LPVOID *)&lpdd2)!=S_OK) { Log.WriteErrorToLogFile("> Error: Query IDirectDraw2 Interface"); return(FALSE); } Log.WriteToLogFile("> Create IDirectDraw2 Interface: OK");

if (lpdd2->SetCooperativeLevel(main_window_handle, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK) { Log.WriteErrorToLogFile("> Error: Set exclusive cooperative level "); return(FALSE); } Log.WriteToLogFile("> Set exclusive cooperative level: OK");

if (lpdd2->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,NULL)!=DD_OK) { sprintf(buffer,"> Error: Set %dx%d display mode",SCREEN_WIDTH,SCREEN_HEIGHT); Log.WriteErrorToLogFile(buffer); return(FALSE); } sprintf(buffer,"> Set %dx%d display mode: OK",SCREEN_WIDTH,SCREEN_HEIGHT); Log.WriteToLogFile(buffer);

memset(&ddsd,0,sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; ddsd.dwBackBufferCount = 1;

if(lpdd2->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK) { Log.WriteErrorToLogFile("> Error: Create primary surface"); return(FALSE); } Log.WriteToLogFile("> Create primary surface: OK"); ddscaps.dwCaps = DDSCAPS_BACKBUFFER; if(lpddsprimary->GetAttachedSurface(&ddscaps,&lpddsback)!=DD_OK) { Log.WriteErrorToLogFile("> Error: Create back buffer"); return(FALSE); } Log.WriteToLogFile("> Create back buffer: OK");

memset(&ddsd,0,sizeof(ddsd)); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH; ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; ddsd.dwWidth = SCREEN_WIDTH; ddsd.dwHeight = SCREEN_HEIGHT; if(lpdd2->CreateSurface(&ddsd,&lpddsos1,NULL)!=DD_OK) { sprintf(buffer,"> Error: Create %dx%d off-screen surface", SCREEN_WIDTH,SCREEN_HEIGHT); Log.WriteErrorToLogFile(buffer); return(FALSE); } sprintf(buffer,"> Create %dx%d off-screen surface: OK",SCREEN_WIDTH,SCREEN_HEIGHT); Log.WriteToLogFile(buffer);

int alloc=(SCREEN_HEIGHT*SCREEN_WIDTH*(SCREEN_BPP/8)*3)/1024; sprintf(buffer,"> Allocated %d KByte of video memory",alloc); Log.WriteToLogFile(buffer);

int memory=(2000*2000*4)/1024; sprintf(buffer,"> Allocated %d KByte for map data",memory); Log.WriteToLogFile(buffer);

return(TRUE); } // end GameInit ////////////////////////////////////////////////////////////////////////////////// BOOL CMain::CheckProzessor() { int OpCPUID=0; int OpMMX=0; int OpFPU=0; int OpCMOV=0; int OpMCA=0; int OpTSC=0; char buffer2[32]; int CFT,CMT,CSIT; ZeroMemory(&buffer2,sizeof(buffer2));

__asm { pushad pushfd pushfd pop ebx xor ebx,0100000h // test for CPUID push ebx // Flag 21 des EFlag Registers popfd // ist setzbar wenn CPUID unterstützt pushfd // wird. pop ebx test ebx,0100000h jz jmp1 popfd mov OpCPUID,0 jmp end jmp1: popfd mov OpCPUID,1

mov eax,0 // CPUID cpuid cmp eax,0 // Nochmals überprüfen jz end mov DWORD PTR [buffer2],ebx // Vendor ID in ebx,edx und ecx mov DWORD PTR [buffer2+4],edx mov DWORD PTR [buffer2+8],ecx

mov eax,1 // CPUID cpuid mov ebx,eax // Prozessorklasse in EAX and ebx,0780h // Bits 8-11 shr ebx,8 mov CFT,ebx mov ebx,eax // Model in EAX Bits 4-8 and ebx,0F0h shr ebx,4 mov CMT,ebx

mov ebx,eax // Stepping ID in EAX Bits 0-3 and ebx,0Fh mov CSIT,ebx

mov eax,1 cpuid

test edx,08h // test for TSC (Bit 4 in edx nach CPUID) jz notsc mov OpTSC,1 jmp tsc notsc: mov OpTSC,0

tsc: test edx,04000h // test for MCA (Bit 14 in edx nach CPUID) jz nomca mov OpMCA,1 jmp mca nomca: mov OpMCA,0

mca: test edx,0800000h // test for MMX (Bit 23 in edx nach CPUID) jz nommx mov OpMMX,1 jmp mmx nommx: mov OpMMX,0

mmx: test edx,010000h // test for CMOV (Bit 15 in edx nach CPUID) jz nocmov mov OpCMOV,1 jmp cmov nocmov: mov OpCMOV,0

cmov: test edx,01h // test for FPU (Bit 0 in edx nach CPUID) jz nofpu mov OpFPU,1 jmp end nofpu: mov OpFPU,0

end: popad }

if(OpCPUID) { CPUID=TRUE; strcpy(VendorString,buffer2); } else { CPUID=FALSE; strcpy(VendorString,"Unknown"); }

AMD=FALSE; INTEL=FALSE;

for(int i=0;i<29;i++) { if(strcmp(&VendorString[i],"AMD")==0) { AMD=TRUE; } }

for(i=0;i<27;i++) { if(strcmp(&VendorString[i],"Intel")==0) { INTEL=TRUE; } }

if(OpFPU) FPU=TRUE; else FPU=FALSE; if(OpMMX) MMX=TRUE; else MMX=FALSE; if(OpTSC) TSC=TRUE; else TSC=FALSE; if(OpCMOV) CMOV=TRUE; else CMOV=FALSE; if(OpMCA) MCA=TRUE; else MCA=FALSE;

CpuFamily = CFT; CpuModel = CMT; CpuStepId = CSIT;

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::CheckDirectX() { HRESULT hr; HINSTANCE DDHinst = 0; HINSTANCE DIHinst = 0; LPDIRECTDRAW lpDDraw = 0; LPDIRECTDRAW2 lpDDraw2 = 0; LPDIRECTDRAW7 lpDDraw7 = 0; DIRECTDRAWCREATE DirectDrawCreate = 0; DIRECTDRAWCREATEEX DirectDrawCreateEx = 0; DIRECTINPUTCREATE DirectInputCreate = 0; OSVERSIONINFO OSVersion; LPDIRECTDRAWSURFACE lpSurf = 0; LPDIRECTDRAWSURFACE3 lpSurf3 = 0; LPDIRECTDRAWSURFACE4 lpSurf4 = 0;

// First get the windows platform OSVersion.dwOSVersionInfoSize = sizeof(OSVersion); if(!GetVersionEx(&OSVersion)) { DXPlatform = 0; DXVersion = 0; return(FALSE); }

if( OSVersion.dwPlatformId == VER_PLATFORM_WIN32_NT ) { DXPlatform = VER_PLATFORM_WIN32_NT;

// NT is easy... NT 4.0 is DX2, 4.0 SP3 is DX3, 5.0 is DX5 // and no DX on earlier versions. if( OSVersion.dwMajorVersion < 4 ) { DXVersion = 0; // No DX on NT3.51 or earlier return(FALSE); }

if( OSVersion.dwMajorVersion == 4 ) { // NT4 up to SP2 is DX2, and SP3 onwards is DX3, so we are at least DX2 DXVersion = 0x200;

// We're not supposed to be able to tell which SP we're on, so check for dinput DIHinst = LoadLibrary( "DINPUT.DLL" ); if( DIHinst == 0 ) { // No DInput... must be DX2 on NT 4 pre-SP3 OutputDebugString( "Couldn't LoadLibrary DInput\r\n" ); return(TRUE); }

DirectInputCreate = (DIRECTINPUTCREATE)GetProcAddress( DIHinst, "DirectInputCreateA" ); FreeLibrary( DIHinst );

if( DirectInputCreate == 0 ) { // No DInput... must be pre-SP3 DX2 OutputDebugString( "Couldn't GetProcAddress DInputCreate\r\n" ); return(TRUE); }

// It must be NT4, DX2 DXVersion = 0x300; // DX3 on NT4 SP3 or higher return(TRUE); } // Else it's NT5 or higher, and it's DX5a or higher: Drop through to // Win9x tests for a test of DDraw (DX6 or higher) } else { // Not NT... must be Win9x DXPlatform = VER_PLATFORM_WIN32_WINDOWS; }

// Now we know we are in Windows 9x (or maybe 3.1), so anything's possible. // First see if DDRAW.DLL even exists. DDHinst = LoadLibrary( "DDRAW.DLL" ); if( DDHinst == 0 ) { DXVersion = 0; DXPlatform = 0; FreeLibrary( DDHinst ); return(FALSE); }

// See if we can create the DirectDraw object. DirectDrawCreate = (DIRECTDRAWCREATE)GetProcAddress( DDHinst, "DirectDrawCreate" ); if( DirectDrawCreate == 0 ) { DXVersion = 0; DXPlatform = 0; FreeLibrary( DDHinst ); OutputDebugString( "Couldn't LoadLibrary DDraw\r\n" ); return(FALSE); }

hr = DirectDrawCreate( NULL, &lpDDraw, NULL ); if( FAILED(hr) ) { DXVersion = 0; DXPlatform = 0; FreeLibrary( DDHinst ); OutputDebugString( "Couldn't create DDraw\r\n" ); return(FALSE); }

// So DirectDraw exists. We are at least DX1. DXVersion = 0x100;

// Let's see if IID_IDirectDraw2 exists. hr = lpDDraw->QueryInterface( IID_IDirectDraw2, (VOID**)&lpDDraw2 ); if( FAILED(hr) ) { // No IDirectDraw2 exists... must be DX1 lpDDraw->Release(); FreeLibrary( DDHinst ); OutputDebugString( "Couldn't QI DDraw2\r\n" ); return(TRUE); }

// IDirectDraw2 exists. We must be at least DX2 lpDDraw2->Release(); DXVersion = 0x200;

/////////////////////////////////////////////////////////////////////////// // DirectX 3.0 Checks /////////////////////////////////////////////////////////////////////////// // DirectInput was added for DX3 DIHinst = LoadLibrary( "DINPUT.DLL" ); if( DIHinst == 0 ) { // No DInput... must not be DX3 OutputDebugString( "Couldn't LoadLibrary DInput\r\n" ); lpDDraw->Release(); FreeLibrary( DDHinst ); return(TRUE); }

DirectInputCreate = (DIRECTINPUTCREATE)GetProcAddress( DIHinst, "DirectInputCreateA" ); if( DirectInputCreate == 0 ) { // No DInput... must be DX2 FreeLibrary( DIHinst ); FreeLibrary( DDHinst ); lpDDraw->Release(); OutputDebugString( "Couldn't GetProcAddress DInputCreate\r\n" ); return(TRUE); }

// DirectInputCreate exists. We are at least DX3 DXVersion = 0x300; FreeLibrary( DIHinst );

// Can do checks for 3a vs 3b here

/////////////////////////////////////////////////////////////////////////// // DirectX 5.0 Checks /////////////////////////////////////////////////////////////////////////// // We can tell if DX5 is present by checking for the existence of // IDirectDrawSurface3. First, we need a surface to QI off of. DDSURFACEDESC ddsd; ZeroMemory( &ddsd, sizeof(ddsd) ); ddsd.dwSize = sizeof(ddsd); ddsd.dwFlags = DDSD_CAPS; ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

hr = lpDDraw->SetCooperativeLevel( NULL, DDSCL_NORMAL ); if( FAILED(hr) ) { // Failure. This means DDraw isn't properly installed. lpDDraw->Release(); FreeLibrary( DDHinst ); DXVersion = 0; OutputDebugString( "Couldn't Set coop level\r\n" ); return(FALSE); }

hr = lpDDraw->CreateSurface( &ddsd, &lpSurf, NULL ); if( FAILED(hr) ) { // Failure. This means DDraw isn't properly installed. lpDDraw->Release(); FreeLibrary( DDHinst ); DXVersion = 0; OutputDebugString( "Couldn't CreateSurface\r\n" ); return(FALSE); }

// Query for the IDirectDrawSurface3 interface if( FAILED( lpSurf->QueryInterface( IID_IDirectDrawSurface3, (VOID**)&lpSurf3 ) ) ) { lpDDraw->Release(); FreeLibrary( DDHinst ); return(TRUE); }

// QI for IDirectDrawSurface3 succeeded. We must be at least DX5 DXVersion = 0x500;

/////////////////////////////////////////////////////////////////////////// // DirectX 6.0 Checks /////////////////////////////////////////////////////////////////////////// // The IDirectDrawSurface4 interface was introduced with DX 6.0 if( FAILED( lpSurf->QueryInterface( IID_IDirectDrawSurface4, (VOID**)&lpSurf4 ) ) ) { lpDDraw->Release(); FreeLibrary( DDHinst ); return(TRUE); }

// IDirectDrawSurface4 was create successfully. We must be at least DX6 DXVersion = 0x600; lpSurf->Release(); lpDDraw->Release();

/////////////////////////////////////////////////////////////////////////// // DirectX 6.1 Checks /////////////////////////////////////////////////////////////////////////// // Check for DMusic, which was introduced with DX6.1 LPDIRECTMUSIC lpDMusic = NULL; CoInitialize( NULL ); hr = CoCreateInstance( CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, IID_IDirectMusic, (VOID**)&lpDMusic ); if( FAILED(hr) ) { OutputDebugString( "Couldn't create CLSID_DirectMusic\r\n" ); FreeLibrary( DDHinst ); return(TRUE); }

// DirectMusic was created successfully. We must be at least DX6.1 DXVersion = 0x601; lpDMusic->Release(); CoUninitialize();

/////////////////////////////////////////////////////////////////////////// // DirectX 7.0 Checks /////////////////////////////////////////////////////////////////////////// // Check for DirectX 7 by creating a DDraw7 object LPDIRECTDRAW7 pDD7; DirectDrawCreateEx = (DIRECTDRAWCREATEEX)GetProcAddress( DDHinst, "DirectDrawCreateEx" ); if( NULL == DirectDrawCreateEx ) { FreeLibrary( DDHinst ); return(TRUE); }

if( FAILED( DirectDrawCreateEx( NULL, (VOID**)&lpDDraw7, IID_IDirectDraw7, NULL ) ) ) { FreeLibrary( DDHinst ); return(TRUE); }

// DDraw7 was created successfully. We must be at least DX7.0 DXVersion = 0x700; lpDDraw7->Release();

/////////////////////////////////////////////////////////////////////////// // End of checks /////////////////////////////////////////////////////////////////////////// // Close open libraries and return FreeLibrary( DDHinst ); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GameStart() { DrawCursor=TRUE; Graphics.DrawFont = TRUE; Graphics.logfont.lfHeight = STANDARTFONTHEIGHT; Graphics.logfont.lfWidth = 0; Graphics.logfont.lfEscapement = 0; Graphics.logfont.lfOrientation = 0; Graphics.logfont.lfWeight = FW_BOLD; Graphics.logfont.lfItalic = FALSE; Graphics.logfont.lfUnderline = FALSE; Graphics.logfont.lfStrikeOut = FALSE; Graphics.logfont.lfCharSet = OEM_CHARSET; Graphics.logfont.lfOutPrecision = OUT_DEFAULT_PRECIS; Graphics.logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS; Graphics.logfont.lfQuality = PROOF_QUALITY; Graphics.logfont.lfPitchAndFamily = DEFAULT_PITCH; lstrcpy(Graphics.logfont.lfFaceName, "Arial");

Viewports[0] = new CViewport(135,20,VIEWPORTTOP); Viewports[1] = new CViewport(405,20,VIEWPORTFRONT); Viewports[2] = new CViewport(135,260,VIEWPORTLEFT); Viewports[3] = new CViewport(405,260,VIEWPORT3D);

Graphics.BlackQuader(0,0,640,480);

Graphics.Lock();

// Land Editor Buttons Buttons[0] = new CButton(10,440,90,460,"Ende",""); Buttons[1] = new CButton(1,20,100,40,"Menu >",""); Buttons[2] = new CButton(562,8,570,239,"",""); Buttons[3] = new CButton(562,240,570,462,"",""); Buttons[4] = new CButton(2,60,32,90,"","data\\Button1.bmp"); //klein Buttons[5] = new CButton(35,60,65,90,"","data\\Button2.bmp"); //mittel Buttons[6] = new CButton(68,60,98,90,"","data\\Button3.bmp"); //groß Buttons[7] = new CButton(2,92,32,122,"","data\\Button4.bmp"); //higher Buttons[8] = new CButton(35,92,65,122,"","data\\Button5.bmp"); //lower Buttons[9] = new CButton(68,92,98,122,"","data\\Button6.bmp"); //brush Buttons[10] = new CButton(2,124,32,154,"","data\\Button7.bmp"); //smoth Buttons[11] = new CButton(35,124,65,154,"","data\\Button8.bmp"); //level Buttons[12] = new CButton(68,124,98,154,"","data\\Button9.bmp"); //redraw Buttons[13] = new CButton(2,156,32,186,"","data\\Button10.bmp"); //spray Buttons[14] = new CButton(35,156,65,186,"","data\\Button11.bmp"); //transparent Buttons[15] = new CButton(68,156,98,186,"","data\\Button12.bmp"); //liquid mode // Voxel Editor Buttons Buttons[30] = new CButton(2,50,32,70,"","data\\ArrowUp.bmp"); Buttons[31] = new CButton(35,50,65,70,"","data\\ArrowUp.bmp"); Buttons[32] = new CButton(68,50,98,70,"","data\\ArrowUp.bmp"); Buttons[33] = new CButton(2,144,32,164,"","data\\ArrowDown.bmp"); Buttons[34] = new CButton(35,144,65,164,"","data\\ArrowDown.bmp"); Buttons[35] = new CButton(68,144,98,164,"","data\\ArrowDown.bmp");

// Check Boxes CheckBoxes[0] = new CCheckBox(6,355,"Lock Screen"); CheckBoxes[1] = new CCheckBox(6,370,"Draw VPF"); CheckBoxes[2] = new CCheckBox(6,385,"ActiveLiquid"); CheckBoxes[3] = new CCheckBox(6,400,"Outlines Off"); CheckBoxes[4] = new CCheckBox(6,415,"Only Outlines");

Graphics.DrawButton(0,0,100,479); Graphics.DrawButton(560,0,639,479); Graphics.DrawPushedButton(13,267,84,338); // MiniMap Graphics.DrawPushedButton(4,215,96,255); for(int i=0;i<96;i++) Graphics.HLine(2+i,2,15,0,0,240-i); Graphics.UnLock();

Menu.Selection=-1; Menu.DrawTextures();

Menu.DrawMiniMap(); Graphics.logfont.lfHeight = SMALFONTHEIGHT; Graphics.OSGetDC(); Graphics.Text(50,5,Version); Graphics.OSReleaseDC(); Graphics.logfont.lfHeight = STANDARTFONTHEIGHT;

Graphics.BltToBackBuffer();

Graphics.Flip();

Cursor = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_CURSOR)); Cross = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_CROSS)); Finger = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_STOP)); Pinpet = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_PINPET)); Clock = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_CLOCK)); Right = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_RIGHT)); Left = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_LEFT)); Up = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_UP)); Down = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_DOWN)); RightDown = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_DOWNRIGHT)); RightUp = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_UPRIGHT)); LeftDown = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_DOWNLEFT)); LeftUp = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_UPLEFT)); LeftRight = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_LEFTRIGHT)); UpDown = LoadIcon(main_instance,MAKEINTRESOURCE(IDI_UPDOWN)); Log.WriteToLogFile("> Loading Cursors: OK");

Land.Day=TRUE; ActiveLiquid=-1;

return(TRUE); } // end GameStart ////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GameMain() { if(Editor==0) { GetMouseInfo(); GetKeyboardInfo();

Land.vps=0;

if(CheckMouseRange(3,2,99,17,TRUE)) Menu.MessageBox("Credits","VoxEd by Comanche",MS_OK); if (Buttons[0]->TestIfPressed()) { if(Menu.MessageBox("VoxEd","Do you realy want to exit?",MS_YESNO)) { PostMessage(main_window_handle,WM_DESTROY,0,0); return(TRUE); } }

if (Buttons[1]->TestIfPressed()) { Menu.Menu(); return(TRUE); } if (Buttons[2]->TestIfPressed()) Menu.ScrollUp(); if (Buttons[3]->TestIfPressed()) Menu.ScrollDown(); if (Buttons[4]->TestIfPressed()) Status=0; if (Buttons[5]->TestIfPressed()) Status=1; if (Buttons[6]->TestIfPressed()) Status=2; if (Buttons[7]->TestIfPressed()) Status2=0; if (Buttons[8]->TestIfPressed()) Status2=1; if (Buttons[9]->TestIfPressed()) Status2=2; if (Buttons[10]->TestIfPressed()) Status2=3; if (Buttons[11]->TestIfPressed()) Status2=4; if (Buttons[12]->TestIfPressed()) { Graphics.Lock(); Land.InitScreen(); Graphics.UnLock(); } if (Buttons[13]->TestIfPressed()) Status2=5; if (Buttons[14]->TestIfPressed()) Status2=6; if (Buttons[15]->TestIfPressed()) Status2=7;

CheckBoxes[0]->TestIfPressed(); CheckBoxes[1]->TestIfPressed(); CheckBoxes[2]->TestIfPressed(); CheckBoxes[3]->TestIfPressed(); CheckBoxes[4]->TestIfPressed(); if (KeyboardB[0]=='R') { Graphics.Lock(); Land.InitScreen(); Graphics.UnLock(); } if (KeyboardB[0]==219) { Buttons[1]->RedrawPushedButton(); Menu.Menu(); Buttons[1]->RedrawButton(); return(TRUE); } if (KeyboardB[0]==56 && KeyboardB[1]==62) { PostMessage(main_window_handle,WM_DESTROY,0,0); } if (CheckMouseRange(572,8,636,463,TRUE)) Menu.SelectTexture(); if (MouseX>100 && MouseX<560 && MouseB[0]) Land.UseBrush();

if (MouseX>100 && MouseX<560 && MouseB[1]) { Land.UseBrush(); while(MouseB[1]) { GetMouseInfo(); } } Icon=Land.CheckMouseCursor(); Graphics.BltToBackBuffer();

if(Status2==7) { if(KeyboardB[0]==211 && ActiveLiquid!=-1) { delete Liquids[ActiveLiquid]; Liquids[ActiveLiquid]=NULL; }

if(KeyboardB[0]=='-' && ActiveLiquid!=-1) { if(Liquids[ActiveLiquid]->height>0) Liquids[ActiveLiquid]->height-=1; }

if(KeyboardB[0]=='+' && ActiveLiquid!=-1) { if(Liquids[ActiveLiquid]->height<32) Liquids[ActiveLiquid]->height+=1; }

RenderLiquids(); CheckLiquids(); if(MouseX>100 && MouseX<560 && MouseB[0] && Menu.Selection>-1 && ActiveLiquid==-1) { for(int i=0;i<128;i++) { if(!Liquids[i]) { Liquids[i] = new CLiquid(Menu.Selection); i=128; } } } }

Land.DrawBrush();

Graphics.GetDC(); if (MouseX>100 && MouseX<560 && Status2==7) DrawIcon(Graphics.xdc,MouseX-7,MouseY-7,Icon); if (MouseX<101 || MouseX>559) DrawIcon(Graphics.xdc,MouseX+CursorRegX,MouseY+CursorRegY,Cursor); Graphics.ReleaseDC();

Graphics.Flip(); return(TRUE); }

if(Editor==1) { GetMouseInfo(); GetKeyboardInfo();

if(CheckMouseRange(3,2,99,17,TRUE)) Menu.MessageBox("Credits","VoxEd by Comanche",MS_OK);

if (Buttons[0]->TestIfPressed()) { PostMessage(main_window_handle,WM_DESTROY,0,0); return(TRUE); } if (Buttons[1]->TestIfPressed()) { Menu.Menu(); return(TRUE); } if(Buttons[30]->TestIfPressed()) { if(Color.redpos<10) Color.redpos=0; else Color.redpos-=10; Color.DrawColors(); } if(Buttons[31]->TestIfPressed()) { if(Color.greenpos<10) Color.greenpos=0; else Color.greenpos-=10; Color.DrawColors(); } if(Buttons[32]->TestIfPressed()) { if(Color.bluepos<10) Color.bluepos=0; else Color.bluepos-=10; Color.DrawColors(); } if(Buttons[33]->TestIfPressed()) { if(Color.redpos>239) Color.redpos=249; else Color.redpos+=10; Color.DrawColors(); } if(Buttons[34]->TestIfPressed()) { if(Color.greenpos>239) Color.greenpos=249; else Color.greenpos+=10; Color.DrawColors(); } if(Buttons[35]->TestIfPressed()) { if(Color.bluepos>239) Color.bluepos=249; else Color.bluepos+=10; Color.DrawColors(); }

Color.TestIfPressed();

if (KeyboardB[0]==219) { Buttons[1]->RedrawPushedButton(); Menu.Menu(); Buttons[1]->RedrawButton(); return(TRUE); } if (KeyboardB[0]==56 && KeyboardB[1]==62) { PostMessage(main_window_handle,WM_DESTROY,0,0); } Graphics.BltToBackBuffer();

Voxel.ViewX=0; Voxel.ViewY=0; Viewports[0]->UseViewport(); Viewports[1]->UseViewport(); Viewports[2]->UseViewport(); Viewports[3]->UseViewport();

HICON icon=Cursor;

Graphics.GetDC(); DrawIcon(Graphics.xdc,MouseX+CursorRegX,MouseY+CursorRegY,icon); Graphics.ReleaseDC();

Graphics.Flip(); return(TRUE); }

return(TRUE); } // end GameMain ////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GameShutdown() { int i; int i2=0; Log.WriteStatusToLogFile("> GameShutdown: Shutting down game");

i2=0; for(i=0;i<128;i++) { if(Liquids[i]) { i2++; delete Liquids[i]; } } sprintf(buffer,"> %d Liquids deleted",i2); Log.WriteToLogFile(buffer);

i2=0; for(i=0;i<60;i++) { if(Buttons[i]) { i2++; delete Buttons[i]; } } sprintf(buffer,"> %d Buttons deleted",i2); Log.WriteToLogFile(buffer);

i2=0; for(i=0;i<20;i++) { if(CheckBoxes[i]) { i2++; delete CheckBoxes[i]; } } sprintf(buffer,"> %d Check Boxes deleted",i2); Log.WriteToLogFile(buffer);

i2=0; for(i=0;i<1024;i++) { if(Textures[i]) { i2++; delete Textures[i]; } } sprintf(buffer,"> %d Textures deleted",i2); Log.WriteToLogFile(buffer);

if(Masks[0]) delete Masks[0]; if(Masks[1]) delete Masks[1]; if(Masks[2]) delete Masks[2]; Log.WriteToLogFile("> 3 Masks deleted");

if(Viewports[0]) delete Viewports[0]; if(Viewports[1]) delete Viewports[1]; if(Viewports[2]) delete Viewports[2]; if(Viewports[3]) delete Viewports[3]; Log.WriteToLogFile("> 4 Viewports deleted");

if (lpddsprimary!=NULL) lpddsprimary->Release(); Log.WriteToLogFile("> Release primary surface: OK"); if(lpddsos1!=NULL) lpddsos1->Release(); Log.WriteToLogFile("> Release off-screen surface: OK");

if (lpdd!=NULL) lpdd->Release(); Log.WriteToLogFile("> Release DirectDraw object: OK");

if (lpdidevice!=NULL) { lpdidevice->Unacquire(); lpdidevice->Release(); lpdidevice=NULL; } Log.WriteToLogFile("> Unacquire mouse: OK"); if(lpdidevice2!=NULL) { lpdidevice2->Unacquire(); lpdidevice2->Release(); lpdidevice2=NULL; } Log.WriteToLogFile("> Unacquire keyboard: OK");

if (lpdi!=NULL) { lpdi->Release(); lpdi=NULL; } Log.WriteToLogFile("> Release DirectInput object: OK");

Log.WriteToLogFile("> GameShutdown: OK"); Log.CloseLogFile();

return(TRUE); } // end GameShutdown ////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GameRestart() { Graphics.RestorePrimarySurface(); Graphics.RestoreOffScreenSurface(); Graphics.BlackQuader(0,0,640,480);

if(Editor==0) { Graphics.Lock(); Graphics.DrawButton(0,0,100,479); Graphics.DrawButton(560,0,639,479); Graphics.DrawPushedButton(13,267,84,338); // MiniMap Graphics.DrawPushedButton(4,215,96,255); for(int i=0;i<96;i++) Graphics.HLine(2+i,2,15,0,0,240-i); Land.InitScreen(); Graphics.UnLock(); Menu.DrawTextures(); Menu.DrawMiniMap(); Log.WriteToLogFile("> Redraw Graphics: OK"); for(i=0;i<30;i++) { if(Buttons[i]) Buttons[i]->RedrawButton(); } for(i=0;i<20;i++) { if(CheckBoxes[i]) CheckBoxes[i]->RedrawCheckBox(); } Graphics.logfont.lfHeight = SMALFONTHEIGHT; Graphics.OSGetDC(); Graphics.Text(50,5,Version); Graphics.OSReleaseDC(); Graphics.logfont.lfHeight = STANDARTFONTHEIGHT; Graphics.BltToBackBuffer(); Graphics.Flip(); return(TRUE); }

if(Editor==1) { Graphics.Lock(); Graphics.DrawButton(0,0,100,479); Graphics.DrawPushedButton(4,215,96,255); Graphics.DrawButton(101,0,369,239); Graphics.DrawButton(370,0,639,239); Graphics.DrawButton(101,240,369,479); Graphics.DrawButton(370,240,639,479); for(int i=0;i<96;i++) Graphics.HLine(2+i,2,15,0,0,200-i); Graphics.UnLock(); Viewports[0]->RedrawViewport(); Viewports[1]->RedrawViewport(); Viewports[2]->RedrawViewport(); Viewports[3]->RedrawViewport(); Log.WriteToLogFile("> Redraw Graphics: OK"); Buttons[0]->RedrawButton(); Buttons[1]->RedrawButton(); for(i=30;i<60;i++) { if(Buttons[i]) Buttons[i]->RedrawButton(); } Graphics.logfont.lfHeight = SMALFONTHEIGHT; Graphics.OSGetDC(); Graphics.Text(50,5,Version); Graphics.OSReleaseDC(); Graphics.logfont.lfHeight = STANDARTFONTHEIGHT; Color.DrawColors(); Graphics.BltToBackBuffer(); Graphics.Flip(); return(TRUE); }

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::MouseInit(HWND hwnd) { if (DirectInputCreate(main_instance,DIRECTINPUT_VERSION,&lpdi,NULL)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Create main DirectInput object"); return(FALSE); } Log.WriteToLogFile("> Create main DirectInput object: OK");

if (lpdi->CreateDevice(GUID_SysMouse,&lpdidevice, NULL)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Create mouse device"); return(FALSE); } Log.WriteToLogFile("> Create mouse device: OK");

if (lpdidevice->SetCooperativeLevel(hwnd,DISCL_EXCLUSIVE | DISCL_FOREGROUND)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Set exclusive cooperative level"); return(FALSE); } Log.WriteToLogFile("> Set exclusive cooperative level: OK");

if (lpdidevice->SetDataFormat(&c_dfDIMouse)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Set mouse data format"); return(FALSE); } Log.WriteToLogFile("> Set mouse data format: OK");

if (lpdidevice->Acquire()!=DI_OK) { Log.WriteErrorToLogFile("> Error: Aquire mouse"); return(FALSE); } Log.WriteToLogFile("> Aquire mouse: OK");

MouseX=320; MouseY=240;

return(TRUE); } // end MouseInit ////////////////////////////////////////////////////////////////////////////////// BOOL CMain::KeyboardInit(HWND hwnd) { if (lpdi->CreateDevice(GUID_SysKeyboard,&lpdidevice2, NULL)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Create keyboard device"); return(FALSE); } Log.WriteToLogFile("> Create keyboard device: OK");

if (lpdidevice2->SetCooperativeLevel(hwnd,DISCL_NONEXCLUSIVE| DISCL_BACKGROUND)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Set exclusive cooperative level"); return(FALSE); } Log.WriteToLogFile("> Set exclusive cooperative level: OK");

if (lpdidevice2->SetDataFormat(&c_dfDIKeyboard)!=DI_OK) { Log.WriteErrorToLogFile("> Error: Set keyboard data format"); return(FALSE); } Log.WriteToLogFile("> Set keyboard data format: OK");

if (lpdidevice2->Acquire()!=DI_OK) { Log.WriteErrorToLogFile("> Error: Aquire keyboard"); return(FALSE); } Log.WriteToLogFile("> Aquire keyboard: OK");

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GetMouseInfo() { HRESULT hresult; hresult = lpdidevice->GetDeviceState(sizeof(DIMOUSESTATE), (LPVOID)&mouse_state); if (hresult==DIERR_INPUTLOST) lpdidevice->Acquire(); else if (hresult!=DI_OK) { Log.WriteErrorToLogFile("> Error: Get device state of mouse"); return(FALSE); }

// move the mouse cursor MouseX=(MouseX+=mouse_state.lX); MouseY=(MouseY+=mouse_state.lY); for(int i=0;i<3;i++) { if (mouse_state.rgbButtons[i]==128) MouseB[i]=1; else MouseB[i]=0; }

// first x boundaries if (MouseX >= SCREEN_WIDTH) MouseX = SCREEN_WIDTH-1; else if (MouseX < 0) MouseX = 0;

// now the y boundaries if (MouseY >= SCREEN_HEIGHT) MouseY= SCREEN_HEIGHT-1; else if (MouseY < 0) MouseY = 0;

return(TRUE); } // end GetMouseInfo ////////////////////////////////////////////////////////////////////////////////// BOOL CMain::CheckMouseRange(int x,int y,int x2,int y2,BOOL Button) { if(Button) { if(MouseX>=x && MouseX<=x2 && MouseY>=y && MouseY<=y2 && MouseB[0]) return(TRUE); } else { if(MouseX>=x && MouseX<=x2 && MouseY>=y && MouseY<=y2) return(TRUE); }

return(FALSE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::GetKeyboardInfo() { HRESULT hresult; hresult = lpdidevice2->GetDeviceState(sizeof(keyboard_state), (LPVOID)&keyboard_state); if (hresult==DIERR_INPUTLOST) lpdidevice2->Acquire(); else if (hresult!=DI_OK) { Log.WriteErrorToLogFile("> Error: Get device state of keyboard"); return(FALSE); }

KeyboardB[0]=0; KeyboardB[1]=0; KeyboardB[2]=0; KeyboardB[3]=0;

int i2=0;

if(keyboard_state[DIK_A] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='A'; i2++; } if(keyboard_state[DIK_B] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='B'; i2++; } if(keyboard_state[DIK_C] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='C'; i2++; } if(keyboard_state[DIK_D] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='D'; i2++; } if(keyboard_state[DIK_E] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='E'; i2++; } if(keyboard_state[DIK_F] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='F'; i2++; } if(keyboard_state[DIK_G] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='G'; i2++; } if(keyboard_state[DIK_H] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='H'; i2++; } if(keyboard_state[DIK_I] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='I'; i2++; } if(keyboard_state[DIK_J] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='J'; i2++; } if(keyboard_state[DIK_K] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='K'; i2++; } if(keyboard_state[DIK_L] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='L'; i2++; } if(keyboard_state[DIK_M] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='M'; i2++; } if(keyboard_state[DIK_N] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='N'; i2++; } if(keyboard_state[DIK_O] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='O'; i2++; } if(keyboard_state[DIK_P] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='P'; i2++; } if(keyboard_state[DIK_Q] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='Q'; i2++; } if(keyboard_state[DIK_R] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='R'; i2++; } if(keyboard_state[DIK_S] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='S'; i2++; } if(keyboard_state[DIK_T] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='T'; i2++; } if(keyboard_state[DIK_U] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='U'; i2++; } if(keyboard_state[DIK_V] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='V'; i2++; } if(keyboard_state[DIK_W] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='W'; i2++; } if(keyboard_state[DIK_X] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='X'; i2++; } if(keyboard_state[DIK_Y] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='Z'; i2++; } if(keyboard_state[DIK_Z] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='Y'; i2++; } if(keyboard_state[DIK_1] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='1'; i2++; } if(keyboard_state[DIK_2] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='2'; i2++; } if(keyboard_state[DIK_3] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='3'; i2++; } if(keyboard_state[DIK_4] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='4'; i2++; } if(keyboard_state[DIK_5] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='5'; i2++; } if(keyboard_state[DIK_6] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='6'; i2++; } if(keyboard_state[DIK_7] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='7'; i2++; } if(keyboard_state[DIK_8] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='8'; i2++; } if(keyboard_state[DIK_9] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='9'; i2++; } if(keyboard_state[DIK_0] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]='0'; i2++; } if(keyboard_state[DIK_ESCAPE] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=27; i2++; } if(keyboard_state[DIK_BACK] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=8; i2++; } if(keyboard_state[DIK_RETURN] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=13; i2++; } if(keyboard_state[DIK_LEFT] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=129; i2++; } if(keyboard_state[DIK_RIGHT] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=130; i2++; } if(keyboard_state[DIK_UP] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=131; i2++; } if(keyboard_state[DIK_DOWN] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=132; i2++; } if((keyboard_state[219] & 0x80) || (keyboard_state[220] & 0x80)) { if(i2>3) return(TRUE); KeyboardB[i2]=219; i2++; } if(keyboard_state[56] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=56; i2++; } if(keyboard_state[62] & 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=62; i2++; }

if((keyboard_state[27] && 0x80) || (keyboard_state[78] && 0x80)) { if(i2>3) return(TRUE); KeyboardB[i2]='+'; i2++; }

if(keyboard_state[53] && 0x80 || (keyboard_state[74] && 0x80)) { if(i2>3) return(TRUE); KeyboardB[i2]='-'; i2++; } if(keyboard_state[211] && 0x80) { if(i2>3) return(TRUE); KeyboardB[i2]=211; i2++; }

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::LoadTextures() { HANDLE SearchHandle; WIN32_FIND_DATA finddata; int NumFiles=0; char name[MAX_PATH];

SearchHandle = FindFirstFile("textures\\*.bmp",&finddata); do { sprintf(buffer,"textures\\%s",finddata.cFileName); Textures[NumFiles] = new CTexture(buffer); NumFiles++; } while(FindNextFile(SearchHandle,&finddata)!=FALSE); FindClose(SearchHandle);

NumTextures=NumFiles;

sprintf(buffer,"> Loaded %d textures",NumFiles); Log.WriteToLogFile(buffer);

Masks[0] = new CTexture("masks\\mask1.msk"); Masks[1] = new CTexture("masks\\mask2.msk"); Masks[2] = new CTexture("masks\\mask3.msk"); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::RenderLiquids() { Icon=Cross;

for(int i=0;i<128;i++) { if(Liquids[i]) { if(!CheckBoxes[3]->State) { if(i!=ActiveLiquid) Liquids[i]->RenderOutline(FALSE); else Liquids[i]->RenderOutline(TRUE); } } }

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMain::CheckLiquids() { ActiveLiquid=-1; if(CheckBoxes[3]->State) return(TRUE);

for(int i=0;i<128;i++) { if(Liquids[i]) { Liquids[i]->CheckMouse(i); } }

return(TRUE); }


Currently browsing [VoxEd.zip] (61,511 bytes) - [CMenu.cpp] - (21,972 bytes)

// CMenu.cpp
// by Comanche

#include "CMenu.h"
#include "CMain.h"
#include "CLog.h"
#include "CButton.h"
#include "CGraphics.h"
#include "CLandScape.h"
#include "CTexture.h"
#include "CViewport.h"
#include "CLiquid.h"

extern CMain GameMain; extern CLog Log; extern CGraphics Graphics; extern CLandScape Land; extern CViewport *Viewports[4]; extern CTexture *Textures[1024];

////////////////////////////////////////////////////////////////////////////////// // main menu functions // ////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::Menu() { Exit=FALSE; Open=TRUE;

MenuButtons[1] = new CButton(101,62,198,82,"Editor >",""); MenuButtons[2] = new CButton(101,20,198,40,"File >",""); MenuButtons[3] = new CButton(101,41,198,61,"Terrain >","");

while(!GameMain.MouseB[0] && !Exit) { GameMain.GetMouseInfo(); GameMain.GetKeyboardInfo();

if(MenuButtons[1]->TestIfPressed()) { Editor(); continue; } if(MenuButtons[2]->TestIfPressed() && GameMain.Editor==0) { File(); continue; } if(MenuButtons[3]->TestIfPressed() && GameMain.Editor==0) { TextureOps(); continue; } if(GameMain.KeyboardB[0]=='E') { MenuButtons[1]->RedrawPushedButton(); Editor(); continue; } if(GameMain.KeyboardB[0]=='F' && GameMain.Editor==0) { MenuButtons[2]->RedrawPushedButton(); File(); continue; } if(GameMain.KeyboardB[0]=='T' && GameMain.Editor==0) { MenuButtons[3]->RedrawPushedButton(); TextureOps(); continue; } if(GameMain.KeyboardB[0]==27) break;

Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); }

if(GameMain.Editor==0) { Graphics.Lock(); Land.FillScreen(101,20,297,104); Graphics.UnLock(); } if(GameMain.Editor==1) { Graphics.Lock(); Graphics.DrawButton(101,0,369,239); Graphics.UnLock(); Viewports[0]->RedrawViewport(); } delete MenuButtons[1]; delete MenuButtons[2]; delete MenuButtons[3];

Open=FALSE; return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::File() { MenuButtons[4] = new CButton(199,20,297,40,"Save File",""); MenuButtons[5] = new CButton(199,41,297,61,"Load File","");

while(!GameMain.MouseB[0] && !Exit) { GameMain.GetMouseInfo(); GameMain.GetKeyboardInfo(); if(GameMain.KeyboardB[0]==27) break; if(GameMain.KeyboardB[0]=='S') SaveMap(); if(GameMain.KeyboardB[0]=='L') LoadMap(); if(MenuButtons[4]->TestIfPressed()) SaveMap(); if(MenuButtons[5]->TestIfPressed()) LoadMap(); Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); }

delete MenuButtons[4]; delete MenuButtons[5]; return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::TextureOps() { MenuButtons[4] = new CButton(199,41,297,61,"Fill Land 32",""); MenuButtons[5] = new CButton(199,62,297,82,"Fill Land 16",""); MenuButtons[6] = new CButton(199,83,297,104,"Fill Land 0",""); while(!GameMain.MouseB[0] && !Exit) { GameMain.GetMouseInfo(); GameMain.GetKeyboardInfo(); if(GameMain.KeyboardB[0]==27) break; if(MenuButtons[4]->TestIfPressed()) FillLand(32); if(MenuButtons[5]->TestIfPressed()) FillLand(16); if(MenuButtons[6]->TestIfPressed()) FillLand(0); Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); }

delete MenuButtons[4]; delete MenuButtons[5]; delete MenuButtons[6]; return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::Editor() { MenuButtons[4] = new CButton(199,62,297,82,"Land",""); MenuButtons[5] = new CButton(199,83,297,103,"Voxel","");

while(!GameMain.MouseB[0] && !Exit) { GameMain.GetMouseInfo(); GameMain.GetKeyboardInfo(); if(GameMain.KeyboardB[0]==27) break; if(MenuButtons[4]->TestIfPressed()) SetEditor(0); if(MenuButtons[5]->TestIfPressed()) SetEditor(1); if(GameMain.KeyboardB[0]=='L') SetEditor(0); if(GameMain.KeyboardB[0]=='V') SetEditor(1); Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); }

delete MenuButtons[4]; delete MenuButtons[5];

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::FillLand(int height) { Exit=TRUE;

if(Selection==-1) return(TRUE);

int x,x2,y,y2; RGBTRIPLE color; BYTE red,green,blue; DWORD buffer2; int Pos=ScrolPos+Selection; int percent;

if(Textures[Pos]->isfailure) return(TRUE);

for(int i=0;i<2000;i++) { for(int i2=0;i2<2000;i2++) { x=i/Textures[Pos]->width; y=i2/Textures[Pos]->height; x2=i-(x*Textures[Pos]->width); y2=i2-(y*Textures[Pos]->height);

color=Textures[Pos]->GetPixel(x2,y2); red=color.rgbtRed; green=color.rgbtGreen; blue=color.rgbtBlue; buffer2=(((height)<<24)|((red)<<16)|((green)<<8)|(blue)); Land.Landscape[i][i2]=buffer2; } }

Land.InitScreen(); CreateMiniMap(); DrawMiniMap();

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::SetEditor(int editor) { Exit=TRUE;

if(editor==GameMain.Editor) return(TRUE);

GameMain.Editor=editor; GameMain.GameRestart();

return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// // MiniMap functions // ////////////////////////////////////////////////////////////////////////////////// void CMenu::CreateMiniMap() { int red=0,green=0,blue=0; int counter=0; BYTE *pointer;

for(BYTE x=0;x<64;x++) for(BYTE y=0;y<64;y++) { counter=0; red=0;green=0;blue=0; for(int i=0;i<32;i++) for(int i2=0;i2<32;i2++) { counter++; pointer=(BYTE*)&Land.Landscape[x+i][y+i2]; blue+=*pointer; green+=*(++pointer); red+=*(++pointer); } MiniMapR[x][y]=red/counter; MiniMapG[x][y]=green/counter; MiniMapB[x][y]=blue/counter; } }

////////////////////////////////////////////////////////////////////////////////// void CMenu::DrawMiniMap() { for(int x=0;x<64;x++) for(int y=0;y<64;y++) { Graphics.Lock(); Graphics.PutPixel(17+x,y+271, MiniMapR[x][y], MiniMapG[x][y], MiniMapB[x][y]); Graphics.UnLock(); } }

////////////////////////////////////////////////////////////////////////////////// // texture menu funktions // //////////////////////////////////////////////////////////////////////////////////

void CMenu::DrawTextures() { int red=0,green=0,blue=0; RGBTRIPLE color; int colord=0; int counter=0; Graphics.logfont.lfHeight = TEXTUREFONTHEIGHT; Graphics.textcolor.rgbtRed = 192; Graphics.textcolor.rgbtGreen = 192; Graphics.textcolor.rgbtBlue = 192;

for(int i=0;i<7;i++) {

int TexPos=i+ScrolPos; int PosX=573; int PosY=9+(65*i);

Graphics.BlackQuader(PosX,PosY,PosX+64,PosY+64);

Graphics.Lock(); if(!Textures[TexPos]) continue; if(Textures[TexPos]->isfailure) continue;

if(Textures[TexPos]->width<=64 && Textures[TexPos]->height<=64) {

for(int x=0;x<Textures[TexPos]->width;x++) for(int y=0;y<Textures[TexPos]->height;y++) { color=Textures[TexPos]->GetPixel(x,y); Graphics.PutPixel(PosX+x,PosY+y,color.rgbtRed, color.rgbtGreen,color.rgbtBlue); } }

else { int scale=0;

if(Textures[TexPos]->width>Textures[TexPos]->height) scale=Textures[TexPos]->width/64; else scale=Textures[TexPos]->height/64;

for(int x=0;x<Textures[TexPos]->width;x++) for(int y=0;y<Textures[TexPos]->height;y++) { counter=0; red=0;green=0;blue=0; for(int i=0;i<scale;i++) for(int i2=0;i2<scale;i2++) { if(Textures[TexPos]->width>(x+i) && Textures[TexPos]->height>(y+i2)) { counter++; color=Textures[TexPos]->GetPixel(x+i,y+i2); red=red+color.rgbtRed; green=green+color.rgbtGreen; blue=blue=blue+color.rgbtBlue; } } red=red/counter; green=green/counter; blue=blue/counter;

Graphics.PutPixel(PosX+x/scale,PosY+y/scale,red,green,blue);

} }

Graphics.UnLock();

Graphics.OSGetLaDC(); Graphics.Text(PosX+2,PosY+2,Textures[TexPos]->Name); Graphics.OSReleaseDC();

} // end for Graphics.textcolor.rgbtRed = 0; Graphics.textcolor.rgbtGreen = 0; Graphics.textcolor.rgbtBlue = 0; Graphics.logfont.lfHeight = STANDARTFONTHEIGHT; }

////////////////////////////////////////////////////////////////////////////////// // file menu functions // ////////////////////////////////////////////////////////////////////////////////// void CMenu::SaveMap() { while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo();

int mfh; OFSTRUCT map_file_data;

Exit=TRUE;

Graphics.Lock(); Land.FillScreen(101,20,297,82); Graphics.DrawButton(101,450,559,479); Graphics.DrawPushedButton(110,455,550,475); Graphics.UnLock();

int i=0; GameMain.GetKeyboardInfo(); sprintf(buffer,"");

while(GameMain.KeyboardB[0]!=13) { GameMain.GetKeyboardInfo();

if(GameMain.KeyboardB[0]==8) { if(i==0) continue; buffer[i-1]=0; i--; while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo(); } if(GameMain.KeyboardB[0]==27) { Graphics.Lock(); Land.FillScreen(101,450,559,479); Graphics.UnLock(); return; }

if(GameMain.KeyboardB[0]!=0) { if(i>20) continue; if(GameMain.KeyboardB[0]==27) continue; if(GameMain.KeyboardB[0]==8) continue; buffer[i]=GameMain.KeyboardB[0]; buffer[i+1]=0; i++; while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo(); }

GameMain.GetMouseInfo(); Graphics.BltToBackBuffer(); Graphics.GetLaDC(); Graphics.Text(114,458,buffer); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip();

GameMain.GetKeyboardInfo(); }

Graphics.Lock(); Land.FillScreen(101,450,559,479); Graphics.UnLock(); Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Clock); Graphics.ReleaseDC(); Graphics.Flip();

if(!buffer[0]) return;

char filename[80]; sprintf(filename,"MAPS\\%s.VMP",buffer); mfh = OpenFile(filename,&map_file_data,OF_CREATE);

if(mfh == HFILE_ERROR) { sprintf(buffer,"> Error: Saving %s",filename); Log.WriteErrorToLogFile(buffer); return; } _lwrite(mfh,"PEVoxEd Map 1.1",strlen("PEVoxEd Map 1.0"));

_lwrite(mfh,(CHAR *)&Land.Day,sizeof(BOOL));

_lwrite(mfh,(CHAR *)&Land.Landscape,sizeof(Land.Landscape));

_close(mfh);

sprintf(buffer,"> Saved File: %s",filename); Log.WriteToLogFile(buffer);

sprintf(buffer,""); }

////////////////////////////////////////////////////////////////////////////////// void CMenu::LoadMap() { while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo();

int mfh; OFSTRUCT map_file_data;

BOOL Cursor=TRUE; char buffer2[80];

Exit=TRUE;

Graphics.Lock(); Land.FillScreen(101,20,297,82); Graphics.DrawButton(101,450,559,479); Graphics.DrawPushedButton(110,455,550,475); Graphics.UnLock();

int i=0; GameMain.GetKeyboardInfo(); sprintf(buffer,"");

while(GameMain.KeyboardB[0]!=13) { GameMain.GetKeyboardInfo();

if(GameMain.KeyboardB[0]==8) { if(i==0) continue; buffer[i-1]=0; i--; while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo(); }

if(GameMain.KeyboardB[0]==27) { Graphics.Lock(); Land.FillScreen(101,450,559,479); Graphics.UnLock(); return; } if(GameMain.KeyboardB[0]!=0) { if(i>20) continue; if(GameMain.KeyboardB[0]==27) continue; if(GameMain.KeyboardB[0]==8) continue; buffer[i]=GameMain.KeyboardB[0]; buffer[i+1]=0; i++; while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo(); }

GameMain.GetMouseInfo(); Graphics.BltToBackBuffer(); Graphics.GetLaDC(); Graphics.Text(114,458,buffer); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip();

GameMain.GetKeyboardInfo(); }

if(!buffer[0]) { Graphics.Lock(); Land.FillScreen(101,450,559,479); Graphics.UnLock(); return; }

Graphics.Lock(); Land.FillScreen(101,450,559,479); Graphics.UnLock(); Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Clock); Graphics.ReleaseDC(); Graphics.Flip();

char filename[80]; sprintf(filename,"MAPS\\%s.VMP",buffer); mfh = OpenFile(filename,&map_file_data,OF_READ); if(mfh == HFILE_ERROR) { _close(mfh); sprintf(buffer,"> Error: Reading %s",filename); Log.WriteErrorToLogFile(buffer); Graphics.Lock(); Land.FillScreen(101,450,559,479); Graphics.UnLock(); MessageBox("Error","Can't read file",MS_OK);

return; }

ZeroMemory(buffer,sizeof(buffer));

_lread(mfh,(LPVOID)buffer,strlen("PEVoxEd Map 1.0")); if(strcmp(buffer,"PEVoxEd Map 1.0")==0) { Land.Day=TRUE;

_lread(mfh,&Land.Landscape,sizeof(Land.Landscape));

_close(mfh);

sprintf(buffer,"> Loaded File: %s",filename); Log.WriteToLogFile(buffer); } else if(strcmp(buffer,"PEVoxEd Map 1.1")==0) { if(_lread(mfh,&Land.Day,sizeof(BOOL))==HFILE_ERROR) Log.WriteErrorToLogFile("> Error");

if(_lread(mfh,&Land.Landscape,sizeof(Land.Landscape))==HFILE_ERROR) Log.WriteErrorToLogFile("> Error");

_close(mfh);

sprintf(buffer,"> Loaded File: %s",filename); Log.WriteToLogFile(buffer); } else { _close(mfh); sprintf(buffer,"> %s: Not a PEVoxEd Map",filename); Log.WriteErrorToLogFile(buffer);

MessageBox("Error","Can't read file",MS_OK);

return; }

Graphics.Lock(); Land.InitScreen(); CreateMiniMap(); DrawMiniMap(); Graphics.UnLock(); }

////////////////////////////////////////////////////////////////////////////////// void CMenu::DrawTextures(int TexPos) { int red=0,green=0,blue=0; RGBTRIPLE color; int colord=0; int counter=0; Graphics.logfont.lfHeight = TEXTUREFONTHEIGHT; Graphics.textcolor.rgbtRed = 192; Graphics.textcolor.rgbtGreen = 192; Graphics.textcolor.rgbtBlue = 192;

int PosX=573; int PosY=9+(65*TexPos); TexPos=TexPos+ScrolPos;

Graphics.BlackQuader(PosX,PosY,PosX+64,PosY+64);

Graphics.Lock(); if(!Textures[TexPos]) return; if(Textures[TexPos]->isfailure) return;

if(Textures[TexPos]->width<=64 && Textures[TexPos]->height<=64) { for(int x=0;x<Textures[TexPos]->width;x++) for(int y=0;y<Textures[TexPos]->height;y++) { color=Textures[TexPos]->GetPixel(x,y); Graphics.PutPixel(PosX+x,PosY+y,color.rgbtRed, color.rgbtGreen,color.rgbtBlue); } }

else { int scale; if(Textures[TexPos]->width>Textures[TexPos]->height) scale=Textures[TexPos]->width/64; else scale=Textures[TexPos]->height/64; for(int x=0;x<Textures[TexPos]->width;x++) for(int y=0;y<Textures[TexPos]->height;y++) { counter=0; red=0;green=0;blue=0; for(int i=0;i<scale;i++) for(int i2=0;i2<scale;i2++) { if(Textures[TexPos]->width>(x+i) && Textures[TexPos]->height>(y+i2)) { counter++; color=Textures[TexPos]->GetPixel(x+i,y+i2); red=red+color.rgbtRed; green=green+color.rgbtGreen; blue=blue=blue+color.rgbtBlue; } } red=red/counter; green=green/counter; blue=blue/counter; Graphics.PutPixel(PosX+x/scale,PosY+y/scale,red,green,blue); } } Graphics.UnLock();

Graphics.OSGetLaDC(); Graphics.Text(PosX+2,PosY+2,Textures[TexPos]->Name); Graphics.OSReleaseDC();

Graphics.textcolor.rgbtRed = 0; Graphics.textcolor.rgbtGreen = 0; Graphics.textcolor.rgbtBlue = 0; Graphics.logfont.lfHeight = STANDARTFONTHEIGHT; }

////////////////////////////////////////////////////////////////////////////////// void CMenu::DrawSelected(int TexPos) { int red=0,green=0,blue=0; RGBTRIPLE color; int colord=0; int counter=0; Graphics.logfont.lfHeight = TEXTUREFONTHEIGHT; Graphics.textcolor.rgbtRed = 192; Graphics.textcolor.rgbtGreen = 192; Graphics.textcolor.rgbtBlue = 192;

int PosX=573; int PosY=9+(65*TexPos); TexPos=TexPos+ScrolPos;

Graphics.BlackQuader(PosX,PosY,PosX+64,PosY+64); Graphics.Lock(); if(!Textures[TexPos]) return; if(Textures[TexPos]->isfailure) return;

if(Textures[TexPos]->width<=64 && Textures[TexPos]->height<=64) { for(int x=0;x<Textures[TexPos]->width;x++) for(int y=0;y<Textures[TexPos]->height;y++) { color=Textures[TexPos]->GetPixel(x,y); blue=color.rgbtBlue; if(blue>=205) blue=255; else blue+=50; Graphics.PutPixel(PosX+x,PosY+y,color.rgbtRed, color.rgbtGreen,blue); } }

else { int scale; if(Textures[TexPos]->width>Textures[TexPos]->height) scale=Textures[TexPos]->width/64; else scale=Textures[TexPos]->height/64; for(int x=0;x<Textures[TexPos]->width;x++) for(int y=0;y<Textures[TexPos]->height;y++) { counter=0; red=0;green=0;blue=0; for(int i=0;i<scale;i++) for(int i2=0;i2<scale;i2++) { if(Textures[TexPos]->width>(x+i) && Textures[TexPos]->height>(y+i2)) { counter++; color=Textures[TexPos]->GetPixel(x+i,y+i2); red=red+color.rgbtRed; green=green+color.rgbtGreen; blue=blue+color.rgbtBlue; } } red=red/counter; green=green/counter; blue=blue/counter; if(blue>=205) blue=255; else blue+=50; Graphics.PutPixel(PosX+x/scale,PosY+y/scale,red,green,blue); } } Graphics.UnLock();

Graphics.OSGetLaDC(); Graphics.Text(PosX+2,PosY+2,Textures[TexPos]->Name); Graphics.OSReleaseDC();

Graphics.textcolor.rgbtRed = 0; Graphics.textcolor.rgbtGreen = 0; Graphics.textcolor.rgbtBlue = 0; Graphics.logfont.lfHeight = STANDARTFONTHEIGHT; }

////////////////////////////////////////////////////////////////////////////////// void CMenu::SelectTexture() { while(GameMain.MouseB[0]) GameMain.GetMouseInfo(); int y=GameMain.MouseY-8; y=y/65; // if(y>=GameMain.NumTextures) return; if(Selection>=0) DrawTextures(Selection); Selection=y; DrawSelected(y); }

////////////////////////////////////////////////////////////////////////////////// void CMenu::ScrollUp() { if(GameMain.NumTextures<8) return; if(ScrolPos==0) return; Selection=-1; if(ScrolPos!=1) { ScrolPos-=2; Graphics.Blt(573,9,637,334,0,130); DrawTextures(0); DrawTextures(1); } else { ScrolPos-=1; Graphics.Blt(573,9,637,399,0,65); DrawTextures(0); } }

////////////////////////////////////////////////////////////////////////////////// void CMenu::ScrollDown() { if(GameMain.NumTextures<8) return; if(ScrolPos+8>GameMain.NumTextures) return; if(ScrolPos+8>1024) return; Selection=-1; if(ScrolPos+9>GameMain.NumTextures) { ScrolPos+=1; Graphics.Blt(573,74,637,464,0,-65); DrawTextures(6); } else { ScrolPos+=2; Graphics.Blt(573,139,637,464,0,-130); DrawTextures(5); DrawTextures(6); } }

////////////////////////////////////////////////////////////////////////////////// // Message Box functions // ////////////////////////////////////////////////////////////////////////////////// BOOL CMenu::MessageBox(char *caption,char *string,int ms) { Exit=FALSE; State=FALSE; BOOL Status7=FALSE;

if(GameMain.Status2==7) { GameMain.Status2=1; Status7=TRUE; }

while(GameMain.KeyboardB[0]) GameMain.GetKeyboardInfo();

if(!Graphics.StoreScreenArea(230,150,430,230)) return(FALSE);

Graphics.Lock(); Graphics.DrawButton(230,150,430,230); for(int i=0;i<98;i++) { Graphics.FullQuader(232+i*2,152,234+i*2,166,0,0,200-i); } Graphics.UnLock();

Graphics.OSGetLaDC(); Graphics.Text(234,151,caption); Graphics.OSReleaseDC(); Graphics.OSGetDC(); Graphics.Text(330,177,string); Graphics.OSReleaseDC(); if(ms==MS_OK) { MenuButtons[0] = new CButton(290,200,370,220,"OK",""); } if(ms==MS_YESNO) { MenuButtons[0] = new CButton(260,200,320,220,"Yes",""); MenuButtons[1] = new CButton(340,200,400,220,"No",""); }

while(!Exit) { GameMain.GetMouseInfo(); GameMain.GetKeyboardInfo();

if(GameMain.KeyboardB[0]==13) { State=TRUE; Exit=TRUE; } if(ms==MS_OK) if(MenuButtons[0]->TestIfPressed()) Exit=TRUE; if(ms==MS_YESNO) { if(MenuButtons[0]->TestIfPressed()) { State=TRUE; Exit=TRUE; } if(MenuButtons[1]->TestIfPressed()) { State=FALSE; Exit=TRUE; } } Graphics.BltToBackBuffer(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX,GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); }

if(ms==MS_OK) { delete MenuButtons[0]; } if(ms==MS_YESNO) { delete MenuButtons[0]; delete MenuButtons[1]; }

if(!Graphics.RestoreScreenArea()) return(FALSE); if(Status7==TRUE) { GameMain.Status2=7; }

return(State); }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CTexture.cpp] - (3,841 bytes)

// CTexture.cpp
// by Comanche

#include "CTexture.h"
#include "CLog.h"

extern CLog Log;

////////////////////////////////////////////////////////////////////////////////// CTexture::CTexture(char *filename) { tfh = OpenFile(filename,&file_data,OF_READ);

int i=0; while(filename[i]!=0) { if(filename[i]=='\\') { i++; break; } i++; } strcpy(Name,&filename[i]); if(!strcmp(filename,"")) { isfailure=TRUE; return; }

if(tfh==HFILE_ERROR) { isfailure=TRUE; sprintf(buffer,"> Error: Reading %s (doesn't exist)",filename); Log.WriteErrorToLogFile(buffer); return; }

_lread(tfh,&bitmap.bitmapfileheader,sizeof(BITMAPFILEHEADER));

if (bitmap.bitmapfileheader.bfType!=BITMAP_ID) { isfailure=TRUE; sprintf(buffer,"> Error: Reading %s (not a bitmap)",filename); Log.WriteErrorToLogFile(buffer); _close(tfh); return; }

_lread(tfh,&bitmap.bitmapinfoheader,sizeof(BITMAPINFOHEADER));

if (bitmap.bitmapinfoheader.biBitCount!=8 && bitmap.bitmapinfoheader.biBitCount!=24) { isfailure=TRUE; sprintf(buffer,"> Error: Reading %s (not 8 or 24 bit)",filename); Log.WriteErrorToLogFile(buffer); _close(tfh); return; }

if (bitmap.bitmapinfoheader.biWidth>256 || bitmap.bitmapinfoheader.biHeight>256) { isfailure=TRUE; sprintf(buffer,"> Error: Reading %s (over 256x256)",filename); Log.WriteErrorToLogFile(buffer); _close(tfh); return; } if(bitmap.bitmapinfoheader.biWidth%32!=0 && bitmap.bitmapinfoheader.biHeight%32!=0) { isfailure=TRUE; sprintf(buffer,"> Error: Reading %s",filename); Log.WriteErrorToLogFile(buffer); _close(tfh); return; }

if(bitmap.bitmapinfoheader.biCompression!=BI_RGB) { isfailure=TRUE; sprintf(buffer,"> Error: Reading %s (is compressed)",filename); Log.WriteErrorToLogFile(buffer); _close(tfh); return; }

if (bitmap.bitmapinfoheader.biBitCount==8) { int NumColor=256; if(bitmap.bitmapinfoheader.biClrUsed!=0) NumColor=bitmap.bitmapinfoheader.biClrUsed; _lread(tfh, &bitmap.palette,NumColor*sizeof(PALETTEENTRY)); for (int index=0; index < NumColor; index++) { int temp_color = bitmap.palette[index].peRed; bitmap.palette[index].peRed = bitmap.palette[index].peBlue; bitmap.palette[index].peBlue = temp_color; bitmap.palette[index].peFlags = PC_NOCOLLAPSE; } }

_lseek(tfh,-(int)(bitmap.bitmapinfoheader.biSizeImage),SEEK_END); if (!(bitmap.buffer = (UCHAR *)malloc(bitmap.bitmapinfoheader.biSizeImage))) { sprintf(buffer,"> Error: Reading %s",filename); Log.WriteErrorToLogFile(buffer); _close(tfh); return; }

_lread(tfh,bitmap.buffer,bitmap.bitmapinfoheader.biSizeImage); width = bitmap.bitmapinfoheader.biWidth; height = bitmap.bitmapinfoheader.biHeight; bitcount = bitmap.bitmapinfoheader.biBitCount;

isfailure=FALSE; _close(tfh); }

////////////////////////////////////////////////////////////////////////////////// CTexture::~CTexture() { free(bitmap.buffer); }

////////////////////////////////////////////////////////////////////////////////// RGBTRIPLE CTexture::GetPixel(int x, int y) { RGBTRIPLE color; if(bitcount==24) { int pos=(x*3)+((height-y-1)*width*3); color.rgbtRed=bitmap.buffer[pos+2]; color.rgbtGreen=bitmap.buffer[pos+1]; color.rgbtBlue=bitmap.buffer[pos]; return(color); } else if(bitcount==8) { int pos=x+((height-y-1)*width); BYTE index=bitmap.buffer[pos]; color.rgbtRed=bitmap.palette[index].peRed; color.rgbtGreen=bitmap.palette[index].peGreen; color.rgbtBlue=bitmap.palette[index].peBlue; return(color); } color.rgbtBlue=255; // Dummies for Compiler color.rgbtGreen=255; color.rgbtRed=255; return(color); }


Currently browsing [VoxEd.zip] (61,511 bytes) - [CTime.cpp] - (449 bytes)

// CTime.cpp
// by Comanche

#include "CTime.h"

////////////////////////////////////////////////////////////////////////////////// int CTime::GetFPS(int FrameTime) { if(!FrameTime) return(0); return(1000/FrameTime); }

////////////////////////////////////////////////////////////////////////////////// int CTime::GetFrameTime() { FrameTime=timeGetTime()-LastFrameTime; LastFrameTime=timeGetTime(); return(FrameTime); }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CViewport.cpp] - (8,252 bytes)

// CViewport.cpp
// by Comanche

#include "CViewport.h"
#include "CMain.h"
#include "CGraphics.h"
#include "CButton.h"
#include "CLog.h"
#include "CVoxel.h"
#include "CColor.h"

extern CMain GameMain; extern CGraphics Graphics; extern CLog Log; extern CVoxel Voxel; extern CColor Color;

////////////////////////////////////////////////////////////////////////////////// CViewport::CViewport(int x,int y,int M) { Vx=x; Vy=y; Vx2=Vx+195; Vy2=Vy+195; Mode=M; Voxel.FrontPos=48;

if(Mode!=VIEWPORT3D) { ViewportButtons[0] = new CButton(x+200,y,x+210,y+98,"",""); ViewportButtons[1] = new CButton(x+200,y+99,x+210,y+196,"",""); } }

////////////////////////////////////////////////////////////////////////////////// CViewport::~CViewport() { if(Mode!=VIEWPORT3D) { delete ViewportButtons[0]; delete ViewportButtons[1]; } }

////////////////////////////////////////////////////////////////////////////////// void CViewport::UseViewport() { if(Mode!=VIEWPORT3D) { if(ViewportButtons[0]->TestIfPressed()) { if(Mode==VIEWPORTTOP) if(Voxel.TopPos>0) { Voxel.TopPos--; Graphics.Lock(); for(int i=0;i<49;i++) for(int i2=0;i2<49;i2++) { Graphics.FullQuader(Vx+(i*4)+1,Vy+(i2*4)+1, Vx+(i*4)+3,Vy+(i2*4)+3, Voxel.Voxels[i][i2][Voxel.TopPos].rgbtRed, Voxel.Voxels[i][i2][Voxel.TopPos].rgbtGreen, Voxel.Voxels[i][i2][Voxel.TopPos].rgbtBlue); } Graphics.UnLock(); } if(Mode==VIEWPORTFRONT) if(Voxel.FrontPos>0) { Voxel.FrontPos--; Graphics.Lock(); for(int i=0;i<49;i++) for(int i2=0;i2<49;i2++) { Graphics.FullQuader(Vx+(i*4)+1,Vy+(i2*4)+1, Vx+(i*4)+3,Vy+(i2*4)+3, Voxel.Voxels[Voxel.FrontPos][i][i2].rgbtRed, Voxel.Voxels[Voxel.FrontPos][i][i2].rgbtGreen, Voxel.Voxels[Voxel.FrontPos][i][i2].rgbtBlue); } Graphics.UnLock(); } if(Mode==VIEWPORTLEFT) { if(Voxel.LeftPos>0) { Voxel.LeftPos--; Graphics.Lock(); for(int i=0;i<49;i++) for(int i2=0;i2<49;i2++) { Graphics.FullQuader(Vx+(i*4)+1,Vy+(i2*4)+1, Vx+(i*4)+3,Vy+(i2*4)+3, Voxel.Voxels[i][Voxel.LeftPos][i2].rgbtRed, Voxel.Voxels[i][Voxel.LeftPos][i2].rgbtGreen, Voxel.Voxels[i][Voxel.LeftPos][i2].rgbtBlue); } Graphics.UnLock(); } } }

////////////////////////////////////////////////////////////////////// if(ViewportButtons[1]->TestIfPressed()) { if(Mode==VIEWPORTTOP) if(Voxel.TopPos<48) { Voxel.TopPos++; Graphics.Lock(); for(int i=0;i<49;i++) for(int i2=0;i2<49;i2++) { Graphics.FullQuader(Vx+(i*4)+1,Vy+(i2*4)+1, Vx+(i*4)+3,Vy+(i2*4)+3, Voxel.Voxels[i][i2][Voxel.TopPos].rgbtRed, Voxel.Voxels[i][i2][Voxel.TopPos].rgbtGreen, Voxel.Voxels[i][i2][Voxel.TopPos].rgbtBlue); } Graphics.UnLock(); } if(Mode==VIEWPORTFRONT) if(Voxel.FrontPos<48) { Voxel.FrontPos++; Graphics.Lock(); for(int i=0;i<49;i++) for(int i2=0;i2<49;i2++) { Graphics.FullQuader(Vx+(i*4)+1,Vy+(i2*4)+1, Vx+(i*4)+3,Vy+(i2*4)+3, Voxel.Voxels[Voxel.FrontPos][i][i2].rgbtRed, Voxel.Voxels[Voxel.FrontPos][i][i2].rgbtGreen, Voxel.Voxels[Voxel.FrontPos][i][i2].rgbtBlue); } Graphics.UnLock(); } if(Mode==VIEWPORTLEFT) if(Voxel.LeftPos<48) { Voxel.LeftPos++; Graphics.Lock(); for(int i=0;i<49;i++) for(int i2=0;i2<49;i2++) { Graphics.FullQuader(Vx+(i*4)+1,Vy+(i2*4)+1, Vx+(i*4)+3,Vy+(i2*4)+3, Voxel.Voxels[i][Voxel.LeftPos][i2].rgbtRed, Voxel.Voxels[i][Voxel.LeftPos][i2].rgbtGreen, Voxel.Voxels[i][Voxel.LeftPos][i2].rgbtBlue); } Graphics.UnLock(); } } }

if(Mode==VIEWPORTLEFT) { Graphics.Lock(); Graphics.FullQuader(Vx+(Voxel.FrontPos*4)-4,Vy+199, Vx+(Voxel.FrontPos*4)+7,Vy+203,150,150,150); Graphics.FullQuader(Vx+(Voxel.FrontPos*4)+1,Vy+199, Vx+(Voxel.FrontPos*4)+2,Vy+203,100,100,100); Graphics.VLine(Vx+(Voxel.FrontPos*4),Vy+200,3,100,100,100);

Graphics.FullQuader(Vx-7,Vy+(Voxel.TopPos*4)-4, Vx-3,Vy+(Voxel.TopPos*4)+7,150,150,150); Graphics.FullQuader(Vx-7,Vy+(Voxel.TopPos*4)+1, Vx-3,Vy+(Voxel.TopPos*4)+2,100,100,100); Graphics.HLine(Vx-4,Vy+(Voxel.TopPos*4),3,100,100,100); Graphics.UnLock(); if(GameMain.CheckMouseRange(Vx,Vy,Vx2,Vy2,FALSE)) { if((GameMain.MouseX-Vx)%4!=0 && (GameMain.MouseY-Vy)%4!=0) { Voxel.ViewX=(GameMain.MouseX-Vx)/4; Voxel.ViewY=(GameMain.MouseY-Vy)/4;

if(GameMain.MouseB[0]) { Voxel.Voxels[Voxel.ViewX][Voxel.LeftPos][Voxel.ViewY] = Color.color; Graphics.Lock(); Graphics.FullQuader(Vx+(Voxel.ViewX*4)+1,Vy+(Voxel.ViewY*4)+1, Vx+(Voxel.ViewX*4)+3,Vy+(Voxel.ViewY*4)+3, Color.color.rgbtRed,Color.color.rgbtGreen, Color.color.rgbtBlue); Graphics.UnLock(); } } }

return; }

if(Mode==VIEWPORTTOP) { Graphics.Lock(); Graphics.FullQuader(Vx+(Voxel.LeftPos*4)-4,Vy+199, Vx+(Voxel.LeftPos*4)+7,Vy+203,150,150,150); Graphics.FullQuader(Vx+(Voxel.LeftPos*4)+1,Vy+199, Vx+(Voxel.LeftPos*4)+2,Vy+203,100,100,100); Graphics.VLine(Vx+(Voxel.LeftPos*4),Vy+200,3,100,100,100); Graphics.FullQuader(Vx-7,Vy+(Voxel.FrontPos*4)-4, Vx-3,Vy+(Voxel.FrontPos*4)+7,150,150,150); Graphics.FullQuader(Vx-7,Vy+(Voxel.FrontPos*4)+1, Vx-3,Vy+(Voxel.FrontPos*4)+2,100,100,100); Graphics.HLine(Vx-4,Vy+(Voxel.FrontPos*4),3,100,100,100); Graphics.UnLock();

if(GameMain.CheckMouseRange(Vx,Vy,Vx2,Vy2,FALSE)) { if((GameMain.MouseX-Vx)%4!=0 && (GameMain.MouseY-Vy)%4!=0) { Voxel.ViewX=(GameMain.MouseX-Vx)/4; Voxel.ViewY=(GameMain.MouseY-Vy)/4; if(GameMain.MouseB[0]) { Voxel.Voxels[Voxel.ViewY][Voxel.ViewX][Voxel.TopPos] = Color.color; Graphics.Lock(); Graphics.FullQuader(Vx+(Voxel.ViewX*4)+1,Vy+(Voxel.ViewY*4)+1, Vx+(Voxel.ViewX*4)+3,Vy+(Voxel.ViewY*4)+3, Color.color.rgbtRed,Color.color.rgbtGreen, Color.color.rgbtBlue); Graphics.UnLock(); } } }

return; }

if(Mode==VIEWPORTFRONT) { Graphics.Lock(); Graphics.FullQuader(Vx+(Voxel.LeftPos*4)-4,Vy+199, Vx+(Voxel.LeftPos*4)+7,Vy+203,150,150,150); Graphics.FullQuader(Vx+(Voxel.LeftPos*4)+1,Vy+199, Vx+(Voxel.LeftPos*4)+2,Vy+203,100,100,100); Graphics.VLine(Vx+(Voxel.LeftPos*4),Vy+200,3,100,100,100);

Graphics.FullQuader(Vx-7,Vy+(Voxel.TopPos*4)-4, Vx-3,Vy+(Voxel.TopPos*4)+7,150,150,150); Graphics.FullQuader(Vx-7,Vy+(Voxel.TopPos*4)+1, Vx-3,Vy+(Voxel.TopPos*4)+2,100,100,100); Graphics.HLine(Vx-4,Vy+(Voxel.TopPos*4),3,100,100,100); Graphics.UnLock();

if(GameMain.CheckMouseRange(Vx,Vy,Vx2,Vy2,FALSE)) { if((GameMain.MouseX-Vx)%4!=0 && (GameMain.MouseY-Vy)%4!=0) { Voxel.ViewX=(GameMain.MouseX-Vx)/4; Voxel.ViewY=(GameMain.MouseY-Vy)/4; } }

return; }

if(Mode==VIEWPORT3D) { return; } }

////////////////////////////////////////////////////////////////////////////////// void CViewport::RedrawViewport() { Graphics.BlackQuader(Vx+1,Vy+1,Vx+196,Vy+196); Graphics.Lock(); Graphics.Quader(Vx,Vy,Vx+196,Vy+196,120,120,120); Graphics.UnLock(); Graphics.OSGetDC(); if (Mode==VIEWPORT3D) Graphics.Text(Vx+98,Vy-16,"3D"); if (Mode==VIEWPORTFRONT) Graphics.Text(Vx+98,Vy-16,"Front"); if (Mode==VIEWPORTLEFT) Graphics.Text(Vx+98,Vy-16,"Left"); if (Mode==VIEWPORTTOP) Graphics.Text(Vx+98,Vy-16,"Top"); Graphics.OSReleaseDC();

if(Mode!=VIEWPORT3D) { ViewportButtons[0]->RedrawButton(); ViewportButtons[1]->RedrawButton(); } }

Currently browsing [VoxEd.zip] (61,511 bytes) - [CVoxel.cpp] - (160 bytes)

// CVoxel.cpp
// by Comanche

#include "CVoxel.h"
#include "CMain.h"

//////////////////////////////////////////////////////////////////////////////////

Currently browsing [VoxEd.zip] (61,511 bytes) - [PEVoxEd.cpp] - (5,472 bytes)

// PEVoxEd.cpp
// by Comanche

#include "defines.h"
#include "CMain.h"
#include "CLog.h"
#include "CGraphics.h"
#include "CButton.h"
#include "CLandScape.h"
#include "CMenu.h"
#include "CTime.h"
#include "CTexture.h"
#include "CViewport.h"
#include "CColor.h"
#include "CVoxel.h"
#include "CLiquid.h"
#include "CCheckBox.h"

////////////////////////////////////////////////////////////////////////////////// CMain GameMain; CLog Log; CGraphics Graphics; CLandScape Land; CMenu Menu; CTime Time; CColor Color; CButton *Buttons[60]; CCheckBox *CheckBoxes[20]; CViewport *Viewports[4]; CTexture *Textures[1024]; CLiquid *Liquids[128]; CTexture *Masks[3]; CVoxel Voxel;

////////////////////////////////////////////////////////////////////////////////// HWND main_window_handle = NULL; // save the window handle HINSTANCE main_instance = NULL; // save the instance BOOL bActive=TRUE, // is the aplication minimized? bMinimized=FALSE; BYTE *video_buffer; int WordsPerLine;

//////////////////////////////////////////////////////////////////////////////////

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { PAINTSTRUCT ps; // used in WM_PAINT HDC hdc; // handle to a device context switch(msg) { case WM_CREATE: { return(0); } break;

case WM_PAINT: { hdc = BeginPaint(hwnd,&ps); EndPaint(hwnd,&ps); return(0); } break;

case WM_DESTROY: { PostQuitMessage(0); return(0); } break;

case WM_ACTIVATEAPP: { bActive = (BOOL)wparam; } break;

default:break;

} // end switch return (DefWindowProc(hwnd, msg, wparam, lparam)); } // end WinProc // WINMAIN //////////////////////////////////////////////// int WINAPI WinMain( HINSTANCE hinstance, HINSTANCE hprevinstance, LPSTR lpcmdline, int ncmdshow) { WNDCLASS winclass; // this will hold the class we create HWND hwnd; // generic window handle MSG msg; // generic message Log.WriteStatusToLogFile("> Initialize Window");

winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW; winclass.lpfnWndProc = WindowProc; winclass.cbClsExtra = 0; winclass.cbWndExtra = 0; winclass.hInstance = hinstance; winclass.hIcon = LoadIcon(hinstance,MAKEINTRESOURCE(IDI_ICON)); winclass.hCursor = LoadCursor(hinstance,IDC_ARROW); winclass.lpszMenuName = NULL; winclass.lpszClassName = WINDOW_CLASS_NAME;

if (!RegisterClass(&winclass)) { Log.WriteErrorToLogFile("> Error: Register window class"); return(0); } Log.WriteToLogFile("> Register window class: OK");

if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class "VoxEd 2.0", // title WS_POPUP | WS_VISIBLE, 0,0, // x,y WINDOW_WIDTH, // width WINDOW_HEIGHT, // height NULL, // handle to parent NULL, // handle to menu hinstance,// instance NULL))) // creation parms { Log.WriteErrorToLogFile("> Error: Create window"); return(FALSE); } Log.WriteToLogFile("> Create window: OK");

main_window_handle = hwnd; main_instance = hinstance;

Log.WriteStatusToLogFile("> GameInit: Initialize MMX DirectDraw graphic subsystem"); if(!GameMain.GameInit(main_window_handle)) // Game initializing { GameMain.GameShutdown(); // an error return(FALSE); } Log.WriteToLogFile("> GameInit: OK");

Log.WriteStatusToLogFile("> MouseInit: Initialize mouse"); if(!GameMain.MouseInit(hwnd)) // Mouse initializing { GameMain.GameShutdown(); // an error return(FALSE); } Log.WriteToLogFile("> MouseInit: OK");

Log.WriteStatusToLogFile("> KeyboardInit: Intialize keyboard"); if(!GameMain.KeyboardInit(hwnd)) // Keyboard initializing { GameMain.GameShutdown(); return(FALSE); } Log.WriteToLogFile("> KeyboardInit: OK");

Log.WriteStatusToLogFile("> LoadTextures: Loading textures"); if(!GameMain.LoadTextures()) { GameMain.GameShutdown(); return(FALSE); } Log.WriteToLogFile("> LoadTextures: OK");

Log.WriteStatusToLogFile("> GameStart: Draw window graphics"); if(!GameMain.GameStart()) // Window Graphics { GameMain.GameShutdown(); // an error return(FALSE); } Log.WriteToLogFile("> GameStart: OK");

// enter main event loop Log.WriteStatusToLogFile("> Entering message loop");

while( 1 ) { if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) ) { // Messages abarbeiten if( !GetMessage( &msg, NULL, 0, 0 ) ) { GameMain.GameShutdown(); return msg.wParam; } TranslateMessage(&msg); DispatchMessage(&msg); } else if ( bActive ) // Keine Messages und aktiv: Game_Main { if (bMinimized) { if (!GameMain.GameRestart()) { GameMain.GameShutdown(); return msg.wParam; } Log.WriteToLogFile("> Game_Restart: OK"); Log.WriteToLogFile("> Maximized"); bMinimized=FALSE; } if (!GameMain.GameMain()) { GameMain.GameShutdown(); // an error: shutdown the Game return(FALSE); } // end if } else // Nichts zu tun: Warten { if (!bMinimized) Log.WriteToLogFile("> Minimized"); WaitMessage(); bMinimized=TRUE; } }

// shutdown game and release all resources } // end WinMain

Currently browsing [VoxEd.zip] (61,511 bytes) - [CButton.h] - (563 bytes)

// CButton.h
// by Comanche

#include "defines.h"
#include "CTexture.h"

#ifndef CBUTTON #define CBUTTON

////////////////////////////////////////////////////////////////////////////////// class CButton { public: CButton(int x1,int y1,int x2,int y2,char *string, char *bitmap); ~CButton(); BOOL RedrawButton(); BOOL RedrawPushedButton(); BOOL TestIfPressed(); private: BOOL DrawPicture(BOOL pressed); char caption[100]; int Bx,By,Bx2,By2; BOOL waspressed; BOOL isTextured; char buffer[80]; CTexture *Texture; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CCheckBox.h] - (405 bytes)

// CCheckBox.h
// by Comanche

#include "defines.h"

#ifndef CCHECKBOX #define CCHECKBOX

////////////////////////////////////////////////////////////////////////////////// class CCheckBox { public: CCheckBox(int x,int y,char *string); BOOL RedrawCheckBox(); BOOL TestIfPressed(); BOOL State; private: int Cx,Cy; char caption[100]; char buffer[80]; BOOL redraw; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CColor.h] - (350 bytes)

// CColor.h
// by Comanche

#include "defines.h"

#ifndef CCOLOR #define CCOLOR

////////////////////////////////////////////////////////////////////////////////// class CColor { public: CColor(); void DrawColors(); void TestIfPressed(); BYTE redpos,greenpos,bluepos; RGBTRIPLE color; private: char buffer[80]; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CGraphics.h] - (2,054 bytes)

// CGraphics.h
// by Comanche

#include "defines.h"

#ifndef CGRAPHICS #define CGRAPHICS

////////////////////////////////////////////////////////////////////////////////// extern BYTE *video_buffer; extern int WordsPerLine;

class CGraphics { public: void Init(); void Lock(); void UnLock(); void LockBackBuffer(); void UnLockBackBuffer(); void Flip(); void BltToBackBuffer(); void GetDC(); void GetLaDC(); void ReleaseDC(); void OSGetDC(); void OSGetLaDC(); void OSReleaseDC(); void RestorePrimarySurface(); void RestoreOffScreenSurface(); BOOL StoreScreenArea(int x,int y,int x2,int y2); BOOL RestoreScreenArea(); void Blt(int x,int y,int x2,int y2,int vx, int vy); void Text(int x,int y,char *string); void PutPixel(int x,int y,BYTE red,BYTE green,BYTE blue); void PutSafePixel(int x,int y,BYTE red,BYTE green,BYTE blue); void Quader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue); void FullQuader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue); void BlackQuader(int x,int y,int x2,int y2); void PutTransPixel(int x,int y,BYTE red, BYTE green,BYTE blue); void FullTransQuader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue); void FullBrightQuader(int x,int y,int x2,int y2, BYTE red,BYTE green,BYTE blue); void Line(int x,int y,int x2, int y2,BYTE red,BYTE green,BYTE blue); void HLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue); void VLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue); void TransHLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue); void TransVLine(int x,int y,int p,BYTE red,BYTE green,BYTE blue); void DrawButton(int x,int y,int x2,int y2); void DrawPushedButton(int x,int y,int x2,int y2); void DrawCheckBoxOff(int x,int y); void DrawCheckBoxOn(int x,int y); HDC xdc; LOGFONT logfont; RGBTRIPLE textcolor; BOOL DrawFont; private: char buffer[80]; int FrameTime; HFONT Arial; int Sx,Sy,Sx2,Sy2; LPDIRECTDRAWSURFACE lpddsos2; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CLandScape.h] - (1,067 bytes)

// CLandScape.h
// by Comanche

#include "defines.h"

#ifndef CLANDSCAPE #define CLANDSCAPE

////////////////////////////////////////////////////////////////////////////////// class CLandScape { public: CLandScape(); BOOL InitScreen(); void FillScreen(int x,int y,int x2,int y2); void MoveRight(); void MoveLeft(); void MoveUp(); void MoveDown(); void MoveRightUp(); void MoveRightDown(); void MoveLeftUp(); void MoveLeftDown(); void DrawBrush(); void UseBrush(); HICON CheckMouseCursor(); int ScreenPosX,ScreenPosY; DWORD Landscape[2000][2000]; BOOL Day; int vps; private: char buffer[80]; inline void PutVoxel(int x,int y,int x2,int y2); inline void PutBrightVoxel(int x,int y,int x2,int y2); inline void Higher(); inline void Lower(); inline void Level(); inline void Brush(); inline void Smoth(); inline void Spray(); inline void Transparent(); inline float GetShadow(int x,int y,int height); inline BYTE GetAlpha(BYTE a,BYTE b,float alpha); int BrushX,BrushY; int test; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CLiquid.h] - (506 bytes)

// CLiquids.h
// by Comanche

#include "defines.h"
#include "CTexture.h"

#ifndef CLIQUID #define CLIQUID

////////////////////////////////////////////////////////////////////////////////// class CLiquid { public: CLiquid(int Texture); ~CLiquid(); void Render(); void RenderOutline(BOOL Marked); void CheckMouse(int Liquid); int height; private: char TextureName[100]; int TexId; BOOL Transparent; int x,y,x2,y2; int bumpmap[8][8][8]; char buffer[80]; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CLog.h] - (508 bytes)

// Clog.h
// by Comanche

#include "defines.h"

#ifndef CLOG #define CLOG

////////////////////////////////////////////////////////////////////////////////// class CLog { public: CLog(); BOOL CloseLogFile(); BOOL WriteToLogFile(char *string); BOOL WriteCodeToLogFile(char *string); BOOL WriteErrorToLogFile(char *string); BOOL WriteStatusToLogFile(char *string); private: int lfh; // the file handle OFSTRUCT log_file_data; char buffer[200]; char buffer2[80]; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CMain.h] - (1,957 bytes)

// CMain.h
// by Comanche

#include "defines.h"

#ifndef CMAIN #define CMAIN

////////////////////////////////////////////////////////////////////////////////// class CMain { public: BOOL GameInit(HWND main_window_handle); BOOL CheckProzessor(); BOOL CheckDirectX(); BOOL GameMain(); BOOL GameStart(); BOOL GameShutdown(); BOOL GameRestart(); BOOL MouseInit(HWND hwnd); BOOL KeyboardInit(HWND hwnd); BOOL GetMouseInfo(); BOOL GetKeyboardInfo(); BOOL CheckMouseRange(int x,int y,int x2,int y2,BOOL Button); BOOL LoadTextures(); BOOL RenderLiquids(); BOOL CheckLiquids();

LPDIRECTDRAW lpdd; // dd object LPDIRECTDRAW2 lpdd2; // dd2 object LPDIRECTDRAWSURFACE lpddsprimary; // dd primary surface LPDIRECTDRAWSURFACE lpddsback; // dd back surface LPDIRECTDRAWSURFACE lpddsos1; // dd off-screen surface 1 LPDIRECTINPUT lpdi; // di object LPDIRECTINPUTDEVICE lpdidevice; // di device LPDIRECTINPUTDEVICE lpdidevice2; // di device 2 DIMOUSESTATE mouse_state; // di mouse state DDSURFACEDESC ddsd; // a direct draw surface description struct DDSCAPS ddscaps; // a direct draw surface capabilities struct HRESULT ddrval; // result back from dd calls int MouseX,MouseY; // Mouse coordinates BYTE MouseB[3]; // Mousebutton states BYTE keyboard_state[256]; BYTE KeyboardB[4]; HICON Icon,Cursor,Cross,Finger,Pinpet,Clock, Right,Left,Up,Down,LeftRight,UpDown, RightDown,RightUp,LeftDown,LeftUp; // Cursors; int NumTextures, CursorRegX,CursorRegY,Status,Status2; BOOL DrawCursor; // Mouse Cursor ON/OFF int Editor; int ActiveLiquid; BOOL MMX,CPUID,FPU,CMOV,MCA,TSC,AMD,INTEL; int CpuFamily,CpuModel,CpuStepId; char VendorString[32]; DWORD DXVersion, DXPlatform; private: char buffer[80]; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CMenu.h] - (853 bytes)

// CMenu.h
// by Comanche

#include "defines.h"
#include "CButton.h"

#ifndef CMENU #define CMENU

////////////////////////////////////////////////////////////////////////////////// class CMenu { public: BOOL Menu(); BOOL File(); BOOL TextureOps(); BOOL Editor(); void SaveMap(); void LoadMap(); BOOL FillLand(int height); BOOL SetEditor(int editor); void DrawTextures(); void DrawTextures(int TexPos); void DrawSelected(int TexPos); void ScrollDown(); void ScrollUp(); void SelectTexture(); void CreateMiniMap(); void DrawMiniMap(); int Selection; int ScrolPos; BOOL MessageBox(char *caption,char *string,int ms); BOOL Open; private: BOOL Exit; BOOL State; char buffer[80]; BYTE MiniMapR[64][64]; BYTE MiniMapG[64][64]; BYTE MiniMapB[64][64]; CButton *MenuButtons[60]; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CTexture.h] - (716 bytes)

// CTexture.h
// by Comanche

#include "defines.h"

#ifndef CTEXTURE #define CTEXTURE

////////////////////////////////////////////////////////////////////////////////// struct BITMAP_FILE { BITMAPFILEHEADER bitmapfileheader; BITMAPINFOHEADER bitmapinfoheader; PALETTEENTRY palette[256]; BYTE *buffer; };

////////////////////////////////////////////////////////////////////////////////// class CTexture { public: CTexture(char *filename); ~CTexture(); RGBTRIPLE GetPixel(int x,int y); BYTE isfailure; LONG width,height; WORD bitcount; char Name[255]; private: int tfh; OFSTRUCT file_data; char buffer[80]; BITMAP_FILE bitmap; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CTime.h] - (308 bytes)

// CTime.h
// by Comanche

#include "defines.h"

#ifndef CTIME #define CTIME

////////////////////////////////////////////////////////////////////////////////// class CTime { public: int GetFPS(int FrameTime); int GetFrameTime(); private: int FrameTime; int LastFrameTime; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CViewport.h] - (421 bytes)

// CViewport.h
// by Comanche

#include "defines.h"
#include "CButton.h"

#ifndef CVIEWPORT #define CVIEWPORT

////////////////////////////////////////////////////////////////////////////////// class CViewport { public: CViewport(int x,int y,int M); CViewport::~CViewport(); void UseViewport(); void RedrawViewport(); private: int Vx,Vy,Vx2,Vy2,Mode; CButton *ViewportButtons[10]; };

#endif

Currently browsing [VoxEd.zip] (61,511 bytes) - [CVoxel.h] - (268 bytes)

// CVoxel.h
// by Comanche

#include "defines.h"

////////////////////////////////////////////////////////////////////////////////// class CVoxel { public: int ViewX, ViewY; int FrontPos; int TopPos; int LeftPos; RGBTRIPLE Voxels[49][49][49]; };

Currently browsing [VoxEd.zip] (61,511 bytes) - [DEFINES.H] - (2,048 bytes)

// defines.h

// INCLUDES ///////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN  

#include <windows.h> // include important windows stuff #include <windowsx.h> #include <mmsystem.h> #include <iostream.h> // include important C/C++ stuff #include <conio.h> #include <stdlib.h> #include <malloc.h> #include <memory.h> #include <string.h> #include <stdarg.h> #include <stdio.h> #include <math.h> #include <io.h> #include <assert.h> #include <fcntl.h> #include <time.h>

#include <ddraw.h> // DirectX includes #define DIRECTINPUT_VERSION 0x0700 #include <dinput.h> #include <dmusici.h>

typedef HRESULT(WINAPI * DIRECTDRAWCREATE)( GUID*, LPDIRECTDRAW*, IUnknown* ); typedef HRESULT(WINAPI * DIRECTDRAWCREATEEX)( GUID*, VOID**, REFIID, IUnknown* ); typedef HRESULT(WINAPI * DIRECTINPUTCREATE)( HINSTANCE, DWORD, LPDIRECTINPUT*, IUnknown* );

#include "resource.h"

// DEFINES //////////////////////////////////////////////// #define DINPUT_BUFFERSIZE 16

#define VIEWPORTTOP 1 #define VIEWPORTFRONT 2 #define VIEWPORTLEFT 3 #define VIEWPORT3D 4

#define STANDARTFONTHEIGHT 15 #define CHECKBOXFONTHEIGHT 14 #define SMALFONTHEIGHT 11 #define TEXTUREFONTHEIGHT 10 #define Version "VoxEd 0.53 MMX"

// defines for windows #define WINDOW_CLASS_NAME "WINXCLASS" // class name #define WINDOW_WIDTH 0 // size of window #define WINDOW_HEIGHT 0 #define SCREEN_WIDTH 640 // size of screen #define SCREEN_HEIGHT 480 #define SCREEN_BPP 32 // bits per pixel #define BITMAP_ID 0x4D42 // universal id for a bitmap // MESSAGE BOX DEFINES //////////////////////////////////// #define MS_OK 1 #define MS_YESNO 2

// TYPES ////////////////////////////////////////////////// typedef unsigned short USHORT; typedef unsigned short WORD; typedef unsigned int UINT; typedef unsigned char UCHAR; typedef unsigned char BYTE;

Currently browsing [VoxEd.zip] (61,511 bytes) - [CButton.cpp] - (4,185 bytes)

// CButton.cpp
// by Comanche

#include "CButton.h"
#include "CLog.h"
#include "CGraphics.h"
#include "CMain.h"
#include "CTexture.h"
#include "CMenu.h"

extern CGraphics Graphics; extern CMain GameMain; extern CLog Log; extern CMenu Menu;

////////////////////////////////////////////////////////////////////////////////// CButton::CButton(int x1,int y1,int x2,int y2, char *string, char *bitmap) { Texture = new CTexture(bitmap); if(!Texture->isfailure) isTextured=TRUE;

Bx=x1; By=y1; Bx2=x2; By2=y2; sprintf(caption,"%s",string); waspressed=TRUE; }

////////////////////////////////////////////////////////////////////////////////// CButton::~CButton() { delete Texture; }

////////////////////////////////////////////////////////////////////////////////// BOOL CButton::RedrawButton() { Graphics.Lock(); Graphics.DrawButton(Bx,By,Bx2,By2); DrawPicture(FALSE); Graphics.UnLock(); Graphics.OSGetDC(); Graphics.Text((Bx+Bx2)/2,By+3,caption); Graphics.OSReleaseDC(); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CButton::RedrawPushedButton() { Graphics.Lock(); Graphics.DrawPushedButton(Bx,By,Bx2,By2); DrawPicture(FALSE); Graphics.UnLock(); Graphics.OSGetDC(); Graphics.Text((Bx+Bx2)/2,By+4,caption); Graphics.OSReleaseDC(); return(TRUE); }

////////////////////////////////////////////////////////////////////////////////// BOOL CButton::TestIfPressed() { if (GameMain.CheckMouseRange(Bx,By,Bx2,By2,TRUE)) { Graphics.Lock(); Graphics.DrawPushedButton(Bx,By,Bx2,By2); DrawPicture(TRUE); Graphics.UnLock(); while(GameMain.MouseB[0]) { GameMain.GetMouseInfo(); if(GameMain.CheckMouseRange(Bx,By,Bx2,By2,FALSE)) { Graphics.Lock(); Graphics.DrawPushedButton(Bx,By,Bx2,By2); DrawPicture(TRUE); Graphics.UnLock(); Graphics.OSGetDC(); Graphics.Text((Bx+Bx2)/2,By+4,caption); Graphics.OSReleaseDC(); Graphics.BltToBackBuffer(); if(GameMain.Status2==7 && Menu.Open!=TRUE) GameMain.RenderLiquids(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX, GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); } else { Graphics.Lock(); Graphics.DrawButton(Bx,By,Bx2,By2); DrawPicture(FALSE); Graphics.UnLock(); Graphics.OSGetDC(); Graphics.Text((Bx+Bx2)/2,By+3,caption); Graphics.OSReleaseDC(); Graphics.BltToBackBuffer(); if(GameMain.Status2==7 && Menu.Open!=TRUE) GameMain.RenderLiquids(); Graphics.GetDC(); DrawIcon(Graphics.xdc,GameMain.MouseX, GameMain.MouseY,GameMain.Cursor); Graphics.ReleaseDC(); Graphics.Flip(); } } if(GameMain.CheckMouseRange(Bx,By,Bx2,By2,FALSE)) { waspressed=TRUE; return(TRUE); } else return(FALSE); } else { if(waspressed) { waspressed=FALSE; Graphics.Lock(); Graphics.DrawButton(Bx,By,Bx2,By2); DrawPicture(FALSE); Graphics.UnLock(); Graphics.OSGetDC(); Graphics.Text((Bx+Bx2)/2,By+3,caption); Graphics.OSReleaseDC(); } return(FALSE); } }

////////////////////////////////////////////////////////////////////////////////// BOOL CButton::DrawPicture(BOOL pressed) { RGBTRIPLE color;

if(!isTextured) return(TRUE);

int width=Texture->width; int height=Texture->height;

for(int i=0;i<width;i++) for(int i2=0;i2<height;i2++) { color=Texture->GetPixel(i,i2); if(!pressed) { if((Bx+i)>(Bx2-2)) continue; if((By+i2)>(By2-2)) continue;

if(color.rgbtRed == 255 && color.rgbtGreen == 255 && color.rgbtBlue == 255) continue;

Graphics.PutPixel(Bx+1+i,By+1+i2, color.rgbtRed,color.rgbtGreen,color.rgbtBlue); } else { if((Bx+i)>(Bx2-2)) continue; if((By+i2)>(By2-3)) continue; if(color.rgbtRed == 255 && color.rgbtGreen == 255 && color.rgbtBlue == 255) continue;

Graphics.PutPixel(Bx+1+i,By+2+i2, color.rgbtRed,color.rgbtGreen,color.rgbtBlue); } }

return(TRUE); }

The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.