/// <summary> /// Creates a new view to this texture. /// </summary> /// <param name="firstMipIndex">The index of the first mip-level in the texture that will be accessible through the returned view.</param> /// <param name="numMips">The number of mip-levels in this texture that will be accessible through the returned view.</param> /// <returns>A new resource view that permits reading data from this texture.</returns> public override ShaderTextureResourceView CreateView(uint firstMipIndex, uint numMips) { if (firstMipIndex + numMips > NumMips || numMips == 0U) { throw new ArgumentOutOfRangeException("numMips"); } if ((PermittedBindings & GPUBindings.ReadableShaderResource) != GPUBindings.ReadableShaderResource) { throw new InvalidOperationException("Can not create an shader resource view to a resource that was created without the " + GPUBindings.ReadableShaderResource + " binding."); } ShaderResourceViewHandle outViewHandle; InteropUtils.CallNative( NativeMethods.ResourceFactory_CreateSRVToTexture3D, RenderingModule.Device, (Texture3DResourceHandle)ResourceHandle, GetFormatForType(TexelFormat), firstMipIndex, numMips, (IntPtr)(&outViewHandle) ).ThrowOnFailure(); return(new ShaderTextureResourceView(outViewHandle, this, firstMipIndex, numMips)); }
public void TestInteropUtilsNativeCallMethods() { // Define variables and constants const string EXPECTED_FAIL_REASON = "I feel sad, so left alone; words are not enough, to live on"; // Set up context // Execute bool manualSuccessResult; unsafe { char *failReason = stackalloc char[InteropUtils.MAX_INTEROP_FAIL_REASON_STRING_LENGTH + 1]; manualSuccessResult = ReturnSuccess((IntPtr)failReason); } bool manualFailureResult; string manualFailureMessage; unsafe { char *failReason = stackalloc char[InteropUtils.MAX_INTEROP_FAIL_REASON_STRING_LENGTH + 1]; manualFailureResult = ReturnFailure((IntPtr)failReason, EXPECTED_FAIL_REASON); manualFailureMessage = Marshal.PtrToStringUni((IntPtr)failReason); } NativeCallResult successNCR = InteropUtils.CallNative(ReturnSuccess); NativeCallResult failureNCR = InteropUtils.CallNative(ReturnFailure, EXPECTED_FAIL_REASON); // Assert outcome Assert.AreEqual(manualSuccessResult, successNCR.Success); Assert.AreEqual(manualFailureResult, failureNCR.Success); Assert.IsNull(null, successNCR.FailureMessage); Assert.AreEqual(manualFailureMessage, failureNCR.FailureMessage); }
/// <summary> /// Creates a new unordered access view to this texture. /// </summary> /// <param name="mipIndex">The mip-level to create a view to. Only one mip-level can be exposed in an <see cref="UnorderedAccessView"/>.</param> /// <param name="firstSliceIndex">The index of the first slice of this 3D texture to expose through the returned view.</param> /// <param name="numSlices">The number of slices of this 3D texture to expose through the returned view.</param> /// <returns>A new resource view that permits reading and writing data from/to this texture.</returns> public UnorderedTextureAccessView CreateUnorderedAccessView(uint mipIndex, uint firstSliceIndex, uint numSlices) { if (firstSliceIndex + numSlices > Depth || numSlices == 0U) { throw new ArgumentOutOfRangeException("numSlices"); } if (mipIndex >= NumMips) { throw new ArgumentOutOfRangeException("mipIndex"); } if ((PermittedBindings & GPUBindings.WritableShaderResource) != GPUBindings.WritableShaderResource) { throw new InvalidOperationException("Can not create an unordered access view to a resource that was created without the " + GPUBindings.WritableShaderResource + " binding."); } UnorderedAccessViewHandle outViewHandle; InteropUtils.CallNative( NativeMethods.ResourceFactory_CreateUAVToTexture3D, RenderingModule.Device, (Texture3DResourceHandle)ResourceHandle, GetFormatForType(TexelFormat), mipIndex, firstSliceIndex, numSlices, (IntPtr)(&outViewHandle) ).ThrowOnFailure(); return(new UnorderedTextureAccessView(outViewHandle, this, mipIndex)); }
void IDisposable.Dispose() { lock (WindowMutationLock) { if (isDisposed) { return; } isDisposed = true; lock (staticMutationLock) { openWindows.Remove(this); } LosgapSystem.InvokeOnMasterAsync(() => { if (!*windowClosureFlagPtr) { InteropUtils.CallNative(NativeMethods.WindowFactory_CloseWindow, WindowHandle).ThrowOnFailure(); } InteropUtils.CallNative(NativeMethods.WindowFactory_CleanUpWindowResources, WindowHandle).ThrowOnFailure(); }); ClearViewports().ForEach(vp => vp.Dispose()); OnWindowClosed(); } }
internal unsafe static PhysicsBodyHandle CreateRigidBody(PhysicsShapeHandle shapeHandle, float mass, bool alwaysActive, bool forceIntransigence, bool collideOnlyAgainstWorld, bool collideAgainstDynamicsOnly, IntPtr translationPtr, IntPtr rotationPtr, IntPtr shapeOffsetPtr) { Assure.GreaterThanOrEqualTo(mass, 0f); if (collideOnlyAgainstWorld && collideAgainstDynamicsOnly) { throw new ArgumentException("Can't collide against world and only dynamics simultaneously."); } return(LosgapSystem.InvokeOnMaster(() => { PhysicsBodyHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateRigidBody, translationPtr, rotationPtr, shapeOffsetPtr, shapeHandle, mass, (InteropBool)alwaysActive, (InteropBool)forceIntransigence, (InteropBool)collideOnlyAgainstWorld, (InteropBool)collideAgainstDynamicsOnly, (IntPtr)(&result) ).ThrowOnFailure(); return result; })); }
public void TryAdd(string aLocation) { IntPtr location = InteropUtils.StringToHGlobalUtf8(aLocation); CpDeviceListUpnpTryAdd(iHandle, location); Marshal.FreeHGlobal(location); }
internal static void DestroyShape(PhysicsShapeHandle shape) { LosgapSystem.InvokeOnMasterAsync(() => InteropUtils.CallNative( NativeMethods.PhysicsManager_DestroyShape, shape ).ThrowOnFailure()); }
internal static void DestroyConstraint(FixedConstraintHandle constraint) { LosgapSystem.InvokeOnMasterAsync(() => InteropUtils.CallNative( NativeMethods.PhysicsManager_DestroyConstraint, constraint ).ThrowOnFailure()); }
public static unsafe PhysicsShapeHandle CreateConcaveHullShape(IEnumerable <Vector3> vertices, IEnumerable <int> indices, CollisionShapeOptionsDesc shapeOptions, string acdFilePath) { return(LosgapSystem.InvokeOnMaster(() => { AlignedAllocation <CollisionShapeOptionsDesc> shapeOptionsAligned = new AlignedAllocation <CollisionShapeOptionsDesc>(16L, (uint)sizeof(CollisionShapeOptionsDesc)); *((CollisionShapeOptionsDesc *)shapeOptionsAligned.AlignedPointer) = shapeOptions; Vector3 *verticesLocal = stackalloc Vector3[vertices.Count()]; int *indicesLocal = stackalloc int[indices.Count()]; int numVertices = 0; int numIndices = 0; foreach (Vector3 vertex in vertices) { verticesLocal[numVertices++] = vertex; } foreach (int index in indices) { indicesLocal[numIndices++] = index; } PhysicsShapeHandle result; InteropUtils.CallNative( NativeMethods.PhysicsManager_CreateConcaveHullShape, (IntPtr)verticesLocal, numVertices, (IntPtr)indicesLocal, numIndices, shapeOptionsAligned.AlignedPointer, acdFilePath, (IntPtr)(&result) ).ThrowOnFailure(); shapeOptionsAligned.Dispose(); return result; })); }
/// <summary> /// Constructor for string input argument for an action /// </summary> /// <remarks>Intended to be write only (its value is written on construction and not be later read)</remarks> /// <param name="aParameter">Defines the name plus any bounds to the value for the argument. /// Must have been previously added to the action using Action.AddInputParameter</param> /// <param name="aValue">Value for the argument</param> public ArgumentString(ParameterString aParameter, String aValue) { IntPtr value = InteropUtils.StringToHGlobalUtf8(aValue); iHandle = ActionArgumentCreateStringInput(aParameter.Handle(), value); Marshal.FreeHGlobal(value); }
/// <summary> /// Creates a new <see cref="IndexBuffer"/> with the supplied builder parameters. /// </summary> /// <remarks> /// In debug mode, this method will check a large number of <see cref="Assure">assurances</see> /// on the builder parameters before creating the resource. /// </remarks> /// <returns>A new <see cref="IndexBuffer"/>.</returns> public unsafe override IndexBuffer Create() { Assure.True(Usage != ResourceUsage.Immutable || InitialData != null, "You must supply initial data to an immutable resource."); Assure.GreaterThan(length, 0U, "Can not create an index buffer with 0 indices."); GCHandle?pinnedArrayHandle = null; IntPtr initialDataPtr = IntPtr.Zero; if (InitialData != null) { pinnedArrayHandle = GCHandle.Alloc(InitialData.Value.ContainingArray, GCHandleType.Pinned); initialDataPtr = pinnedArrayHandle.Value.AddrOfPinnedObject() + (IndexBuffer.INDEX_SIZE_BYTES * (int)InitialData.Value.Offset); } try { BufferResourceHandle outResourceHandle; InteropUtils.CallNative(NativeMethods.ResourceFactory_CreateIndexBuffer, RenderingModule.Device, length, Usage.GetUsage(), Usage.GetCPUUsage(), initialDataPtr, (IntPtr)(&outResourceHandle) ).ThrowOnFailure(); return(new IndexBuffer(outResourceHandle, Usage, length)); } finally { if (pinnedArrayHandle != null) { pinnedArrayHandle.Value.Free(); } } }
internal static void DestroyRigidBody(PhysicsBodyHandle body) { LosgapSystem.InvokeOnMasterAsync(() => InteropUtils.CallNative( NativeMethods.PhysicsManager_DestroyRigidBody, body ).ThrowOnFailure()); }
public string GetInteropWif(Nexus nexus, PhantasmaKeys nodeKeys, string platformName) { var genesisHash = nexus.GetGenesisHash(nexus.RootStorage); var interopKeys = InteropUtils.GenerateInteropKeys(nodeKeys, genesisHash, platformName); var defaultWif = interopKeys.ToWIF(); string customWIF = null; SwapPlatformChain targetChain; if (Enum.TryParse(platformName, true, out targetChain)) { var platform = this.Oracle.SwapPlatforms.FirstOrDefault(x => x.Chain == targetChain); if (platform != null) { customWIF = platform.WIF; } } var result = !string.IsNullOrEmpty(customWIF) ? customWIF: defaultWif; if (result != null && result.Length == 64) { var temp = new PhantasmaKeys(Base16.Decode(result)); result = temp.ToWIF(); } return(result); }
/// <summary> /// Constructor. Creates a device capable of operating on any of the protocols the device /// stack supports as standard but with no services or attributes as yet /// </summary> /// <param name="aUdn">Universally unique identifier. The caller is responsible for calculating/assigning this</param> public unsafe DvDeviceStandard(string aUdn) { IntPtr udn = InteropUtils.StringToHGlobalUtf8(aUdn); iHandle = DvDeviceStandardCreateNoResources(udn); Marshal.FreeHGlobal(udn); }
private WindowsCredential CreateCredentialFromStructure(Win32Credential credential) { string password = null; if (credential.CredentialBlobSize != 0 && credential.CredentialBlob != IntPtr.Zero) { byte[] passwordBytes = InteropUtils.ToByteArray( credential.CredentialBlob, credential.CredentialBlobSize); password = Encoding.Unicode.GetString(passwordBytes); } // Recover the target name we gave from the internal (raw) target name string targetName = credential.TargetName.TrimUntilIndexOf(TargetNameLegacyGenericPrefix); // Recover the service name from the target name string serviceName = targetName; if (!string.IsNullOrWhiteSpace(_namespace)) { serviceName = serviceName.TrimUntilIndexOf($"{_namespace}:"); } // Strip any userinfo component from the service name serviceName = RemoveUriUserInfo(serviceName); return(new WindowsCredential(serviceName, credential.UserName, password, targetName)); }
protected void CopyTo(BaseResource dest) { Assure.NotNull(dest); Assure.NotEqual(this, dest, "Can not copy to self."); Assure.Equal(Size, dest.Size, "Resources must be of equal size."); Assure.Equal(GetType(), dest.GetType(), "Resources must be of equal type."); dest.ThrowIfCannotBeCopyDestination(); lock (InstanceMutationLock) { if (IsDisposed) { Logger.Warn("Attempted copy manipulation from disposed resource of type: " + GetType().Name); return; } lock (dest.InstanceMutationLock) { if (dest.IsDisposed) { Logger.Warn("Attempted copy manipulation to disposed resource of type: " + GetType().Name); return; } InteropUtils.CallNative( NativeMethods.ResourceFactory_CopyResource, RenderingModule.DeviceContext, ResourceHandle, dest.ResourceHandle ).ThrowOnFailure(); } } }
protected void CopyTo(BaseResource dest, SubresourceBox srcBox, uint srcSubresourceIndex, uint dstSubresourceIndex, uint dstX, uint dstY, uint dstZ) { Assure.NotNull(dest); Assure.False(this == dest && srcSubresourceIndex == dstSubresourceIndex, "Can not copy to/from same subresource."); dest.ThrowIfCannotBeCopyDestination(); lock (InstanceMutationLock) { if (IsDisposed) { Logger.Warn("Attempted copy manipulation from disposed resource of type: " + GetType().Name); return; } lock (dest.InstanceMutationLock) { if (IsDisposed) { Logger.Warn("Attempted copy manipulation to disposed resource of type: " + GetType().Name); return; } InteropUtils.CallNative( NativeMethods.ResourceFactory_CopySubresourceRegion, RenderingModule.DeviceContext, ResourceHandle, srcSubresourceIndex, (IntPtr)(&srcBox), dest.ResourceHandle, dstSubresourceIndex, dstX, dstY, dstZ ).ThrowOnFailure(); } } }
private void Mutate_MapRead(Action <IntPtr> mappedDataReadAction, ResourceMapping readType) { lock (InstanceMutationLock) { if (IsDisposed) { Logger.Warn("Attempted read manipulation on disposed resource of type: " + GetType().Name); return; } IntPtr outDataPtr; uint outUnused; InteropUtils.CallNative( NativeMethods.ResourceFactory_MapSubresource, RenderingModule.DeviceContext, ResourceHandle, 0U, readType, (IntPtr)(&outDataPtr), (IntPtr)(&outUnused), (IntPtr)(&outUnused) ).ThrowOnFailure(); try { mappedDataReadAction(outDataPtr); } finally { InteropUtils.CallNative( NativeMethods.ResourceFactory_UnmapSubresource, RenderingModule.DeviceContext, ResourceHandle, 0U ).ThrowOnFailure(); } } }
public string GetInteropWif(Nexus nexus, PhantasmaKeys nodeKeys, string platformName) { var genesisHash = nexus.GetGenesisHash(nexus.RootStorage); var interopKeys = InteropUtils.GenerateInteropKeys(nodeKeys, genesisHash, platformName); var defaultWif = interopKeys.ToWIF(); string customWIF = null; switch (platformName) { case "neo": customWIF = this.Oracle.NeoWif; break; case "ethereum": customWIF = this.Oracle.EthWif; break; } var result = !string.IsNullOrEmpty(customWIF) ? customWIF: defaultWif; if (result != null && result.Length == 64) { var temp = new PhantasmaKeys(Base16.Decode(result)); result = temp.ToWIF(); } return(result); }
/// <summary> /// Creates a new view to this buffer. /// </summary> /// <param name="firstElementIndex">The index of the first element in this buffer that will be accessible through the returned view.</param> /// <param name="numElements">The number of elements in this buffer that will be accessible through the returned view.</param> /// <returns>A new resource view that permits reading data from this buffer.</returns> public unsafe ShaderBufferResourceView CreateView(uint firstElementIndex, uint numElements) { if (firstElementIndex + numElements > Length || numElements == 0U) { throw new ArgumentOutOfRangeException("numElements"); } if ((PermittedBindings & GPUBindings.ReadableShaderResource) != GPUBindings.ReadableShaderResource) { throw new InvalidOperationException("Can not create an shader resource view to a resource that was created without the " + GPUBindings.ReadableShaderResource + " binding."); } ShaderResourceViewHandle outViewHandle; InteropUtils.CallNative( NativeMethods.ResourceFactory_CreateSRVToBuffer, RenderingModule.Device, (BufferResourceHandle)ResourceHandle, GetFormatForType(ElementType), firstElementIndex, numElements, (IntPtr)(&outViewHandle) ).ThrowOnFailure(); return(new ShaderBufferResourceView(outViewHandle, this, firstElementIndex, numElements)); }
private static int WriteResource(IntPtr aUserData, IntPtr aUriTail, uint aInterface, IntPtr aLanguageList, IntPtr aWriterData, CallbackWriteResourceBegin aWriteBegin, CallbackWriteResource aWriteResource, CallbackWriteResourceEnd aWriteEnd) { GCHandle gch = GCHandle.FromIntPtr(aUserData); DvDeviceStandard self = (DvDeviceStandard)gch.Target; string uriTail = InteropUtils.PtrToStringUtf8(aUriTail); List <string> languageList = new List <string>(); uint count = DvResourceWriterLanguageCount(aLanguageList); for (uint i = 0; i < count; i++) { languageList.Add(InteropUtils.PtrToStringUtf8(DvResourceWriterLanguage(aLanguageList, i))); } ResourceWriter writer = new ResourceWriter(aWriterData, aWriteBegin, aWriteResource, aWriteEnd); try { writer.Write(self.iResourceManager, uriTail, aInterface, languageList); } catch { return(-1); } return(0); }
/// <summary> /// Constructor. Creates a device without support for any protocol but capable of adding services or attributes. /// This should only be used with CpDeviceDv. /// </summary> /// <param name="aUdn">Universally unique identifier. The caller is responsible for calculating/assigning this</param> public unsafe DvDevice(string aUdn) { IntPtr udn = InteropUtils.StringToHGlobalUtf8(aUdn); iHandle = DvDeviceCreate(udn); Marshal.FreeHGlobal(udn); iCallbackDisabled = new DisabledCallback(Disabled); }
/// <summary> /// Set the value of an unsigned integer output argument for an invocation. /// </summary> /// <param name="aName">Name of the parameter associated with this output argument</param> /// <param name="aValue">Value of the output argument</param> public void WriteUint(String aName, uint aValue) { IntPtr name = InteropUtils.StringToHGlobalUtf8(aName); int err = DvInvocationWriteUint(iHandle, name, aValue); Marshal.FreeHGlobal(name); CheckError(err); }
internal unsafe static void RemoveAllForceAndTorqueFromBody(PhysicsBodyHandle body) { LosgapSystem.InvokeOnMasterAsync(() => { InteropUtils.CallNative(NativeMethods.PhysicsManager_RemoveAllForceAndTorqueFromBody, body ).ThrowOnFailure(); }); }
internal static void SetBodyMass(PhysicsBodyHandle body, float newMass) { LosgapSystem.InvokeOnMasterAsync(() => InteropUtils.CallNative( NativeMethods.PhysicsManager_SetBodyMass, body, newMass ).ThrowOnFailure()); }
/// <summary> /// Query the unique identifier associated with a device /// </summary> /// <returns>Device's (universally unique) name</returns> public String Udn() { IntPtr ptr; uint len; CpDeviceCGetUdn(iHandle, out ptr, out len); return(InteropUtils.PtrToStringUtf8(ptr, len)); }
/// <summary> /// Report an error reading or writing an invocation /// </summary> /// <remarks>Must be called if ReadEnd() isn't reached. /// May be called if WriteStart() or later have been called.</remarks> /// <param name="aCode">Error code</param> /// <param name="aDescription">Error description</param> public void ReportError(uint aCode, String aDescription) { IntPtr desc = InteropUtils.StringToHGlobalUtf8(aDescription); // no point in propogating any error - client code can't cope with error reporting failing DvInvocationReportError(iHandle, aCode, desc); Marshal.FreeHGlobal(desc); }
/// <summary> /// Query the value of an atrribute /// </summary> /// <param name="aKey">string of the form protocol_name.protocol_specific_key. /// Commonly used keys are published ... (!!!! where?)</param> /// <param name="aValue">string containing the attribute or null if the attribute has not been set.</param> public unsafe void GetAttribute(string aKey, out string aValue) { IntPtr key = InteropUtils.StringToHGlobalUtf8(aKey); char * value; DvDeviceGetAttribute(iHandle, key, &value); Marshal.FreeHGlobal(key); aValue = InteropUtils.PtrToStringUtf8((IntPtr)value); }
protected virtual Boolean Set(String key, String value, String section) { if (WritePrivateProfileString(section, key, value, Path) == 0) { InteropUtils.ThrowLastWin32Exception(); } return(true); }
/// <summary> /// Set the value of an attribute /// </summary> /// <param name="aKey">string of the form protocol_name.protocol_specific_key</param> /// <param name="aValue">attribute will be set to a copy of this string</param> public unsafe void SetAttribute(string aKey, string aValue) { IntPtr key = InteropUtils.StringToHGlobalUtf8(aKey); IntPtr value = InteropUtils.StringToHGlobalUtf8(aValue); DvDeviceSetAttribute(iHandle, key, value); Marshal.FreeHGlobal(key); Marshal.FreeHGlobal(value); }