void UMaterialExpressionLandscapeLayerWeight::GetCaption(TArray<FString>& OutCaptions) const { OutCaptions.Add(FString::Printf(TEXT("Layer '%s'"), *ParameterName.ToString())); }
HRESULT CLAVSplitterSettingsProp::OnActivate() { HRESULT hr = S_OK; INITCOMMONCONTROLSEX icc; icc.dwSize = sizeof(INITCOMMONCONTROLSEX); icc.dwICC = ICC_BAR_CLASSES | ICC_STANDARD_CLASSES; if (InitCommonControlsEx(&icc) == FALSE) { return E_FAIL; } ASSERT(m_pLAVF != nullptr); const WCHAR *version = TEXT(LAV_SPLITTER) L" " TEXT(LAV_VERSION_STR); SendDlgItemMessage(m_Dlg, IDC_SPLITTER_FOOTER, WM_SETTEXT, 0, (LPARAM)version); hr = LoadData(); memset(m_subLangBuffer, 0, sizeof(m_advSubBuffer)); memset(m_advSubBuffer, 0, sizeof(m_advSubBuffer)); m_selectedSubMode = LAVSubtitleMode_Default; if (m_pszAdvSubConfig) wcsncpy_s(m_advSubBuffer, m_pszAdvSubConfig, _TRUNCATE); // Notify the UI about those settings SendDlgItemMessage(m_Dlg, IDC_PREF_LANG, WM_SETTEXT, 0, (LPARAM)m_pszPrefLang); SendDlgItemMessage(m_Dlg, IDC_PREF_LANG_SUBS, WM_SETTEXT, 0, (LPARAM)m_pszPrefSubLang); // Init the Combo Box SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_RESETCONTENT, 0, 0); WideStringFromResource(stringBuffer, IDS_SUBMODE_NO_SUBS); SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer); WideStringFromResource(stringBuffer, IDS_SUBMODE_FORCED_SUBS); SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer); WideStringFromResource(stringBuffer, IDS_SUBMODE_DEFAULT); SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer); WideStringFromResource(stringBuffer, IDS_SUBMODE_ADVANCED); SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_ADDSTRING, 0, (LPARAM)stringBuffer); SendDlgItemMessage(m_Dlg, IDC_SUBTITLE_MODE, CB_SETCURSEL, m_subtitleMode, 0); addHint(IDC_SUBTITLE_MODE, L"Configure how subtitles are selected."); SendDlgItemMessage(m_Dlg, IDC_BD_SEPARATE_FORCED_SUBS, BM_SETCHECK, m_PGSForcedStream, 0); addHint(IDC_BD_SEPARATE_FORCED_SUBS, L"Enabling this causes the creation of a new \"Forced Subtitles\" stream, which will try to always display forced subtitles matching your selected audio language.\n\nNOTE: This option may not work on all Blu-ray discs.\nRequires restart to take effect."); SendDlgItemMessage(m_Dlg, IDC_BD_ONLY_FORCED_SUBS, BM_SETCHECK, m_PGSOnlyForced, 0); addHint(IDC_BD_ONLY_FORCED_SUBS, L"When enabled, all Blu-ray (PGS) subtitles will be filtered, and only forced subtitles will be sent to the renderer.\n\nNOTE: When this option is active, you will not be able to get the \"full\" subtitles."); SendDlgItemMessage(m_Dlg, IDC_VC1TIMESTAMP, BM_SETCHECK, m_VC1Mode, 0); addHint(IDC_VC1TIMESTAMP, L"Checked - Frame timings will be corrected.\nUnchecked - Frame timings will be sent untouched.\nIndeterminate (Auto) - Only enabled for decoders that rely on the splitter doing the corrections.\n\nNOTE: Only for debugging, if unsure, set to \"Auto\"."); SendDlgItemMessage(m_Dlg, IDC_MKV_EXTERNAL, BM_SETCHECK, m_MKVExternal, 0); SendDlgItemMessage(m_Dlg, IDC_SUBSTREAMS, BM_SETCHECK, m_substreams, 0); addHint(IDC_SUBSTREAMS, L"Controls if sub-streams should be exposed as a separate stream.\nSub-streams are typically streams for backwards compatibility, for example the AC3 part of TrueHD streams on Blu-rays."); SendDlgItemMessage(m_Dlg, IDC_STREAM_SWITCH_REMOVE_AUDIO, BM_SETCHECK, m_StreamSwitchRemoveAudio, 0); addHint(IDC_STREAM_SWITCH_REMOVE_AUDIO, L"Remove the old Audio Decoder from the Playback Chain before switching the audio stream, forcing DirectShow to select a new one.\n\nThis option ensures that the preferred decoder is always used, however it does not work properly with all players."); addHint(IDC_SELECT_AUDIO_QUALITY, L"Controls if the stream with the highest quality (matching your language preferences) should always be used.\nIf disabled, the first stream is always used."); SendDlgItemMessage(m_Dlg, IDC_SELECT_AUDIO_QUALITY, BM_SETCHECK, m_PreferHighQualityAudio, 0); SendDlgItemMessage(m_Dlg, IDC_IMPAIRED_AUDIO, BM_SETCHECK, m_ImpairedAudio, 0); SendDlgItemMessage(m_Dlg, IDC_QUEUE_MEM_SPIN, UDM_SETRANGE32, 0, 2048); addHint(IDC_QUEUE_MEM, L"Set the maximum memory a frame queue can use for buffering (in megabytes).\nNote that this is the maximum value, only very high bitrate files will usually even reach the default maximum value."); addHint(IDC_QUEUE_MEM_SPIN, L"Set the maximum memory a frame queue can use for buffering (in megabytes).\nNote that this is the maximum value, only very high bitrate files will usually even reach the default maximum value."); WCHAR stringBuffer[100]; swprintf_s(stringBuffer, L"%d", m_QueueMaxMem); SendDlgItemMessage(m_Dlg, IDC_QUEUE_MEM, WM_SETTEXT, 0, (LPARAM)stringBuffer); SendDlgItemMessage(m_Dlg, IDC_QUEUE_PACKETS_SPIN, UDM_SETRANGE32, 100, 100000); addHint(IDC_QUEUE_PACKETS, L"Set the maximum numbers of packets to buffer in the frame queue.\nNote that the frame queue will never exceed the memory limited set above."); addHint(IDC_QUEUE_PACKETS_SPIN, L"Set the maximum numbers of packets to buffer in the frame queue.\nNote that the frame queue will never exceed the memory limited set above."); swprintf_s(stringBuffer, L"%d", m_QueueMaxPackets); SendDlgItemMessage(m_Dlg, IDC_QUEUE_PACKETS, WM_SETTEXT, 0, (LPARAM)stringBuffer); SendDlgItemMessage(m_Dlg, IDC_STREAM_ANADUR_SPIN, UDM_SETRANGE32, 200, 10000); addHint(IDC_STREAM_ANADUR, L"Set the duration (in milliseconds) a network stream is analyzed for before playback starts.\nA longer duration ensures the stream parameters are properly detected, however it will delay playback start.\n\nDefault: 1000 (1 second)"); addHint(IDC_STREAM_ANADUR_SPIN, L"Set the duration (in milliseconds) a network stream is analyzed for before playback starts.\nA longer duration ensures the stream parameters are properly detected, however it will delay playback start.\n\nDefault: 1000 (1 second)"); swprintf_s(stringBuffer, L"%d", m_NetworkAnalysisDuration); SendDlgItemMessage(m_Dlg, IDC_STREAM_ANADUR, WM_SETTEXT, 0, (LPARAM)stringBuffer); UpdateSubtitleMode(m_subtitleMode); SendDlgItemMessage(m_Dlg, IDC_TRAYICON, BM_SETCHECK, m_TrayIcon, 0); return hr; }
inline FString convert(void* x) { return "Pointer: " + FString::Printf(TEXT("%p"), x); }
int KG_HttpClient::RequestPost( const TCHAR cszAgent[], const TCHAR cszAddress[], const TCHAR cszVerb[], int nPort ) { int nResult = false; int nRetCode = false; LPCSTR clpAcceptTypeArray[] = {"*/*", NULL}; BYTE *pbyBuffer = NULL; DWORD dwBufferSize = 0; DWORD dwBytesWrite = 0; DWORD dwBytesRead = 0; DWORD dwBytesToRead = 0; INTERNET_BUFFERS InternetBuffer; LPCSTR clpContent = TEXT("Content-Type: multipart/form-data; boundary=-------------------------24822581126073\r\n"); TCHAR szContentLength[64]; KG_DELETE_ARRAY(m_pResponseBuffer); m_hInternetSession = ::InternetOpen( cszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0 ); KGLOG_PROCESS_ERROR(m_hInternetSession); m_hInternetConnection = ::InternetConnect( m_hInternetSession, cszAddress, (INTERNET_PORT)nPort, NULL, NULL, INTERNET_SERVICE_HTTP, INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_CACHE_WRITE, 0 ); KGLOG_PROCESS_ERROR(m_hInternetConnection); m_hHttpRequest = ::HttpOpenRequest( m_hInternetConnection, "POST", cszVerb, HTTP_VERSION, NULL, clpAcceptTypeArray, INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_FORMS_SUBMIT, 0 ); KGLOG_PROCESS_ERROR(m_hHttpRequest); nRetCode = GetPostBuffer(&pbyBuffer, &dwBufferSize); KGLOG_PROCESS_ERROR(nRetCode); nRetCode = ::HttpAddRequestHeaders(m_hHttpRequest, "Accept: */*\r\n", (DWORD)_tcslen("Accept: */*\r\n"), HTTP_ADDREQ_FLAG_REPLACE); KGLOG_PROCESS_ERROR(nRetCode); nRetCode = ::HttpAddRequestHeaders(m_hHttpRequest, clpContent, (DWORD)_tcslen(clpContent), HTTP_ADDREQ_FLAG_ADD_IF_NEW); KGLOG_PROCESS_ERROR(nRetCode); _stprintf(szContentLength, "Content-Length: %d\r\n", dwBufferSize); nRetCode = ::HttpAddRequestHeaders(m_hHttpRequest, szContentLength,(DWORD) _tcslen(szContentLength), HTTP_ADDREQ_FLAG_ADD_IF_NEW); KGLOG_PROCESS_ERROR(nRetCode); memset(&InternetBuffer, 0, sizeof(InternetBuffer)); InternetBuffer.dwStructSize = sizeof(InternetBuffer); nRetCode = ::HttpSendRequestEx(m_hHttpRequest, &InternetBuffer, NULL, HSR_INITIATE, 0); KGLOG_PROCESS_ERROR(nRetCode); nRetCode = ::InternetWriteFile(m_hHttpRequest, pbyBuffer, dwBufferSize, &dwBytesWrite); KGLOG_PROCESS_ERROR(nRetCode); nRetCode = ::HttpEndRequest(m_hHttpRequest, NULL, HSR_INITIATE, 0); KGLOG_PROCESS_ERROR(nRetCode); dwBufferSize = (DWORD)sizeof(szContentLength); nRetCode = ::HttpQueryInfo(m_hHttpRequest, HTTP_QUERY_CONTENT_LENGTH, szContentLength, &dwBufferSize, NULL); KGLOG_PROCESS_ERROR(nRetCode); dwBytesToRead = atoi(szContentLength); KG_DELETE_ARRAY(m_pResponseBuffer); m_pResponseBuffer = new BYTE[dwBytesToRead + 1]; ZeroMemory(m_pResponseBuffer, dwBytesToRead + 1); nRetCode = ::InternetReadFile(m_hHttpRequest, m_pResponseBuffer, dwBytesToRead, &dwBytesRead); KGLOG_PROCESS_ERROR(nRetCode); m_pResponseBuffer[dwBytesToRead] = '\0'; m_dwBufferSize = dwBytesRead; nResult = true; Exit0: if (!nResult) { KG_DELETE_ARRAY(m_pResponseBuffer); } KG_DELETE_ARRAY(pbyBuffer); KG_INTERNET_HANDLE_CLOSE(m_hHttpRequest); KG_INTERNET_HANDLE_CLOSE(m_hInternetConnection); KG_INTERNET_HANDLE_CLOSE(m_hInternetSession); for (size_t i = 0; i < m_PostList.size(); ++i) { KG_DELETE_ARRAY(m_PostList[i].pParamName); KG_DELETE_ARRAY(m_PostList[i].pValue); } m_PostList.clear(); return nResult; }
void UNavMeshRenderingComponent::GatherData(struct FNavMeshSceneProxyData* CurrentData) const { #if WITH_RECAST const ARecastNavMesh* NavMesh = Cast<ARecastNavMesh>(GetOwner()); if (CurrentData && NavMesh && NavMesh->bEnableDrawing && (!NavMesh->bShowOnlyDefaultAgent || NavMesh->IsSupportingDefaultAgent())) { FHitProxyId HitProxyId = FHitProxyId(); CurrentData->Reset(); CurrentData->bEnableDrawing = NavMesh->bEnableDrawing; CurrentData->bShowOnlyDefaultAgent = NavMesh->bShowOnlyDefaultAgent; CurrentData->bSupportsDefaultAgent = NavMesh->IsSupportingDefaultAgent(); CurrentData->bDrawPathCollidingGeometry = NavMesh->bDrawPathCollidingGeometry; CurrentData->NavMeshDrawOffset.Z = NavMesh->DrawOffset; CurrentData->NavMeshGeometry.bGatherPolyEdges = NavMesh->bDrawPolyEdges; CurrentData->NavMeshGeometry.bGatherNavMeshEdges = NavMesh->bDrawNavMeshEdges; const FNavDataConfig& NavConfig = NavMesh->GetConfig(); CurrentData->NavMeshColors[RECAST_DEFAULT_AREA] = NavConfig.Color.DWColor() > 0 ? NavConfig.Color : NavMeshRenderColor_RecastMesh; for (uint8 i = 0; i < RECAST_DEFAULT_AREA; ++i) { CurrentData->NavMeshColors[i] = NavMesh->GetAreaIDColor(i); } // just a little trick to make sure navmeshes with different sized are not drawn with same offset CurrentData->NavMeshDrawOffset.Z += NavMesh->GetConfig().AgentRadius / 10.f; NavMesh->BeginBatchQuery(); NavMesh->GetDebugGeometry(CurrentData->NavMeshGeometry); const TArray<FVector>& MeshVerts = CurrentData->NavMeshGeometry.MeshVerts; // @fixme, this is going to double up on lots of interior lines if (NavMesh->bDrawTriangleEdges) { for (int32 AreaIdx = 0; AreaIdx < RECAST_MAX_AREAS; ++AreaIdx) { const TArray<int32>& MeshIndices = CurrentData->NavMeshGeometry.AreaIndices[AreaIdx]; for (int32 Idx=0; Idx<MeshIndices.Num(); Idx += 3) { CurrentData->BatchedElements.AddLine(MeshVerts[MeshIndices[Idx+0]] + CurrentData->NavMeshDrawOffset, MeshVerts[MeshIndices[Idx+1]] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TriangleEdges,HitProxyId,DefaultEdges_LineThickness, 0, true); CurrentData->BatchedElements.AddLine(MeshVerts[MeshIndices[Idx+1]] + CurrentData->NavMeshDrawOffset, MeshVerts[MeshIndices[Idx+2]] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TriangleEdges,HitProxyId,DefaultEdges_LineThickness, 0, true); CurrentData->BatchedElements.AddLine(MeshVerts[MeshIndices[Idx+2]] + CurrentData->NavMeshDrawOffset, MeshVerts[MeshIndices[Idx+0]] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TriangleEdges,HitProxyId,DefaultEdges_LineThickness, 0, true); } } } // make lines for tile edges if (NavMesh->bDrawPolyEdges) { const TArray<FVector>& TileEdgeVerts = CurrentData->NavMeshGeometry.PolyEdges; for (int32 Idx=0; Idx < TileEdgeVerts.Num(); Idx += 2) { CurrentData->TileEdgeLines.Add( FDebugRenderSceneProxy::FDebugLine(TileEdgeVerts[Idx] + CurrentData->NavMeshDrawOffset, TileEdgeVerts[Idx+1] + CurrentData->NavMeshDrawOffset, NavMeshRenderColor_Recast_TileEdges)); } } // make lines for navmesh edges if (NavMesh->bDrawNavMeshEdges) { const FColor EdgesColor = DarkenColor(CurrentData->NavMeshColors[RECAST_DEFAULT_AREA]); const TArray<FVector>& NavMeshEdgeVerts = CurrentData->NavMeshGeometry.NavMeshEdges; for (int32 Idx=0; Idx < NavMeshEdgeVerts.Num(); Idx += 2) { CurrentData->NavMeshEdgeLines.Add( FDebugRenderSceneProxy::FDebugLine(NavMeshEdgeVerts[Idx] + CurrentData->NavMeshDrawOffset, NavMeshEdgeVerts[Idx+1] + CurrentData->NavMeshDrawOffset, EdgesColor)); } } if (NavMesh->bDrawTileBounds) { FBox OuterBBox; int32 NumTilesX, NumTilesY; NavMesh->GetDebugTileBounds(OuterBBox, NumTilesX, NumTilesY); float DrawZ = (OuterBBox.Min.Z + OuterBBox.Max.Z) * 0.5f; // @hack average FVector LL(OuterBBox.Min.X, OuterBBox.Min.Y, DrawZ); FVector UR(OuterBBox.Max.X, OuterBBox.Max.Y, DrawZ); FVector UL(LL.X, UR.Y, DrawZ); FVector LR(UR.X, LL.Y, DrawZ); CurrentData->BatchedElements.AddLine(LL, UL, NavMeshRenderColor_TileBounds,HitProxyId,DefaultEdges_LineThickness, 0, true); CurrentData->BatchedElements.AddLine(UL, UR, NavMeshRenderColor_TileBounds,HitProxyId,DefaultEdges_LineThickness, 0, true); CurrentData->BatchedElements.AddLine(UR, LR, NavMeshRenderColor_TileBounds,HitProxyId,DefaultEdges_LineThickness, 0, true); CurrentData->BatchedElements.AddLine(LR, LL, NavMeshRenderColor_TileBounds,HitProxyId,DefaultEdges_LineThickness, 0, true); float const TileSizeX = (LL.X - LR.X) / NumTilesX; float const TileSizeY = (LL.Y - UL.Y) / NumTilesY; for (int32 Idx=1; Idx<NumTilesX; ++Idx) { float const DrawX = FMath::Lerp(LL.X, LR.X, (float)Idx/(float)NumTilesX); CurrentData->BatchedElements.AddLine(FVector(DrawX, LL.Y, DrawZ), FVector(DrawX, UL.Y, DrawZ), NavMeshRenderColor_TileBounds,HitProxyId,DefaultEdges_LineThickness, 0, true); } for (int32 Idx=1; Idx<NumTilesY; ++Idx) { float const DrawY = FMath::Lerp(LL.Y, UL.Y, (float)Idx/(float)NumTilesY); CurrentData->BatchedElements.AddLine(FVector(LL.X, DrawY, DrawZ), FVector(LR.X, DrawY, DrawZ), NavMeshRenderColor_TileBounds,HitProxyId,DefaultEdges_LineThickness, 0, true); } } if (NavMesh->bDrawPathCollidingGeometry) { // draw all geometry gathered in navoctree const FNavigationOctree* NavOctree = NavMesh->GetWorld()->GetNavigationSystem()->GetNavOctree(); for (FNavigationOctree::TConstIterator<> It(*NavOctree); It.HasPendingNodes(); It.Advance()) { const FNavigationOctree::FNode& Node = It.GetCurrentNode(); for (FNavigationOctree::ElementConstIt ElementIt(Node.GetElementIt()); ElementIt; ElementIt++) { const FNavigationOctreeElement& Element = *ElementIt; if (Element.ShouldUseGeometry(&NavMesh->NavDataConfig) && Element.Data.CollisionData.Num()) { const FRecastGeometryCache CachedGeometry(Element.Data.CollisionData.GetTypedData()); AppendGeometry(CurrentData->PathCollidingGeomVerts, CurrentData->PathCollidingGeomIndices, CachedGeometry.Verts, CachedGeometry.Header.NumVerts, CachedGeometry.Indices, CachedGeometry.Header.NumFaces); } } } } // offset all navigation-link positions if (!NavMesh->bDrawClusters) { for (int32 OffMeshLineIndex = 0; OffMeshLineIndex < CurrentData->NavMeshGeometry.OffMeshLinks.Num(); ++OffMeshLineIndex) { FRecastDebugGeometry::FOffMeshLink& Link = CurrentData->NavMeshGeometry.OffMeshLinks[OffMeshLineIndex]; const bool bLinkValid = (Link.ValidEnds & FRecastDebugGeometry::OMLE_Left) && (Link.ValidEnds & FRecastDebugGeometry::OMLE_Right); if (NavMesh->bDrawFailedNavLinks || (NavMesh->bDrawNavLinks && bLinkValid)) { const FVector V0 = Link.Left + CurrentData->NavMeshDrawOffset; const FVector V1 = Link.Right + CurrentData->NavMeshDrawOffset; const FColor LinkColor = ((Link.Direction && Link.ValidEnds) || (Link.ValidEnds & FRecastDebugGeometry::OMLE_Left)) ? DarkenColor(CurrentData->NavMeshColors[Link.AreaID]) : NavMeshRenderColor_OffMeshConnectionInvalid; CacheArc(CurrentData->NavLinkLines, V0, V1, 0.4f, 4, LinkColor, LinkLines_LineThickness); const FVector VOffset(0, 0, FVector::Dist(V0, V1) * 1.333f); CacheArrowHead(CurrentData->NavLinkLines, V1, V0+VOffset, 30.f, LinkColor, LinkLines_LineThickness); if (Link.Direction) { CacheArrowHead(CurrentData->NavLinkLines, V0, V1+VOffset, 30.f, LinkColor, LinkLines_LineThickness); } // if the connection as a whole is valid check if there are any of ends is invalid if (LinkColor != NavMeshRenderColor_OffMeshConnectionInvalid) { if (Link.Direction && (Link.ValidEnds & FRecastDebugGeometry::OMLE_Left) == 0) { // left end invalid - mark it DrawWireCylinder(CurrentData->NavLinkLines, V0, FVector(1,0,0), FVector(0,1,0), FVector(0,0,1), NavMeshRenderColor_OffMeshConnectionInvalid, Link.Radius, NavMesh->AgentMaxStepHeight, 16, 0, DefaultEdges_LineThickness); } if ((Link.ValidEnds & FRecastDebugGeometry::OMLE_Right) == 0) { DrawWireCylinder(CurrentData->NavLinkLines, V1, FVector(1,0,0), FVector(0,1,0), FVector(0,0,1), NavMeshRenderColor_OffMeshConnectionInvalid, Link.Radius, NavMesh->AgentMaxStepHeight, 16, 0, DefaultEdges_LineThickness); } } } } } if (NavMesh->bDrawTileLabels || NavMesh->bDrawPolygonLabels || NavMesh->bDrawDefaultPolygonCost) { // calculate appropriate points for displaying debug labels const int32 TilesCount = NavMesh->GetNavMeshTilesCount(); CurrentData->DebugLabels.Reserve(TilesCount); for (int32 TileIndex = 0; TileIndex < TilesCount; ++TileIndex) { int32 X = -1; int32 Y = -1; int32 Layer = -1; NavMesh->GetNavMeshTileXY(TileIndex, X, Y, Layer); if (X >= 0 && Y >= 0) { const FBox TileBoundingBox = NavMesh->GetNavMeshTileBounds(TileIndex); FVector TileLabelLocation = TileBoundingBox.GetCenter(); TileLabelLocation.Z = TileBoundingBox.Max.Z; FNavLocation NavLocation(TileLabelLocation); if (!NavMesh->ProjectPoint(TileLabelLocation, NavLocation, FVector(NavMesh->TileSizeUU/100, NavMesh->TileSizeUU/100, TileBoundingBox.Max.Z-TileBoundingBox.Min.Z))) { NavMesh->ProjectPoint(TileLabelLocation, NavLocation, FVector(NavMesh->TileSizeUU/2, NavMesh->TileSizeUU/2, TileBoundingBox.Max.Z-TileBoundingBox.Min.Z)); } if (NavMesh->bDrawTileLabels) { CurrentData->DebugLabels.Add(FNavMeshSceneProxyData::FDebugText( /*Location*/NavLocation.Location + CurrentData->NavMeshDrawOffset , /*Text*/FString::Printf(TEXT("(%d,%d:%d)"), X, Y, Layer) )); } if (NavMesh->bDrawPolygonLabels || NavMesh->bDrawDefaultPolygonCost) { TArray<FNavPoly> Polys; NavMesh->GetPolysInTile(TileIndex, Polys); if (NavMesh->bDrawDefaultPolygonCost) { float DefaultCosts[RECAST_MAX_AREAS]; float FixedCosts[RECAST_MAX_AREAS]; NavMesh->GetDefaultQueryFilter()->GetAllAreaCosts(DefaultCosts, FixedCosts, RECAST_MAX_AREAS); for(int k = 0; k < Polys.Num(); ++k) { uint32 AreaID = NavMesh->GetPolyAreaID(Polys[k].Ref); CurrentData->DebugLabels.Add(FNavMeshSceneProxyData::FDebugText( /*Location*/Polys[k].Center + CurrentData->NavMeshDrawOffset , /*Text*/FString::Printf(TEXT("\\%.3f; %.3f\\"), DefaultCosts[AreaID], FixedCosts[AreaID]) )); } } else { for(int k = 0; k < Polys.Num(); ++k) { CurrentData->DebugLabels.Add(FNavMeshSceneProxyData::FDebugText( /*Location*/Polys[k].Center + CurrentData->NavMeshDrawOffset , /*Text*/FString::Printf(TEXT("[%08X]"), Polys[k].Ref) )); } } } } } } CurrentData->bSkipDistanceCheck = GIsEditor && (GEngine->GetDebugLocalPlayer() == NULL); CurrentData->bDrawClusters = NavMesh->bDrawClusters; NavMesh->FinishBatchQuery(); // Draw Mesh if (NavMesh->bDrawClusters) { for (int32 Idx = 0; Idx < CurrentData->NavMeshGeometry.Clusters.Num(); ++Idx) { const TArray<int32>& MeshIndices = CurrentData->NavMeshGeometry.Clusters[Idx].MeshIndices; if (MeshIndices.Num() == 0) { continue; } FNavMeshSceneProxyData::FDebugMeshData DebugMeshData; for (int32 VertIdx=0; VertIdx < MeshVerts.Num(); ++VertIdx) { AddVertexHelper(DebugMeshData, MeshVerts[VertIdx] + CurrentData->NavMeshDrawOffset); } for (int32 TriIdx=0; TriIdx < MeshIndices.Num(); TriIdx+=3) { AddTriangleHelper(DebugMeshData, MeshIndices[TriIdx], MeshIndices[TriIdx+1], MeshIndices[TriIdx+2]); } DebugMeshData.ClusterColor = GetClusterColor(Idx); CurrentData->MeshBuilders.Add(DebugMeshData); } } else { for (int32 AreaType = 0; AreaType < RECAST_MAX_AREAS; ++AreaType) { const TArray<int32>& MeshIndices = CurrentData->NavMeshGeometry.AreaIndices[AreaType]; if (MeshIndices.Num() == 0) { continue; } FNavMeshSceneProxyData::FDebugMeshData DebugMeshData; for (int32 VertIdx=0; VertIdx < MeshVerts.Num(); ++VertIdx) { AddVertexHelper(DebugMeshData, MeshVerts[VertIdx] + CurrentData->NavMeshDrawOffset); } for (int32 TriIdx=0; TriIdx < MeshIndices.Num(); TriIdx+=3) { AddTriangleHelper(DebugMeshData, MeshIndices[TriIdx], MeshIndices[TriIdx+1], MeshIndices[TriIdx+2]); } DebugMeshData.ClusterColor = CurrentData->NavMeshColors[AreaType]; CurrentData->MeshBuilders.Add(DebugMeshData); } } // Draw path generation input geometry if (CurrentData->bDrawPathCollidingGeometry) { FNavMeshSceneProxyData::FDebugMeshData DebugMeshData; for (int32 VertIdx=0; VertIdx < CurrentData->PathCollidingGeomVerts.Num(); ++VertIdx) { AddVertexHelper(DebugMeshData, CurrentData->PathCollidingGeomVerts[VertIdx]); } DebugMeshData.Indices.Append(CurrentData->PathCollidingGeomIndices); DebugMeshData.ClusterColor = NavMeshRenderColor_PathCollidingGeom; CurrentData->MeshBuilders.Add(DebugMeshData); } if (CurrentData->NavMeshGeometry.BuiltMeshIndices.Num() > 0) { FNavMeshSceneProxyData::FDebugMeshData DebugMeshData; for (int32 VertIdx=0; VertIdx < MeshVerts.Num(); ++VertIdx) { AddVertexHelper(DebugMeshData, MeshVerts[VertIdx] + CurrentData->NavMeshDrawOffset); } DebugMeshData.Indices.Append(CurrentData->NavMeshGeometry.BuiltMeshIndices); DebugMeshData.ClusterColor = NavMeshRenderColor_RecastTileBeingRebuilt; CurrentData->MeshBuilders.Add(DebugMeshData); // if we got here it means there's something being built, or is fresh so we better redraw in some time FSimpleDelegateGraphTask::CreateAndDispatchWhenReady( FSimpleDelegateGraphTask::FDelegate::CreateUObject(NavMesh, &ARecastNavMesh::MarkComponentsRenderStateDirty) , TEXT("Requesting navmesh redraw") , NULL , ENamedThreads::GameThread ); } if (NavMesh->bDrawClusters) { for (int i = 0; i < CurrentData->NavMeshGeometry.ClusterLinks.Num(); i++) { const FRecastDebugGeometry::FClusterLink& CLink = CurrentData->NavMeshGeometry.ClusterLinks[i]; const FVector V0 = CLink.FromCluster + CurrentData->NavMeshDrawOffset; const FVector V1 = CLink.ToCluster + CurrentData->NavMeshDrawOffset + FVector(0,0,20.0f); CacheArc(CurrentData->ClusterLinkLines, V0, V1, 0.4f, 4, FColor::Black, ClusterLinkLines_LineThickness); const FVector VOffset(0, 0, FVector::Dist(V0, V1) * 1.333f); CacheArrowHead(CurrentData->ClusterLinkLines, V1, V0+VOffset, 30.f, FColor::Black, ClusterLinkLines_LineThickness); } } // cache segment links if (NavMesh->bDrawNavLinks) { for (int32 iArea = 0; iArea < RECAST_MAX_AREAS; iArea++) { const TArray<int32>& Indices = CurrentData->NavMeshGeometry.OffMeshSegmentAreas[iArea]; FNavMeshSceneProxyData::FDebugMeshData DebugMeshData; int32 VertBase = 0; for (int32 i = 0; i < Indices.Num(); i++) { FRecastDebugGeometry::FOffMeshSegment& SegInfo = CurrentData->NavMeshGeometry.OffMeshSegments[Indices[i]]; const FVector A0 = SegInfo.LeftStart + CurrentData->NavMeshDrawOffset; const FVector A1 = SegInfo.LeftEnd + CurrentData->NavMeshDrawOffset; const FVector B0 = SegInfo.RightStart + CurrentData->NavMeshDrawOffset; const FVector B1 = SegInfo.RightEnd + CurrentData->NavMeshDrawOffset; const FVector Edge0 = B0 - A0; const FVector Edge1 = B1 - A1; const float Len0 = Edge0.Size(); const float Len1 = Edge1.Size(); const FColor SegColor = DarkenColor(CurrentData->NavMeshColors[SegInfo.AreaID]); const FColor ColA = (SegInfo.ValidEnds & FRecastDebugGeometry::OMLE_Left) ? FColor::White : FColor::Black; const FColor ColB = (SegInfo.ValidEnds & FRecastDebugGeometry::OMLE_Right) ? FColor::White : FColor::Black; const int32 NumArcPoints = 8; const float ArcPtsScale = 1.0f / NumArcPoints; FVector Prev0 = EvalArc(A0, Edge0, Len0*0.25f, 0); FVector Prev1 = EvalArc(A1, Edge1, Len1*0.25f, 0); AddVertexHelper(DebugMeshData, Prev0, ColA); AddVertexHelper(DebugMeshData, Prev1, ColA); for (int32 j = 1; j <= NumArcPoints; j++) { const float u = j * ArcPtsScale; FVector Pt0 = EvalArc(A0, Edge0, Len0*0.25f, u); FVector Pt1 = EvalArc(A1, Edge1, Len1*0.25f, u); AddVertexHelper(DebugMeshData, Pt0, (j == NumArcPoints) ? ColB : FColor::White); AddVertexHelper(DebugMeshData, Pt1, (j == NumArcPoints) ? ColB : FColor::White); AddTriangleHelper(DebugMeshData, VertBase+0, VertBase+2, VertBase+1); AddTriangleHelper(DebugMeshData, VertBase+2, VertBase+3, VertBase+1); AddTriangleHelper(DebugMeshData, VertBase+0, VertBase+1, VertBase+2); AddTriangleHelper(DebugMeshData, VertBase+2, VertBase+1, VertBase+3); VertBase += 2; Prev0 = Pt0; Prev1 = Pt1; } VertBase += 2; DebugMeshData.ClusterColor = SegColor; } if (DebugMeshData.Indices.Num()) { CurrentData->MeshBuilders.Add(DebugMeshData); } } } CurrentData->NavMeshGeometry.PolyEdges.Empty(); CurrentData->NavMeshGeometry.NavMeshEdges.Empty(); } #endif //WITH_RECAST }
/*函数名称:HWD_Seek **函数参数:hOpenContext, XXX_Open()返回的设备打开上下文 Amount, 要移动的距离,负数表示前移,正数表示后移 Type 缓冲中的数据的字节数 **函数功能:移动设备中的数据指针 与应用程序SetFilePointer()函数据对应 **函数返回:返回数据的新指针位置,-1表示失败 **修 改 人: **修改日期: */ DWORD HWD_Seek(DWORD hOpenContext, LONG Amount,DWORD Type) { RETAILMSG(1, (TEXT("[HW drv] HWD Seek!\r\n"))); return 0; }
#if ! defined( HB_DYNLIB ) #include "hbapi.h" #include "hbwinuni.h" #include "hbwinole.h" #include <olectl.h> #define MAX_CLSID_SIZE 64 #define MAX_CLSNAME_SIZE 256 #define MAX_REGSTR_SIZE ( MAX_CLSNAME_SIZE + 64 ) static const LPCTSTR s_regTable[][ 3 ] = { { TEXT( "CLSID\\@" ), NULL, TEXT( "$" ) }, { TEXT( "CLSID\\@\\InprocServer32" ), NULL, ( LPCTSTR ) -1 }, { TEXT( "CLSID\\@\\InprocServer32" ), TEXT( "ThreadingModel" ), TEXT( "Apartment" ) }, { TEXT( "CLSID\\@\\ProgId" ), NULL, TEXT( "$" ) }, { TEXT( "$" ), NULL, TEXT( "$" ) }, { TEXT( "$\\CLSID" ), NULL, TEXT( "@" ) } }; static LONG s_lLockCount; static LONG s_lObjectCount; static GUID s_IID_IHbOleServer; static TCHAR s_lpClsId[ MAX_CLSID_SIZE ] = TEXT( "" ); static TCHAR s_lpClsName[ MAX_CLSNAME_SIZE ] = TEXT( "" );
/** @func BOOL | deinitializes the driver. @comm @xref **/ BOOL EPCTL_Deinit(DWORD hDeviceContext) { RETAILMSG(EPCTL_DBG_MSG,(TEXT("EPCTL: EPCTL_Deinit\r\n"))); return TRUE; }
/** @func BOOL | IOControll dispatch. @comm @xref **/ BOOL EPCTL_IOControl( DWORD dwOpenContext, DWORD dwIoControlCode, LPBYTE lpInBuf, DWORD nInBufSize, LPBYTE lpOutBuf, DWORD nOutBufSize, LPDWORD lpBytesReturned) { RETAILMSG(EPCTL_DBG_MSG,(TEXT("EPCTL_IOControl+++\r\n"))); RETAILMSG(EPCTL_DBG_MSG,(TEXT("dwIoControlCode = %d.\r\n"), dwIoControlCode)); PWRCTL_powerCTLInit(v_pIOP_PIO_regs); // again, make sure everything is setup as we need it switch(dwIoControlCode) { case IOCTL_LCD_ON_SET: PWRCTL_setPower(&power, LCD); PWRCTL_setAllTo(&power); break; case IOCTL_USB_ON_SET: PWRCTL_setPower(&power, USB); PWRCTL_setAllTo(&power); break; case IOCTL_CAMERA_ON_SET: PWRCTL_setPower(&power, CAM); PWRCTL_setAllTo(&power); break; case IOCTL_DAC0_ON_SET: PWRCTL_setPower(&power, DAC0); PWRCTL_setAllTo(&power); break; case IOCTL_DAC1_ON_SET: PWRCTL_setPower(&power, DAC1); PWRCTL_setAllTo(&power); break; case IOCTL_ETH_ON_SET: PWRCTL_setPower(&power, ETH); PWRCTL_setAllTo(&power); break; case IOCTL_WIFI_ON_SET: PWRCTL_setPower(&power, WIFI); PWRCTL_setAllTo(&power); break; case IOCTL_LCD_OFF_SET: PWRCTL_clrPower(&power, LCD); PWRCTL_setAllTo(&power); break; case IOCTL_USB_OFF_SET: PWRCTL_clrPower(&power, USB); PWRCTL_setAllTo(&power); break; case IOCTL_CAMERA_OFF_SET: PWRCTL_clrPower(&power, CAM); PWRCTL_setAllTo(&power); break; case IOCTL_DAC0_OFF_SET: PWRCTL_clrPower(&power, DAC0); PWRCTL_setAllTo(&power); break; case IOCTL_DAC1_OFF_SET: PWRCTL_clrPower(&power, DAC1); PWRCTL_setAllTo(&power); break; case IOCTL_ETH_OFF_SET: PWRCTL_clrPower(&power, ETH); PWRCTL_setAllTo(&power); break; case IOCTL_WIFI_OFF_SET: PWRCTL_clrPower(&power, WIFI); PWRCTL_setAllTo(&power); break; case IOCTL_ALL_OFF_SET: power=0x0; PWRCTL_setAllTo(&power); break; case IOCTL_SLEEP_SET: // powers all modules down, w\o changing the current setting { DWORD null_power=0x0; PWRCTL_setAllTo(&null_power); break; } case IOCTL_ALL_ON_SET: power=0xFF; PWRCTL_setAllTo(&power); break; case IOCTL_LCD_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, LCD); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_USB_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, USB); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_CAMERA_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, CAM); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_DAC0_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, DAC0); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_DAC1_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, DAC1); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_ETH_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, ETH); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_WIFI_GET: *((DWORD *)lpOutBuf)=PWRCTL_getStatus(&power, WIFI); *((DWORD *)lpBytesReturned)=sizeof(DWORD); break; case IOCTL_ALL_GET: *((DWORD *)lpOutBuf)=power; *((DWORD *)lpBytesReturned)=sizeof(power); break; case IOCTL_AWAKE_SET: // sets all modules to configured state default: PWRCTL_setAllTo(&power); break; }; return TRUE; }
void UCrowdManager::DebugTick() const { #if WITH_RECAST if (DetourCrowd == NULL || DetourAgentDebug == NULL) { return; } for (auto It = ActiveAgents.CreateConstIterator(); It; ++It) { const FCrowdAgentData& AgentData = It.Value(); if (AgentData.IsValid()) { UpdateSelectedDebug(It.Key(), AgentData.AgentIndex); } } // on screen debugging const dtCrowdAgent* SelectedAgent = DetourAgentDebug->idx >= 0 ? DetourCrowd->getAgent(DetourAgentDebug->idx) : NULL; if (SelectedAgent && CrowdDebugDrawing::bDebugSelectedActors) { if (CrowdDebugDrawing::bDrawDebugCorners) { DrawDebugCorners(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugCollisionSegments) { DrawDebugCollisionSegments(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugPath) { DrawDebugPath(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugVelocityObstacles) { DrawDebugVelocityObstacles(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugPathOptimization) { DrawDebugPathOptimization(SelectedAgent); } if (CrowdDebugDrawing::bDrawDebugNeighbors) { DrawDebugNeighbors(SelectedAgent); } } if (CrowdDebugDrawing::bDrawDebugBoundaries) { DrawDebugSharedBoundary(); } // vislog debugging if (CrowdDebugDrawing::bDebugVisLog) { for (auto It = ActiveAgents.CreateConstIterator(); It; ++It) { const ICrowdAgentInterface* IAgent = It.Key(); const UObject* AgentOb = IAgent ? Cast<const UObject>(IAgent) : NULL; const AActor* LogOwner = AgentOb ? Cast<const AActor>(AgentOb->GetOuter()) : NULL; const FCrowdAgentData& AgentData = It.Value(); const dtCrowdAgent* CrowdAgent = AgentData.IsValid() ? DetourCrowd->getAgent(AgentData.AgentIndex) : NULL; if (CrowdAgent && LogOwner) { FString LogData = DetourAgentDebug->agentLog.FindRef(AgentData.AgentIndex); if (LogData.Len() > 0) { UE_VLOG(LogOwner, LogCrowdFollowing, Log, *LogData); } { FVector P0 = Recast2UnrealPoint(CrowdAgent->npos); for (int32 Idx = 0; Idx < CrowdAgent->ncorners; Idx++) { FVector P1 = Recast2UnrealPoint(&CrowdAgent->cornerVerts[Idx * 3]); UE_VLOG_SEGMENT(LogOwner, LogCrowdFollowing, Log, P0 + CrowdDebugDrawing::Offset, P1 + CrowdDebugDrawing::Offset, CrowdDebugDrawing::Corner, TEXT("")); UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P1 + CrowdDebugDrawing::Offset, FVector(2, 2, 2)), CrowdDebugDrawing::Corner, TEXT("%d"), CrowdAgent->cornerFlags[Idx]); P0 = P1; } } ARecastNavMesh* RecastNavData = Cast<ARecastNavMesh>(MyNavData); if (RecastNavData) { for (int32 Idx = 0; Idx < CrowdAgent->corridor.getPathCount(); Idx++) { dtPolyRef PolyRef = CrowdAgent->corridor.getPath()[Idx]; TArray<FVector> PolyPoints; RecastNavData->GetPolyVerts(PolyRef, PolyPoints); UE_VLOG_CONVEXPOLY(LogOwner, LogCrowdFollowing, Verbose, PolyPoints, FColor::Cyan, TEXT("")); } } if (CrowdAgent->ncorners && (CrowdAgent->cornerFlags[CrowdAgent->ncorners - 1] & DT_STRAIGHTPATH_OFFMESH_CONNECTION)) { FVector P0 = Recast2UnrealPoint(&CrowdAgent->cornerVerts[(CrowdAgent->ncorners - 1) * 3]); UE_VLOG_SEGMENT(LogOwner, LogCrowdFollowing, Log, P0, P0 + CrowdDebugDrawing::Offset * 2.0f, CrowdDebugDrawing::CornerLink, TEXT("")); } if (CrowdAgent->corridor.hasNextFixedCorner()) { FVector P0 = Recast2UnrealPoint(CrowdAgent->corridor.getNextFixedCorner()); UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P0 + CrowdDebugDrawing::Offset, FVector(10, 10, 10)), CrowdDebugDrawing::CornerFixed, TEXT("")); } if (CrowdAgent->corridor.hasNextFixedCorner2()) { FVector P0 = Recast2UnrealPoint(CrowdAgent->corridor.getNextFixedCorner2()); UE_VLOG_BOX(LogOwner, LogCrowdFollowing, Log, FBox::BuildAABB(P0 + CrowdDebugDrawing::Offset, FVector(10, 10, 10)), CrowdDebugDrawing::CornerFixed, TEXT("")); } for (int32 Idx = 0; Idx < CrowdAgent->boundary.getSegmentCount(); Idx++) { const float* s = CrowdAgent->boundary.getSegment(Idx); const int32 SegFlags = CrowdAgent->boundary.getSegmentFlags(Idx); const FColor Color = (SegFlags & DT_CROWD_BOUNDARY_IGNORE) ? CrowdDebugDrawing::CollisionSegIgnored : (dtTriArea2D(CrowdAgent->npos, s, s + 3) < 0.0f) ? CrowdDebugDrawing::CollisionSeg1 : CrowdDebugDrawing::CollisionSeg0; FVector Pt0 = Recast2UnrealPoint(s); FVector Pt1 = Recast2UnrealPoint(s + 3); UE_VLOG_SEGMENT_THICK(LogOwner, LogCrowdFollowing, Log, Pt0 + CrowdDebugDrawing::Offset, Pt1 + CrowdDebugDrawing::Offset, Color, 3.0f, TEXT("")); } } } } DetourAgentDebug->agentLog.Reset(); #endif // WITH_RECAST }
#include "bsp_cfg.h" #include "bsp_args.h" #include "ExtPowerCTL_DRV.h" extern "C" { #include "ExtPowerCTL_LIB.h" } #ifdef DEBUG // NOTE: One file should use INSTANTIATE_GPE_ZONES. This allows it to be pre-compiled // initialZones should typically be 0x0003 (refer to "gpe.h") DBGPARAM dpCurSettings = { TEXT("ExtPowerCTL Driver"), { TEXT("Fatal"), TEXT("Error"), TEXT("Warning"), TEXT("Message"), TEXT("Verbose"), TEXT("Call Trace"), TEXT("Alloc"), TEXT("Flip"), TEXT(""), TEXT(""), TEXT(""), TEXT(""), TEXT(""), TEXT(""),
#include "AIModulePrivate.h" #if WITH_RECAST #include "AI/Navigation/PImplRecastNavMesh.h" #include "AI/Navigation/RecastHelpers.h" #include "DetourCrowd/DetourCrowd.h" #include "Detour/DetourCommon.h" #endif #include "Navigation/CrowdManager.h" #include "Navigation/CrowdFollowingComponent.h" #include "Navigation/CrowdAgentInterface.h" #include "DrawDebugHelpers.h" DECLARE_STATS_GROUP(TEXT("Crowd"), STATGROUP_AICrowd, STATCAT_Advanced); DECLARE_CYCLE_STAT(TEXT("Nav Tick: crowd simulation"), STAT_AI_Crowd_Tick, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: corridor update"), STAT_AI_Crowd_StepCorridorTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: paths"), STAT_AI_Crowd_StepPathsTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: proximity"), STAT_AI_Crowd_StepProximityTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: next point"), STAT_AI_Crowd_StepNextPointTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: steering"), STAT_AI_Crowd_StepSteeringTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: avoidance"), STAT_AI_Crowd_StepAvoidanceTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: collisions"), STAT_AI_Crowd_StepCollisionsTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: components"), STAT_AI_Crowd_StepComponentsTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: navlinks"), STAT_AI_Crowd_StepNavLinkTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Step: movement"), STAT_AI_Crowd_StepMovementTime, STATGROUP_AICrowd); DECLARE_CYCLE_STAT(TEXT("Agent Update Time"), STAT_AI_Crowd_AgentUpdateTime, STATGROUP_AICrowd); DECLARE_DWORD_COUNTER_STAT(TEXT("Num Agents"), STAT_AI_Crowd_NumAgents, STATGROUP_AICrowd);
/* MODULE: terminal.c PURPOSE: Program's main entry point AUTHOR: Steffen L. Norgren A00683006 */ #include "terminal.h" // Private variables TCHAR szAppName[] = TEXT("Terminal Emulator, Assignment #2"); // Private function prototypes BOOL InitApp(HINSTANCE, int); BOOL VersionCheck(); /* FUNCTION: WinMain(HINSTANCE, HINSTANCE, LPSTR, int) PURPOSE: Start application and process all window messages PARAMETERS: hInstance - this application's instance hPrevInstance - previous instance of this application (always NULL) lpCmdLine - command line parameters nCmdShow - code for showing the window RETURN: 1 for success
void Filesets_General_OnEndTask_InitDialog (HWND hDlg, LPTASKPACKET ptp, LPIDENT lpi) { LPTSTR pszText; TCHAR szUnknown[ cchRESOURCE ]; GetString (szUnknown, IDS_UNKNOWN); if (!ptp->rc) { SetDlgItemText (hDlg, IDC_SET_CREATEDATE, szUnknown); SetDlgItemText (hDlg, IDC_SET_UPDATEDATE, szUnknown); SetDlgItemText (hDlg, IDC_SET_ACCESSDATE, szUnknown); SetDlgItemText (hDlg, IDC_SET_BACKUPDATE, szUnknown); SetDlgItemText (hDlg, IDC_SET_USAGE, szUnknown); SetDlgItemText (hDlg, IDC_SET_STATUS, szUnknown); SetDlgItemText (hDlg, IDC_SET_FILES, szUnknown); TCHAR szSvrName[ cchNAME ]; TCHAR szAggName[ cchNAME ]; TCHAR szSetName[ cchNAME ]; lpi->GetServerName (szSvrName); lpi->GetAggregateName (szAggName); lpi->GetFilesetName (szSetName); ErrorDialog (ptp->status, IDS_ERROR_REFRESH_FILESET_STATUS, TEXT("%s%s%s"), szSvrName, szAggName, szSetName); } else { TCHAR szText[ cchRESOURCE ]; EnableWindow (GetDlgItem (hDlg, IDC_SET_LOCK), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_UNLOCK), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_QUOTA), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_DEF), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_PERCENT), TRUE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_DESC), TRUE); if (!FormatTime (szText, TEXT("%s"), &TASKDATA(ptp)->fs.timeCreation)) SetDlgItemText (hDlg, IDC_SET_CREATEDATE, szUnknown); else SetDlgItemText (hDlg, IDC_SET_CREATEDATE, szText); if (!FormatTime (szText, TEXT("%s"), &TASKDATA(ptp)->fs.timeLastUpdate)) SetDlgItemText (hDlg, IDC_SET_UPDATEDATE, szUnknown); else SetDlgItemText (hDlg, IDC_SET_UPDATEDATE, szText); if (!FormatTime (szText, TEXT("%s"), &TASKDATA(ptp)->fs.timeLastAccess)) SetDlgItemText (hDlg, IDC_SET_ACCESSDATE, szUnknown); else SetDlgItemText (hDlg, IDC_SET_ACCESSDATE, szText); if (!FormatTime (szText, TEXT("%s"), &TASKDATA(ptp)->fs.timeLastBackup)) SetDlgItemText (hDlg, IDC_SET_BACKUPDATE, szUnknown); else SetDlgItemText (hDlg, IDC_SET_BACKUPDATE, szText); wsprintf (szText, TEXT("%lu"), TASKDATA(ptp)->fs.nFiles); SetDlgItemText (hDlg, IDC_SET_FILES, szText); size_t nAlerts = Alert_GetCount (lpi); if (nAlerts == 1) { GetString (szText, IDS_SETSTATUS_1ALERT); SetDlgItemText (hDlg, IDC_SET_STATUS, szText); } else if (nAlerts > 1) { pszText = FormatString (IDS_SETSTATUS_2ALERT, TEXT("%lu"), nAlerts); SetDlgItemText (hDlg, IDC_SET_STATUS, pszText); FreeString (pszText); } else // (nAlerts == 0) { if (TASKDATA(ptp)->fs.State & fsBUSY) GetString (szText, IDS_SETSTATUS_BUSY); else if (TASKDATA(ptp)->fs.State & fsSALVAGE) GetString (szText, IDS_SETSTATUS_SALVAGE); else if (TASKDATA(ptp)->fs.State & fsMOVED) GetString (szText, IDS_SETSTATUS_MOVED); else if (TASKDATA(ptp)->fs.State & fsLOCKED) GetString (szText, IDS_SETSTATUS_LOCKED); else if (TASKDATA(ptp)->fs.State & fsNO_VOL) GetString (szText, IDS_SETSTATUS_NO_VOL); else GetString (szText, IDS_STATUS_NOALERTS); SetDlgItemText (hDlg, IDC_SET_STATUS, szText); } if (TASKDATA(ptp)->fs.Type == ftREADWRITE) { Filesets_DisplayQuota (hDlg, &TASKDATA(ptp)->fs); } else { if (TASKDATA(ptp)->fs.Type == ftREPLICA) GetString (szText, IDS_USAGE_REPLICA); else // (TASKDATA(ptp)->fs.Type == ftCLONE) GetString (szText, IDS_USAGE_CLONE); pszText = FormatString (szText, TEXT("%.1B"), (double)TASKDATA(ptp)->fs.ckUsed * cb1KB); SetDlgItemText (hDlg, IDC_SET_USAGE, pszText); FreeString (pszText); if (GetDlgItem (hDlg, IDC_SET_USAGEBAR)) { RECT rUsagebar; GetRectInParent (GetDlgItem (hDlg, IDC_SET_USAGEBAR), &rUsagebar); HFONT hf = (HFONT)SendMessage (GetDlgItem (hDlg, IDC_SET_USAGEBAR), WM_GETFONT, 0, 0); DestroyWindow (GetDlgItem (hDlg, IDC_SET_USAGEBAR)); if (TASKDATA(ptp)->fs.Type == ftREPLICA) GetString (szText, IDS_NO_QUOTA_REPLICA); else // (TASKDATA(ptp)->fs.Type == ftCLONE) GetString (szText, IDS_NO_QUOTA_CLONE); HWND hDesc = CreateWindow (TEXT("static"), szText, WS_CHILD | SS_SIMPLE, rUsagebar.left, rUsagebar.top, cxRECT(rUsagebar), cyRECT(rUsagebar), hDlg, (HMENU)-1, THIS_HINST, 0); SendMessage (hDesc, WM_SETFONT, (WPARAM)hf, MAKELPARAM(TRUE,0)); ShowWindow (hDesc, SW_SHOW); } EnableWindow (GetDlgItem (hDlg, IDC_SET_QUOTA), FALSE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN), FALSE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_DEF), FALSE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL), FALSE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_PERCENT), FALSE); EnableWindow (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_DESC), FALSE); } if (TASKDATA(ptp)->lpsp->perWarnSetFull == 0) { GetString (szText, IDS_SETFULL_WARN_OFF); SetDlgItemText (hDlg, IDC_SET_WARN_SETFULL_DEF, szText); } else { GetString (szText, IDS_SETFULL_WARN_ON); pszText = FormatString (szText, TEXT("%lu"), TASKDATA(ptp)->lpsp->perWarnSetFull); SetDlgItemText (hDlg, IDC_SET_WARN_SETFULL_DEF, pszText); FreeString (pszText); } CheckDlgButton (hDlg, IDC_SET_WARN, (TASKDATA(ptp)->lpfp->perWarnSetFull != 0)); if (TASKDATA(ptp)->lpfp->perWarnSetFull != 0) { if (TASKDATA(ptp)->lpfp->perWarnSetFull != -1) CheckDlgButton (hDlg, IDC_SET_WARN_SETFULL, TRUE); else CheckDlgButton (hDlg, IDC_SET_WARN_SETFULL_DEF, TRUE); } CreateSpinner (GetDlgItem (hDlg, IDC_SET_WARN_SETFULL_PERCENT), 10, FALSE, // base, signed 1, (TASKDATA(ptp)->lpfp->perWarnSetFull == 0 || TASKDATA(ptp)->lpfp->perWarnSetFull == -1) ? perDEFAULT_SETFULL_WARNING : TASKDATA(ptp)->lpfp->perWarnSetFull, 100); // min, default, max Filesets_General_OnWarnings (hDlg, lpi); } }
/*函数名称:HWD_Close **函数参数:hDeviceContext 设备的打开上下文,由XXX_Open()函数返回 **函数功能:关闭设备 与应用程序的CloseHandle()函数对应 **函数返回:返回设备关闭是否成功 **修 改 人: **修改日期: */ BOOL HWD_Close(DWORD hDeviceContext) { RETAILMSG(1, (TEXT("[HW drv] HWD Close!\r\n"))); return TRUE; }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- DWORD EPCTL_Open(DWORD hDeviceContext, DWORD AccessCode, DWORD ShareMode) { RETAILMSG(EPCTL_DBG_MSG,(TEXT("EPCTL : EPCTL_Open\r\n"))); return TRUE; }
/*函数名称:HWD_PowerDown **函数参数:hDeviceContext 设备的打开上下文,由XXX_Open()函数返回 **函数功能:电源挂起 **函数返回: **修 改 人: **修改日期: */ VOID HWD_PowerDown(DWORD hDeviceContext) { RETAILMSG(1, (TEXT("[HW drv] HWD PowerDown!\r\n"))); }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- BOOL EPCTL_Close(DWORD hOpenContext) { RETAILMSG(EPCTL_DBG_MSG,(TEXT("EPCTL : EPCTL_Close\r\n"))); PWRCTL_deinit(); return TRUE; }
/*函数名称:HWD_IOControl **函数参数:hOpenContext, 由XXX_Open()返回的设备打开上下文 dwCode, 要发送的控制码,一个32位无符号数 pBufIn, 输入,指向输入缓冲区的指针 dwLenIn, 输入缓冲区的长度 pBufOut, 输出,指向输出缓冲区的指针 dwLenOut, 输出缓冲区的最大长度 pdwActualOut) 输出,设备实际输出的字节数 **函数功能:向驱动程序发送控制命令 与应用程序DeviceIoControl()函数据对应 **函数返回:布尔值:TRUE表示操作成功,FALSE表示操作失败 **修 改 人: **修改日期: */ BOOL HWD_IOControl(DWORD hOpenContext, DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut,PDWORD pdwActualOut) { RETAILMSG(1, (TEXT("\r\n[HW drv] HWD IOControl commd:%d!\r\n"),dwCode)); return TRUE; }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- DWORD EPCTL_Seek(DWORD hOpenContext, long Amount, DWORD Type) { RETAILMSG(EPCTL_DBG_MSG,(TEXT("EPCTL : EPCTL_Seek\r\n"))); return 0; }
virtual void StartupModule() override { // load required libraries IMediaModule* MediaModule = FModuleManager::LoadModulePtr<IMediaModule>("Media"); if (MediaModule == nullptr) { UE_LOG(LogWmfMedia, Log, TEXT("Failed to load Media module")); return; } if (!LoadRequiredLibraries()) { UE_LOG(LogWmfMedia, Log, TEXT("Failed to load required Windows Media Foundation libraries")); return; } // initialize Windows Media Foundation HRESULT Result = MFStartup(MF_VERSION); if (FAILED(Result)) { UE_LOG(LogWmfMedia, Log, TEXT("Failed to initialize Windows Media Foundation, Error %i"), Result); return; } // initialize supported media formats SupportedFormats.Add(TEXT("3g2"), LOCTEXT("Format3g2", "3G2 Multimedia Stream")); SupportedFormats.Add(TEXT("3gp"), LOCTEXT("Format3gp", "3GP Video Stream")); SupportedFormats.Add(TEXT("3gp2"), LOCTEXT("Format3gp2", "3GPP2 Multimedia File")); SupportedFormats.Add(TEXT("3gpp"), LOCTEXT("Format3gpp", "3GPP Multimedia File")); SupportedFormats.Add(TEXT("aac"), LOCTEXT("FormatAac", "MPEG-2 Advanced Audio Coding File")); SupportedFormats.Add(TEXT("adts"), LOCTEXT("FormatAdts", "Audio Data Transport Stream")); SupportedFormats.Add(TEXT("asf"), LOCTEXT("FormatAsf", "ASF Media File")); SupportedFormats.Add(TEXT("avi"), LOCTEXT("FormatAvi", "Audio Video Interleave File")); SupportedFormats.Add(TEXT("m4v"), LOCTEXT("FormatM4v", "Apple MPEG-4 Video")); SupportedFormats.Add(TEXT("mov"), LOCTEXT("FormatMov", "Apple QuickTime Movie")); SupportedFormats.Add(TEXT("mp4"), LOCTEXT("FormatMp4", "MPEG-4 Movie")); SupportedFormats.Add(TEXT("sami"), LOCTEXT("FormatSami", "Synchronized Accessible Media Interchange (SAMI) File")); SupportedFormats.Add(TEXT("smi"), LOCTEXT("FormatSmi", "Synchronized Multimedia Integration (SMIL) File")); SupportedFormats.Add(TEXT("wmv"), LOCTEXT("FormatWmv", "Windows Media Video")); // register factory MediaModule->RegisterPlayerFactory(*this); Initialized = true; }
//设置关系 tagCompanionInfo * CUserInformation::InsertCompanionInfo(IClientUserItem * pIClientUserItem, BYTE cbCompanion) { //效验参数 ASSERT(pIClientUserItem!=NULL); if (pIClientUserItem==NULL) return NULL; //用户搜索 DWORD dwUserID=pIClientUserItem->GetUserID(); tagCompanionInfo * pCompanionInfo=SearchCompanionInfo(dwUserID); //设置信息 if (pCompanionInfo==NULL) { //创建对象 pCompanionInfo=CreateCompanionItem(); if (pCompanionInfo==NULL) return NULL; //设置信息 pCompanionInfo->cbCompanion=cbCompanion; pCompanionInfo->dwGameID=pIClientUserItem->GetGameID(); pCompanionInfo->dwUserID=pIClientUserItem->GetUserID(); lstrcpyn(pCompanionInfo->szNickName,pIClientUserItem->GetNickName(),CountArray(pCompanionInfo->szNickName)); lstrcpyn(pCompanionInfo->szUserNote,pIClientUserItem->GetUserNoteInfo(),CountArray(pCompanionInfo->szUserNote)); //插入通知 if (m_pIUserCompanionSink!=NULL) m_pIUserCompanionSink->OnCompanionInsert(pCompanionInfo); } else { //修改判断 bool bModify=false; if (pCompanionInfo->cbCompanion!=cbCompanion) bModify=true; if ((bModify==false)&&(lstrcmp(pCompanionInfo->szNickName,pIClientUserItem->GetNickName())!=0)) bModify=true; if ((bModify==false)&&(lstrcmp(pCompanionInfo->szUserNote,pIClientUserItem->GetUserNoteInfo())!=0)) bModify=true; //修改判断 if (bModify=false) return pCompanionInfo; //设置信息 pCompanionInfo->cbCompanion=cbCompanion; pCompanionInfo->dwGameID=pIClientUserItem->GetGameID(); pCompanionInfo->dwUserID=pIClientUserItem->GetUserID(); lstrcpyn(pCompanionInfo->szNickName,pIClientUserItem->GetNickName(),CountArray(pCompanionInfo->szNickName)); lstrcpyn(pCompanionInfo->szUserNote,pIClientUserItem->GetUserNoteInfo(),CountArray(pCompanionInfo->szUserNote)); //更新通知 if (m_pIUserCompanionSink!=NULL) m_pIUserCompanionSink->OnCompanionUpdate(pCompanionInfo); } //变量定义 IStream * pIStreamSub=NULL; IStorage * pIStorageSub=NULL; IStorage * pIStorageRoot=NULL; //写入数据 try { //构造名字 WCHAR szStorageName[16]=L""; _snwprintf(szStorageName,CountArray(szStorageName),L"%ld",dwUserID); //工作目录 TCHAR szDirectory[MAX_PATH]=TEXT(""); CWHService::GetWorkDirectory(szDirectory,CountArray(szDirectory)); //打开文件 WCHAR szInfomationFile[MAX_PATH]=L""; _snwprintf(szInfomationFile,CountArray(szInfomationFile),L"%s\\%s",(LPCWSTR)(CT2CW(szDirectory)),INFORMATION_FILE); //打开文件 StgOpenStorage(szInfomationFile,NULL,STGM_READWRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageRoot); if (pIStorageRoot==NULL) StgCreateDocfile(szInfomationFile,STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,0,&pIStorageRoot); //错误判断 if (pIStorageRoot==NULL) throw TEXT("StgCreateDocfile Create pIStorageRoot Error"); //打开存储 pIStorageRoot->CreateStorage(szStorageName,STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageSub); if (pIStorageSub==NULL) pIStorageRoot->CreateStorage(szStorageName,STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageSub); //错误处理 if (pIStorageSub==NULL) throw TEXT("CreateStorage Create pIStorageSub Error"); //创建数据 pIStorageSub->CreateStream(STREAM_COMPANION,STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStreamSub); if (pIStreamSub==NULL) pIStorageSub->CreateStream(STREAM_COMPANION,STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStreamSub); //错误处理 if (pIStreamSub==NULL) throw TEXT("CreateStream Create pIStreamSub Error"); //写入数据 ULONG cbWriteCount=0L; pIStreamSub->Write(pCompanionInfo,sizeof(tagCompanionInfo),&cbWriteCount); //释放接口 SafeRelease(pIStreamSub); SafeRelease(pIStorageSub); SafeRelease(pIStorageRoot); return pCompanionInfo; } catch (...) { //错误断言 ASSERT(FALSE); //释放接口 SafeRelease(pIStreamSub); SafeRelease(pIStorageSub); SafeRelease(pIStorageRoot); } return NULL; }
AFPSCharacter::AFPSCharacter(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { // Create a CameraComponent FirstPersonCameraComponent = ObjectInitializer.CreateDefaultSubobject<UCameraComponent>(this, TEXT("FirstPersonCamera")); FirstPersonCameraComponent->AttachParent = CapsuleComponent; // Position the camera a bit above the eyes FirstPersonCameraComponent->RelativeLocation = FVector(0, 0, 50.0f + BaseEyeHeight); // Allow the pawn to control rotation. FirstPersonCameraComponent->bUsePawnControlRotation = true; }
//加载信息 bool CUserInformation::LoadInformation() { //变量定义 IStream * pIStreamSub=NULL; IStorage * pIStorageSub=NULL; IStorage * pIStorageRoot=NULL; IEnumSTATSTG * pIEnumSTATSTG=NULL; //读取数据 try { //变量定义 STATSTG Statstg; tagCompanionInfo CompanionInfo; ZeroMemory(&Statstg,sizeof(Statstg)); ZeroMemory(&CompanionInfo,sizeof(CompanionInfo)); //工作目录 TCHAR szDirectory[MAX_PATH]=TEXT(""); CWHService::GetWorkDirectory(szDirectory,CountArray(szDirectory)); //打开文件 WCHAR szInfomationFile[MAX_PATH]=L""; _snwprintf(szInfomationFile,CountArray(szInfomationFile),L"%s\\%s",(LPCWSTR)(CT2CW(szDirectory)),INFORMATION_FILE); //打开文件 StgOpenStorage(szInfomationFile,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageRoot); if (pIStorageRoot==NULL) return false; //创建枚举 pIStorageRoot->EnumElements(0,NULL,0,&pIEnumSTATSTG); if (pIEnumSTATSTG==NULL) throw TEXT("EnumElements Create pIEnumSTATSTG Error"); //枚举对象 while (pIEnumSTATSTG->Next(1,&Statstg,NULL)==NOERROR) { //目录类型 if (Statstg.type==STGTY_STORAGE) { //打开存储 pIStorageRoot->OpenStorage(Statstg.pwcsName,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageSub); if (pIStorageSub==NULL) throw TEXT("CreateStorage Create pIStorageSub Error"); //打开数据 pIStorageSub->OpenStream(STREAM_COMPANION,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE,0,&pIStreamSub); //读取数据 if (pIStreamSub!=NULL) { //读取关系 ULONG cbReadCount=0L; pIStreamSub->Read(&CompanionInfo,sizeof(CompanionInfo),&cbReadCount); //读取效验 ASSERT(cbReadCount==sizeof(CompanionInfo)); if (cbReadCount!=sizeof(CompanionInfo)) throw TEXT("Read Data CompanionInfo Error"); //创建对象 tagCompanionInfo * pCompanionInfo=CreateCompanionItem(); if (pCompanionInfo==NULL) throw TEXT("CreateCompanionItem Error"); //设置信息 CopyMemory(pCompanionInfo,&CompanionInfo,sizeof(CompanionInfo)); } //释放接口 SafeRelease(pIStreamSub); SafeRelease(pIStorageSub); } //释放内存 CoTaskMemFree(Statstg.pwcsName); } //释放接口 SafeRelease(pIEnumSTATSTG); SafeRelease(pIStreamSub); SafeRelease(pIStorageSub); SafeRelease(pIStorageRoot); return true; } catch (...) { //错误断言 ASSERT(FALSE); //释放接口 SafeRelease(pIEnumSTATSTG); SafeRelease(pIStreamSub); SafeRelease(pIStorageSub); SafeRelease(pIStorageRoot); } return false; }
void FSlateOpenGLShader::CompileShader( const FString& Filename, GLenum ShaderType ) { // Create a new shader ID. ShaderID = glCreateShader( ShaderType ); GLint CompileStatus = GL_FALSE; check( ShaderID ); // Load the file to a string FString Source; bool bFileFound = FFileHelper::LoadFileToString( Source, *Filename ); check(bFileFound); FString Header; // pass the #define along to the shader #if PLATFORM_USES_ES2 Header.Append("#define PLATFORM_USES_ES2 1\n"); #elif PLATFORM_LINUX #if LINUX_USE_OPENGL_3_2 Header.Append("#version 150\n#define PLATFORM_USES_ES2 0\n"); #else Header.Append("#version 120\n#define PLATFORM_USES_ES2 0\n"); #endif // LINUX_USE_OPENGL_3_2 #else Header.Append("#version 120\n#define PLATFORM_USES_ES2 0\n"); #endif #if PLATFORM_LINUX Header.Append("#define PLATFORM_LINUX 1\n"); #else Header.Append("#define PLATFORM_LINUX 0\n"); #endif #if PLATFORM_MAC Header.Append("#define PLATFORM_MAC 1\n"); #else Header.Append("#define PLATFORM_MAC 0\n"); #endif #if USE_709 Header.Append("#define USE_709 1\n"); #else Header.Append("#define USE_709 0\n"); #endif // Allocate a buffer big enough to store the string in ascii format ANSICHAR* Chars[2] = {0}; Chars[0] = new ANSICHAR[Header.Len()+1]; FCStringAnsi::Strcpy(Chars[0], Header.Len() + 1, TCHAR_TO_ANSI(*Header)); Chars[1] = new ANSICHAR[Source.Len()+1]; FCStringAnsi::Strcpy(Chars[1], Source.Len() + 1, TCHAR_TO_ANSI(*Source)); // give opengl the source code for the shader glShaderSource( ShaderID, 2, (const ANSICHAR**)Chars, NULL ); delete[] Chars[0]; delete[] Chars[1]; // Compile the shader and check for success glCompileShader( ShaderID ); glGetShaderiv( ShaderID, GL_COMPILE_STATUS, &CompileStatus ); if( CompileStatus == GL_FALSE ) { // The shader did not compile. Display why it failed. FString Log = GetGLSLShaderLog( ShaderID ); checkf(false, TEXT("Failed to compile shader: %s\n%s"), *Filename, *Log ); // Delete the shader since it failed. glDeleteShader( ShaderID ); ShaderID = 0; } }
TSharedRef<SWidget> SLocalizationDashboardTargetRow::GenerateWidgetForColumn( const FName& ColumnName ) { TSharedPtr<SWidget> Return; if (ColumnName == "Target") { // Target Name Return = SNew(SHyperlink) .Text(this, &SLocalizationDashboardTargetRow::GetTargetName) .OnNavigate(this, &SLocalizationDashboardTargetRow::OnNavigate); } else if(ColumnName == "Status") { ULocalizationTarget* const LocalizationTarget = GetTarget(); if (LocalizationTarget) { // Status icon button. Return = SNew(SLocalizationTargetStatusButton, *LocalizationTarget); } } else if (ColumnName == "Cultures") { // Culture Names Return = SNew(STextBlock) .Text(this, &SLocalizationDashboardTargetRow::GetCulturesText); } else if(ColumnName == "WordCount") { // Progress Bar and Word Counts Return = SNew(STextBlock) .Text(this, &SLocalizationDashboardTargetRow::GetWordCountText); } else if(ColumnName == "Actions") { TSharedRef<SHorizontalBox> HorizontalBox = SNew(SHorizontalBox); Return = HorizontalBox; // Gather HorizontalBox->AddSlot() .FillWidth(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SButton) .ButtonStyle( FEditorStyle::Get(), TEXT("HoverHintOnly") ) .ToolTipText( LOCTEXT("GatherButtonLabel", "Gather") ) .OnClicked(this, &SLocalizationDashboardTargetRow::Gather) .Content() [ SNew(SImage) .Image( FEditorStyle::GetBrush("LocalizationDashboard.GatherTarget") ) ] ]; // Refresh Word Counts HorizontalBox->AddSlot() .FillWidth(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SButton) .ButtonStyle( FEditorStyle::Get(), TEXT("HoverHintOnly") ) .ToolTipText( LOCTEXT("RefreshWordCountButtonLabel", "Refresh") ) .OnClicked(this, &SLocalizationDashboardTargetRow::RefreshWordCount) .Content() [ SNew(SImage) .Image(FEditorStyle::GetBrush("LocalizationDashboard.RefreshWordCount")) ] ]; // Import All HorizontalBox->AddSlot() .FillWidth(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SButton) .ButtonStyle( FEditorStyle::Get(), TEXT("HoverHintOnly") ) .ToolTipText( LOCTEXT("ImportAllButtonLabel", "Import All") ) .OnClicked(this, &SLocalizationDashboardTargetRow::ImportAll) .Content() [ SNew(SImage) .Image( FEditorStyle::GetBrush("LocalizationDashboard.ImportForAllCultures") ) ] ]; // Export All HorizontalBox->AddSlot() .FillWidth(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SButton) .ButtonStyle( FEditorStyle::Get(), TEXT("HoverHintOnly") ) .ToolTipText(LOCTEXT("ExportAllButtonLabel", "Export All")) .OnClicked(this, &SLocalizationDashboardTargetRow::ExportAll) .Content() [ SNew(SImage) .Image(FEditorStyle::GetBrush("LocalizationDashboard.ExportForAllCultures")) ] ]; // Compile HorizontalBox->AddSlot() .FillWidth(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SButton) .ButtonStyle( FEditorStyle::Get(), TEXT("HoverHintOnly") ) .ToolTipText( LOCTEXT("CompileButtonLabel", "Compile") ) .OnClicked(this, &SLocalizationDashboardTargetRow::Compile) .Content() [ SNew(SImage) .Image( FEditorStyle::GetBrush("LocalizationDashboard.CompileTarget") ) ] ]; // Delete Target HorizontalBox->AddSlot() .FillWidth(1.0f) .HAlign(HAlign_Center) .VAlign(VAlign_Center) [ SNew(SButton) .ButtonStyle( FEditorStyle::Get(), TEXT("HoverHintOnly") ) .ToolTipText(LOCTEXT("DeleteButtonLabel", "Delete")) .OnClicked(this, &SLocalizationDashboardTargetRow::EnqueueDeletion) .Content() [ SNew(SImage) .Image(FEditorStyle::GetBrush("LocalizationDashboard.DeleteTarget")) ] ]; } return Return.IsValid() ? Return.ToSharedRef() : SNullWidget::NullWidget; }
inline FString convert(Frame* x) { return FString::Printf(TEXT("%s (%p)"), *(x->GetName()), x); }
/*函数名称:HWD_Open **函数参数:DWORD hDeviceContext, 设备上下文,由XXX_Init()函数创建 DWORD AccessCode, 设备的访问模式,从CreateFile()函数传入 DWORD ShareMode) 设备的共享模式,从CreateFile()函数传入 **函数功能:打开设备进行读写 与应用程序的CreateFile()函数对应 **函数返回:返回设备的打开上下文 **修 改 人: **修改日期: */ DWORD HWD_Open(DWORD hDeviceContext, DWORD AccessCode,DWORD ShareMode) { RETAILMSG(1, (TEXT("[HW drv] HWD Open ok\r\n"))); return hDeviceContext; }
string CKinectXboxSyncThread::GetXboxIP() { // The xbdm.dll contains the functionality that DebugConsole needs. However // this DLL is not in the system path, and shouldn't be. To avoid this we // get DebugConsole to add %XEDK%\bin\win32 to its own copy of the path. // Then it loads xbdm.dll. This works because the project specifies that // xbdm.dll should be delay loaded, so the Win32 loader doesn't load it // when the process loads. As long as we load xbdm.dll before we use it // this all works magically. // If DebugConsole tries to use xbdm.dll and it cannot be loaded then // an exception is thrown. Loading xbdm.dll now is the best way to ensure // that it will be available when it is needed. // Alternate strategies would include copying xbdm.dll to the tool's directory, // or using the COM interface. const char* errorMessage = NULL; char* path; _dupenv_s( &path, NULL, "path" ); char* xedkDir; _dupenv_s( &xedkDir, NULL, "xedk" ); if( !xedkDir ) xedkDir = ""; // Build up a new path using std::string to handle memory management. string newpath = "path=" + string( path ) + ";" + string( xedkDir ) + "\\bin\\win32"; // Set the path to the update version. _putenv( newpath.c_str() ); HMODULE hXBDM = LoadLibrary( TEXT( "xbdm.dll" ) ); if( !hXBDM ) { if( xedkDir[0] ) errorMessage = "Couldn't load xbdm.dll"; else errorMessage = "Couldn't load xbdm.dll\nXEDK environment variable not set."; } // If anything goes wrong while trying to load xbdm.dll, bail out with // an error message. if( errorMessage ) { gEnv->pLog->LogError( errorMessage ); return ""; } typedef HRESULT (_stdcall *TDmSetConnectionTimeout)(DWORD,DWORD); typedef HRESULT (_stdcall *TDmGetNameOfXbox)(LPSTR,LPDWORD,BOOL); typedef HRESULT (_stdcall *TDmGetAltAddress)(LPDWORD); TDmSetConnectionTimeout pDmSetConnectionTimeout = reinterpret_cast<TDmSetConnectionTimeout>(GetProcAddress(hXBDM, "DmSetConnectionTimeout")); TDmGetNameOfXbox pDmGetNameOfXbox = reinterpret_cast<TDmGetNameOfXbox>(GetProcAddress(hXBDM, "DmGetNameOfXbox")); TDmGetAltAddress pDmGetAltAddress = reinterpret_cast<TDmGetAltAddress>(GetProcAddress(hXBDM, "DmGetAltAddress")); // put only half a second of connection timeout HRESULT eResult = pDmSetConnectionTimeout(500, 500); if (eResult != XBDM_NOERR) return ""; char acName[512]; DWORD dwSize; eResult = pDmGetNameOfXbox(acName, &dwSize, true); if (eResult != XBDM_NOERR) return ""; DWORD dwAltAddress; eResult = pDmGetAltAddress(&dwAltAddress); if (eResult != XBDM_NOERR) return ""; // endian swap the ip address to make it readable on PC SwapEndian(dwAltAddress, true); // transform into string IP address struct in_addr addr; addr.s_addr = (long)dwAltAddress; string XboxIP = inet_ntoa(addr); return XboxIP; }
/** * Serialize function used to serialize this bulk data structure. * * @param Ar Archive to serialize with * @param Owner Object owning the bulk data * @param Idx Index of bulk data item being serialized */ void FUntypedBulkData::Serialize( FArchive& Ar, UObject* Owner, int32 Idx ) { check( LockStatus == LOCKSTATUS_Unlocked ); if(Ar.IsTransacting()) { // Special case for transacting bulk data arrays. // constructing the object during load will save it to the transaction buffer. If it tries to load the bulk data now it will try to break it. bool bActuallySave = Ar.IsSaving() && (!Owner || !Owner->HasAnyFlags(RF_NeedLoad)); Ar << bActuallySave; if (bActuallySave) { if(Ar.IsLoading()) { // Flags for bulk data. Ar << BulkDataFlags; // Number of elements in array. Ar << ElementCount; // Allocate bulk data. check(bShouldFreeOnEmpty); BulkData = FMemory::Realloc( BulkData, GetBulkDataSize() ); // Deserialize bulk data. SerializeBulkData( Ar, BulkData ); } else if(Ar.IsSaving()) { // Flags for bulk data. Ar << BulkDataFlags; // Number of elements in array. Ar << ElementCount; // Make sure bulk data is loaded. MakeSureBulkDataIsLoaded(); // Serialize bulk data. SerializeBulkData( Ar, BulkData ); } } } else if( Ar.IsPersistent() && !Ar.IsObjectReferenceCollector() && !Ar.ShouldSkipBulkData() ) { #if TRACK_BULKDATA_USE BulkDataToObjectMap.Add( this, Owner ); #endif // Offset where the bulkdata flags are stored int64 SavedBulkDataFlagsPos = Ar.Tell(); Ar << BulkDataFlags; // Number of elements in array. Ar << ElementCount; // We're loading from the persistent archive. if( Ar.IsLoading() ) { Filename = TEXT(""); // @todo when Landscape (and others?) only Lock/Unlock once, we can enable this if (false) // FPlatformProperties::RequiresCookedData()) { // Bulk data that is being serialized via seekfree loading is single use only. This allows us // to free the memory as e.g. the bulk data won't be attached to an archive in the case of // seek free loading. BulkDataFlags |= BULKDATA_SingleUse; } // Size on disk, which in the case of compression is != GetBulkDataSize() Ar << BulkDataSizeOnDisk; // Read the Offset in file if (Ar.UE4Ver() < VER_UE4_BULKDATA_AT_LARGE_OFFSETS) { // legacy fallback to read 32bit integer int32 LegacyOffset = 0; Ar << LegacyOffset; BulkDataOffsetInFile = LegacyOffset; } else { Ar << BulkDataOffsetInFile; } // fix up the file offset if (Owner != NULL && Owner->GetLinker()) { BulkDataOffsetInFile += Owner->GetLinker()->Summary.BulkDataStartOffset; } // determine whether the payload is stored inline or at the end of the file bool bPayloadInline = !(BulkDataFlags&BULKDATA_PayloadAtEndOfFile); // check( (bPayloadInline && BulkDataOffsetInFile == Ar.Tell()) || // (!bPayloadInline && BulkDataOffsetInFile > Ar.Tell())); // We're allowing defered serialization. if( Ar.IsAllowingLazyLoading() && Owner != NULL) { Linker = Owner->GetLinker(); #if WITH_EDITOR check(Linker); Ar.AttachBulkData( Owner, this ); AttachedAr = &Ar; #else check(Linker.IsValid()); Filename = Linker->Filename; #endif // WITH_EDITOR // only skip over payload, if it's stored inline if (bPayloadInline) { Ar.Seek( Ar.Tell() + BulkDataSizeOnDisk ); } } // Serialize the bulk data right away. else { // memory for bulk data can come from preallocated GPU-accessible resource memory or default to system memory BulkData = GetBulkDataResourceMemory(Owner,Idx); if( !BulkData ) { BulkData = FMemory::Realloc( BulkData, GetBulkDataSize() ); } if (bPayloadInline) { // if the payload is stored inline, just serialize it SerializeBulkData( Ar, BulkData ); } else { // if the payload is NOT stored inline ... // store the current file offset int64 CurOffset = Ar.Tell(); // seek to the location in the file where the payload is stored Ar.Seek(BulkDataOffsetInFile); // serialize the payload SerializeBulkData( Ar, BulkData ); // seek to the location we came from Ar.Seek(CurOffset); } } } // We're saving to the persistent archive. else if( Ar.IsSaving() ) { // check if we save the package compressed UPackage* Pkg = Cast<UPackage>(Owner != NULL ? Owner->GetOutermost() : NULL); if (Pkg && !!(Pkg->PackageFlags & PKG_StoreCompressed) ) { ECompressionFlags BaseCompressionMethod = COMPRESS_Default; if (Ar.IsCooking()) { BaseCompressionMethod = Ar.CookingTarget()->GetBaseCompressionMethod(); } StoreCompressedOnDisk(BaseCompressionMethod); } // Remove single element serialization requirement before saving out bulk data flags. BulkDataFlags &= ~BULKDATA_ForceSingleElementSerialization; // Make sure bulk data is loaded. MakeSureBulkDataIsLoaded(); // Only serialize status information if wanted. int64 SavedBulkDataSizeOnDiskPos = INDEX_NONE; int64 SavedBulkDataOffsetInFilePos = INDEX_NONE; // Keep track of position we are going to serialize placeholder BulkDataSizeOnDisk. SavedBulkDataSizeOnDiskPos = Ar.Tell(); BulkDataSizeOnDisk = INDEX_NONE; // And serialize the placeholder which is going to be overwritten later. Ar << BulkDataSizeOnDisk; // Keep track of position we are going to serialize placeholder BulkDataOffsetInFile. SavedBulkDataOffsetInFilePos = Ar.Tell(); BulkDataOffsetInFile = INDEX_NONE; // And serialize the placeholder which is going to be overwritten later. Ar << BulkDataOffsetInFile; // try to get the linkersave object ULinkerSave* LinkerSave = Cast<ULinkerSave>(Ar.GetLinker()); // determine whether we are going to store the payload inline or not. bool bStoreInline = !!(BulkDataFlags&BULKDATA_ForceInlinePayload) || LinkerSave == NULL; if (!bStoreInline) { // set the flag indicating where the payload is stored BulkDataFlags |= BULKDATA_PayloadAtEndOfFile; // with no LinkerSave we have to store the data inline check(LinkerSave != NULL); // add the bulkdata storage info object to the linkersave int32 Index = LinkerSave->BulkDataToAppend.AddZeroed(1); ULinkerSave::FBulkDataStorageInfo& BulkStore = LinkerSave->BulkDataToAppend[Index]; BulkStore.BulkDataOffsetInFilePos = SavedBulkDataOffsetInFilePos; BulkStore.BulkDataSizeOnDiskPos = SavedBulkDataSizeOnDiskPos; BulkStore.BulkData = this; // Serialize bulk data into the storage info BulkDataSizeOnDisk = -1; } else { // set the flag indicating where the payload is stored BulkDataFlags &= ~BULKDATA_PayloadAtEndOfFile; int64 SavedBulkDataStartPos = Ar.Tell(); // Serialize bulk data. SerializeBulkData( Ar, BulkData ); // store the payload endpos int64 SavedBulkDataEndPos = Ar.Tell(); checkf(SavedBulkDataStartPos >= 0 && SavedBulkDataEndPos >= 0, TEXT("Bad archive positions for bulkdata. StartPos=%d EndPos=%d"), SavedBulkDataStartPos, SavedBulkDataEndPos); BulkDataSizeOnDisk = SavedBulkDataEndPos - SavedBulkDataStartPos; BulkDataOffsetInFile = SavedBulkDataStartPos; } // store current file offset before seeking back int64 CurrentFileOffset = Ar.Tell(); // Seek back and overwrite the flags Ar.Seek(SavedBulkDataFlagsPos); Ar << BulkDataFlags; // Seek back and overwrite placeholder for BulkDataSizeOnDisk Ar.Seek( SavedBulkDataSizeOnDiskPos ); Ar << BulkDataSizeOnDisk; // Seek back and overwrite placeholder for BulkDataOffsetInFile Ar.Seek( SavedBulkDataOffsetInFilePos ); Ar << BulkDataOffsetInFile; // Seek to the end of written data so we don't clobber any data in subsequent write // operations Ar.Seek(CurrentFileOffset); } } }