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; }