GlfTextureRegistry::_TextureMetadata::_TextureMetadata( const TfToken *textures, const std::uint32_t numTextures) : _numTextures(numTextures) , _fileSize(0) , _mtime(0) { TRACE_FUNCTION(); for (std::uint32_t i = 0; i < numTextures; ++i) { const TfToken& tex = textures[i]; double time; if (!ArchGetModificationTime(tex.GetText(), &time)) { continue; } int64_t size = ArchGetFileLength(tex.GetText()); if (size == -1) { continue; } // The file size is not a particularly good indicator that the texture // has changed (i.e. uncompressed images with the same dimensions, // depth, etc are very likely to have the same size even if they are // different.) // // We aggregate the size of every file in the texture array, but use // the most recent mtime of any file so that we reload the array if any // file is modified. _fileSize += size; _mtime = std::max(_mtime, time); } }
SdfAttributeSpecHandle SdfAttributeSpec::New( const SdfPrimSpecHandle& owner, const std::string& name, const SdfValueTypeName& typeName, SdfVariability variability, bool custom) { TRACE_FUNCTION(); if (not owner) { TF_CODING_ERROR("Cannot create an SdfAttributeSpec with a null owner"); return TfNullPtr; } if (not Sdf_ChildrenUtils<Sdf_AttributeChildPolicy>::IsValidName(name)) { TF_CODING_ERROR( "Cannot create attribute on %s with invalid name: %s", owner->GetPath().GetText(), name.c_str()); return TfNullPtr; } SdfPath attributePath = owner->GetPath().AppendProperty(TfToken(name)); if (not attributePath.IsPropertyPath()) { TF_CODING_ERROR( "Cannot create attribute at invalid path <%s.%s>", owner->GetPath().GetText(), name.c_str()); return TfNullPtr; } return _New(owner, attributePath, typeName, variability, custom); }
nsresult sbRequestThreadQueue::PushRequest(sbRequestItem * aRequestItem) { TRACE_FUNCTION("RequestType=%ui", aRequestItem->mType); NS_ENSURE_ARG_POINTER(aRequestItem); NS_ENSURE_STATE(mLock); nsresult rv; { /* scope for request lock */ nsAutoLock lock(mLock); nsAutoMonitor monitor(mStopWaitMonitor); // If we're aborting or shutting down don't accept any more requests if (mAbortRequests || mStopProcessing) { return NS_ERROR_ABORT; } rv = PushRequestInternal(aRequestItem); NS_ENSURE_SUCCESS(rv, rv); } NS_ASSERTION(mBatchDepth >= 0, "Batch depth out of whack in sbBaseDevice::PushRequest"); // Only process requests if we're not in a batch if (mBatchDepth == 0) { rv = ProcessRequest(); NS_ENSURE_SUCCESS(rv, rv); } return NS_OK; }
UsdGeomPrimvar UsdGeomPrimvarsAPI::FindPrimvarWithInheritance(const TfToken &name, const std::vector<UsdGeomPrimvar> &inheritedFromAncestors) const { TRACE_FUNCTION(); const UsdPrim &prim = GetPrim(); if (!prim) { TF_CODING_ERROR("FindPrimvarWithInheritance called on invalid prim: %s", UsdDescribe(prim).c_str()); return UsdGeomPrimvar(); } const TfToken attrName = UsdGeomPrimvar::_MakeNamespaced(name); UsdGeomPrimvar pv = GetPrimvar(attrName); if (pv.HasAuthoredValue()){ return pv; } for (UsdGeomPrimvar const &inherited : inheritedFromAncestors) { if (inherited.GetName() == attrName){ return inherited; } } return pv; }
//解析图标 STDMETHODIMP CExtractIcon::Extract( LPCTSTR pstrName, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT /*nIconSize*/ ) { TRACE_FUNCTION(); LOG(_T("%s GetIcon %s %d"), __TFUNCTION__, pstrName, nIconIndex ); ATLASSERT(phiconLarge); ATLASSERT(phiconSmall); //HMODULE hLib = LoadLibrary( pstrName ); //if ( hLib ) //{ // *phiconSmall = LoadIcon( (HINSTANCE)hLib, MAKEINTRESOURCE(nIconIndex) ); // *phiconLarge = LoadIcon( (HINSTANCE)hLib, MAKEINTRESOURCE(nIconIndex) ); // FreeLibrary( hLib ); // return S_OK; //} SHFILEINFO sfi = { 0 }; HIMAGELIST hImgList = (HIMAGELIST)SHGetFileInfo( m_szPath, 0,\ &sfi, sizeof(SHFILEINFO), SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_ICON ); if ( hImgList ) { LOG( _T("%s Geting Smallone"), __TFUNCTION__ ); *phiconSmall = ImageList_ExtractIcon(NULL, hImgList, nIconIndex); } hImgList = (HIMAGELIST)SHGetFileInfo( m_szPath, 0, &sfi, \ sizeof(SHFILEINFO), SHGFI_SYSICONINDEX|SHGFI_LARGEICON|SHGFI_ICON ); if ( hImgList ) { LOG( _T("%s Geting Bigone"), __TFUNCTION__ ); *phiconLarge = ImageList_ExtractIcon(NULL, hImgList, nIconIndex); } TRACE_RETURN S_OK; }
UsdSkelAnimQuery UsdSkel_CacheImpl::ReadScope::FindOrCreateAnimQuery(const UsdPrim& prim) { TRACE_FUNCTION(); if(ARCH_UNLIKELY(!prim || !prim.IsActive())) return UsdSkelAnimQuery(); if(prim.IsInstanceProxy()) return FindOrCreateAnimQuery(prim.GetPrimInMaster()); { _PrimToAnimMap::const_accessor a; if(_cache->_animQueryCache.find(a, prim)) return UsdSkelAnimQuery(a->second); } if (UsdSkelIsSkelAnimationPrim(prim)) { _PrimToAnimMap::accessor a; if(_cache->_animQueryCache.insert(a, prim)) { a->second = UsdSkel_AnimQueryImpl::New(prim); } return UsdSkelAnimQuery(a->second); } return UsdSkelAnimQuery(); }
void HdxIntersector::SetResolution(GfVec2i const& widthHeight) { TRACE_FUNCTION(); // Make sure we're in a sane GL state before attempting anything. if (GlfHasLegacyGraphics()) { TF_RUNTIME_ERROR("framebuffer object not supported"); return; } if (!_drawTarget) { // Initialize the shared draw target late to ensure there is a valid GL // context, which may not be the case at constructon time. _Init(widthHeight); return; } if (widthHeight == _drawTarget->GetSize()){ return; } // Make sure master draw target is always modified on the shared context, // so we access it consistently. GlfSharedGLContextScopeHolder sharedContextHolder; { _drawTarget->Bind(); _drawTarget->SetSize(widthHeight); _drawTarget->Unbind(); } }
bool UsdGeomPrimvarsAPI::HasPossiblyInheritedPrimvar(const TfToken &name) const { TRACE_FUNCTION(); UsdPrim prim = GetPrim(); if (!prim) { TF_CODING_ERROR("HasPossiblyInheritedPrimvar called on invalid prim: %s", UsdDescribe(prim).c_str()); return false; } UsdGeomPrimvar pv = GetPrimvar(name); if (pv.HasAuthoredValue()){ return true; } const TfToken attrName = UsdGeomPrimvar::_MakeNamespaced(name); if (attrName.IsEmpty()) { return false; } for (prim = prim.GetParent(); prim && !prim.IsPseudoRoot(); prim = prim.GetParent()) { UsdAttribute attr = prim.GetAttribute(attrName); if (attr.HasAuthoredValue() && UsdGeomPrimvar::IsPrimvar(attr)) { // Only constant primvars can be inherited. // Non-constant interpolation blocks inheritance. return UsdGeomPrimvar(attr).GetInterpolation() == UsdGeomTokens->constant; } } return false; }
UsdSkel_SkelDefinitionRefPtr UsdSkel_CacheImpl::ReadScope::FindOrCreateSkelDefinition(const UsdPrim& prim) { TRACE_FUNCTION(); if(ARCH_UNLIKELY(!prim || !prim.IsActive())) return nullptr; if(prim.IsInstanceProxy()) return FindOrCreateSkelDefinition(prim.GetPrimInMaster()); { _PrimToSkelDefinitionMap::const_accessor a; if(_cache->_skelDefinitionCache.find(a, prim)) return a->second; } if(prim.IsA<UsdSkelSkeleton>()) { _PrimToSkelDefinitionMap::accessor a; if(_cache->_skelDefinitionCache.insert(a, prim)) { a->second = UsdSkel_SkelDefinition::New(UsdSkelSkeleton(prim)); } return a->second; } return nullptr; }
UsdSkelSkeletonQuery UsdSkel_CacheImpl::ReadScope::FindOrCreateSkelQuery(const UsdPrim& prim) { TRACE_FUNCTION(); { _PrimToSkelQueryMap::const_accessor a; if (_cache->_skelQueryCache.find(a, prim)) return a->second; } if (auto skelDef = FindOrCreateSkelDefinition(prim)) { _PrimToSkelQueryMap::accessor a; if (_cache->_skelQueryCache.insert(a, prim)) { UsdSkelAnimQuery animQuery = FindOrCreateAnimQuery( UsdSkelBindingAPI(prim).GetInheritedAnimationSource()); a->second = UsdSkelSkeletonQuery(skelDef, animQuery); } return a->second; } return UsdSkelSkeletonQuery(); }
nsresult sbRequestThreadQueue::CancelRequests() { TRACE_FUNCTION(""); NS_ENSURE_STATE(mStopWaitMonitor); nsresult rv; Batch batch; { // Have to lock mLock before mStopWaitMonitor to avoid deadlocks nsAutoLock lock(mLock); nsAutoMonitor monitor(mStopWaitMonitor); // If we're aborting set the flag, reset batch depth and clear requests if (!mAbortRequests) { if (mIsHandlingRequests) { mAbortRequests = true; monitor.NotifyAll(); } mBatchDepth = 0; rv = ClearRequestsNoLock(batch); NS_ENSURE_SUCCESS(rv, rv); } } // must not hold onto the monitor while we create sbDeviceStatus objects // because that involves proxying to the main thread rv = CleanupBatch(batch); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; }
void bigfixedTest::testInitialise() { TRACE_FUNCTION(); fixed_128_64 v; verify ("init default", v.toDecString() == "0.0"); v = fixed_128_64(100); verify ("init 100", v.toDecString() == "100.0"); v = fixed_128_64(-100); verify ("init -100", v.toDecString() == "-100.0"); v = fixed_128_64(1.0); verify ("init 1.0", v.toDecString() == "1.0"); v = fixed_128_64 (1000.0); verify ("init 1000.0", v.toDecString() == "1000.0"); v = fixed_128_64 (1000.125); verify ("init 1000.125", v.toDecString() == "1000.125"); v = fixed_128_64 (0.0001220703125); verify ("init 0.0001220703125", v.toDecString() == "0.0001220703125"); v = fixed_128_64 (-0.00000762939453125); verify ("init -0.00000762939453125", v.toDecString() == "-0.00000762939453125"); fixed_128_128 v2 = fixed_128_128 (std::numeric_limits<double>::denorm_min()); verify ("init subnormal", v2.toDecString() == "0.0"); v = fixed_128_64 (-2000.123456); double d = v.toDouble(); }
UsdGeomPrimvar UsdGeomPrimvarsAPI::FindPrimvarWithInheritance(const TfToken &name) const { TRACE_FUNCTION(); const TfToken attrName = UsdGeomPrimvar::_MakeNamespaced(name); UsdPrim prim = GetPrim(); if (!prim) { TF_CODING_ERROR("FindPrimvarWithInheritance called on invalid prim: %s", UsdDescribe(prim).c_str()); return UsdGeomPrimvar(); } UsdGeomPrimvar localPv = GetPrimvar(name); if (localPv.HasAuthoredValue()){ return localPv; } for (prim = prim.GetParent(); prim && !prim.IsPseudoRoot(); prim = prim.GetParent()) { UsdAttribute attr = prim.GetAttribute(attrName); if (attr.HasAuthoredValue()) { if (UsdGeomPrimvar pv = UsdGeomPrimvar(attr)) { // Only constant primvars can be inherited. if (pv.GetInterpolation() == UsdGeomTokens->constant) { return pv; } else { // Non-constant interpolation blocks inheritance. return UsdGeomPrimvar(); } } } } return localPv; }
nsresult sbRequestThreadQueue::ClearRequests() { TRACE_FUNCTION(""); nsresult rv; NS_ENSURE_STATE(mLock); Batch batch; // Lock the queue while copy and clear it { nsAutoLock lock(mLock); rv = ClearRequestsNoLock(batch); NS_ENSURE_SUCCESS(rv, rv); } // Now that we have released the lock, cleanup the unprocessed items in the // the batch. Cleanup can result in proxying to the main thread which can // deadlock if we're holding the lock. rv = CleanupBatch(batch); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; }
bool HdxIntersector::Result::ResolveNearest(HdxIntersector::Hit* hit) const { TRACE_FUNCTION(); if (!IsValid()) { return false; } int xMin = 0; int yMin = 0; double zMin = 1.0; int zMinIndex = -1; float const* depths = _depths.get(); // Find the smallest value (nearest pixel) in the z buffer for (int y=0, i=0; y < _viewport[2]; y++) { for (int x=0; x < _viewport[3]; x++, i++) { if (depths[i] < zMin) { xMin = x; yMin = y; zMin = depths[i]; zMinIndex = i; } } } if (zMin >= 1.0) { return false; } return _ResolveHit(zMinIndex, xMin, yMin, zMin, hit); }
bool Usd_ClipCache::PopulateClipsForPrim( const SdfPath& path, const PcpPrimIndex& primIndex) { TRACE_FUNCTION(); std::vector<Clips> allClips; Clips clipsFromNode; _AddClipsFromNode(primIndex, &clipsFromNode); if (!clipsFromNode.valueClips.empty()) { allClips.push_back(clipsFromNode); } const bool primHasClips = !allClips.empty(); if (primHasClips) { tbb::mutex::scoped_lock lock(_mutex); const std::vector<Clips>& ancestralClips = _GetClipsForPrim_NoLock(path.GetParentPath()); allClips.insert( allClips.end(), ancestralClips.begin(), ancestralClips.end()); TF_DEBUG(USD_CLIPS).Msg( "Populated clips for prim <%s>\n", path.GetString().c_str()); _table[path].swap(allClips); } return primHasClips; }
const std::vector<Usd_ClipCache::Clips>& Usd_ClipCache::GetClipsForPrim(const SdfPath& path) const { TRACE_FUNCTION(); tbb::mutex::scoped_lock lock(_mutex); return _GetClipsForPrim_NoLock(path); }
///////////////////////////////////////////////////////////////////////////// // IShellView HRESULT CSEShellView::AddPropertySheetPages( DWORD /*dwReserved*/, LPFNADDPROPSHEETPAGE /*lpfn*/, LPARAM /*lParam*/) { TRACE_FUNCTION(); TRACE_RETURN E_NOTIMPL; }
STDMETHODIMP CSEShellView::DestroyViewWindow(void) { TRACE_FUNCTION(); UIActivate(SVUIA_DEACTIVATE); ::DestroyWindow(m_hWnd); m_pShellBrowser->Release(); TRACE_RETURN S_OK; }
void Recursion(int N) { TRACE_FUNCTION(); if (N <= 1) { return; } Recursion(N-1); }
bool HdSt_MeshTopology::operator==(HdSt_MeshTopology const &other) const { TRACE_FUNCTION(); // no need to compare _adajency and _quadInfo return HdMeshTopology::operator==(other); }
HRESULT CExtractIcon::_Init(LPCITEMIDLIST pidl) { TRACE_FUNCTION(); m_pidl=m_pidlManager.Copy(pidl); DWORD dwLen = MAX_PATH; m_pidlManager.GetFullName( m_pidl, m_szPath, &dwLen ); m_pidlManager.ReplaceRoot( m_szPath ); LOG( _T("%s %s"), __TFUNCTION__, m_szPath ); TRACE_RETURN S_OK; }
HRESULT CSEShellView::GetWindow(HWND* phWnd) { TRACE_FUNCTION(); if(::IsWindow(m_hWnd)==0) { TRACE_RETURN E_FAIL; } *phWnd = m_hWnd; TRACE_RETURN S_OK; }
PcpPrimIndex_GraphRefPtr PcpPrimIndex_Graph::New(const PcpPrimIndex_GraphPtr& copy) { TfAutoMallocTag2 tag("Pcp", "PcpPrimIndex_Graph"); TRACE_FUNCTION(); return TfCreateRefPtr( new PcpPrimIndex_Graph(*boost::get_pointer(copy))); }
void GlfTextureRegistry::GarbageCollectIfNeeded() { // Even if we hold the list of texture handles to be deleted, we have to // traverse entire map to remove the entry for them. So simple flag works // enough to avoid unnecessary process. if (!_requiresGarbageCollection) return; // XXX: // Frequent garbage collection causing slow UI when reading textures. // We're freeing and re-loading textures instead of caching them. // // Can we only garbage collect when GPU memory is high? Or have a // least-recently-used queue or something? TRACE_FUNCTION(); std::map<std::pair<TfToken, GlfImage::ImageOriginLocation>, _TextureMetadata>::iterator it = _textureRegistry.begin(); while (it != _textureRegistry.end()){ const GlfTextureHandleRefPtr &handle = it->second.GetHandle(); // Null handles should not have been added to the registry if (TF_VERIFY(handle) && handle->IsUnique()) { it = _textureRegistry.erase(it); // TextureHandle (and its GlfTexture) will be released here. } else { ++it; } } // we only have a weakptr for non-shared texture handle (i.e. DrawTarget) // note: Since the lifetime of drawtarget attachment is controlled by // GlfDrawTarget, even though there are no samplers refers to that // attachment, it may still exists when this GC function is called. // As a result the entry of textureHandle might remain in // _textureRegistryNonShared, but it just holds an invalid WeakPtr and // will be cleaned at the next GC opportunity. so it's no harm. { std::map<GlfTexturePtr, GlfTextureHandlePtr>::iterator it = _textureRegistryNonShared.begin(); while (it != _textureRegistryNonShared.end() ){ if (it->second.IsExpired()) { // TextureHandle has already been released by its owner // (GlfDrawTarget) _textureRegistryNonShared.erase(it++); } else { ++it; } } } _requiresGarbageCollection = false; }
void close_fifo( void ) /***********************************************************************/ { TRACE_FUNCTION("single.c: close_fifo"); TerminateThread( hThread, 0 ); DisconnectNamedPipe( (HANDLE)fifo_fd ); CloseHandle( (HANDLE)fifo_fd ); CloseHandle( (HANDLE)hPipeRead ); CloseHandle( (HANDLE)hSemCommandCount ); TRACE_RETURN(); }
HRESULT CSEShellView::FinalConstruct() { TRACE_FUNCTION(); m_pShellBrowser=NULL; m_hWnd=NULL; m_hMenu = NULL; m_pFolder = NULL; m_pidlRoot = NULL; TRACE_RETURN S_OK; }
nsresult sbRequestThreadQueue::BatchBegin() { TRACE_FUNCTION(""); NS_ENSURE_STATE(mLock); nsAutoLock lock(mLock); ++mBatchDepth; return NS_OK; }
int STRICT( INSTRUCTION_FN_ARGS ) { unsigned char strict = istate.ep[0].num.c; TRACE_FUNCTION(); istate.ep[0].num.c = strict_unsigned_conversions; strict_unsigned_conversions = strict; return 1; }
void PcpPrimIndex_Graph::_DetachSharedNodePool() { if (!_data.unique()) { TRACE_FUNCTION(); _data.reset(new _SharedData(*_data)); // XXX: This probably causes more finalization than necessary. Only // need to finalize if (a) nodes are added (b) nodes are culled. _data->finalized = false; } }