// Create a DX11 context //----------------------------------------------------------------------------- CPUTResult CPUT_DX11::CreateDXContext(CPUTContextCreation ContextParams ) { HRESULT hr = S_OK; CPUTResult result = CPUT_SUCCESS; // window params RECT rc; HWND hWnd = mpWindow->GetHWnd(); GetClientRect( hWnd, &rc ); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top; // set up DirectX creation parameters mdriverType = D3D_DRIVER_TYPE_NULL; mfeatureLevel = D3D_FEATURE_LEVEL_11_0; mpD3dDevice = NULL; mpContext = NULL; mpSwapChain = NULL; mSwapChainBufferCount = ContextParams.swapChainBufferCount; mpBackBufferRTV = NULL; UINT createDeviceFlags = 0; #ifdef _DEBUG createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; #endif D3D_DRIVER_TYPE driverTypes[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP, D3D_DRIVER_TYPE_REFERENCE, }; UINT numDriverTypes = ARRAYSIZE( driverTypes ); // SRV's (shader resource views) require Structured Buffer // usage (D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) which was // introduced in shader model 5 (directx 11.0) // D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0 }; UINT numFeatureLevels = ARRAYSIZE( featureLevels ); // swap chain information DXGI_SWAP_CHAIN_DESC sd; ZeroMemory( &sd, sizeof( sd ) ); sd.BufferCount = mSwapChainBufferCount; sd.BufferDesc.Width = width; sd.BufferDesc.Height = height; mSwapChainFormat = ContextParams.swapChainFormat; sd.BufferDesc.Format = ContextParams.swapChainFormat; sd.BufferDesc.RefreshRate.Numerator = ContextParams.refreshRate; sd.BufferDesc.RefreshRate.Denominator = 1; sd.BufferUsage = ContextParams.swapChainUsage; sd.OutputWindow = hWnd; sd.SampleDesc.Count = 1; // Number of MSAA samples sd.SampleDesc.Quality = 0; sd.Windowed = TRUE; sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; // set the vsync parameter if(0 != ContextParams.refreshRate) { mSyncInterval = 1; } // walk devices and create device and swap chain on best matching piece of hardware bool functionalityTestPassed = false; for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ ) { mdriverType = driverTypes[driverTypeIndex]; hr = D3D11CreateDeviceAndSwapChain( NULL, mdriverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &sd, &mpSwapChain, &mpD3dDevice, &mfeatureLevel, &mpContext ); if( SUCCEEDED( hr ) ) { functionalityTestPassed = TestContextForRequiredFeatures(); if(true == functionalityTestPassed) { break; } else { // context was created, but failed to have required features // release and destroy this context and created resources SAFE_RELEASE(mpSwapChain); SAFE_RELEASE(mpContext); SAFE_RELEASE(mpD3dDevice); } } } ASSERT( (SUCCEEDED(hr) && (true==functionalityTestPassed)), _L("Failed creating device and swap chain.") ); if(!SUCCEEDED(hr) || !functionalityTestPassed) { CPUTOSServices::GetOSServices()->OpenMessageBox(_L("Required DirectX hardware support not present"), _L("Your system does not support the DirectX feature levels required for this sample.")); exit(1); // exit app directly } // If the WARP or Reference rasterizer is being used, the performance is probably terrible. // we throw up a dialog right after drawing the loading screen in CPUTCreateWindowAndContext // warning about that perf problem // call the DeviceCreated callback/backbuffer/etc creation result = CreateContext(); CPUTRenderStateBlock *pBlock = new CPUTRenderStateBlockDX11(); pBlock->CreateNativeResources(); CPUTRenderStateBlock::SetDefaultRenderStateBlock( pBlock ); // Create the per-frame constant buffer. D3D11_BUFFER_DESC bd = {0}; bd.ByteWidth = sizeof(CPUTFrameConstantBuffer); bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER; bd.Usage = D3D11_USAGE_DYNAMIC; bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; ID3D11Buffer *pPerFrameConstantBuffer; hr = (CPUT_DX11::GetDevice())->CreateBuffer( &bd, NULL, &pPerFrameConstantBuffer ); ASSERT( !FAILED( hr ), _L("Error creating constant buffer.") ); CPUTSetDebugName( pPerFrameConstantBuffer, _L("Per-Frame Constant buffer") ); cString name = _L("$cbPerFrameValues"); mpPerFrameConstantBuffer = new CPUTBufferDX11( name, pPerFrameConstantBuffer ); CPUTAssetLibrary::GetAssetLibrary()->AddConstantBuffer( name, mpPerFrameConstantBuffer ); SAFE_RELEASE(pPerFrameConstantBuffer); // We're done with it. The CPUTBuffer now owns it. return result; }
BOOL UpdateValidationX509::ValidateUpdate( MFUpdate* pUpdate, UINT8* pValidation, INT32 validationLen ) { CK_MECHANISM_TYPE mechs[] = { CKM_RSA_PKCS }; CK_SLOT_ID slotID; CK_SESSION_HANDLE session; CK_OBJECT_CLASS ckoCert = CKO_CERTIFICATE; CK_OBJECT_HANDLE hCACert; CK_MECHANISM_TYPE sha1Mech = CKM_SHA_1; CK_MECHANISM mech = { CKM_RSA_PKCS, &sha1Mech, sizeof(sha1Mech) }; BOOL retVal = FALSE; UINT8* caCert; UINT32 certLen = 0; if(g_DebuggerPortSslConfig.GetCertificateAuthority == NULL) { return FALSE; } g_DebuggerPortSslConfig.GetCertificateAuthority( &caCert, &certLen ); CK_ATTRIBUTE attribs[] = { { CKA_CLASS , &ckoCert, sizeof(ckoCert) }, { CKA_VALUE , caCert , certLen } }; if(pUpdate->Providers->Storage == NULL) return FALSE; if(certLen == 0 || caCert == NULL ) return FALSE; if(pValidation == NULL ) return FALSE; C_Initialize(NULL); slotID = Cryptoki_FindSlot(NULL, mechs, ARRAYSIZE(mechs)); if(CK_SLOT_ID_INVALID == slotID) return FALSE; if(CKR_OK == C_OpenSession(slotID, CKF_SERIAL_SESSION, NULL, NULL, &session) && (CK_SESSION_HANDLE_INVALID != session)) { if(CKR_OK == C_CreateObject(session, attribs, ARRAYSIZE(attribs), &hCACert) && hCACert != CK_OBJECT_HANDLE_INVALID) { if(CKR_OK == C_VerifyInit(session, &mech, hCACert)) { UINT8 buff[512]; INT32 len = sizeof(buff); INT32 updateSize = pUpdate->Header.UpdateSize; INT32 offset = 0; while(offset < updateSize) { if((offset + len) > updateSize) { len = updateSize - offset; } if(!pUpdate->Providers->Storage->Read(pUpdate->StorageHandle, offset, buff, len)) break; C_VerifyUpdate(session, buff, len); offset += len; } retVal = CKR_OK == C_VerifyFinal(session, pValidation, (CK_ULONG)validationLen); } C_DestroyObject(session, hCACert); } C_CloseSession(session); } return retVal; }
void KyraEngine_MR::freeSceneShapes() { for (uint i = 0; i < ARRAYSIZE(_sceneShapes); ++i) { delete[] _sceneShapes[i]; _sceneShapes[i] = 0; } }
RemoteDesktop::EventLog::EventLog(std::wstring name){ Name = name; auto key_path(L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\" + name); HKEY key; DWORD last_error = RegCreateKeyEx(HKEY_LOCAL_MACHINE, key_path.c_str(), 0, 0, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, 0, &key, 0); if (ERROR_SUCCESS == last_error) { wchar_t szPath[MAX_PATH]; bool ret = false; GetModuleFileName(NULL, szPath, ARRAYSIZE(szPath)); const DWORD types_supported = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE; RegSetValueEx(key, L"EventMessageFile", 0, REG_SZ, (BYTE*)szPath, wcsnlen_s(szPath, MAX_PATH) * 2); RegSetValueEx(key, L"CategoryMessageFile", 0, REG_SZ, (BYTE*)szPath, wcsnlen_s(szPath, MAX_PATH) * 2); RegSetValueEx(key, L"ParameterMessageFile", 0, REG_SZ, (BYTE*)szPath, wcsnlen_s(szPath, MAX_PATH) * 2); RegSetValueEx(key, L"TypesSupported", 0, REG_DWORD, (LPBYTE)&types_supported, sizeof(types_supported)); DWORD catcount = 3; RegSetValueEx(key, L"CategoryCount", 0, REG_DWORD, (LPBYTE)&catcount, sizeof(catcount)); RegCloseKey(key); } else { std::cerr << "Failed to install source: " << last_error << "\n"; } _EventSource = RegisterEventSource(NULL, name.c_str()); }
void DoWrap(BOOL abWordWrap, EditorInfo &ei, int iMaxWidth) { INT_PTR iRc = 0; INT_PTR cchMax = 0; TCHAR* pszCopy = NULL; TCHAR szEOL[4]; INT_PTR iFrom, iTo, iEnd, iFind; bool bWasModifed = (ei.CurState & ECSTATE_MODIFIED) && !(ei.CurState & ECSTATE_SAVED); gbLastWrap = TRUE; for (INT_PTR i = 0; i < ei.TotalLines; i++) { //bool lbCurLine = (i == ei.CurLine); EditorGetString egs = {FARSTRUCTSIZE(egs)}; egs.StringNumber = i; iRc = EditCtrl(ECTL_GETSTRING, &egs); if (!iRc) { _ASSERTE(iRc!=0); goto wrap; } _ASSERTE(egs.StringText!=NULL); if ((egs.StringLength <= iMaxWidth) && ((egs.StringLength <= 0) || !(egs.StringText && wcschr(egs.StringText, L'\t')))) { // Эту строку резать не нужно continue; } lstrcpyn(szEOL, egs.StringEOL?egs.StringEOL:_T(""), ARRAYSIZE(szEOL)); if (egs.StringLength >= cchMax || !pszCopy) { if (pszCopy) free(pszCopy); cchMax = egs.StringLength + 255; pszCopy = (TCHAR*)malloc(cchMax*sizeof(*pszCopy)); if (!pszCopy) { _ASSERTE(pszCopy!=NULL); goto wrap; } } // Делаем копию, над которой можем издеваться memmove(pszCopy, egs.StringText, egs.StringLength*sizeof(*pszCopy)); pszCopy[egs.StringLength] = 0; // на всякий случай, хотя вроде должен быть ASCIIZ bool lbFirst = 0; iFrom = 0; iEnd = egs.StringLength; while (iFrom < iEnd) { //iTo = min(iEnd,(iFrom+iMaxWidth)); iTo = FindExceed(pszCopy, i, iFrom, min(iEnd/*+1*/,(iFrom+iMaxWidth)), iMaxWidth, ei.TabSize); iFind = iTo; if (iFind >= iEnd) { iFind = iTo = iEnd; } else if (abWordWrap /*&& (((egs.StringLength - iFrom) > iMaxWidth) || IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize))*/ ) { while (iFind > iFrom) { if (IsSpaceOrNull(pszCopy[iFind-1])) break; //{ // // Если есть табы - нужно учитывать их ширину // //TODO: Optimize, по хорошему, если есть табы, нужно оптимизировать расчет экранной позиции // bool bExceed = IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize); // if (!bExceed) // break; //} iFind--; } // Если по пробелам порезать не удалось, попробуем по другим знакам? if (iFind == iFrom) { iFind = iTo; while (iFind > iFrom) { if (_tcschr(gsPuctuators, pszCopy[iFind]) && !_tcschr(gsWordDiv, pszCopy[iFind-1])) break; //{ // // Если есть табы - нужно учитывать их ширину // //TODO: Optimize, по хорошему, если есть табы, нужно оптимизировать расчет экранной позиции // bool bExceed = IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize); // if (!bExceed) // break; //} iFind--; } if (iFind == iFrom) { iFind = iTo; while (iFind > iFrom) { if (_tcschr(gsWordDiv, pszCopy[iFind]) && !_tcschr(gsWordDiv, pszCopy[iFind-1])) break; //{ // // Если есть табы - нужно учитывать их ширину // //TODO: Optimize, по хорошему, если есть табы, нужно оптимизировать расчет экранной позиции // bool bExceed = IsExceed(pszCopy, i, iFrom, iFind, iMaxWidth, ei.TabSize); // if (!bExceed) // break; //} iFind--; } } } } if (iFind == iFrom) iFind = iTo; if (iFind < iEnd) { // Для ECTL_INSERTSTRING нужно установить курсор EditorSetPosition eset = {FARSTRUCTSIZE(eset)}; eset.CurLine = i; eset.TopScreenLine = -1; EditCtrl(ECTL_SETPOSITION, &eset); // Теперь можно разорвать строку EditCtrl(ECTL_INSERTSTRING, NULL); // Чтобы вернуть курсор на исходную строку if (i < ei.CurLine) ei.CurLine++; } // И менять ее данные EditorSetString esset = {FARSTRUCTSIZE(esset)}; esset.StringNumber = i; esset.StringText = pszCopy+iFrom; esset.StringEOL = (iFind == iEnd) ? szEOL : _T(""); esset.StringLength = (iFind - iFrom); EditCtrl(ECTL_SETSTRING, &esset); // Накрутить счетчики if (iFind < iEnd) { i++; ei.TotalLines++; // т.к. вставили строку } // Следующая часть строки iFrom = iFind; } } // Обновить позицию курсора { EditorSetPosition eset = {FARSTRUCTSIZE(eset)}; eset.CurLine = ei.CurLine; eset.TopScreenLine = -1; EditCtrl(ECTL_SETPOSITION, &eset); } wrap: if (pszCopy) free(pszCopy); #ifdef _UNICODE // Сброс флага "редактирован" //TODO: bis-сборка? if (!bWasModifed) EditCtrl(ECTL_DROPMODIFEDFLAG, NULL); #endif }
static struct Rotation3AnimData r3ad_104E1AA8[] = { { 0, { 0, 3345, -5139 } }, { 15, { 0, 3345, -5139 } } }; static struct Rotation3AnimData r3ad_104E1AC8[] = { { 0, { 0, -3159, -5149 } }, { 15, { 0, -3159, -5149 } } }; static struct AnimFrame_PosRot afpr_104E1AE8[] = { { v3ad_104E0684, NULL, ARRAYSIZE(v3ad_104E0684), 0 }, { NULL, r3ad_104E06A8, 0, ARRAYSIZE(r3ad_104E06A8) }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, r3ad_104E07A8, 0, ARRAYSIZE(r3ad_104E07A8) }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, r3ad_104E08A8, 0, ARRAYSIZE(r3ad_104E08A8) }, { NULL, r3ad_104E09A8, 0, ARRAYSIZE(r3ad_104E09A8) }, { NULL, r3ad_104E0AA8, 0, ARRAYSIZE(r3ad_104E0AA8) }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 },
bool wcePutFile(const char *host_file, const char *wce_file) { TCHAR tszSrcFile[MAX_PATH]; WCHAR wszDestFile[MAX_PATH]; BYTE buffer[5120]; WIN32_FIND_DATA wfd; HRESULT hr; DWORD dwAttr, dwNumRead, dwNumWritten; HANDLE hSrc, hDest, hFind; int nResult; #ifdef UNICODE nResult = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, host_file, strlen(host_file)+1, tszSrcFile, ARRAYSIZE(tszSrcFile)); if(0 == nResult) return false; #else hr = StringCchCopy(tszSrcFile, ARRAYSIZE(tszSrcFile), argv[1]); if(FAILED(hr)) return false; #endif nResult = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, wce_file, strlen(wce_file)+1, wszDestFile, ARRAYSIZE(wszDestFile)); if(0 == nResult) return false; hFind = FindFirstFile( tszSrcFile, &wfd); if (INVALID_HANDLE_VALUE == hFind) { _tprintf(TEXT("Host file does not exist\n")); return false; } FindClose( hFind); if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { _tprintf( TEXT("Host file specifies a directory\n")); return false; } if (wceConnect()) { dwAttr = CeGetFileAttributes( wszDestFile); if (dwAttr & FILE_ATTRIBUTE_DIRECTORY) { hr = StringCchCatW(wszDestFile, ARRAYSIZE(wszDestFile), L"\\"); if(FAILED(hr)) return false; #ifdef UNICODE hr = StringCchCatW(wszDestFile, ARRAYSIZE(wszDestFile), wfd.cFileName); if(FAILED(hr)) return false; #else nResult = MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, wfd.cFileName, strlen(wfd.cFileName)+1, wszDestFile+wcslen(wszDestFile), ARRAYSIZE(wszDestFile)-wcslen(wszDestFile)); if(0 == nResult) { return 1; } #endif } hSrc = CreateFile(tszSrcFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (INVALID_HANDLE_VALUE == hSrc) { _tprintf( TEXT("Unable to open host file\n")); return false; } hDest = CeCreateFile(wszDestFile, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (INVALID_HANDLE_VALUE == hDest ) { _tprintf( TEXT("Unable to open target WinCE file\n")); return false; } //copy file do { if(ReadFile(hSrc, &buffer, sizeof(buffer), &dwNumRead, NULL)) { if (!CeWriteFile(hDest, &buffer, dwNumRead, &dwNumWritten, NULL)) { _tprintf( TEXT("Error !!! Writing WinCE file\n")); goto FatalError; } } else { _tprintf( TEXT("Error !!! Reading host file\n")); goto FatalError; } _tprintf( TEXT(".")); } while (dwNumRead); //_tprintf( TEXT("\n")); CeCloseHandle( hDest); CloseHandle (hSrc); } wceDisconnect(); return true; FatalError: CeCloseHandle( hDest); CloseHandle (hSrc); wceDisconnect(); return false; }
BOOL wf_post_connect(freerdp* instance) { rdpGdi* gdi; DWORD dwStyle; rdpCache* cache; wfContext* wfc; rdpContext* context; WCHAR lpWindowName[64]; rdpSettings* settings; EmbedWindowEventArgs e; settings = instance->settings; context = instance->context; wfc = (wfContext*) instance->context; cache = instance->context->cache; wfc->dstBpp = 32; wfc->width = settings->DesktopWidth; wfc->height = settings->DesktopHeight; if (wfc->sw_gdi) { gdi_init(instance, CLRCONV_ALPHA | CLRCONV_INVERT | CLRBUF_32BPP, NULL); gdi = instance->context->gdi; wfc->hdc = gdi->primary->hdc; wfc->primary = wf_image_new(wfc, wfc->width, wfc->height, wfc->dstBpp, gdi->primary_buffer); } else { wf_gdi_register_update_callbacks(instance->update); wfc->srcBpp = instance->settings->ColorDepth; wfc->primary = wf_image_new(wfc, wfc->width, wfc->height, wfc->dstBpp, NULL); wfc->hdc = gdi_GetDC(); wfc->hdc->bitsPerPixel = wfc->dstBpp; wfc->hdc->bytesPerPixel = wfc->dstBpp / 8; wfc->hdc->alpha = wfc->clrconv->alpha; wfc->hdc->invert = wfc->clrconv->invert; wfc->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND)); wfc->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0); wfc->hdc->hwnd->invalid->null = 1; wfc->hdc->hwnd->count = 32; wfc->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * wfc->hdc->hwnd->count); wfc->hdc->hwnd->ninvalid = 0; if (settings->RemoteFxCodec) { wfc->tile = wf_image_new(wfc, 64, 64, 32, NULL); wfc->rfx_context = rfx_context_new(FALSE); } if (settings->NSCodec) { wfc->nsc_context = nsc_context_new(); } } if (settings->WindowTitle != NULL) _snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"%S", settings->WindowTitle); else if (settings->ServerPort == 3389) _snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S", settings->ServerHostname); else _snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S:%d", settings->ServerHostname, settings->ServerPort); if (settings->EmbeddedWindow) settings->Decorations = FALSE; if (!settings->Decorations) dwStyle = WS_CHILD | WS_BORDER; else dwStyle = 0; if (!wfc->hwnd) { wfc->hwnd = CreateWindowEx((DWORD) NULL, wfc->wndClassName, lpWindowName, dwStyle, 0, 0, 0, 0, wfc->hWndParent, NULL, wfc->hInstance, NULL); SetWindowLongPtr(wfc->hwnd, GWLP_USERDATA, (LONG_PTR) wfc); } wf_resize_window(wfc); wf_add_system_menu(wfc); BitBlt(wfc->primary->hdc, 0, 0, wfc->width, wfc->height, NULL, 0, 0, BLACKNESS); wfc->drawing = wfc->primary; EventArgsInit(&e, "wfreerdp"); e.embed = FALSE; e.handle = (void*) wfc->hwnd; PubSub_OnEmbedWindow(context->pubSub, context, &e); ShowWindow(wfc->hwnd, SW_SHOWNORMAL); UpdateWindow(wfc->hwnd); if (wfc->sw_gdi) { instance->update->BeginPaint = (pBeginPaint) wf_sw_begin_paint; instance->update->EndPaint = (pEndPaint) wf_sw_end_paint; instance->update->DesktopResize = (pDesktopResize) wf_sw_desktop_resize; } else { instance->update->BeginPaint = (pBeginPaint) wf_hw_begin_paint; instance->update->EndPaint = (pEndPaint) wf_hw_end_paint; instance->update->DesktopResize = (pDesktopResize) wf_hw_desktop_resize; } pointer_cache_register_callbacks(instance->update); if (wfc->sw_gdi != TRUE) { brush_cache_register_callbacks(instance->update); bitmap_cache_register_callbacks(instance->update); offscreen_cache_register_callbacks(instance->update); } wf_register_graphics(instance->context->graphics); freerdp_channels_post_connect(instance->context->channels, instance); wf_cliprdr_init(wfc, instance->context->channels); floatbar_window_create(wfc); return TRUE; }
{ -0.002852f, 0.988813f, 0.149136f }, { 0.015325f, 0.108138f, -0.994018f } }; static short unsigned int strips_10681990[] = { 10, 7, 1, 3, 0, 2, 4, 6, 5, 7, 1 }; static struct MESH mesh_106819A8[] = { { 0 | MeshPolyType_StripsB, 1, strips_10681990, 0, NULL, NULL, NULL, 0 } }; extern struct MATERIAL mat_106804E8[1]; struct ATTACH attach_10681A88 = { vec3_106819C8, vec3_10681A28, ARRAYSIZE(vec3_106819C8), mesh_106819A8, mat_106804E8, ARRAYSIZE(mesh_106819A8), ARRAYSIZE(mat_106804E8), { 0.470043f, 0.006634f, -0.017387f }, 0.829958f, 0 };
int ExtendFileSystem (HWND hwndDlg , wchar_t *lpszVolume, Password *pVolumePassword, int VolumePkcs5, int VolumePim, uint64 newDataAreaSize) { wchar_t szVolumeGUID[128]; int driveNo = -1; wchar_t rootPath[] = L"A:\\"; enum EV_FileSystem fs; DWORD dwError; int nStatus = ERR_SUCCESS; DWORD BytesPerSector; // mount and resize file system DebugAddProgressDlgStatus (hwndDlg, "Mounting volume ...\r\n"); nStatus=MountVolTemp(hwndDlg, lpszVolume, &driveNo, pVolumePassword, VolumePkcs5, VolumePim); if (nStatus!=ERR_SUCCESS) { driveNo = -1; goto error; } rootPath[0] += driveNo; if ( !GetFileSystemType(rootPath,&fs) ) { dwError = GetLastError(); if (dwError == ERROR_UNRECOGNIZED_VOLUME) { // raw volume with unrecognized file system -> return with no error nStatus = ERR_SUCCESS; goto error; } nStatus = ERR_OS_ERROR; goto error; } if (fs != EV_FS_TYPE_RAW && fs != EV_FS_TYPE_NTFS ) { // FsctlExtendVolume only supports NTFS and RAW -> return with no error nStatus = ERR_SUCCESS; goto error; } // Get volume GUID if (!GetVolumeNameForVolumeMountPoint(rootPath,szVolumeGUID,ARRAYSIZE(szVolumeGUID))) { nStatus = ERR_OS_ERROR; goto error; } else { // strip trailing backslash from volume GUID (otherwise it means root dir) size_t len = wcslen(szVolumeGUID); if (len>0) --len; if (szVolumeGUID[len]==L'\\') szVolumeGUID[len]=0; } // Get Sector Size if ( !GetNtfsNumberOfSectors(rootPath, NULL, &BytesPerSector) ) { nStatus = ERR_OS_ERROR; goto error; } DebugAddProgressDlgStatus (hwndDlg, "Extending file system ...\r\n"); // extend volume nStatus = FsctlExtendVolume(szVolumeGUID, newDataAreaSize/BytesPerSector ); error: dwError = GetLastError(); if (driveNo>=0) { DebugAddProgressDlgStatus (hwndDlg, "Unmounting volume ...\r\n"); UnmountVolume (hwndDlg, driveNo, TRUE); } SetLastError (dwError); return nStatus; }
static gboolean PowerOpsStateChange(RpcInData *data) { size_t i; PowerOpState *state = data->clientData; if (state->pid != INVALID_PID) { g_debug("State change already in progress.\n"); return RPCIN_SETRETVALS(data, "State change already in progress", FALSE); } g_debug("State change: %s\n", data->name); for (i = 0; i < ARRAYSIZE(stateChangeCmdTable); i++) { if (strcmp(data->name, stateChangeCmdTable[i].tcloCmd) == 0) { gchar *script; const char *result; const char *confName; Bool ret; state->stateChgInProgress = stateChangeCmdTable[i].id; /* Check for the toolScripts option. */ if (!state->scriptEnabled[stateChangeCmdTable[i].id]) { PowerOpsStateChangeDone(state, TRUE); g_debug("Script for %s not configured to run\n", stateChangeCmdTable[i].tcloCmd); return RPCIN_SETRETVALS(data, "", TRUE); } confName = stateChgConfNames[stateChangeCmdTable[i].id]; script = g_key_file_get_string(state->ctx->config, "powerops", confName, NULL); if (script == NULL) { /* Use default script if not set in config file. */ const char *dfltScript = GuestApp_GetDefaultScript(confName); if (dfltScript == NULL) { g_debug("No default script to run for state change %s.\n", stateChangeCmdTable[i].name); PowerOpsStateChangeDone(state, TRUE); return RPCIN_SETRETVALS(data, "", TRUE); } script = g_strdup(dfltScript); } else if (strlen(script) == 0) { g_debug("No script to run for state change %s.\n", stateChangeCmdTable[i].name); g_free(script); PowerOpsStateChangeDone(state, TRUE); return RPCIN_SETRETVALS(data, "", TRUE); } /* If script path is not absolute, assume the Tools install path. */ if (!g_path_is_absolute(script)) { char *dfltPath; char *tmp; dfltPath = GuestApp_GetInstallPath(); ASSERT(dfltPath != NULL); /* * Before the switch to vmtoolsd, the config file was saved with * quotes around the script path to make the old VMware dict code * happy. Now we need to undo that when modifying the script path. * * PowerOpsRunScript will "re-quote" the script path. */ if (script[0] == '"') { script[strlen(script) - 1] = '\0'; tmp = g_strdup_printf("%s%c%s", dfltPath, DIRSEPC, script + 1); } else { tmp = g_strdup_printf("%s%c%s", dfltPath, DIRSEPC, script); } g_free(script); vm_free(dfltPath); script = tmp; } if (PowerOpsRunScript(state, script)) { result = ""; ret = TRUE; } else { PowerOpsStateChangeDone(state, FALSE); result = "Error starting script"; ret = FALSE; } g_free(script); return RPCIN_SETRETVALS(data, (char *) result, ret); } } g_warning("Invalid state change command.\n"); return RPCIN_SETRETVALS(data, "Invalid state change command", FALSE); }
void FTP::AddToQueque(FAR_FIND_DATA* FileName, LPCSTR Path, BOOL Download) { String str; char *m; int num; FTPUrl* p = new FTPUrl; memcpy(&p->Host, &Host, sizeof(Host)); p->Download = Download; p->Next = NULL; p->FileName = *FileName; p->Error.Null(); p->DestPath = Path; if(Download) m = strrchr(FileName->cFileName, '/'); else m = strrchr(FileName->cFileName, '\\'); if(m) { *m = 0; p->DestPath.Add(m); memmove(FileName->cFileName, m+1, m-FileName->cFileName); } if(Download) { GetCurPath(p->SrcPath); AddEndSlash(p->SrcPath, '/'); str.printf("%s%s", p->SrcPath.c_str(), FileName->cFileName); FixLocalSlash(p->DestPath); AddEndSlash(p->DestPath, '\\'); num = str.Chr('/'); } else { PanelInfo pi; FP_Info->Control(this, FCTL_GETANOTHERPANELINFO, &pi); p->SrcPath = pi.CurDir; AddEndSlash(p->SrcPath, '\\'); str.printf("%s%s", p->SrcPath.c_str(), FileName->cFileName); FixLocalSlash(str); AddEndSlash(p->DestPath, '/'); num = str.Chr('\\'); } if(num != -1) { StrCpy(p->FileName.cFileName, str.c_str()+num+1, ARRAYSIZE(p->FileName.cFileName)); str.SetLength(num); p->SrcPath = str; } else { StrCpy(p->FileName.cFileName, str.c_str(), ARRAYSIZE(p->FileName.cFileName)); p->SrcPath.Null(); } if(!UrlsList) UrlsList = p; if(UrlsTail) UrlsTail->Next = p; UrlsTail = p; QuequeSize++; }
void FTP::QuequeMenu(void) { int n, num; int Breaks[] = { VK_DELETE, VK_INSERT, VK_F4, VK_RETURN, 0 }, BNumber; FarMenuItem *mi = NULL; FTPUrl* p,*p1; char str1[MAX_PATH], str2[MAX_PATH], str3[MAX_PATH]; QueueExecOptions exOp; SetupQOpt(&exOp); num = -1; do { mi = (FarMenuItem *)realloc(mi, (QuequeSize+1)*sizeof(FarMenuItem)); memset(mi, 0, QuequeSize*sizeof(FarMenuItem)); for(p = UrlsList,n = 0; p; p = p->Next, n++) { StrCpy(str1, p->SrcPath.c_str(), 20); StrCpy(str2, p->DestPath.c_str(), 20); StrCpy(str3, p->FileName.cFileName, 20); _snprintf(mi[n].Text, ARRAYSIZE(mi[n].Text), "%c%c %-20s%c%-20s%c%-20s", p->Download ? '-' : '<', p->Download ? '>' : '-', str1, FAR_VERT_CHAR, str2, FAR_VERT_CHAR, str3); if(p->Error[0]) mi[n].Checked = TRUE; } //Title char title[MAX_PATH]; _snprintf(title, ARRAYSIZE(title), "%s: %d %s", FP_GetMsg(MQMenuTitle), n, FP_GetMsg(MQMenuItems)); //Menu if(num != -1 && num < QuequeSize) mi[num].Selected = TRUE; n = FP_Info->Menu(FP_Info->ModuleNumber,-1,-1,0,FMENU_SHOWAMPERSAND, title, FP_GetMsg(MQMenuFooter), "FTPQueue", Breaks, &BNumber, mi, QuequeSize); //key ESC if(BNumber == -1 && n == -1) goto Done; //key Enter if(BNumber == -1) { //?? goto Done; } //Set selected if(num != -1) mi[num].Selected = FALSE; num = n; //Process keys switch(BNumber) { /*DEL*/ case 0: if(QuequeSize) switch(AskDeleteQueue()) { case -1: case 2: break; case 0: p = UrlItem(n, &p1); DeleteUrlItem(p, p1); break; case 1: ClearQueue(); break; } break; /*Ins*/ case 1: InsertToQueue(); break; /*F4*/ case 2: p = UrlItem(n, NULL); if(p) EditUrlItem(p); break; /*Return*/ case 3: if(QuequeSize && WarnExecuteQueue(&exOp)) { ExecuteQueue(&exOp); if(!QuequeSize) goto Done; } break; } } while(true); Done: free(mi); }
VOID ProgressSetStep( IN PPROGRESSBAR Bar, IN ULONG Step) { COORD coPos; DWORD Written; ULONG NewPos; CHAR TextBuffer[256]; if (Step > Bar->StepCount) return; Bar->CurrentStep = Step; /* Update the progress and redraw it if it has changed */ if (Bar->UpdateProgressProc && Bar->UpdateProgressProc(Bar, FALSE, TextBuffer, ARRAYSIZE(TextBuffer))) { coPos.X = Bar->Left + (Bar->Width - strlen(TextBuffer) + 1) / 2; coPos.Y = Bar->Top; WriteConsoleOutputCharacterA(StdOutput, TextBuffer, strlen(TextBuffer), coPos, &Written); } /* Calculate the bar position */ NewPos = (((Bar->Width - 2) * 2 * Bar->CurrentStep + (Bar->StepCount / 2)) / Bar->StepCount); /* Redraw the bar if it has changed */ if (Bar->Pos != NewPos) { Bar->Pos = NewPos; for (coPos.Y = Bar->Top + 2; coPos.Y <= Bar->Bottom - 1; coPos.Y++) { coPos.X = Bar->Left + 1; FillConsoleOutputCharacterA(StdOutput, 0xDB, Bar->Pos / 2, coPos, &Written); coPos.X += Bar->Pos / 2; if (NewPos & 1) { FillConsoleOutputCharacterA(StdOutput, 0xDD, 1, coPos, &Written); coPos.X++; } if (coPos.X <= Bar->Right - 1) { FillConsoleOutputCharacterA(StdOutput, ' ', Bar->Right - coPos.X, coPos, &Written); } } } }
u32 stuff( AtomicBitSet( &StuffToDo, ~job, 0x00000000 ) ); if( stuff == 0 ) { Dynarec_ClearedCPUStuffToDo(); } } #ifdef DAEDALUS_ENABLE_SYNCHRONISATION static const char * const kRegisterNames[] = { "zr", "at", "v0", "v1", "a0", "a1", "a2", "a3", "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra" }; DAEDALUS_STATIC_ASSERT(ARRAYSIZE(kRegisterNames) == 32); void SCPUState::Dump() { DBGConsole_Msg(0, "Emulation CPU State:"); { for(int i=0; i<32; i+=4) { DBGConsole_Msg(0, "%s:%08X %s:%08X %s:%08X %s:%08X", kRegisterNames[i+0], gCPUState.CPU[i+0]._u32_0, kRegisterNames[i+1], gCPUState.CPU[i+1]._u32_0, kRegisterNames[i+2], gCPUState.CPU[i+2]._u32_0, kRegisterNames[i+3], gCPUState.CPU[i+3]._u32_0); } DBGConsole_Msg(0, "TargetPC: %08x", gCPUState.TargetPC);
#endif { WLC_E_WAKE_EVENT, "WAKE_EVENT" }, { WLC_E_DCS_REQUEST, "DCS_REQUEST" }, { WLC_E_RM_COMPLETE, "RM_COMPLETE" }, #ifdef WLMEDIA_HTSF { WLC_E_HTSFSYNC, "HTSF_SYNC_EVENT" }, #endif { WLC_E_OVERLAY_REQ, "OVERLAY_REQ_EVENT" }, { WLC_E_CSA_COMPLETE_IND, "WLC_E_CSA_COMPLETE_IND"}, { WLC_E_EXCESS_PM_WAKE_EVENT, "EXCESS_PM_WAKE_EVENT" }, { WLC_E_PFN_SCAN_NONE, "PFN_SCAN_NONE" }, { WLC_E_PFN_SCAN_ALLGONE, "PFN_SCAN_ALLGONE" }, #ifdef SOFTAP { WLC_E_GTK_PLUMBED, "GTK_PLUMBED" }, #endif { WLC_E_ASSOC_REQ_IE, "ASSOC_REQ_IE" }, { WLC_E_ASSOC_RESP_IE, "ASSOC_RESP_IE" }, #ifdef WLTDLS { WLC_E_TDLS_PEER_EVENT, "TDLS_PEER_EVENT" }, #endif /* WLTDLS */ { WLC_E_NATIVE, "NATIVE" }, #ifdef WLPKTDLYSTAT { WLC_E_PKTDELAY_IND, "PKTDELAY_IND" }, #endif /* WLPKTDLYSTAT */ { WLC_E_SERVICE_FOUND, "SERVICE_FOUND" }, { WLC_E_GAS_FRAGMENT_RX, "GAS_FRAGMENT_RX" }, { WLC_E_GAS_COMPLETE, "GAS_COMPLETE" } }; const int bcmevent_names_size = ARRAYSIZE(bcmevent_names);
// Fail Schedule //========================================================= Task_t tlAssassinFail[] = { { TASK_STOP_MOVING, 0 }, { TASK_SET_ACTIVITY, (float)ACT_IDLE }, { TASK_WAIT_FACE_ENEMY, (float)2 }, // { TASK_WAIT_PVS, (float)0 }, { TASK_SET_SCHEDULE, (float)SCHED_CHASE_ENEMY }, }; Schedule_t slAssassinFail[] = { { tlAssassinFail, ARRAYSIZE ( tlAssassinFail ), bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE | bits_COND_PROVOKED | bits_COND_CAN_RANGE_ATTACK1 | bits_COND_CAN_RANGE_ATTACK2 | bits_COND_CAN_MELEE_ATTACK1 | bits_COND_HEAR_SOUND, bits_SOUND_DANGER | bits_SOUND_PLAYER, "AssassinFail" }, };
STDAPI SHCoCreateInstance(LPCTSTR pszCLSID, const CLSID * pclsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID FAR* ppv) { HRESULT hres = ResultFromScode(REGDB_E_CLASSNOTREG); CLSID clsidT; TCHAR szClass[GUIDSTR_MAX+ARRAYSIZE(c_szInProcServer)]; if (pclsid) { if (!pszCLSID) { StringFromGUID2A(pclsid, szClass, ARRAYSIZE(szClass)); } } else { if (pszCLSID) { lstrcpy(szClass,pszCLSID); if (SUCCEEDED(SHCLSIDFromString(pszCLSID, &clsidT))) pclsid=&clsidT; } } if (pclsid) { LONG err; HKEY hkeyDll; IClassFactory *pCF; Assert(hres == ResultFromScode(REGDB_E_CLASSNOTREG)); lstrcat(szClass,c_szInProcServer); // Add "\InProcServer32" hres = _FindRegisteredClass(pclsid, &pCF); if (SUCCEEDED(hres)) { hres = pCF->lpVtbl->CreateInstance(pCF, pUnkOuter, riid, ppv); pCF->lpVtbl->Release(pCF); } else { if (g_hkcrCLSID && RegOpenKey(g_hkcrCLSID, szClass, &hkeyDll) == ERROR_SUCCESS) { TCHAR szDllName[MAX_PATH]; LONG cbValue = SIZEOF(szDllName); // 1 2 3 // 012345678901234567890123456789012345678 = nul is at 38! // "{12345678-1234-1234-1234-123456789012}" // szClass[38] = TEXT('\0'); // Get rid of "\InProcServer32" err = RegQueryValue(hkeyDll, NULL, szDllName, &cbValue); #ifdef WINNT // // On NT, we must check to ensure that this CLSID exists in // the list of approved CLSIDs that can be used in-process. // If not, we fail the creation with ERROR_ACCESS_DENIED. // We explicitly allow anything serviced by this DLL // if (err == ERROR_SUCCESS && NULL != g_hklmApprovedExt) { TCHAR szBuf[MAX_PATH]; // // Check to see if we are using this DLL // // BUGBUG Assumes no parameters in InProcServer32. We // should remove this assumption once we lose shellalt, // after which we can just lstrcpyn(,,<length of dll name>); LPCTSTR pszDllName = PathFindFileName(szDllName); if (lstrcmp(pszDllName, TEXT("shell32.dll")) && lstrcmp(pszDllName, TEXT("shellalt.dll"))) { DWORD dwType; TCHAR szValue[MAX_PATH]; DWORD cbSize = SIZEOF(szValue); if (ERROR_SUCCESS != RegQueryValueEx(g_hklmApprovedExt, szClass, 0, &dwType, (LPBYTE) szValue, &cbSize)) { hres = HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED); return hres; } } } #endif if (err == ERROR_SUCCESS) { TCHAR szThreadingModel[MAX_PATH]; BOOL fMultiThreadAware = FALSE; DWORD dwRegType; DWORD cbRead = SIZEOF(szThreadingModel); err = RegQueryValueEx(hkeyDll, c_szThreadingModel, NULL, &dwRegType, (LPBYTE)szThreadingModel, &cbRead); if (err == ERROR_SUCCESS && dwRegType == REG_SZ) { if (lstrcmpi(szThreadingModel, c_szApartment)==0 || lstrcmpi(szThreadingModel, c_szBoth)==0) { fMultiThreadAware = TRUE; } } // #define HACK_APARTMENT_ONLY_ASSERT #ifdef HACK_APARTMENT_ONLY_ASSERT if (!fMultiThreadAware) { _asm { int 3; } } Assert(fMultiThreadAware); hres = _CreateInstance(pclsid, szDllName, pUnkOuter, riid, ppv); #else if (fMultiThreadAware) { hres = _CreateInstance(pclsid, szDllName, pUnkOuter, riid, ppv); } else { Assert(hres == ResultFromScode(REGDB_E_CLASSNOTREG)); DebugMsg(DM_ERROR, TEXT("sh TR - SHCoCreateInstance !!! InProcServer32 (%s) does not support multi-threading"), szDllName); Assert(0); } #endif } RegCloseKey(hkeyDll); }
static struct Rotation3AnimData r3ad_101C24A0[] = { { 0, { 0, 0, -32767 } }, { 31, { 0, 0, -32767 } } }; static struct Rotation3AnimData r3ad_101C24C0[] = { { 0, { 0, -12315, 32735 } }, { 31, { 0, -12315, 32735 } } }; static struct AnimFrame_PosRot afpr_101C24E0[] = { { v3ad_101C0A6C, NULL, ARRAYSIZE(v3ad_101C0A6C), 0 }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, r3ad_101C0A8C, 0, ARRAYSIZE(r3ad_101C0A8C) }, { NULL, r3ad_101C0AAC, 0, ARRAYSIZE(r3ad_101C0AAC) }, { NULL, r3ad_101C0ACC, 0, ARRAYSIZE(r3ad_101C0ACC) }, { NULL, NULL, 0, 0 }, { NULL, r3ad_101C0AF0, 0, ARRAYSIZE(r3ad_101C0AF0) }, { NULL, r3ad_101C0CF0, 0, ARRAYSIZE(r3ad_101C0CF0) }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 }, { NULL, r3ad_101C0EF0, 0, ARRAYSIZE(r3ad_101C0EF0) }, { NULL, r3ad_101C0F10, 0, ARRAYSIZE(r3ad_101C0F10) }, { NULL, r3ad_101C0F30, 0, ARRAYSIZE(r3ad_101C0F30) }, { NULL, NULL, 0, 0 }, { NULL, NULL, 0, 0 },
/* <18805> ../engine/cvar.c:198 */ void EXT_FUNC Cvar_DirectSet_internal(struct cvar_s *var, const char *value) { if (!var || !value) { return; } const char *pszValue = value; char szNew[MAX_CVAR_VALUE]; szNew[0] = 0; if (var->flags & FCVAR_PRINTABLEONLY) { if (Q_UnicodeValidate(value)) { Q_strncpy(szNew, value, ARRAYSIZE(szNew) - 1); szNew[ARRAYSIZE(szNew) - 1] = 0; } else { // Copy only printable chars // TODO: Why not UTF-8 too? const char *pS = pszValue; char *pD = szNew; while (*pS) { if (*pS < 32 || *pS > 126) { pS++; continue; } *pD++ = *pS++; } *pD = 0; } if (!Q_UnicodeValidate(szNew)) { // Call the artillery Q_UnicodeRepair(szNew); } if (szNew[0] == 0) { Q_strcpy(szNew, "empty"); } pszValue = szNew; } if (var->flags & FCVAR_NOEXTRAWHITEPACE) { if (pszValue != szNew) { Q_strncpy(szNew, value, ARRAYSIZE(szNew) - 1); szNew[ARRAYSIZE(szNew) - 1] = 0; } Q_StripUnprintableAndSpace(szNew); pszValue = szNew; } qboolean changed = Q_strcmp(var->string, pszValue); if (var->flags & FCVAR_USERINFO) { if (g_pcls.state == ca_dedicated) { char *info = Info_Serverinfo(); Info_SetValueForKey(info, var->name, pszValue, MAX_INFO_STRING); SV_BroadcastCommand("fullserverinfo \"%s\"\n", info); } #ifndef SWDS else { Info_SetValueForKey(g_pcls.userinfo, var->name, pszValue, MAX_INFO_STRING); if (changed && g_pcls.state >= ca_connected) { MSG_WriteByte(&g_pcls.netchan.message, clc_stringcmd); SZ_Print(&g_pcls.netchan.message, va("setinfo \"%s\" \"%s\"\n", var->name, pszValue)); } } #endif } if (changed && var->flags & FCVAR_SERVER) { if (!(var->flags & FCVAR_UNLOGGED)) { if (var->flags & FCVAR_PROTECTED) { Log_Printf("Server cvar \"%s\" = \"%s\"\n", var->name, "***PROTECTED***"); SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, "***PROTECTED***"); } else { Log_Printf("Server cvar \"%s\" = \"%s\"\n", var->name, pszValue); SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, pszValue); } } if (!(var->flags & FCVAR_PROTECTED)) { Steam_SetCVar(var->name, pszValue); } else if (pszValue[0] && Q_stricmp(pszValue, "none")) { Steam_SetCVar(var->name, "1"); } else { Steam_SetCVar(var->name, "0"); } } Z_Free(var->string); var->string = (char *)Z_Malloc(Q_strlen(pszValue) + 1); Q_strcpy(var->string, pszValue); var->value = (float)Q_atof(var->string); }
bool wceInvokeCabSetup(const char *wceload_params) { HRESULT hr = S_OK; WCHAR wszCabFile[MAX_PATH]; //convert pathname int nResult = 0; int len = strlen(wceload_params)+1; nResult = MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED, wceload_params, len, wszCabFile, ARRAYSIZE(wszCabFile)); if(0 == nResult) return false; wceConnect(); DWORD dwInSize = sizeof(wszCabFile); DWORD dwOutSize = 0; BYTE *pInBuff = NULL; pInBuff = (BYTE *)LocalAlloc(LPTR, dwInSize); memcpy(pInBuff, &wszCabFile, dwInSize); hr = CeRapiInvoke(TEXT("\\rhosetup"), TEXT("rhoCabSetup"), dwInSize, pInBuff, &dwOutSize, NULL, NULL, 0); if(FAILED(hr)) { //printf("Failed to setup cab!\r\n"); return false; } wceDisconnect(); return true ; }
/* <18d23> ../engine/cvar.c:671 */ void Cmd_CvarList_f(void) { cvar_t *var; int iCvars; int iArgs; const char *partial, *arg1; int ipLen; qboolean bAOnly; qboolean bSOnly; char szTemp[MAX_PATH]; FileHandle_t f; FileHandle_t fp; qboolean bLogging; iCvars = 0; partial = NULL; bAOnly = FALSE; bSOnly = FALSE; f = NULL; fp = NULL; bLogging = FALSE; iArgs = Cmd_Argc(); if (iArgs > 1) { arg1 = Cmd_Argv(1); if (!Q_stricmp(arg1, "?")) { Con_Printf("CvarList : List all cvars\nCvarList [Partial] : List cvars starting with 'Partial'\nCvarList log [Partial] : Logs cvars to file \"cvarlist.txt\" in the gamedir.\n"); return; } if (!Q_stricmp(arg1, "log")) { // Open log int i; for (i = 0; i < 100; i++) { Q_snprintf(szTemp, ARRAYSIZE(szTemp) - 1, "cvarlist%02d.txt", i); szTemp[ARRAYSIZE(szTemp) - 1] = 0; fp = FS_Open(szTemp, "r"); if (!fp) { break; } FS_Close(fp); } if (i >= 100) { Con_Printf("Can't cvarlist! Too many existing cvarlist output files in the gamedir!\n"); return; } f = FS_Open(szTemp, "wt"); if (!f) { Con_Printf("Couldn't open \"%s\" for writing!\n", szTemp); return; } bLogging = TRUE; // Get next argument into partial, if present if (iArgs > 2) { partial = Cmd_Argv(2); ipLen = Q_strlen(partial); } } else if (!Q_stricmp(arg1, "-a")) { bAOnly = TRUE; } else if (!Q_stricmp(arg1, "-s")) { bSOnly = TRUE; } else { partial = arg1; ipLen = Q_strlen(partial); } } // Print cvars Con_Printf("CVar List\n--------------\n"); for (var = cvar_vars; var; var = var->next) { if (bAOnly && !(var->flags & FCVAR_ARCHIVE)) { continue; } if (bSOnly && !(var->flags & FCVAR_SERVER)) { continue; } if (partial && Q_strnicmp(var->name, partial, ipLen)) { continue; } Cmd_CvarListPrintCvar(var, f); iCvars++; } if (partial && *partial) { Con_Printf("--------------\n%3i CVars for [%s]\nCvarList ? for syntax\n", iCvars, partial); } else { Con_Printf("--------------\n%3i Total CVars\nCvarList ? for syntax\n", iCvars); } // Close log if (bLogging) { FS_Close(f); Con_Printf("cvarlist logged to %s\n", szTemp); } }
// プログラマブルシェーダ作成 HRESULT MakeShaders( void ) { HRESULT hr; ID3DBlob* pVertexShaderBuffer = NULL; ID3DBlob* pPixelShaderBuffer = NULL; ID3DBlob* pError = NULL; DWORD dwShaderFlags = 0; #ifdef _DEBUG dwShaderFlags |= D3DCOMPILE_DEBUG; #endif // コンパイル hr = D3DX11CompileFromFile( _T( "Basic_2D.fx" ), NULL, NULL, "VS", "vs_4_0_level_9_1", dwShaderFlags, 0, NULL, &pVertexShaderBuffer, &pError, NULL ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "Can't open Basic_2D.fx" ), _T( "Error" ), MB_OK ); SAFE_RELEASE( pError ); return hr; } hr = D3DX11CompileFromFile( _T( "Basic_2D.fx" ), NULL, NULL, "PS", "ps_4_0_level_9_1", dwShaderFlags, 0, NULL, &pPixelShaderBuffer, &pError, NULL ); if ( FAILED( hr ) ) { SAFE_RELEASE( pVertexShaderBuffer ); SAFE_RELEASE( pError ); return hr; } SAFE_RELEASE( pError ); // VertexShader作成 hr = g_pd3dDevice->CreateVertexShader( pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), NULL, &g_pVertexShader ); if ( FAILED( hr ) ) { SAFE_RELEASE( pVertexShaderBuffer ); SAFE_RELEASE( pPixelShaderBuffer ); return hr; } // PixelShader作成 hr = g_pd3dDevice->CreatePixelShader( pPixelShaderBuffer->GetBufferPointer(), pPixelShaderBuffer->GetBufferSize(), NULL, &g_pPixelShader ); if ( FAILED( hr ) ) { SAFE_RELEASE( pVertexShaderBuffer ); SAFE_RELEASE( pPixelShaderBuffer ); return hr; } // 入力バッファの入力形式 D3D11_INPUT_ELEMENT_DESC layout[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXTURE", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE( layout ); // 入力バッファの入力形式作成 hr = g_pd3dDevice->CreateInputLayout( layout, numElements, pVertexShaderBuffer->GetBufferPointer(), pVertexShaderBuffer->GetBufferSize(), &g_pInputLayout ); SAFE_RELEASE( pVertexShaderBuffer ); SAFE_RELEASE( pPixelShaderBuffer ); if ( FAILED( hr ) ) { return hr; } // シェーダ定数バッファ作成 D3D11_BUFFER_DESC bd; ZeroMemory( &bd, sizeof( bd ) ); bd.Usage = D3D11_USAGE_DEFAULT; bd.ByteWidth = sizeof( CBNeverChanges ); bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER; bd.CPUAccessFlags = 0; hr = g_pd3dDevice->CreateBuffer( &bd, NULL, &g_pCBNeverChanges ); if( FAILED( hr ) ) return hr; // 変換行列 CBNeverChanges cbNeverChanges; XMMATRIX mScreen; mScreen = XMMatrixIdentity(); mScreen._11 = 2.0f / g_nClientWidth; mScreen._22 = -2.0f / g_nClientHeight; mScreen._41 = -1.0f; mScreen._42 = 1.0f; cbNeverChanges.mView = XMMatrixTranspose( mScreen ); g_pImmediateContext->UpdateSubresource( g_pCBNeverChanges, 0, NULL, &cbNeverChanges, 0, 0 ); return S_OK; }
}; static struct test_address _addrs[] = { { .addr = _addr1, .plen = 32, }, { .addr = _addr2, .plen = 32, }, { .addr = _addr3, .plen = 32, .tlv_count = ARRAYSIZE(_addrtlv1), .tlvs = _addrtlv1, }, { .addr = _addr4, .plen = 32, .tlv_count = ARRAYSIZE(_addrtlv1), .tlvs = _addrtlv1, }, { .addr = _addr5, .plen = 16, .tlv_count = ARRAYSIZE(_addrtlv1), .tlvs = _addrtlv1,
void DoUnwrap(EditorInfo &ei) { INT_PTR iRc = 0; INT_PTR cchMax = 0, cchPos = 0; TCHAR* pszCopy = NULL; TCHAR szEOL[4]; bool bWasModifed = (ei.CurState & ECSTATE_MODIFIED) && !(ei.CurState & ECSTATE_SAVED); gbLastWrap = FALSE; for (INT_PTR i = 0; i < ei.TotalLines; i++) { EditorGetString egs = {FARSTRUCTSIZE(egs)}; egs.StringNumber = i; iRc = EditCtrl(ECTL_GETSTRING, &egs); if (!iRc) { _ASSERTE(iRc!=0); goto wrap; } _ASSERTE(egs.StringText!=NULL); if (egs.StringEOL && *egs.StringEOL) { // В этой строке есть EOL, ее не сворачивали continue; } cchPos = 0; szEOL[0] = 0; INT_PTR j = i; while (j < ei.TotalLines) { if (!pszCopy || ((egs.StringLength + cchPos + 65536) > cchMax)) { cchMax = egs.StringLength + cchPos + 65536; TCHAR* pszNew = (TCHAR*)malloc(cchMax*sizeof(*pszCopy)); if (!pszNew) { _ASSERTE(pszNew!=NULL); goto wrap; } if (pszCopy) { if (cchPos > 0) memmove(pszNew, pszCopy, cchPos*sizeof(*pszCopy)); free(pszCopy); } pszCopy = pszNew; } if (egs.StringLength > 0) { memmove(pszCopy+cchPos, egs.StringText, egs.StringLength*sizeof(*pszCopy)); cchPos += egs.StringLength; } bool lbApplyAndBreak = false; if (*szEOL) { lbApplyAndBreak = true; } // Получить следующую строку if ((j+1) >= ei.TotalLines) { lbApplyAndBreak = true; } else if (!lbApplyAndBreak) { egs.StringNumber = ++j; iRc = EditCtrl(ECTL_GETSTRING, &egs); if (!iRc) { _ASSERTE(iRc!=0); goto wrap; } _ASSERTE(egs.StringText!=NULL); if (egs.StringEOL && *egs.StringEOL) { // В этой строке есть EOL, ее не сворачивали lstrcpyn(szEOL, egs.StringEOL?egs.StringEOL:_T(""), ARRAYSIZE(szEOL)); } } if (lbApplyAndBreak) { EditorSetString esset = {FARSTRUCTSIZE(esset)}; esset.StringNumber = i; esset.StringText = pszCopy; esset.StringEOL = szEOL; esset.StringLength = cchPos; EditCtrl(ECTL_SETSTRING, &esset); for (INT_PTR k = i+1; k <= j; k++) { // Для ECTL_DELETESTRING нужно установить курсор EditorSetPosition eset = {FARSTRUCTSIZE(eset)}; eset.CurLine = i+1; eset.TopScreenLine = -1; iRc = EditCtrl(ECTL_SETPOSITION, &eset); _ASSERTE(iRc); // Удаляем "свернутое" iRc = EditCtrl(ECTL_DELETESTRING, NULL); _ASSERTE(iRc); ei.TotalLines--; if (ei.CurLine > i) ei.CurLine--; } // Выход из while break; } } } // Обновить позицию курсора { EditorSetPosition eset = {FARSTRUCTSIZE(eset)}; eset.CurLine = ei.CurLine; eset.TopScreenLine = -1; EditCtrl(ECTL_SETPOSITION, &eset); } wrap: if (pszCopy) free(pszCopy); #ifdef _UNICODE // Сброс флага "редактирован" //TODO: bis-сборка? if (!bWasModifed) EditCtrl(ECTL_DROPMODIFEDFLAG, NULL); #endif }
void CBreakable::KeyValue( KeyValueData* pkvd ) { // UNDONE_WC: explicitly ignoring these fields, but they shouldn't be in the map file! if (FStrEq(pkvd->szKeyName, "explosion")) { if (!stricmp(pkvd->szValue, "directed")) m_Explosion = expDirected; else if (!stricmp(pkvd->szValue, "random")) m_Explosion = expRandom; else m_Explosion = expRandom; pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "material")) { int i = atoi( pkvd->szValue); // 0:glass, 1:metal, 2:flesh, 3:wood if ((i < 0) || (i >= matLastMaterial)) m_Material = matWood; else m_Material = (Materials)i; pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "deadmodel")) { pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "shards")) { // m_iShards = atof(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "gibmodel") ) { m_iszGibModel = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "spawnobject") ) { int object = atoi( pkvd->szValue ); if ( object > 0 && object < ARRAYSIZE(pSpawnObjects) ) m_iszSpawnObject = MAKE_STRING( pSpawnObjects[object] ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "explodemagnitude") ) { ExplosionSetMagnitude( atoi( pkvd->szValue ) ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "lip") ) pkvd->fHandled = TRUE; else if (FStrEq(pkvd->szKeyName, "respawn") ) //LRC { m_iRespawnTime = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "whenhit") ) //LRC { m_iszWhenHit = ALLOC_STRING(pkvd->szValue); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "m_iClass") ) { m_iClass = atoi( pkvd->szValue ); pkvd->fHandled = TRUE; } else CBaseDelay::KeyValue( pkvd ); }
SciEvent EventManager::getScummVMEvent() { #ifdef ENABLE_SCI32 SciEvent input = { SCI_EVENT_NONE, 0, 0, Common::Point(), Common::Point() }; SciEvent noEvent = { SCI_EVENT_NONE, 0, 0, Common::Point(), Common::Point() }; #else SciEvent input = { SCI_EVENT_NONE, 0, 0, Common::Point() }; SciEvent noEvent = { SCI_EVENT_NONE, 0, 0, Common::Point() }; #endif Common::EventManager *em = g_system->getEventManager(); Common::Event ev; bool found = em->pollEvent(ev); // Don't generate events for mouse movement while (found && ev.type == Common::EVENT_MOUSEMOVE) found = em->pollEvent(ev); // Save the mouse position // // We call getMousePos of the event manager here, since we also want to // store the mouse position in case of keyboard events, which do not feature // any mouse position information itself. // This should be safe, since the mouse position in the event manager should // only be updated when a mouse related event has been taken from the queue // via pollEvent. // We also adjust the position based on the scaling of the screen. Common::Point mousePos = em->getMousePos(); #if ENABLE_SCI32 if (getSciVersion() >= SCI_VERSION_2) { Buffer &screen = g_sci->_gfxFrameout->getCurrentBuffer(); Common::Point mousePosSci = mousePos; mulru(mousePosSci, Ratio(screen.scriptWidth, screen.screenWidth), Ratio(screen.scriptHeight, screen.screenHeight)); noEvent.mousePosSci = input.mousePosSci = mousePosSci; } else { #endif g_sci->_gfxScreen->adjustBackUpscaledCoordinates(mousePos.y, mousePos.x); #if ENABLE_SCI32 } #endif noEvent.mousePos = input.mousePos = mousePos; if (!found || ev.type == Common::EVENT_MOUSEMOVE) { int modifiers = em->getModifierState(); noEvent.modifiers = ((modifiers & Common::KBD_ALT) ? SCI_KEYMOD_ALT : 0) | ((modifiers & Common::KBD_CTRL) ? SCI_KEYMOD_CTRL : 0) | ((modifiers & Common::KBD_SHIFT) ? SCI_KEYMOD_LSHIFT | SCI_KEYMOD_RSHIFT : 0); return noEvent; } if (ev.type == Common::EVENT_QUIT) { input.type = SCI_EVENT_QUIT; return input; } int scummVMKeyFlags; switch (ev.type) { case Common::EVENT_KEYDOWN: case Common::EVENT_KEYUP: // Use keyboard modifiers directly in case this is a keyboard event scummVMKeyFlags = ev.kbd.flags; break; default: // Otherwise get them from EventManager scummVMKeyFlags = em->getModifierState(); break; } input.modifiers = ((scummVMKeyFlags & Common::KBD_ALT) ? SCI_KEYMOD_ALT : 0) | ((scummVMKeyFlags & Common::KBD_CTRL) ? SCI_KEYMOD_CTRL : 0) | ((scummVMKeyFlags & Common::KBD_SHIFT) ? SCI_KEYMOD_LSHIFT | SCI_KEYMOD_RSHIFT : 0); // Caps lock and Scroll lock have been removed, cause we already handle upper // case keys and Scroll lock doesn't seem to be used anywhere //((ourModifiers & Common::KBD_CAPS) ? SCI_KEYMOD_CAPSLOCK : 0) | //((ourModifiers & Common::KBD_SCRL) ? SCI_KEYMOD_SCRLOCK : 0) | // Handle mouse events for (int i = 0; i < ARRAYSIZE(mouseEventMappings); i++) { if (mouseEventMappings[i].commonType == ev.type) { input.type = mouseEventMappings[i].sciType; // Sierra passed keyboard modifiers for mouse events, too. // Sierra also set certain modifiers within their mouse interrupt handler // This whole thing was probably meant for people using a mouse, that only featured 1 button // So the user was able to press Ctrl and click the mouse button to create a right click. switch (ev.type) { case Common::EVENT_RBUTTONDOWN: // right button case Common::EVENT_RBUTTONUP: input.modifiers |= (SCI_KEYMOD_RSHIFT | SCI_KEYMOD_LSHIFT); // this value was hardcoded in the mouse interrupt handler break; case Common::EVENT_MBUTTONDOWN: // middle button case Common::EVENT_MBUTTONUP: input.modifiers |= SCI_KEYMOD_CTRL; // this value was hardcoded in the mouse interrupt handler break; default: break; } return input; } } // If we reached here, make sure that it's a keydown event if (ev.type != Common::EVENT_KEYDOWN) return noEvent; // Check for Control-Shift-D (debug console) if (ev.kbd.hasFlags(Common::KBD_CTRL | Common::KBD_SHIFT) && ev.kbd.keycode == Common::KEYCODE_d) { // Open debug console Console *con = g_sci->getSciDebugger(); con->attach(); return noEvent; } // Process keyboard events bool numlockOn = (ev.kbd.flags & Common::KBD_NUM); Common::KeyCode scummVMKeycode = ev.kbd.keycode; input.character = ev.kbd.ascii; input.type = SCI_EVENT_KEYBOARD; if (scummVMKeycode >= Common::KEYCODE_KP0 && scummVMKeycode <= Common::KEYCODE_KP9) { if (!(scummVMKeyFlags & Common::KBD_NUM)) { // HACK: Num-Lock not enabled // We shouldn't get a valid ascii code in these cases. We fix it here, so that cursor keys // on the numpad work properly. input.character = 0; } } if ((input.character) && (input.character <= 0xFF)) { // Directly accept most common keys without conversion if ((input.character >= 0x80) && (input.character <= 0xFF)) { // If there is no extended font, we will just clear the // current event. // Sierra SCI actually accepted those characters, but // didn't display them inside text edit controls because // the characters were missing inside the font(s). // We filter them out for non-multilingual games because // of that. if (!_fontIsExtended) return noEvent; // Convert 8859-1 characters to DOS (cp850/437) for // multilingual SCI01 games input.character = codePageMap88591ToDOS[input.character & 0x7f]; } if (scummVMKeycode == Common::KEYCODE_TAB) { input.character = SCI_KEY_TAB; if (scummVMKeyFlags & Common::KBD_SHIFT) input.character = SCI_KEY_SHIFT_TAB; } if (scummVMKeycode == Common::KEYCODE_DELETE) input.character = SCI_KEY_DELETE; } else if ((scummVMKeycode >= Common::KEYCODE_F1) && scummVMKeycode <= Common::KEYCODE_F10) { // SCI_K_F1 == 59 << 8 // SCI_K_SHIFT_F1 == 84 << 8 if (!(scummVMKeyFlags & Common::KBD_SHIFT)) input.character = SCI_KEY_F1 + ((scummVMKeycode - Common::KEYCODE_F1)<<8); else input.character = SCI_KEY_SHIFT_F1 + ((scummVMKeycode - Common::KEYCODE_F1)<<8); } else { // Special keys that need conversion for (int i = 0; i < ARRAYSIZE(keyMappings); i++) { if (keyMappings[i].scummVMKey == scummVMKeycode) { input.character = numlockOn ? keyMappings[i].sciKeyNumlockOn : keyMappings[i].sciKeyNumlockOff; break; } } } // When Ctrl AND Alt are pressed together with a regular key, Linux will give us control-key, Windows will give // us the actual key. My opinion is that windows is right, because under DOS the keys worked the same, anyway // we support the other case as well if ((scummVMKeyFlags & Common::KBD_ALT) && input.character > 0 && input.character < 27) input.character += 96; // 0x01 -> 'a' // Scancodify if appropriate if (scummVMKeyFlags & Common::KBD_ALT) input.character = altify(input.character); if (getSciVersion() <= SCI_VERSION_1_MIDDLE && (scummVMKeyFlags & Common::KBD_CTRL) && input.character > 0 && input.character < 27) input.character += 96; // 0x01 -> 'a' #ifdef ENABLE_SCI32 if (getSciVersion() >= SCI_VERSION_2 && (scummVMKeyFlags & Common::KBD_CTRL) && input.character == 'c') { input.character = SCI_KEY_ETX; } #endif // If no actual key was pressed (e.g. if only a modifier key was pressed), // ignore the event if (!input.character) return noEvent; return input; }
BOOL CheckThreads ( __in DWORD ProcId ) /*++ Routine Description: Enumerates all threads (or optionally only threads for one process) in the system. It the calls the WCT API on each of them. Arguments: ProcId--Specifies the process ID to analyze. If '0' all processes in the system will be checked. Return Value: TRUE if processes could be checked; FALSE if a general failure occurred. --*/ { DWORD processes[1024]; DWORD numProcesses; DWORD i; // Try to enable the SE_DEBUG_NAME privilege for this process. We // continue even if this fails--we just won't be able to retrieve // wait chains for processes not owned by the current user. if (!GrantDebugPrivilege()) { printf("Couldn't enable debug privilege"); } // Get a list of all processes currently running. if (EnumProcesses(processes, sizeof(processes), &numProcesses) == FALSE) { printf("Couldn't enumerate processes"); return FALSE; } for (i = 0; i < numProcesses / sizeof(DWORD); i++) { HANDLE process; HANDLE snapshot; if (processes[i] == GetCurrentProcessId()) { continue; } // If the caller specified a Process ID, check if we have a match. if (ProcId != 0) { if (processes[i] != ProcId) { continue; } } // Get a handle to this process. process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processes[i]); if (process) { WCHAR file[MAX_PATH]; printf("Process 0x%x - ", processes[i]); // Retrieve the EXE's name and print it. if (GetProcessImageFileName(process, file, ARRAYSIZE(file)) > 0) { PCWSTR filePart = wcsrchr(file, L'\\'); if (filePart) { filePart++; } else { filePart = file; } printf("%S", filePart); } printf("\n----------------------------------\n"); // Get a snapshot of this process. This allows us to // enumerate its threads. snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, processes[i]); if (snapshot) { THREADENTRY32 thread; thread.dwSize = sizeof(thread); // Walk the thread list and print the wait chain // for each. if (Thread32First(snapshot, &thread)) { do { if (thread.th32OwnerProcessID == processes[i]) { // Open a handle to this specific thread,... HANDLE threadHandle = OpenThread(THREAD_ALL_ACCESS, FALSE, thread.th32ThreadID); if (threadHandle) { // ...check if it is still running,... DWORD exitCode; GetExitCodeThread(threadHandle, &exitCode); if (exitCode == STILL_ACTIVE) { // ...and print its wait chain. PrintWaitChain(thread.th32ThreadID); } CloseHandle(threadHandle); } } } while (Thread32Next(snapshot, &thread)); } CloseHandle(snapshot); } CloseHandle(process); printf("\n"); } } return TRUE; }
{ { 0 | MeshPolyType_StripsB, 7, strips_1011D988, 0, NULL, NULL, uv_1011DA08, 0 } }; static struct MATERIAL mat_1011D974[] = { { 0xFFB2B2B2, 0x00FFFFFF, 11.0f, 0x00000020, 0xA400, 0x29, 0x94 } }; struct ATTACH attach_1011DD40 = { vec3_1011DB00, vec3_1011DC20, ARRAYSIZE(vec3_1011DB00), mesh_1011DAE0, mat_1011D974, ARRAYSIZE(mesh_1011DAE0), ARRAYSIZE(mat_1011D974), { 1.479647f, 0.037022f, 0.262757f }, 2.904496f, 0 };
uint32 EXT_FUNC CGameClient::GetVoiceStream(int stream_id) { if (stream_id >= 0 && stream_id < ARRAYSIZE(m_pClient->m_VoiceStreams)) return m_pClient->m_VoiceStreams[stream_id]; return 0; }