//--------------------------------------------------------------------------
void VeWindows::_SetWindowTitle(Window* pkWindow)
{
WindowData* pkData = (WindowData*)(VeRefObject*)pkWindow->m_spDriverData;
VeUInt32 u32Len = MultiByteToWideChar(CP_UTF8, 0, pkWindow->m_kTitle, -1, NULL, 0);
VeChar16* wszGBK = VeAlloc(VeChar16, u32Len + 1);
VeZeroMemory(wszGBK, sizeof(VeChar16) * (u32Len + 1));
MultiByteToWideChar(CP_UTF8, 0, pkWindow->m_kTitle, -1, wszGBK, u32Len);
u32Len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
VeChar8* szGBK = VeAlloc(VeChar8, u32Len + 1);
VeZeroMemory(szGBK, sizeof(VeChar8) * (u32Len + 1));
WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, u32Len, NULL, NULL);
SetWindowText(pkData->m_hWnd, szGBK);
VeFree(wszGBK);
VeFree(szGBK);
}
//--------------------------------------------------------------------------
VeOMBlendStateTick::VeOMBlendStateTick(const VeChar8* pcName)
: VeRenderTick(VeRenderTick::OM_BLEND_STATE)
, m_u32SampleMask(0xffffffff)
{
VeZeroMemory(m_af32Factor, sizeof(m_af32Factor));
g_pRenderer->GetRenderObject(pcName, m_spBlendState);
}
//--------------------------------------------------------------------------
void VeStringA_S::UpdateGBKToValueData()
{
if(m_kGBKData.Length())
{
VeUInt32 u32Len = MultiByteToWideChar(CP_ACP, 0, m_kGBKData, -1, NULL, 0);
VeChar16* wszGBK = VeAlloc(VeChar16, u32Len + 1);
VeZeroMemory(wszGBK, sizeof(VeChar16) * (u32Len + 1));
MultiByteToWideChar(CP_ACP, 0, m_kGBKData, -1, wszGBK, u32Len);
u32Len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
VeChar8* szUTF8 = VeAlloc(VeChar8, u32Len + 1);
VeZeroMemory(szUTF8, sizeof(VeChar8) * (u32Len + 1));
WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUTF8, u32Len, NULL, NULL);
m_kValue = szUTF8;
VeFree(wszGBK);
VeFree(szUTF8);
}
else
{
m_kValue = "";
}
}
//--------------------------------------------------------------------------
VeSurfacePtr VeSurface::CreateRGBSurface(VeUInt32 u32Flags,
VeInt32 i32Width, VeInt32 i32Height, VeInt32 i32Depth,
VeUInt32 u32Rmask, VeUInt32 u32Gmask, VeUInt32 u32Bmask,
VeUInt32 u32Amask) noexcept
{
VeUInt32 u32Format = VeMasksToPixelFormatEnum(i32Depth, u32Rmask,
u32Gmask, u32Bmask, u32Amask);
if (u32Format == VE_PIXELFORMAT_UNKNOWN) return nullptr;
VeSurfacePtr spSurface = VE_NEW VeSurface();
VE_ASSERT(spSurface);
spSurface->m_spFormat = VePixelFormat::Create(u32Format);
if (!spSurface->m_spFormat) return nullptr;
spSurface->m_i32Width = i32Width;
spSurface->m_i32Height = i32Height;
spSurface->m_i32Pitch = spSurface->CalculatePitch();
if (VE_ISPIXELFORMAT_INDEXED(spSurface->m_spFormat->m_u32Format))
{
VePalettePtr spPattle = VE_NEW VePalette((1 << spSurface->m_spFormat->m_u8BitsPerPixel));
VE_ASSERT(spPattle);
if (spPattle->m_kColors.size() == 2)
{
spPattle->m_kColors[0].r() = 0xFF;
spPattle->m_kColors[0].g() = 0xFF;
spPattle->m_kColors[0].b() = 0xFF;
spPattle->m_kColors[1].r() = 0x00;
spPattle->m_kColors[1].g() = 0x00;
spPattle->m_kColors[1].b() = 0x00;
}
spSurface->SetPalette(spPattle);
}
if (spSurface->m_i32Width && spSurface->m_i32Height)
{
VeSizeT stSize = spSurface->m_i32Height * spSurface->m_i32Pitch;
spSurface->m_spPixels = VE_NEW VeBlob(stSize);
VeZeroMemory(*spSurface->m_spPixels, stSize);
}
return spSurface;
}
//--------------------------------------------------------------------------
bool WindowsMouse::_CreateCursor(VeCursor::Data* pkCur,
const VeSurfacePtr& spSurface,
VeInt32 i32HotX, VeInt32 i32HotY) noexcept
{
VE_ASSERT(spSurface && pkCur);
const VeSizeT pad = (sizeof(VeSizeT) * 8);
HICON hicon;
HDC hdc;
BITMAPV4HEADER bmh;
LPVOID pixels;
LPVOID maskbits;
size_t maskbitslen;
ICONINFO ii;
VeInt32 w = spSurface->GetWidth();
VeInt32 h = spSurface->GetHeight();
VeZeroMemory(&bmh, sizeof(bmh));
bmh.bV4Size = sizeof(bmh);
bmh.bV4Width = w;
bmh.bV4Height = -h;
bmh.bV4Planes = 1;
bmh.bV4BitCount = 32;
bmh.bV4V4Compression = BI_BITFIELDS;
bmh.bV4AlphaMask = 0xFF000000;
bmh.bV4RedMask = 0x00FF0000;
bmh.bV4GreenMask = 0x0000FF00;
bmh.bV4BlueMask = 0x000000FF;
maskbitslen = ((w + (pad - (w % pad))) / 8) * h;
maskbits = VeStackAlloc(VeUInt8, maskbitslen);
VeMemorySet(maskbits, 0xFF, maskbitslen);
hdc = GetDC(nullptr);
VeZeroMemory(&ii, sizeof(ii));
ii.fIcon = FALSE;
ii.xHotspot = (DWORD)i32HotX;
ii.yHotspot = (DWORD)i32HotY;
ii.hbmColor = CreateDIBSection(hdc, (BITMAPINFO*)&bmh, DIB_RGB_COLORS, &pixels, nullptr, 0);
ii.hbmMask = CreateBitmap(w, h, 1, 1, maskbits);
ReleaseDC(nullptr, hdc);
VeStackFree(maskbits);
VE_ASSERT(spSurface->GetFormat()->m_u32Format == VE_PIXELFORMAT_ARGB8888);
VE_ASSERT(spSurface->GetPitch() == w * 4);
VeMemoryCopy(pixels, spSurface->GetBuffer(), h * spSurface->GetPitch());
hicon = CreateIconIndirect(&ii);
DeleteObject(ii.hbmColor);
DeleteObject(ii.hbmMask);
pkCur->m_pvDriverdata = hicon;
if (!hicon)
{
return false;
}
return true;
}
//--------------------------------------------------------------------------
void Server::Start()
{
VeXMLElement* pkServer = m_kConfig.RootElement()->FirstChildElement("Server");
const VeChar8* pcVersion = pkServer->FirstChildElement("Version")->GetText();
{
VeZeroMemory(&m_kVersion, sizeof(Version));
VeChar8 acBuffer[64];
VeStrcpy(acBuffer, 64, pcVersion);
VeChar8* pcContext;
const VeChar8* pcTemp = VeStrtok(acBuffer, ".", &pcContext);
VeUInt32 i(0);
while(pcTemp && i < 4)
{
m_kVersion.m_au8Version[i] = VeAtoi(pcTemp);
pcTemp = VeStrtok(NULL, ".", &pcContext);
++i;
}
}
VeUInt16 u16Port;
VE_ASSERT_EQ(VeStringA(pkServer->FirstChildElement("ServerPort")->GetText()).To(u16Port), true);
VeUInt16 u16MaxConnections;
VE_ASSERT_EQ(VeStringA(pkServer->FirstChildElement("MaxConnections")->GetText()).To(u16MaxConnections), true);
VeUInt32 u32TimeOut;
VE_ASSERT_EQ(VeStringA(pkServer->FirstChildElement("TimeOut")->GetText()).To(u32TimeOut), true);
const VeChar8* pcPassword = pkServer->FirstChildElement("Password")->GetText();
m_pkPeer->SetIncomingPassword(pcPassword, (VeInt32)VeStrlen(pcPassword));
m_pkPeer->SetTimeoutTime(u32TimeOut, UNASSIGNED_SYSTEM_ADDRESS);
SocketDescriptor akSocketDesc[2];
akSocketDesc[0].port = u16Port;
akSocketDesc[0].socketFamily = AF_INET;
akSocketDesc[1].port = u16Port;
akSocketDesc[1].socketFamily = AF_INET6;
bool bRes = m_pkPeer->Startup(u16MaxConnections, akSocketDesc, 2, 30) == VENET_STARTED;
m_pkPeer->SetMaximumIncomingConnections(u16MaxConnections);
if(bRes)
{
printf("%s Server Started, Waiting For Connections.\n", m_kName);
}
else
{
bRes = m_pkPeer->Startup(u16MaxConnections, akSocketDesc, 1, 30) == VENET_STARTED;
if(!bRes)
{
VeChar8 acBuffer[256];
VeSprintf(acBuffer, 256, "%s Server failed to start. Terminating.", m_kName);
puts(acBuffer);
exit(1);
}
printf("%s Server Started, Waiting For Connections.\n", m_kName);
}
m_pkPeer->SetOccasionalPing(true);
m_pkPeer->SetUnreliableTimeout(1000);
DataStructures::List< VENetSmartPtr<VENetSocket> > kSockets;
m_pkPeer->GetSockets(kSockets);
for(VeUInt32 i(0); i < kSockets.Size(); ++i)
{
printf("Ports Used By :%i. %i\n", i+1, kSockets[i]->boundAddress.ToString(true));
}
for(VeUInt32 i(0); i < m_pkPeer->GetNumberOfAddresses(); ++i)
{
printf("\n本机可提供服务的IP :\n%i. %s\n", i+1, m_pkPeer->GetLocalIP(i));
}
printf("%s Server GUID is %s\n", m_kName, m_pkPeer->GetGuidFromSystemAddress(UNASSIGNED_SYSTEM_ADDRESS).ToString());
{
VeXMLElement* pkDBLink = m_kConfig.RootElement()->FirstChildElement("DBLink");
VeStringA kAccount = pkDBLink->FirstChildElement("Account")->GetText();
VeStringA kPassword = pkDBLink->FirstChildElement("Password")->GetText();
VeStringA kDBSource = pkDBLink->FirstChildElement("DBSource")->GetText();
printf("\nDBSource :%s\n", pkDBLink->FirstChildElement("DBSource")->GetText());
m_kDatabase = VE_NEW DBBusiness(kAccount,kPassword,kDBSource);
}
LoadProperties();
m_u64ServerStartTime = m_u64ServerTime;
AttachByDelay(TIMER(_SyncToDatabase), SAVE_DB_DELAY);
OnStart();
}
//--------------------------------------------------------------------------
VE_BOOL VeWindows::GetDisplayMode(LPCSTR deviceName, DWORD index,
VeDevice::DisplayMode* pkMode)
{
DisplayModeData* pkData;
DEVMODEA kDevMode;
HDC hHdc;
kDevMode.dmSize = sizeof(kDevMode);
kDevMode.dmDriverExtra = 0;
if(!EnumDisplaySettings(deviceName, index, &kDevMode)) return VE_FALSE;
pkData = VE_NEW DisplayModeData;
if (!pkData) return VE_FALSE;
pkData->m_kDeviceMode = kDevMode;
pkData->m_kDeviceMode.dmFields =
(DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY |
DM_DISPLAYFLAGS);
pkData->m_f32ScaleX = 1.0f;
pkData->m_f32ScaleY = 1.0f;
pkMode->m_u32Format = VeRenderer::FMT_UNKNOWN;
pkMode->w = kDevMode.dmPelsWidth;
pkMode->h = kDevMode.dmPelsHeight;
pkMode->m_i32RefreshRate = kDevMode.dmDisplayFrequency;
pkMode->m_spDriverData = pkData;
if (index == ENUM_CURRENT_SETTINGS
&& (hHdc = CreateDC(deviceName, NULL, NULL, NULL)) != NULL)
{
char bmi_data[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
LPBITMAPINFO bmi;
HBITMAP hbm;
int logical_width = GetDeviceCaps( hHdc, HORZRES );
int logical_height = GetDeviceCaps( hHdc, VERTRES );
pkData->m_f32ScaleX = (float)logical_width / kDevMode.dmPelsWidth;
pkData->m_f32ScaleY = (float)logical_height / kDevMode.dmPelsHeight;
pkMode->w = logical_width;
pkMode->h = logical_height;
VeZeroMemory(bmi_data, sizeof(bmi_data));
bmi = (LPBITMAPINFO) bmi_data;
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
hbm = CreateCompatibleBitmap(hHdc, 1, 1);
GetDIBits(hHdc, hbm, 0, 1, NULL, bmi, DIB_RGB_COLORS);
GetDIBits(hHdc, hbm, 0, 1, NULL, bmi, DIB_RGB_COLORS);
DeleteObject(hbm);
DeleteDC(hHdc);
if (bmi->bmiHeader.biCompression == BI_BITFIELDS) {
switch (*(VeUInt32 *) bmi->bmiColors) {
case 0x00FF0000:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB888;
break;
case 0x000000FF:
pkMode->m_u32Format = VE_PIXELFORMAT_BGR888;
break;
case 0xF800:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB565;
break;
case 0x7C00:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB555;
break;
}
} else if (bmi->bmiHeader.biBitCount == 8) {
pkMode->m_u32Format = VE_PIXELFORMAT_INDEX8;
} else if (bmi->bmiHeader.biBitCount == 4) {
pkMode->m_u32Format = VE_PIXELFORMAT_INDEX4LSB;
}
}
else
{
if ((kDevMode.dmFields & DM_BITSPERPEL) == DM_BITSPERPEL) {
switch (kDevMode.dmBitsPerPel) {
case 32:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB888;
break;
case 24:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB24;
break;
case 16:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB565;
break;
case 15:
pkMode->m_u32Format = VE_PIXELFORMAT_RGB555;
break;
case 8:
pkMode->m_u32Format = VE_PIXELFORMAT_INDEX8;
break;
case 4:
pkMode->m_u32Format = VE_PIXELFORMAT_INDEX4LSB;
break;
}
}
}
return VE_TRUE;
}
//--------------------------------------------------------------------------
static bool GetDisplayMode(LPCSTR deviceName, DWORD index,
VeDisplayMode* mode) noexcept
{
VeDisplayModeData* data;
DEVMODEA devmode;
HDC hdc;
devmode.dmSize = sizeof(devmode);
devmode.dmDriverExtra = 0;
if (!EnumDisplaySettingsA(deviceName, index, &devmode))
{
return false;
}
data = VE_NEW VeDisplayModeData;
VE_ASSERT(data);
data->DeviceMode = devmode;
data->DeviceMode.dmFields =
(DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY |
DM_DISPLAYFLAGS);
data->ScaleX = 1.0f;
data->ScaleY = 1.0f;
mode->m_u32Format = VE_PIXELFORMAT_UNKNOWN;
mode->m_i32Width = devmode.dmPelsWidth;
mode->m_i32Height = devmode.dmPelsHeight;
mode->m_i32RefreshRate = devmode.dmDisplayFrequency;
mode->m_spDriverData = data;
if (index == ENUM_CURRENT_SETTINGS
&& (hdc = CreateDCA(deviceName, nullptr, nullptr, nullptr)) != nullptr)
{
char bmi_data[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
LPBITMAPINFO bmi;
HBITMAP hbm;
int logical_width = GetDeviceCaps(hdc, HORZRES);
int logical_height = GetDeviceCaps(hdc, VERTRES);
data->ScaleX = (float)logical_width / devmode.dmPelsWidth;
data->ScaleY = (float)logical_height / devmode.dmPelsHeight;
mode->m_i32Width = logical_width;
mode->m_i32Height = logical_height;
VeZeroMemory(bmi_data, sizeof(bmi_data));
bmi = (LPBITMAPINFO)bmi_data;
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
hbm = CreateCompatibleBitmap(hdc, 1, 1);
GetDIBits(hdc, hbm, 0, 1, nullptr, bmi, DIB_RGB_COLORS);
GetDIBits(hdc, hbm, 0, 1, nullptr, bmi, DIB_RGB_COLORS);
DeleteObject(hbm);
DeleteDC(hdc);
if (bmi->bmiHeader.biCompression == BI_BITFIELDS)
{
switch (*(VeUInt32 *)bmi->bmiColors)
{
case 0x00FF0000:
mode->m_u32Format = VE_PIXELFORMAT_RGB888;
break;
case 0x000000FF:
mode->m_u32Format = VE_PIXELFORMAT_BGR888;
break;
case 0xF800:
mode->m_u32Format = VE_PIXELFORMAT_RGB565;
break;
case 0x7C00:
mode->m_u32Format = VE_PIXELFORMAT_RGB555;
break;
}
}
else if (bmi->bmiHeader.biBitCount == 8)
{
mode->m_u32Format = VE_PIXELFORMAT_INDEX8;
}
else if (bmi->bmiHeader.biBitCount == 4)
{
mode->m_u32Format = VE_PIXELFORMAT_INDEX4LSB;
}
}
else
{
if ((devmode.dmFields & DM_BITSPERPEL) == DM_BITSPERPEL)
{
switch (devmode.dmBitsPerPel)
{
case 32:
mode->m_u32Format = VE_PIXELFORMAT_RGB888;
break;
case 24:
mode->m_u32Format = VE_PIXELFORMAT_RGB24;
break;
case 16:
mode->m_u32Format = VE_PIXELFORMAT_RGB565;
break;
case 15:
mode->m_u32Format = VE_PIXELFORMAT_RGB555;
break;
case 8:
mode->m_u32Format = VE_PIXELFORMAT_INDEX8;
break;
case 4:
mode->m_u32Format = VE_PIXELFORMAT_INDEX4LSB;
break;
}
}
}
return true;
}
