Ejemplos de Axiom.Core ResourceManager.Unload en C# (CSharp)

Unload() public method

Unloads a Resource from the managed resources list, calling it's Unload() method.

This method removes a resource from the list maintained by this manager, and unloads it from memory. It does NOT destroy the resource itself, although the memory used by it will be largely freed up. This would allow you to reload the resource again if you wished.

public Unload ( Resource resource ) : void
resource	Resource
return	void

Ejemplo n.º 1

        public virtual RequestID Unload(string resType, ResourceHandle handle, OnOperationCompleted listener)
#endif
        {
#if AXIOM_THREAD_SUPPORT
            // queue a request
            ResourceRequest req = new ResourceRequest();
            req.Type           = RequestType.UnloadResource;
            req.ResourceType   = resType;
            req.ResourceHandle = handle;
            req.Listener       = listener;
            return(AddRequest(req));
#else
            // synchronous
            ResourceManager rm = ResourceGroupManager.Instance.ResourceManagers[resType];
            rm.Unload(handle);
            return(0);
#endif
        }

Ejemplo n.º 2

        /// <see cref="WorkQueue.IRequestHandler.HandleRequest"/>
        //[OgreVersion(1, 7, 2)]
        public WorkQueue.Response HandleRequest(WorkQueue.Request req, WorkQueue srcQ)
        {
            var resreq = (ResourceRequest)req.Data;

            if (req.Aborted)
            {
                if (resreq.Type == RequestType.PrepareResource || resreq.Type == RequestType.LoadResource)
                {
                    resreq.LoadParams.Clear();
                    resreq.LoadParams = null;
                }

                resreq.Result.Error = false;
                var resresp = new ResourceResponse(null, resreq);
                return(new WorkQueue.Response(req, true, resresp));
            }

            ResourceManager rm       = null;
            Resource        resource = null;

            try {
                switch (resreq.Type)
                {
                case RequestType.InitializeGroup:
                    ResourceGroupManager.Instance.InitializeResourceGroup(resreq.GroupName);
                    break;

                case RequestType.InitializeAllGroups:
                    ResourceGroupManager.Instance.InitializeAllResourceGroups();
                    break;

                case RequestType.PrepareGroup:
                    ResourceGroupManager.Instance.PrepareResourceGroup(resreq.GroupName);
                    break;

                case RequestType.LoadGroup:
#if AXIOM_THREAD_SUPPORT
                    if (Axiom.Configuration.Config.AxiomThreadLevel == 2)
                    {
                        ResourceGroupManager.Instance.PrepareResourceGroup(resreq.GroupName);
                    }
                    else
                    {
                        ResourceGroupManager.Instance.LoadResourceGroup(resreq.GroupName);
                    }
#endif
                    break;

                case RequestType.UnloadGroup:
                    ResourceGroupManager.Instance.UnloadResourceGroup(resreq.GroupName);
                    break;

                case RequestType.PrepareResource:
                    rm       = ResourceGroupManager.Instance.ResourceManagers[resreq.ResourceType];
                    resource = rm.Prepare(resreq.ResourceName, resreq.GroupName, resreq.IsManual, resreq.Loader, resreq.LoadParams,
                                          true);
                    break;

                case RequestType.LoadResource:
#if AXIOM_THREAD_SUPPORT
                    rm = ResourceGroupManager.Instance.ResourceManagers[resreq.ResourceType];
                    if (Axiom.Configuration.Config.AxiomThreadLevel == 2)
                    {
                        resource = rm.Prepare(resreq.ResourceName, resreq.GroupName, resreq.IsManual, resreq.Loader, resreq.LoadParams, true);
                    }
                    else
                    {
                        resource = rm.Load(resreq.ResourceName, resreq.GroupName, resreq.IsManual, resreq.Loader, resreq.LoadParams, true);
                    }
#endif
                    break;

                case RequestType.UnloadResource:
                    rm = ResourceGroupManager.Instance.ResourceManagers[resreq.ResourceType];
                    if (string.IsNullOrEmpty(resreq.ResourceName))
                    {
                        rm.Unload(resreq.ResourceHandle);
                    }
                    else
                    {
                        rm.Unload(resreq.ResourceName);
                    }
                    break;
                }
            }
            catch (Exception e) {
                if (resreq.Type == RequestType.PrepareResource || resreq.Type == RequestType.LoadResource)
                {
                    resreq.LoadParams.Clear();
                    resreq.LoadParams = null;
                }
                resreq.Result.Error   = true;
                resreq.Result.Message = e.Message;

                //return error response
                var resresp = new ResourceResponse(resource, resreq);
                return(new WorkQueue.Response(req, false, resresp, e.Message));
            }

            //success
            if (resreq.Type == RequestType.PrepareResource || resreq.Type == RequestType.LoadResource)
            {
                resreq.LoadParams.Clear();
                resreq.LoadParams = null;
            }

            resreq.Result.Error = false;
            var resp = new ResourceResponse(resource, resreq);
            return(new WorkQueue.Response(req, true, resp));
        }