void CVisualizerScope::Create(int Width, int Height)
{
CVisualizerBase::Create(Width, Height);
SAFE_RELEASE_ARRAY(m_pBlitBuffer);
SAFE_RELEASE_ARRAY(m_pWindowBuf);
m_pBlitBuffer = new COLORREF[Width * (Height + 1)];
memset(m_pBlitBuffer, 0, Width * Height * sizeof(COLORREF));
m_pWindowBuf = new short[Width];
m_iWindowBufPtr = 0;
}
//-------------------------------------------------------------------------------------
bool KBEEmailVerificationTableMysql::delAccount(DBInterface * dbi, int8 type, const std::string& name)
{
std::string sqlstr = "delete from kbe_email_verification where accountName=";
char* tbuf = new char[MAX_BUF * 3];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\" and type=";
kbe_snprintf(tbuf, MAX_BUF, "%d", type);
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::delAccount({}): sql({}) is failed({})!\n",
name, sqlstr, dbi->getstrerror()));
return false;
}
return true;
}
//-------------------------------------------------------------------------------------
bool KBEAccountTableMysql::logAccount(DBInterface * dbi, ACCOUNT_INFOS& info)
{
std::string sqlstr = "insert into kbe_accountinfos (accountName, password, entityDBID) values(";
char* tbuf = new char[MAX_BUF * 3];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.name.c_str(), info.name.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.password.c_str(), info.password.size());
sqlstr += "md5(\"";
sqlstr += tbuf;
sqlstr += "\"),";
kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, info.dbid);
sqlstr += tbuf;
sqlstr += ")";
SAFE_RELEASE_ARRAY(tbuf);
// 如果查询失败则返回存在， 避免可能产生的错误
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
return false;
return true;
}
void CSampleView::CalculateSample(CDSample *pSample, int Start)
{
int Samples = pSample->SampleSize;
int Size = Samples * 8;
SAFE_RELEASE_ARRAY(m_pSamples);
if (pSample->SampleSize == 0) {
m_iSize = 0;
m_iStartCursor = 0;
m_iSelStart = m_iSelEnd = -1;
return;
}
m_pSamples = new int[Size];
m_iSize = Size;
int cntr = Start;
for (int i = 0; i < Size; ++i) {
if (pSample->SampleData[i / 8] & (1 << (i % 8))) {
if (cntr < 126)
cntr += 2;
}
else {
if (cntr > 1)
cntr -= 2;
}
m_pSamples[i] = cntr;
}
m_iSelStart = m_iSelEnd = -1;
m_iStartCursor = 0;
}
CSampleView::~CSampleView()
{
SAFE_RELEASE_ARRAY(m_pSamples);
SAFE_RELEASE(m_pSolidPen);
SAFE_RELEASE(m_pDashedPen);
SAFE_RELEASE(m_pGrayDashedPen);
SAFE_RELEASE(m_pDarkGrayDashedPen);
}
//-------------------------------------------------------------------------------------
bool KBEEntityLogTableMysql::logEntity(DBInterface * dbi, const char* ip, uint32 port, DBID dbid,
COMPONENT_ID componentID, ENTITY_ID entityID, ENTITY_SCRIPT_UID entityType)
{
std::string sqlstr = "insert into kbe_entitylog (entityDBID, entityType, entityID, ip, port, componentID) values(";
char* tbuf = new char[MAX_BUF * 3];
kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, dbid);
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%u", entityType);
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%d", entityID);
sqlstr += tbuf;
sqlstr += ",\"";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, ip, strlen(ip));
sqlstr += tbuf;
sqlstr += "\",";
kbe_snprintf(tbuf, MAX_BUF, "%u", port);
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, componentID);
sqlstr += tbuf;
sqlstr += ")";
SAFE_RELEASE_ARRAY(tbuf);
try
{
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
// 1062 int err = dbi->getlasterror();
return false;
}
}
catch (std::exception & e)
{
DBException& dbe = static_cast<DBException&>(e);
if(dbe.isLostConnection())
{
if(dbi->processException(e))
return true;
}
return false;
}
return true;
}
//-------------------------------------------------------------------------------------
void Channel::clearState( bool warnOnDiscard /*=false*/ )
{
// 清空未处理的接受包缓存
if (bufferedReceives_.size() > 0)
{
BufferedReceives::iterator iter = bufferedReceives_.begin();
int hasDiscard = 0;
for(; iter != bufferedReceives_.end(); iter++)
{
Packet* pPacket = (*iter);
if(pPacket->opsize() > 0)
hasDiscard++;
if(pPacket->isTCPPacket())
TCPPacket::ObjPool().reclaimObject(static_cast<TCPPacket*>(pPacket));
else
UDPPacket::ObjPool().reclaimObject(static_cast<UDPPacket*>(pPacket));
}
if (hasDiscard > 0 && warnOnDiscard)
{
WARNING_MSG( "Channel::clearState( %s ): "
"Discarding %u buffered packet(s)\n",
this->c_str(), hasDiscard );
}
bufferedReceives_.clear();
}
lastReceivedTime_ = timestamp();
roundTripTime_ =
this->isInternal() ? stampsPerSecond() / 10 : stampsPerSecond();
isCondemn_ = false;
shouldDropNextSend_ = false;
numPacketsSent_ = 0;
numPacketsReceived_ = 0;
numBytesSent_ = 0;
numBytesReceived_ = 0;
fragmentDatasFlag_ = FRAGMENT_DATA_UNKNOW;
pFragmentDatasWpos_ = 0;
pFragmentDatasRemain_ = 0;
currMsgID_ = 0;
currMsgLen_ = 0;
proxyID_ = 0;
isHandshake_ = false;
channelType_ = CHANNEL_NORMAL;
SAFE_RELEASE_ARRAY(pFragmentDatas_);
MemoryStream::ObjPool().reclaimObject(pFragmentStream_);
pFragmentStream_ = NULL;
inactivityTimerHandle_.cancel();
this->endpoint(NULL);
}
//-------------------------------------------------------------------------------------
DataDownload::~DataDownload()
{
SAFE_RELEASE_ARRAY(stream_);
Proxy* proxy = static_cast<Proxy*>(Baseapp::getSingleton().findEntity(entityID_));
if(proxy)
{
proxy->onStreamComplete(id_, totalBytes_ > 0 ? totalSentBytes_ == totalBytes_ : false);
}
}
void CVisualizerSpectrum::Create(int Width, int Height)
{
CVisualizerBase::Create(Width, Height);
SAFE_RELEASE_ARRAY(m_pBlitBuffer);
m_pBlitBuffer = new COLORREF[Width * Height];
memset(m_pBlitBuffer, BG_COLOR, Width * Height * sizeof(COLORREF));
// Calculate window function (Hann)
float fraction = 6.283185f / (FFT_POINTS - 1);
for (int i = FFT_POINTS; i--;)
m_fWindow[i] = 0.5f * (1.0f - cosf(float(i * fraction)));
}
//-------------------------------------------------------------------------------------
bool KBEEmailVerificationTableMysql::logAccount(DBInterface * dbi, int8 type, const std::string& name,
const std::string& datas, const std::string& code)
{
std::string sqlstr = "insert into kbe_email_verification (accountName, type, datas, code, logtime) values(";
char* tbuf = new char[MAX_BUF > datas.size() ? MAX_BUF * 3 :
(code.size() > datas.size() ? code.size() * 3 : datas.size() * 3)];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
kbe_snprintf(tbuf, MAX_BUF, "%d,", type);
sqlstr += tbuf;
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, datas.c_str(), datas.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, code.c_str(), code.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
kbe_snprintf(tbuf, MAX_BUF, "%"PRTime, time(NULL));
sqlstr += tbuf;
sqlstr += ")";
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::logAccount({}): sql({}) is failed({})!\n",
code, sqlstr, dbi->getstrerror()));
return false;
}
return true;
}
//-------------------------------------------------------------------------------------
bool KBEAccountTableMysql::updatePassword(DBInterface * dbi, const std::string& name, const std::string& password)
{
char* tbuf = new char[MAX_BUF * 3];
char* tbuf1 = new char[MAX_BUF * 3];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, password.c_str(), password.size());
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf1, name.c_str(), name.size());
// 如果查询失败则返回存在， 避免可能产生的错误
if(!dbi->query(fmt::format("update kbe_accountinfos set password=\"{}\" where accountName like \"{}\"",
password, tbuf1), false))
{
SAFE_RELEASE_ARRAY(tbuf);
SAFE_RELEASE_ARRAY(tbuf1);
return false;
}
SAFE_RELEASE_ARRAY(tbuf);
SAFE_RELEASE_ARRAY(tbuf1);
return true;
}
//-------------------------------------------------------------------------------------
bool KBEAccountTableMysql::setFlagsDeadline(DBInterface * dbi, const std::string& name, uint32 flags, uint64 deadline)
{
char* tbuf = new char[name.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
std::string sqlstr = fmt::format("update kbe_accountinfos set flags={}, deadline={} where accountName like \"{}\"",
flags, deadline, tbuf);
SAFE_RELEASE_ARRAY(tbuf);
// 如果查询失败则返回存在， 避免可能产生的错误
if(dbi->query(sqlstr.c_str(), sqlstr.size(), false))
return true;
return false;
}
//-------------------------------------------------------------------------------------
bool KBEEmailVerificationTableMysql::queryAccount(DBInterface * dbi, int8 type, const std::string& name, ACCOUNT_INFOS& info)
{
std::string sqlstr = "select code, datas from kbe_email_verification where accountName like \"";
char* tbuf = new char[name.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
sqlstr += tbuf;
sqlstr += "\" and type=";
kbe_snprintf(tbuf, MAX_BUF, "%d", type);
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::queryAccount({}): sql({}) is failed({})!\n",
name, sqlstr, dbi->getstrerror()));
return false;
}
info.datas = "";
MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql());
if(pResult)
{
MYSQL_ROW arow;
while((arow = mysql_fetch_row(pResult)) != NULL)
{
info.name = name;
info.datas = arow[0];
info.password = arow[1];
}
mysql_free_result(pResult);
}
return info.datas.size() > 0;
}
void CSWSpectrum::Activate()
{
memset(&bmi, 0, sizeof(BITMAPINFO));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biHeight = -WIN_HEIGHT;
bmi.bmiHeader.biWidth = WIN_WIDTH;
bmi.bmiHeader.biPlanes = 1;
SAFE_RELEASE_ARRAY(m_pBlitBuffer);
m_pBlitBuffer = new int[WIN_WIDTH * WIN_HEIGHT * 2];
memset(m_pBlitBuffer, 0, WIN_WIDTH * WIN_HEIGHT * sizeof(int));
SAFE_RELEASE(m_pFftObject);
// m_pFftObject = new Fft(FFT_POINTS, 44100);
// Set default sample-rate
SetSampleRate(44100);
}
//-------------------------------------------------------------------------------------
bool KBEAccountTableMysql::queryAccount(DBInterface * dbi, const std::string& name, ACCOUNT_INFOS& info)
{
std::string sqlstr = "select entityDBID, password from kbe_accountinfos where accountName like \"";
char* tbuf = new char[name.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
sqlstr += "\"";
// 如果查询失败则返回存在， 避免可能产生的错误
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
return true;
info.dbid = 0;
MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql());
if(pResult)
{
MYSQL_ROW arow;
while((arow = mysql_fetch_row(pResult)) != NULL)
{
std::stringstream sval;
sval << arow[0];
DBID old_dbid;
sval >> old_dbid;
info.dbid = old_dbid;
info.name = name;
info.password = arow[1];
}
mysql_free_result(pResult);
}
return info.dbid > 0;
}
bool CExportTest::Setup()
{
HMODULE hModule = LoadLibrary(_T("ExportTest.dll"));
if (hModule == NULL) {
AfxMessageBox(_T("Could not load ExportTest.dll"));
return false;
}
ImportFuncs.LoadFileFunc = (LoadFile_t)GetProcAddress(hModule, "LoadFile");
ImportFuncs.RunFrameFunc = (RunFrame_t)GetProcAddress(hModule, "RunFrame");
ImportFuncs.ReadResultFunc = (ReadResult_t)GetProcAddress(hModule, "ReadResult");
if (ImportFuncs.LoadFileFunc == NULL)
return false;
if (ImportFuncs.RunFrameFunc == NULL)
return false;
if (ImportFuncs.ReadResultFunc == NULL)
return false;
CFamiTrackerDoc *pDoc = CFamiTrackerDoc::GetDoc();
CCompiler Compiler(pDoc, NULL);
char *pMemory;
pMemory = new char[0x10000];
//stNSFHeader header;
int song = 0;
Compiler.ExportTest(pMemory, m_pHeader, MACHINE_NTSC);
// Setup memory
ImportFuncs.LoadFileFunc(pMemory, m_pHeader->LoadAddr, 0x10000);
SAFE_RELEASE_ARRAY(pMemory);
return true;
}
//-------------------------------------------------------------------------------------
bool KBEAccountTableMysql::queryAccountAllInfos(DBInterface * dbi, const std::string& name, ACCOUNT_INFOS& info)
{
std::string sqlstr = "select entityDBID, password, email, flags, deadline from kbe_accountinfos where accountName like \"";
char* tbuf = new char[name.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
sqlstr += "\"";
// 如果查询失败则返回存在， 避免可能产生的错误
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
return true;
info.dbid = 0;
MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql());
if(pResult)
{
MYSQL_ROW arow;
while((arow = mysql_fetch_row(pResult)) != NULL)
{
KBEngine::StringConv::str2value(info.dbid, arow[0]);
info.name = name;
info.password = arow[1];
info.email = arow[2];
KBEngine::StringConv::str2value(info.flags, arow[3]);
KBEngine::StringConv::str2value(info.deadline, arow[4]);
}
mysql_free_result(pResult);
}
return info.dbid > 0;
}
//-------------------------------------------------------------------------------------
bool NavMeshHandle::_create(int layer, const std::string& resPath, const std::string& res, NavMeshHandle* pNavMeshHandle)
{
KBE_ASSERT(pNavMeshHandle);
FILE* fp = fopen(res.c_str(), "rb");
if (!fp)
{
ERROR_MSG(fmt::format("NavMeshHandle::create: open({}) is error!\n",
Resmgr::getSingleton().matchRes(res)));
return false;
}
DEBUG_MSG(fmt::format("NavMeshHandle::create: ({}), layer={}\n",
res, layer));
bool safeStorage = true;
int pos = 0;
int size = sizeof(NavMeshSetHeader);
fseek(fp, 0, SEEK_END);
size_t flen = ftell(fp);
fseek(fp, 0, SEEK_SET);
uint8* data = new uint8[flen];
if(data == NULL)
{
ERROR_MSG(fmt::format("NavMeshHandle::create: open({}), memory(size={}) error!\n",
Resmgr::getSingleton().matchRes(res), flen));
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return false;
}
size_t readsize = fread(data, 1, flen, fp);
if(readsize != flen)
{
ERROR_MSG(fmt::format("NavMeshHandle::create: open({}), read(size={} != {}) error!\n",
Resmgr::getSingleton().matchRes(res), readsize, flen));
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return false;
}
if (readsize < sizeof(NavMeshSetHeader))
{
ERROR_MSG(fmt::format("NavMeshHandle::create: open({}), NavMeshSetHeader is error!\n",
Resmgr::getSingleton().matchRes(res)));
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return false;
}
NavMeshSetHeader header;
memcpy(&header, data, size);
pos += size;
if (header.version != NavMeshHandle::RCN_NAVMESH_VERSION)
{
ERROR_MSG(fmt::format("NavMeshHandle::create: navmesh version({}) is not match({})!\n",
header.version, ((int)NavMeshHandle::RCN_NAVMESH_VERSION)));
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return false;
}
dtNavMesh* mesh = dtAllocNavMesh();
if (!mesh)
{
ERROR_MSG("NavMeshHandle::create: dtAllocNavMesh is failed!\n");
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return false;
}
dtStatus status = mesh->init(&header.params);
if (dtStatusFailed(status))
{
ERROR_MSG(fmt::format("NavMeshHandle::create: mesh init is error({})!\n", status));
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return false;
}
// Read tiles.
bool success = true;
for (int i = 0; i < header.tileCount; ++i)
{
NavMeshTileHeader tileHeader;
size = sizeof(NavMeshTileHeader);
memcpy(&tileHeader, &data[pos], size);
pos += size;
size = tileHeader.dataSize;
if (!tileHeader.tileRef || !tileHeader.dataSize)
{
success = false;
status = DT_FAILURE + DT_INVALID_PARAM;
break;
}
unsigned char* tileData =
(unsigned char*)dtAlloc(size, DT_ALLOC_PERM);
if (!tileData)
{
success = false;
status = DT_FAILURE + DT_OUT_OF_MEMORY;
break;
}
memcpy(tileData, &data[pos], size);
pos += size;
status = mesh->addTile(tileData
, size
, (safeStorage ? DT_TILE_FREE_DATA : 0)
, tileHeader.tileRef
, 0);
if (dtStatusFailed(status))
{
success = false;
break;
}
}
fclose(fp);
SAFE_RELEASE_ARRAY(data);
if (!success)
{
ERROR_MSG(fmt::format("NavMeshHandle::create: error({})!\n", status));
dtFreeNavMesh(mesh);
return false;
}
dtNavMeshQuery* pMavmeshQuery = new dtNavMeshQuery();
pMavmeshQuery->init(mesh, 1024);
pNavMeshHandle->resPath = resPath;
pNavMeshHandle->navmeshLayer[layer].pNavmeshQuery = pMavmeshQuery;
pNavMeshHandle->navmeshLayer[layer].pNavmesh = mesh;
uint32 tileCount = 0;
uint32 nodeCount = 0;
uint32 polyCount = 0;
uint32 vertCount = 0;
uint32 triCount = 0;
uint32 triVertCount = 0;
uint32 dataSize = 0;
const dtNavMesh* navmesh = mesh;
for (int32 i = 0; i < navmesh->getMaxTiles(); ++i)
{
const dtMeshTile* tile = navmesh->getTile(i);
if (!tile || !tile->header)
continue;
tileCount ++;
nodeCount += tile->header->bvNodeCount;
polyCount += tile->header->polyCount;
vertCount += tile->header->vertCount;
triCount += tile->header->detailTriCount;
triVertCount += tile->header->detailVertCount;
dataSize += tile->dataSize;
// DEBUG_MSG(fmt::format("NavMeshHandle::create: verts({}, {}, {})\n", tile->verts[0], tile->verts[1], tile->verts[2]));
}
DEBUG_MSG(fmt::format("\t==> tiles loaded: {}\n", tileCount));
DEBUG_MSG(fmt::format("\t==> BVTree nodes: {}\n", nodeCount));
DEBUG_MSG(fmt::format("\t==> {} polygons ({} vertices)\n", polyCount, vertCount));
DEBUG_MSG(fmt::format("\t==> {} triangles ({} vertices)\n", triCount, triVertCount));
DEBUG_MSG(fmt::format("\t==> {:.2f} MB of data (not including pointers)\n", (((float)dataSize / sizeof(unsigned char)) / 1048576)));
return true;
}
CConfigShortcuts::~CConfigShortcuts()
{
SAFE_RELEASE_ARRAY(m_iKeys);
SAFE_RELEASE_ARRAY(m_iMods);
}
//-------------------------------------------------------------------------------------
NavMeshHandle* NavMeshEx::loadNavmesh(std::string name)
{
if(name == "")
return NULL;
KBEngine::thread::ThreadGuard tg(&mutex_);
std::string path = Resmgr::getSingleton().matchRes("spaces/" + name + "/" + name + ".navmesh_srv");
if(navmeshs_.find(name) != navmeshs_.end())
{
return NULL;
}
FILE* fp = fopen(path.c_str(), "rb");
if (!fp)
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: open(%1%) is error!\n") % path);
return NULL;
}
bool safeStorage = true;
int pos = 0;
int size = sizeof(NavMeshSetHeader);
fseek(fp, 0, SEEK_END);
size_t flen = ftell(fp);
fseek(fp, 0, SEEK_SET);
uint8* data = new uint8[flen];
if(data == NULL)
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: open(%1%), memory(size=%2%) error!\n") % path % flen);
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return NULL;
}
size_t readsize = fread(data, 1, flen, fp);
if(readsize != flen)
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: open(%1%), read(size=%2% != %3%) error!\n") % path % readsize % flen);
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return NULL;
}
if (readsize < sizeof(NavMeshSetHeader))
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: open(%1%), NavMeshSetHeader is error!\n") % path);
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return NULL;
}
NavMeshSetHeader header;
memcpy(&header, data, size);
pos += size;
if (header.version != RCN_NAVMESH_VERSION)
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: version(%1%) is not match(%2%)!\n") % header.version % RCN_NAVMESH_VERSION);
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return NULL;
}
dtNavMesh* mesh = dtAllocNavMesh();
if (!mesh)
{
ERROR_MSG("NavMeshEx::loadNavmesh: dtAllocNavMesh is failed!\n");
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return NULL;
}
dtStatus status = mesh->init(&header.params);
if (dtStatusFailed(status))
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: mesh init is error(%1%)!\n") % status);
fclose(fp);
SAFE_RELEASE_ARRAY(data);
return NULL;
}
// Read tiles.
bool success = true;
for (int i = 0; i < header.tileCount; ++i)
{
NavMeshTileHeader tileHeader;
size = sizeof(NavMeshTileHeader);
memcpy(&tileHeader, &data[pos], size);
pos += size;
size = tileHeader.dataSize;
if (!tileHeader.tileRef || !tileHeader.dataSize)
{
success = false;
status = DT_FAILURE + DT_INVALID_PARAM;
break;
}
unsigned char* tileData =
(unsigned char*)dtAlloc(size, DT_ALLOC_PERM);
if (!tileData)
{
success = false;
status = DT_FAILURE + DT_OUT_OF_MEMORY;
break;
}
memcpy(tileData, &data[pos], size);
pos += size;
status = mesh->addTile(tileData
, size
, (safeStorage ? DT_TILE_FREE_DATA : 0)
, tileHeader.tileRef
, 0);
if (dtStatusFailed(status))
{
success = false;
break;
}
}
fclose(fp);
SAFE_RELEASE_ARRAY(data);
if (!success)
{
ERROR_MSG(boost::format("NavMeshEx::loadNavmesh: error(%1%)!\n") % status);
dtFreeNavMesh(mesh);
return NULL;
}
NavMeshHandle* pNavMeshHandle = new NavMeshHandle();
pNavMeshHandle->navmesh = mesh;
pNavMeshHandle->navmeshQuery = new dtNavMeshQuery();
pNavMeshHandle->navmeshQuery->init(mesh, 1024);
pNavMeshHandle->name = name;
navmeshs_[name] = pNavMeshHandle;
uint32 tileCount = 0;
uint32 nodeCount = 0;
uint32 polyCount = 0;
uint32 vertCount = 0;
uint32 triCount = 0;
uint32 triVertCount = 0;
uint32 dataSize = 0;
const dtNavMesh* navmesh = mesh;
for (int32 i = 0; i < navmesh->getMaxTiles(); ++i)
{
const dtMeshTile* tile = navmesh->getTile(i);
if (!tile || !tile->header)
continue;
tileCount ++;
nodeCount += tile->header->bvNodeCount;
polyCount += tile->header->polyCount;
vertCount += tile->header->vertCount;
triCount += tile->header->detailTriCount;
triVertCount += tile->header->detailVertCount;
dataSize += tile->dataSize;
// DEBUG_MSG(boost::format("NavMeshEx::loadNavmesh: verts(%1%, %2%, %3%)\n") % tile->verts[0] % tile->verts[1] % tile->verts[2]);
}
DEBUG_MSG(boost::format("NavMeshEx::loadNavmesh: (%1%)\n") % name);
DEBUG_MSG(boost::format("\t==> tiles loaded: %1%\n") % tileCount);
DEBUG_MSG(boost::format("\t==> BVTree nodes: %1%\n") % nodeCount);
DEBUG_MSG(boost::format("\t==> %1% polygons (%2% vertices)\n") % polyCount % vertCount);
DEBUG_MSG(boost::format("\t==> %1% triangles (%2% vertices)\n") % triCount % triVertCount);
DEBUG_MSG(boost::format("\t==> %.2f MB of data (not including pointers)\n") % (((float)dataSize / sizeof(unsigned char)) / 1048576));
return pNavMeshHandle;
}
//-------------------------------------------------------------------------------------
bool KBEEmailVerificationTableMysql::activateAccount(DBInterface * dbi, const std::string& code, ACCOUNT_INFOS& info)
{
std::string sqlstr = "select accountName, datas, logtime from kbe_email_verification where code like \"";
char* tbuf = new char[code.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, code.c_str(), code.size());
sqlstr += tbuf;
sqlstr += "\" and type=";
kbe_snprintf(tbuf, MAX_BUF, "%d", (int)KBEEmailVerificationTable::V_TYPE_CREATEACCOUNT);
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): sql({}) is failed({})!\n",
code, sqlstr, dbi->getstrerror()));
return false;
}
uint64 logtime = 1;
MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql());
if(pResult)
{
MYSQL_ROW arow;
while((arow = mysql_fetch_row(pResult)) != NULL)
{
info.name = arow[0];
info.password = arow[1];
KBEngine::StringConv::str2value(logtime, arow[2]);
}
mysql_free_result(pResult);
}
if(logtime > 0 && time(NULL) - logtime > g_kbeSrvConfig.emailAtivationInfo_.deadline)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): is expired! {} > {}.\n",
code, (time(NULL) - logtime), g_kbeSrvConfig.emailAtivationInfo_.deadline));
return false;
}
if(info.name.size() == 0)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): name is NULL.\n",
code));
return false;
}
std::string password = info.password;
// 寻找dblog是否有此账号
KBEAccountTable* pTable = static_cast<KBEAccountTable*>(EntityTables::getSingleton().findKBETable("kbe_accountinfos"));
KBE_ASSERT(pTable);
info.flags = 0;
if(!pTable->queryAccount(dbi, info.name, info))
{
return false;
}
if((info.flags & ACCOUNT_FLAG_NOT_ACTIVATED) <= 0)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): Has been activated, flags={}.\n",
code, info.flags));
return false;
}
info.flags &= ~ACCOUNT_FLAG_NOT_ACTIVATED;
if(!pTable->setFlagsDeadline(dbi, info.name, info.flags, info.deadline))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): set deadline is error({})!\n",
code, dbi->getstrerror()));
return false;
}
if(!pTable->updatePassword(dbi, info.name, password))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): update password is error({})!\n",
code, dbi->getstrerror()));
return false;
}
info.dbid = 0;
ScriptDefModule* pModule = EntityDef::findScriptModule(DBUtil::accountScriptName());
// 防止多线程问题， 这里做一个拷贝。
MemoryStream copyAccountDefMemoryStream(pTable->accountDefMemoryStream());
info.dbid = EntityTables::getSingleton().writeEntity(dbi, 0, -1,
©AccountDefMemoryStream, pModule);
KBE_ASSERT(info.dbid > 0);
// 如果查询失败则返回存在， 避免可能产生的错误
tbuf = new char[MAX_BUF * 3];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.name.c_str(), info.name.size());
if(!dbi->query(fmt::format("update kbe_accountinfos set entityDBID={} where accountName like \"{}\"",
info.dbid, tbuf), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::activateAccount({}): update kbe_accountinfos is error({})!\n",
code, dbi->getstrerror()));
SAFE_RELEASE_ARRAY(tbuf);
return false;
}
SAFE_RELEASE_ARRAY(tbuf);
try
{
delAccount(dbi, (int8)V_TYPE_CREATEACCOUNT, info.name);
}
catch (...)
{
}
return true;
}
CVisualizerSpectrum::~CVisualizerSpectrum()
{
SAFE_RELEASE_ARRAY(m_pBlitBuffer);
SAFE_RELEASE(m_pFftObject);
}
//-------------------------------------------------------------------------------------
bool KBEEmailVerificationTableMysql::bindEMail(DBInterface * dbi, const std::string& name, const std::string& code)
{
std::string sqlstr = "select accountName, datas, logtime from kbe_email_verification where code like \"";
char* tbuf = new char[code.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, code.c_str(), code.size());
sqlstr += tbuf;
sqlstr += "\" and type=";
kbe_snprintf(tbuf, MAX_BUF, "%d", (int)KBEEmailVerificationTable::V_TYPE_BIND_MAIL);
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::bindEMail({}): sql({}) is failed({})!\n",
code, sqlstr, dbi->getstrerror()));
return false;
}
uint64 logtime = 1;
std::string qname, qemail;
MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql());
if(pResult)
{
MYSQL_ROW arow;
while((arow = mysql_fetch_row(pResult)) != NULL)
{
qname = arow[0];
qemail = arow[1];
KBEngine::StringConv::str2value(logtime, arow[2]);
}
mysql_free_result(pResult);
}
if(logtime > 0 && time(NULL) - logtime > g_kbeSrvConfig.emailBindInfo_.deadline)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::bindEMail({}): is expired! {} > {}.\n",
code, (time(NULL) - logtime), g_kbeSrvConfig.emailBindInfo_.deadline));
return false;
}
if(qname.size() == 0 || qemail.size() == 0)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::bindEMail({}): name or email is NULL.\n",
code));
return false;
}
if(qname != name)
{
WARNING_MSG(fmt::format("KBEEmailVerificationTableMysql::bindEMail: code({}) username({}, {}) not match.\n"
, code, name, qname));
return false;
}
tbuf = new char[code.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, qemail.c_str(), qemail.size());
sqlstr = "update kbe_accountinfos set email=\"";
sqlstr += tbuf;
sqlstr += "\" where accountName like \"";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, name.c_str(), name.size());
sqlstr += tbuf;
sqlstr += "\"";
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr, false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::bindEMail({}): update kbe_accountinfos is error({})!\n",
code, dbi->getstrerror()));
return false;
}
try
{
delAccount(dbi, (int8)V_TYPE_BIND_MAIL, name);
}
catch (...)
{
}
return true;
}
//-------------------------------------------------------------------------------------
bool KBEEmailVerificationTableMysql::resetpassword(DBInterface * dbi, const std::string& name,
const std::string& password, const std::string& code)
{
std::string sqlstr = "select accountName, logtime from kbe_email_verification where code like \"";
char* tbuf = new char[code.size() * 2 + 1];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, code.c_str(), code.size());
sqlstr += tbuf;
sqlstr += "\" and type=";
kbe_snprintf(tbuf, MAX_BUF, "%d", (int)KBEEmailVerificationTable::V_TYPE_RESETPASSWORD);
sqlstr += tbuf;
SAFE_RELEASE_ARRAY(tbuf);
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::resetpassword({}): sql({}) is failed({})!\n",
code, sqlstr, dbi->getstrerror()));
return false;
}
uint64 logtime = 1;
std::string qname;
MYSQL_RES * pResult = mysql_store_result(static_cast<DBInterfaceMysql*>(dbi)->mysql());
if(pResult)
{
MYSQL_ROW arow;
while((arow = mysql_fetch_row(pResult)) != NULL)
{
qname = arow[0];
KBEngine::StringConv::str2value(logtime, arow[1]);
}
mysql_free_result(pResult);
}
if(logtime > 0 && time(NULL) - logtime > g_kbeSrvConfig.emailResetPasswordInfo_.deadline)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::bindEMail({}): is expired! {} > {}.\n",
code, (time(NULL) - logtime), g_kbeSrvConfig.emailResetPasswordInfo_.deadline));
return false;
}
if(qname.size() == 0 || password.size() == 0)
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::resetpassword({}): name or password is NULL.\n",
code));
return false;
}
if(qname != name)
{
WARNING_MSG(fmt::format("KBEEmailVerificationTableMysql::resetpassword: code({}) username({}, {}) not match.\n"
, code, name, qname));
return false;
}
// 寻找dblog是否有此账号
KBEAccountTable* pTable = static_cast<KBEAccountTable*>(EntityTables::getSingleton().findKBETable("kbe_accountinfos"));
KBE_ASSERT(pTable);
if(!pTable->updatePassword(dbi, name, KBE_MD5::getDigest(password.data(), password.length())))
{
ERROR_MSG(fmt::format("KBEEmailVerificationTableMysql::resetpassword({}): update password is error({})!\n",
code, dbi->getstrerror()));
return false;
}
try
{
delAccount(dbi, (int8)V_TYPE_RESETPASSWORD, name);
}
catch (...)
{
}
return true;
}
bool CExportTest::Setup(LPCTSTR lpszFile)
{
if (m_hModule == NULL)
m_hModule = ::LoadLibrary(_T("ExportTest.dll"));
if (m_hModule == NULL) {
AfxMessageBox(_T("Could not load ExportTest.dll"));
return false;
}
ImportFuncs.LoadFileFunc = (LoadFile_t)GetProcAddress(m_hModule, "LoadFile");
ImportFuncs.RunFrameFunc = (RunFrame_t)GetProcAddress(m_hModule, "RunFrame");
ImportFuncs.ReadResultFunc = (ReadResult_t)GetProcAddress(m_hModule, "ReadResult");
if (ImportFuncs.LoadFileFunc == NULL)
return false;
if (ImportFuncs.RunFrameFunc == NULL)
return false;
if (ImportFuncs.ReadResultFunc == NULL)
return false;
TCHAR TempPath[MAX_PATH];
TCHAR TempFile[MAX_PATH];
if (lpszFile == NULL || strlen(lpszFile) == 0) {
// Get a temporary filename
GetTempPath(MAX_PATH, TempPath);
GetTempFileName(TempPath, _T("NSF-TEST"), 0, TempFile);
TRACE1("ExportTest: Creating file %s\n", TempFile);
// Export file
CFamiTrackerDoc *pDoc = CFamiTrackerDoc::GetDoc();
CCompiler Compiler(pDoc, NULL);
Compiler.ExportNSF(CString(TempFile), MACHINE_NTSC);
}
else {
_tcscpy_s(TempFile, MAX_PATH, lpszFile);
}
CFile inFile(TempFile, CFile::modeRead);
int size = (int)inFile.GetLength() - sizeof(stNSFHeader);
char *pMemory = new char[size];
inFile.Read(m_pHeader, sizeof(stNSFHeader));
inFile.Read(pMemory, size);
inFile.Close();
if (lpszFile == NULL) {
// Delete temporary file
DeleteFile(TempFile);
}
m_iFileSize = size;
// Setup memory
ImportFuncs.LoadFileFunc(pMemory, size, m_pHeader);
SAFE_RELEASE_ARRAY(pMemory);
return true;
}
CFrameClipData::~CFrameClipData()
{
SAFE_RELEASE_ARRAY(pFrames);
}
//--------------------------------------------------------------------------------
void GFSDK::SSAO::RandomTexture::Release()
{
SAFE_RELEASE_ARRAY(m_pSRVs);
SAFE_RELEASE(m_pTexture);
}
//-------------------------------------------------------------------------------------
bool KBEAccountTableMysql::logAccount(DBInterface * dbi, ACCOUNT_INFOS& info)
{
std::string sqlstr = "insert into kbe_accountinfos (accountName, password, bindata, email, entityDBID, flags, deadline, regtime, lasttime) values(";
char* tbuf = new char[MAX_BUF > info.datas.size() ? MAX_BUF * 3 : info.datas.size() * 3];
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.name.c_str(), info.name.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.password.c_str(), info.password.size());
sqlstr += "md5(\"";
sqlstr += tbuf;
sqlstr += "\"),";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.datas.data(), info.datas.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
mysql_real_escape_string(static_cast<DBInterfaceMysql*>(dbi)->mysql(),
tbuf, info.email.c_str(), info.email.size());
sqlstr += "\"";
sqlstr += tbuf;
sqlstr += "\",";
kbe_snprintf(tbuf, MAX_BUF, "%"PRDBID, info.dbid);
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%u", info.flags);
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%"PRIu64, info.deadline);
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%"PRTime, time(NULL));
sqlstr += tbuf;
sqlstr += ",";
kbe_snprintf(tbuf, MAX_BUF, "%"PRTime, time(NULL));
sqlstr += tbuf;
sqlstr += ")";
SAFE_RELEASE_ARRAY(tbuf);
// 如果查询失败则返回存在， 避免可能产生的错误
if(!dbi->query(sqlstr.c_str(), sqlstr.size(), false))
{
ERROR_MSG(fmt::format("KBEAccountTableMysql::logAccount({}): sql({}) is failed({})!\n",
info.name, sqlstr, dbi->getstrerror()));
return false;
}
return true;
}
CVisualizerScope::~CVisualizerScope()
{
SAFE_RELEASE_ARRAY(m_pBlitBuffer);
SAFE_RELEASE_ARRAY(m_pWindowBuf);
}
void CSWSpectrum::Deactivate()
{
SAFE_RELEASE_ARRAY(m_pBlitBuffer);
SAFE_RELEASE(m_pFftObject);
}
