//--------------------------------------------------------------------------
void VeAssetPath::FindFileList(const VeChar8* pcDesc,
VeVector<VeFixedString>& kOut) const noexcept
{
const VeChar8* pcFile = VeStrrchr(pcDesc, '/');
pcFile = pcFile ? (pcFile + 1) : pcDesc;
AAssetDir* pkDir(nullptr);
if (pcFile == pcDesc)
{
pkDir = AAssetManager_openDir(s_pkAssetManager, m_kPath);
}
else
{
VeChar8 acBuffer[VE_MAX_PATH_LEN];
VeChar8* pcTemp = acBuffer;
if (m_kPath.GetLength())
{
pcTemp += VeSprintf(acBuffer, "%s/", m_kPath.GetStr());
}
VeStrncpy(pcTemp, VE_MAX_PATH_LEN, pcDesc, pcFile - pcDesc - 1);
pkDir = AAssetManager_openDir(s_pkAssetManager, acBuffer);
}
if (pkDir)
{
const VeChar8* pcEntry;
while ((pcEntry = AAssetDir_getNextFileName(pkDir)))
{
if (VeWildNameMatch(pcEntry, pcFile))
{
kOut.push_back(pcEntry);
}
}
AAssetDir_close(pkDir);
}
}
//--------------------------------------------------------------------------
static void OutputDebug(VeLog::Type eType, const VeChar8* pcTag,
const VeChar8* pcText) noexcept
{
#ifdef VE_PLATFORM_ANDROID
const android_LogPriority aeLogTypeMap[VeLog::TYPE_MAX] =
{
ANDROID_LOG_DEBUG,
ANDROID_LOG_INFO,
ANDROID_LOG_WARN,
ANDROID_LOG_ERROR
};
__android_log_print(aeLogTypeMap[eType], pcTag, "%s", pcText);
#else
# ifdef VE_PLATFORM_WIN
VeChar8 acLogBuffer[VE_LOG_BUFFER_SIZE + 64];
VeSprintf(acLogBuffer, "%s,%s: %s\n", s_apcLogTypeNames[eType], pcTag, pcText);
OutputDebugStringA(acLogBuffer);
# else
printf("%s,%s: %s\n", s_apcLogTypeNames[eType], pcTag, pcText);
# endif
#endif
}
//--------------------------------------------------------------------------
void VeFilePath::FindFileList(const VeChar8* pcDesc,
VeVector<VeFixedString>& kOut) const noexcept
{
# ifdef VE_PLATFORM_WIN
VeChar8 acBuffer[VE_MAX_PATH_LEN];
PATH_CAT(acBuffer, m_kPath, pcDesc);
_finddata_t kData;
VeSizeT stHandle = _findfirst(acBuffer, &kData);
if (stHandle != VE_ELF)
{
do
{
if ((kData.attrib & 0xf0) == _A_ARCH)
{
kOut.push_back(kData.name);
}
} while (VE_SUCCEEDED(_findnext(stHandle, &kData)));
VE_ASSERT_EQ(_findclose(stHandle), VE_S_OK);
}
# else
const VeChar8* pcFile = VeStrrchr(pcDesc, '/');
pcFile = pcFile ? (pcFile + 1) : pcDesc;
DIR* pkDir(nullptr);
if (pcFile == pcDesc)
{
pkDir = opendir(m_kPath.GetLength() ? m_kPath : ".");
}
else
{
VeChar8 acBuffer[VE_MAX_PATH_LEN];
VeChar8* pcTemp = acBuffer;
if (m_kPath.GetLength())
{
pcTemp += VeSprintf(acBuffer, "%s/", m_kPath.GetStr());
}
VeStrncpy(pcTemp, VE_MAX_PATH_LEN, pcDesc, pcFile - pcDesc - 1);
pkDir = opendir(acBuffer);
}
if (pkDir)
{
struct dirent* pkEntry;
while ((pkEntry = readdir(pkDir)))
{
if (pkEntry->d_type != DT_DIR)
{
if (VeWildNameMatch(pkEntry->d_name, pcFile))
{
kOut.push_back(pkEntry->d_name);
}
}
}
VE_ASSERT_EQ(closedir(pkDir), VE_S_OK);
}
# endif
}
//--------------------------------------------------------------------------
static void OutputLuaDebug(VeLog::Type eType, const VeChar8* pcTag,
const VeChar8* pcText) noexcept
{
VeChar8 acLogBuffer[VE_LOG_BUFFER_SIZE + 64];
VeSprintf(acLogBuffer, "%s,%s: %s", s_apcLogTypeNames[eType], pcTag, pcText);
if (ve_lua)
{
venus::call_function("print", acLogBuffer);
}
}
//--------------------------------------------------------------------------
void VeRenderTest::OnUpdate() noexcept
{
/*VE_VECTOR eye = { 500,0,500,0 };
VE_VECTOR focus = { 0,0,0,0 };
VE_VECTOR up = g_MathIdentityR2;
VE_MATRIX4X3 view = VeMatrixLookAtLH(eye, focus, up);
VE_MATRIX view4;
view4.r[0] = view.r[0];
view4.r[1] = view.r[1];
view4.r[2] = view.r[2];
view4.r[3] = g_MathIdentityR3;
VE_MATRIX proj = VeMatrixPerspectiveFovLH(VE_MATH_PI_2_F, 720.f / 1280.f, 0.25f, 8000.f);
view4 = VeMatrixMultiply(view4, proj);*/
//static VeFloat32 s_Test = 0.0f;
//s_Test -= ve_time.GetDeltaTime() * 0.3f;
//VE_FLOAT4A* pvData = (VE_FLOAT4A*)spCB->Map();
//VE_VECTOR v = { 0, s_Test, 0.5f, 0.5f };
//VeStoreFloat4A(pvData, v);
////VeStoreFloat4x4A(pvData, view4);
//spCB->Unmap();
//VE_FLOAT4X4A* pvData = (VE_FLOAT4X4A*)spCB->Map();
//VeStoreFloat4x4A(pvData, view4);
//spCB->Unmap();
static VeFloat32 s_f32TimeCount(0);
static VeUInt32 s_u32FrameCount(0);
static VeUInt32 s_u32FPS;
s_f32TimeCount += ve_time.GetDeltaTime();
++s_u32FrameCount;
if (s_f32TimeCount > 1.0f)
{
s_u32FPS = s_u32FrameCount;
VeChar8 s_acFPS[64];
VeSprintf(s_acFPS, "%s[FPS:%d]", (const VeChar8*)m_kString, s_u32FrameCount);
m_spMainWindow->SetTitle(s_acFPS);
s_f32TimeCount -= VeFloorf(s_f32TimeCount);
s_u32FrameCount = 0;
}
}
//--------------------------------------------------------------------------
Server::Server(const VeChar8* pcName, const VeChar8* pcConfigPath)
: PropertySContainer(this), m_kName(pcName), m_pkPeer(NULL), m_kAgentMap(1024), m_kDatabase(NULL)
, m_strServerName(this, FLAG_DATABASE, "ServerName", pcName)
, m_u64ServerTime(this, FLAG_DATABASE, "ServerTime", 0)
{
m_kNode.m_tContent = this;
g_pServerManager->AddServer(pcName, this);
m_pkPeer = VEPeerInterface::GetInstance();
VeChar8 acBuffer[64];
VeSprintf(acBuffer, 64, "%s.xml", pcName);
VeDirectory* pkDir = g_pResourceManager->CreateDir(pcConfigPath);
VeBinaryIStreamPtr spConfig = pkDir->OpenSync(acBuffer);
(*spConfig) >> m_kConfig;
g_pResourceManager->DestoryDir(pkDir);
TIMER_INIT(Server, _SyncToDatabase);
}
//--------------------------------------------------------------------------
VeAbortState VeReportAssertion(const char* pcCond, const char* pcFile,
int32_t i32Line, const char* pcFunc) noexcept
{
auto& spVideo = venus3d.GetVideo();
if (spVideo)
{
char acBuffer[VE_MAX_LOG_MESSAGE];
VeSprintf(acBuffer,
"Assertion failed!\n\n"
"File: %s\n"
"Line: %d\n"
"Function: %s\n\n"
"Expression: %s\n\n"
"For information on how your program can cause an assertion failure\n\n"
"(Press Retry to debug the application)",
pcFile, i32Line, pcFunc, pcCond);
switch (spVideo->MessageBoxSync(VE_ASSERT_CAPTION, acBuffer,
VE_MB_ABORTRETRYIGNORE | VE_MB_ERROR))
{
case VE_MB_IDABORT:
return VE_AS_STOP;
case VE_MB_IDRETRY:
return VE_AS_BREAK;
case VE_MB_IDIGNORE:
return VE_AS_IGNORE;
default:
return VE_AS_RETRY;
};
}
else
{
VeCoreLogE("*****************************************************");
VeCoreLogE("Assertion failed!");
VeCoreLogE("File: ", pcFile);
VeCoreLogE("Line: ", i32Line);
VeCoreLogE("Function: ", pcFunc);
VeCoreLogE("Expression: ", pcCond);
VeCoreLogE("*****************************************************");
return VE_AS_BREAK;
}
}
//--------------------------------------------------------------------------
const VeChar8* VeQuaternion::ToString(const VeQuaternion& kQuat)
{
VeSprintf(g_acPrintBuffer, "quat(%.2f,%.2f,%.2f,%.2f)", kQuat.x, kQuat.y, kQuat.z, kQuat.w);
return g_acPrintBuffer;
}
//--------------------------------------------------------------------------
void D3D12Renderer::PrepareShaders(const VeDirectoryPtr& spSrc,
const VeDirectoryPtr&) noexcept
{
char acBuffer[VE_MAX_PATH_LEN];
auto c = spSrc->FindFirst("hlsl/*.?so_5_0");
if (c)
{
do
{
auto d = c->data();
if (VE_MASK_HAS_ANY(d.m_u32Attribute, VE_PATTR_ARCH))
{
VeSprintf(acBuffer, "hlsl/%s", d.m_pcName);
VeArchivePtr spArchive = spSrc->OpenArchive(acBuffer);
VE_ASSERT(spArchive);
const char* dot = vtd::strrchr(d.m_pcName, '.');
switch (dot[1])
{
case 'v':
{
D3D12VertexShader* pkShader = VE_NEW D3D12VertexShader(d.m_stSize);
VE_ASSERT_EQ(spArchive->Read(pkShader->m_pvData, d.m_stSize), d.m_stSize);
m_kVertexShaderMap[vtd::string(d.m_pcName, (size_t)(dot - d.m_pcName))] = pkShader;
break;
}
case 'p':
{
D3D12PixelShader* pkShader = VE_NEW D3D12PixelShader(d.m_stSize);
VE_ASSERT_EQ(spArchive->Read(pkShader->m_pvData, d.m_stSize), d.m_stSize);
m_kPixelShaderMap[vtd::string(d.m_pcName, (size_t)(dot - d.m_pcName))] = pkShader;
break;
}
case 'g':
{
D3DGeometryShader* pkShader = VE_NEW D3DGeometryShader(d.m_stSize);
VE_ASSERT_EQ(spArchive->Read(pkShader->m_pvData, d.m_stSize), d.m_stSize);
m_kGeometryShaderMap[vtd::string(d.m_pcName, (size_t)(dot - d.m_pcName))] = pkShader;
break;
}
case 'h':
{
D3DHullShader* pkShader = VE_NEW D3DHullShader(d.m_stSize);
VE_ASSERT_EQ(spArchive->Read(pkShader->m_pvData, d.m_stSize), d.m_stSize);
m_kHullShaderMap[vtd::string(d.m_pcName, (size_t)(dot - d.m_pcName))] = pkShader;
break;
}
case 'd':
{
D3DDomainShader* pkShader = VE_NEW D3DDomainShader(d.m_stSize);
VE_ASSERT_EQ(spArchive->Read(pkShader->m_pvData, d.m_stSize), d.m_stSize);
m_kDomainShaderMap[vtd::string(d.m_pcName, (size_t)(dot - d.m_pcName))] = pkShader;
break;
}
case 'c':
{
D3DComputeShader* pkShader = VE_NEW D3DComputeShader(d.m_stSize);
VE_ASSERT_EQ(spArchive->Read(pkShader->m_pvData, d.m_stSize), d.m_stSize);
m_kComputeShaderMap[vtd::string(d.m_pcName, (size_t)(dot - d.m_pcName))] = pkShader;
break;
}
default:
break;
}
}
} while (c->next());
}
}
//--------------------------------------------------------------------------
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();
}
