f643f6cc8a
Removed universal GameContext references Refactored GameContext: It's now only responsible for item management. As such it's now called ItemManager GlobalData is gone, relevant settings are distributed amongst specialized settings classes Entities are no longer database entries, references to them are now direct - Zone is reponsible for storing them in ZonePacks Controller subtypes are now generic classes, class argument is task type Inventory is now a 2D grid instead of a list Entity temperature is now a 2D grid instead of a number Item sizes are now arbitrary shapes instead of a number Hardpoints are now arbitrary shapes instead Equipped items have their own temperatures Map view now displays sunlight colors Integrated Allegorithmic Substance Plugin Imported Djinni ship and assigned Substance materials Removed Node Editor framework (might come back later but needs work to integrate with behavior system)
1159 lines
No EOL
45 KiB
C#
1159 lines
No EOL
45 KiB
C#
#if (!UNITY_EDITOR && UNITY_ANDROID)
|
|
#define IMPORT_STATIC
|
|
#elif (!UNITY_EDITOR && UNITY_IOS)
|
|
#define IMPORT_STATIC
|
|
#else
|
|
#define IMPORT_DYNAMIC // Make this an "#else" so that, by default, the corresponding script code (below) is enabled!
|
|
#endif
|
|
|
|
using System;
|
|
using UnityEngine;
|
|
using System.Runtime.InteropServices;
|
|
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Substance.Platform
|
|
{
|
|
public class NativeFunctions
|
|
{
|
|
// ToDo: move "build target" function out of here, they have nothing to do with "native functions".
|
|
public enum BuildTarget
|
|
{
|
|
Default = 0, // or: Editor
|
|
StandAlone,
|
|
IOS,
|
|
Android
|
|
}
|
|
|
|
|
|
public static BuildTarget GetBuildTarget()
|
|
{
|
|
// Use Unity's environment variables:
|
|
BuildTarget buildTarget = BuildTarget.Default;
|
|
|
|
#if (UNITY_STANDALONE)
|
|
buildTarget = BuildTarget.StandAlone;
|
|
#elif (UNITY_IOS)
|
|
buildTarget = BuildTarget.IOS;
|
|
#elif (UNITY_ANDROID)
|
|
buildTarget = BuildTarget.Android;
|
|
#endif
|
|
|
|
return buildTarget;
|
|
}
|
|
|
|
public static string GetBuildTargetString()
|
|
{
|
|
// Use Unity's environment variables:
|
|
string buildTarget = "UNKNOWN";
|
|
|
|
#if (UNITY_STANDALONE)
|
|
buildTarget = "StandAlone";
|
|
#elif (UNITY_IOS)
|
|
buildTarget = "IOS";
|
|
#elif (UNITY_ANDROID)
|
|
buildTarget = "Android";
|
|
#endif
|
|
|
|
return buildTarget;
|
|
}
|
|
|
|
public static bool IsMobile()
|
|
{
|
|
bool bMobile = false;
|
|
|
|
#if (UNITY_IOS || UNITY_ANDROID)
|
|
bMobile = true;
|
|
#endif
|
|
|
|
return bMobile;
|
|
}
|
|
|
|
public static TextureFormat GetMobileTextureFormat()
|
|
{
|
|
TextureFormat format = TextureFormat.RGBA32;
|
|
|
|
#if (UNITY_IOS)
|
|
format = TextureFormat.PVRTC_RGBA4;
|
|
#elif (UNITY_ANDROID)
|
|
format = TextureFormat.ETC2_RGBA8;
|
|
#else
|
|
Debug.LogError("The current build target is NOT for a modbile platform!");
|
|
#endif
|
|
return format;
|
|
}
|
|
|
|
#if DEBUG
|
|
public static void ShowBuildTargetEnvironment() // dev/debug tool
|
|
{
|
|
#if (UNITY_EDITOR)
|
|
Debug.Log("UNITY_EDITOR");
|
|
#endif
|
|
#if (UNITY_EDITOR_WIN)
|
|
Debug.Log("UNITY_EDITOR_WIN");
|
|
#endif
|
|
#if (UNITY_EDITOR_OSX)
|
|
Debug.Log("UNITY_EDITOR_OSX");
|
|
#endif
|
|
#if (UNITY_STANDALONE_OSX)
|
|
Debug.Log("UNITY_STANDALONE_OSX");
|
|
#endif
|
|
#if (UNITY_STANDALONE_WIN)
|
|
Debug.Log("UNITY_STANDALONE_WIN");
|
|
#endif
|
|
#if (UNITY_STANDALONE_LINUX)
|
|
Debug.Log("UNITY_STANDALONE_LINUX");
|
|
#endif
|
|
#if (UNITY_STANDALONE)
|
|
Debug.Log("UNITY_STANDALONE");
|
|
#endif
|
|
#if (UNITY_IOS)
|
|
Debug.Log("UNITY_IOS");
|
|
#endif
|
|
#if (UNITY_IPHONE)
|
|
Debug.Log("UNITY_IPHONE");
|
|
#endif
|
|
#if (ENABLE_MONO)
|
|
Debug.Log("ENABLE_MONO");
|
|
#endif
|
|
#if (UNITY_ANDROID)
|
|
Debug.Log("UNITY_ANDROID");
|
|
#endif
|
|
#if (ENABLE_IL2CPP)
|
|
Debug.Log("ENABLE_IL2CPP");
|
|
#endif
|
|
}
|
|
#endif // DEBUG
|
|
|
|
// ========================================================================================
|
|
|
|
// STATIC IMPORT UTILITIES:
|
|
// Define DllImport's attribute value here:
|
|
#if (UNITY_IOS)
|
|
public const string attributeValue = "__Internal";
|
|
#elif (UNITY_ANDROID)
|
|
public const string attributeValue = "Substance.Engine.Mobile";
|
|
#else
|
|
public const string attributeValue = "UnknownAttributeValue";
|
|
#endif
|
|
|
|
// ======================================================================
|
|
// DYNAMIC IMPORT UTILITIES:
|
|
#if IMPORT_DYNAMIC
|
|
internal class DLLHelpers
|
|
{
|
|
[DllImport("kernel32.dll", EntryPoint = "LoadLibrary", SetLastError = true, CharSet = CharSet.Unicode)]
|
|
protected static extern IntPtr LoadLibrary(string filename);
|
|
|
|
[DllImport("kernel32.dll", EntryPoint = "GetProcAddress", SetLastError = true)]
|
|
protected static extern IntPtr GetProcAddress(IntPtr hModule, string procname);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
static extern bool FreeLibrary(IntPtr hModule);
|
|
|
|
[DllImport("libdl")]
|
|
protected static extern IntPtr dlopen(string filename, int flags);
|
|
|
|
[DllImport("libdl")]
|
|
protected static extern IntPtr dlsym(IntPtr handle, string symbol);
|
|
|
|
[DllImport("libdl")]
|
|
protected static extern IntPtr dlerror();
|
|
|
|
[DllImport("libdl")]
|
|
protected static extern int dlclose(IntPtr handle);
|
|
|
|
internal static IntPtr DllHandle = IntPtr.Zero;
|
|
private static object[] mParams = new object[0];
|
|
|
|
internal static object[] GetParams(int size)
|
|
{
|
|
Array.Resize<object>(ref mParams, size);
|
|
return mParams;
|
|
}
|
|
|
|
internal static void LoadDLL(string dataPath)
|
|
{
|
|
//load external library
|
|
if (DllHandle == IntPtr.Zero)
|
|
{
|
|
string LibDestination = "";
|
|
|
|
if (IsWindows())
|
|
{
|
|
LibDestination = Path.Combine(dataPath, "Plugins/Substance.Engine.dll");
|
|
DllHandle = LoadLibrary(LibDestination);
|
|
|
|
if (DllHandle == IntPtr.Zero)
|
|
{
|
|
// Unity added the subfolder 'x86_64' in Unity2019.3.9f1 & later versions...
|
|
LibDestination = Path.Combine(dataPath, "Plugins/x86_64/Substance.Engine.dll");
|
|
DllHandle = LoadLibrary(LibDestination);
|
|
}
|
|
}
|
|
else if (IsMac())
|
|
{
|
|
LibDestination = Path.Combine(dataPath, "Plugins/Substance.Engine.bundle/Contents/MacOS/Substance.Engine");
|
|
DllHandle = dlopen(LibDestination, 3);
|
|
}
|
|
else if (IsLinux())
|
|
{
|
|
LibDestination = Path.Combine(dataPath, "Plugins/libSubstance.Engine.so");
|
|
DllHandle = dlopen(LibDestination, 3);
|
|
}
|
|
|
|
if (DllHandle == IntPtr.Zero)
|
|
{
|
|
Debug.LogError("Substance engine failed to load.");
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static void UnloadDLL()
|
|
{
|
|
if (DllHandle != IntPtr.Zero)
|
|
{
|
|
if (IsWindows())
|
|
{
|
|
FreeLibrary(DllHandle);
|
|
}
|
|
else if (IsMac() || IsLinux())
|
|
{
|
|
dlclose(DllHandle);
|
|
}
|
|
|
|
DllHandle = IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
internal static Delegate GetFunction(string funcname, Type t)
|
|
{
|
|
IntPtr ptr = IntPtr.Zero;
|
|
if (DllHandle == IntPtr.Zero)
|
|
return null;
|
|
|
|
if (IsWindows())
|
|
{
|
|
ptr = GetProcAddress(DllHandle, funcname);
|
|
}
|
|
else if (IsMac() || IsLinux())
|
|
{
|
|
ptr = dlsym(DllHandle, funcname);
|
|
}
|
|
|
|
if (ptr == IntPtr.Zero)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return Marshal.GetDelegateForFunctionPointer(ptr, t);
|
|
}
|
|
|
|
private static bool IsWindows()
|
|
{
|
|
return (Application.platform == RuntimePlatform.WindowsEditor
|
|
|| Application.platform == RuntimePlatform.WindowsPlayer);
|
|
}
|
|
|
|
private static bool IsMac()
|
|
{
|
|
return (Application.platform == RuntimePlatform.OSXEditor
|
|
|| Application.platform == RuntimePlatform.OSXPlayer);
|
|
}
|
|
|
|
private static bool IsLinux()
|
|
{
|
|
return (Application.platform == RuntimePlatform.LinuxEditor
|
|
|| Application.platform == RuntimePlatform.LinuxPlayer);
|
|
}
|
|
}
|
|
#endif // IMPORT_DYNAMIC
|
|
|
|
// ======================================================================
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppHelloDelegate();
|
|
public static IntPtr cppHello()
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppHelloDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppHelloDelegate)) as cppHelloDelegate;
|
|
return (IntPtr)function.Invoke();
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppHello();
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppInitSubstanceDelegate(string applicationDataPath, int pTextureClampExposant);
|
|
public static void cppInitSubstance(string applicationDataPath, int pTextureClampExposant)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
DLLHelpers.LoadDLL(applicationDataPath);
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppInitSubstanceDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppInitSubstanceDelegate)) as cppInitSubstanceDelegate;
|
|
function.Invoke(applicationDataPath, pTextureClampExposant);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppInitSubstance(string applicationDataPath, int pTextureClampExposant);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppSetCallbacksDelegate(IntPtr log, IntPtr texture, IntPtr numerical, IntPtr graphInitialized);
|
|
public static void cppSetCallbacks(IntPtr log, IntPtr texture, IntPtr numerical, IntPtr graphInitialized)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppSetCallbacksDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetCallbacksDelegate)) as cppSetCallbacksDelegate;
|
|
function.Invoke(log, texture, numerical, graphInitialized);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppSetCallbacks(IntPtr log, IntPtr texture, IntPtr numerical, IntPtr graphInitialized);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC // not used!
|
|
public delegate bool cppIsValidGraphHandleDelegate(IntPtr pGraphHandle);
|
|
public static bool cppIsValidGraphHandle(IntPtr pGraphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return false;
|
|
|
|
cppIsValidGraphHandleDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppIsValidGraphHandleDelegate)) as cppIsValidGraphHandleDelegate;
|
|
return function.Invoke(pGraphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern bool cppIsValidGraphHandle(IntPtr pGraphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppApplyPresetDelegate(IntPtr graphHandle, string presetStr);
|
|
public static void cppApplyPreset(IntPtr graphHandle, string presetStr)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppApplyPresetDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppApplyPresetDelegate)) as cppApplyPresetDelegate;
|
|
function.Invoke(graphHandle, presetStr);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppApplyPreset(IntPtr graphHandle, string presetStr);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetPresetDelegate(IntPtr graphHandle);
|
|
public static IntPtr cppGetPreset(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetPresetDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetPresetDelegate)) as cppGetPresetDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetPreset(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppListAssetsDelegate();
|
|
public static IntPtr cppListAssets()
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppListAssetsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppListAssetsDelegate)) as cppListAssetsDelegate;
|
|
return (IntPtr)function.Invoke();
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppListAssets();
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppGetNumOutputsDelegate(IntPtr graphHandle);
|
|
public static int cppGetNumOutputs(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppGetNumOutputsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetNumOutputsDelegate)) as cppGetNumOutputsDelegate;
|
|
return (int)function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppGetNumOutputs(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetColorSpaceListDelegate(IntPtr graphHandle, int numOutputs);
|
|
public static IntPtr cppGetColorSpaceList(IntPtr graphHandle, int numOutputs)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetColorSpaceListDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetColorSpaceListDelegate)) as cppGetColorSpaceListDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle, numOutputs);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetColorSpaceList(IntPtr graphHandle, int numOutputs);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppFreeMemoryDelegate(IntPtr pointer);
|
|
public static void cppFreeMemory(IntPtr pointer)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppFreeMemoryDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppFreeMemoryDelegate)) as cppFreeMemoryDelegate;
|
|
function.Invoke(pointer);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppFreeMemory(IntPtr pointer);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppSetCreateSubstanceGraphCallbackEditorPtrDelegate(IntPtr fp);
|
|
public static void cppSetCreateSubstanceGraphCallbackEditorPtr(IntPtr fp)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppSetCreateSubstanceGraphCallbackEditorPtrDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetCreateSubstanceGraphCallbackEditorPtrDelegate)) as cppSetCreateSubstanceGraphCallbackEditorPtrDelegate;
|
|
function.Invoke(fp);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppSetCreateSubstanceGraphCallbackEditorPtr(IntPtr fp);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetMInputsDelegate(IntPtr graphHandle, int pNumInputs);
|
|
public static IntPtr cppGetMInputs(IntPtr graphHandle, int pNumInputs)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetMInputsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetMInputsDelegate)) as cppGetMInputsDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle, pNumInputs);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetMInputs(IntPtr graphHandle, int pNumInputs);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetOutputsDescDelegate(IntPtr graphHandle, ref int pNumOutputs);
|
|
public static IntPtr cppGetOutputsDesc(IntPtr graphHandle, ref int pNumOutputs)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetOutputsDescDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetOutputsDescDelegate)) as cppGetOutputsDescDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle, ref pNumOutputs);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetOutputsDesc(IntPtr graphHandle, ref int pNumOutputs);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppShutdownSubstanceDelegate();
|
|
public static int cppShutdownSubstance()
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppShutdownSubstanceDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppShutdownSubstanceDelegate)) as cppShutdownSubstanceDelegate;
|
|
int result = (int)function.Invoke();
|
|
|
|
DLLHelpers.UnloadDLL();
|
|
|
|
return result;
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppShutdownSubstance();
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppRemoveAssetDelegate(string pAssetPath);
|
|
public static int cppRemoveAsset(string pAssetPath)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppRemoveAssetDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppRemoveAssetDelegate)) as cppRemoveAssetDelegate;
|
|
return (int)function.Invoke(pAssetPath);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppRemoveAsset(string pAssetPath);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppMoveAssetDelegate(string pFromAssetPath, string pToAssetPath);
|
|
public static int cppMoveAsset(string pFromAssetPath, string pToAssetPath)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppMoveAssetDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppMoveAssetDelegate)) as cppMoveAssetDelegate;
|
|
return (int)function.Invoke(pFromAssetPath, pToAssetPath);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppMoveAsset(string pFromAssetPath, string pToAssetPath);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppLoadSubstanceDelegate(string pAssetPath, IntPtr array, Int32 size,
|
|
IntPtr assetCtx, IntPtr substanceObject,
|
|
UInt32[] graphIndices, string[] graphPrototypeNames, string[] graphLabels,
|
|
int[] graphFormats, int[] normalFormats, UInt32 numGraphIndices,
|
|
int rawOverride, int pPipeline);
|
|
public static int cppLoadSubstance(string pAssetPath, IntPtr array, Int32 size, IntPtr assetCtx, IntPtr substanceObject,
|
|
UInt32[] graphIndices, string[] graphPrototypeNames, string[] graphLabels,
|
|
int[] graphFormats, int[] normalFormats, UInt32 numGraphIndices,
|
|
int rawOverride, int pPipeline)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppLoadSubstanceDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppLoadSubstanceDelegate)) as cppLoadSubstanceDelegate;
|
|
return (int)function.Invoke(pAssetPath, array, size, assetCtx, substanceObject,
|
|
graphIndices, graphPrototypeNames, graphLabels,
|
|
graphFormats, normalFormats, numGraphIndices,
|
|
rawOverride, pPipeline);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppLoadSubstance(string pAssetPath, IntPtr array, Int32 size, IntPtr assetCtx,
|
|
IntPtr substanceObject, UInt32[] graphIndices, string[] graphPrototypeNames, string[] graphLabels,
|
|
int[] graphFormats, int[] normalFormats, UInt32 numGraphIndices, int rawOverride, int pPipeline);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppQueueSubstanceDelegate(IntPtr graphHandle);
|
|
public static void cppQueueSubstance(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppQueueSubstanceDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppQueueSubstanceDelegate)) as cppQueueSubstanceDelegate;
|
|
function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppQueueSubstance(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate uint cppRenderSubstancesDelegate(bool bAsync, IntPtr preComputeCallback);
|
|
public static uint cppRenderSubstances(bool bAsync, IntPtr preComputeCallback)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppRenderSubstancesDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppRenderSubstancesDelegate)) as cppRenderSubstancesDelegate;
|
|
return (uint)function.Invoke(bAsync, preComputeCallback);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern uint cppRenderSubstances(bool bAsync, IntPtr preComputeCallback);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate bool cppIsRendererBusyDelegate(uint runid);
|
|
public static bool cppIsRendererBusy(uint runid)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return false;
|
|
|
|
cppIsRendererBusyDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppIsRendererBusyDelegate)) as cppIsRendererBusyDelegate;
|
|
return (bool)function.Invoke(runid);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern bool cppIsRendererBusy(uint runid);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppSetDirtyOutputsDelegate(IntPtr graphHandle);
|
|
public static void cppSetDirtyOutputs(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppSetDirtyOutputsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetDirtyOutputsDelegate)) as cppSetDirtyOutputsDelegate;
|
|
function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppSetDirtyOutputs(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppGetNumInputsDelegate(IntPtr graphHandle);
|
|
public static int cppGetNumInputs(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppGetNumInputsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetNumInputsDelegate)) as cppGetNumInputsDelegate;
|
|
return (int)function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppGetNumInputs(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetInput_IntsDelegate(IntPtr graphHandle, string pFieldName, int pNumInputs);
|
|
public static IntPtr cppGetInput_Ints(IntPtr graphHandle, string pFieldName, int pNumInputs)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetInput_IntsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetInput_IntsDelegate)) as cppGetInput_IntsDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle, pFieldName, pNumInputs);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetInput_Ints(IntPtr graphHandle, string pFieldName, int pNumInputs);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetMComboBoxItemsDelegate(IntPtr graphHandle, string pIdentifier, out int pNumValues);
|
|
public static IntPtr cppGetMComboBoxItems(IntPtr graphHandle, string pIdentifier, out int pNumValues)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
{
|
|
pNumValues = 0;
|
|
return IntPtr.Zero;
|
|
}
|
|
|
|
cppGetMComboBoxItemsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetMComboBoxItemsDelegate)) as cppGetMComboBoxItemsDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle, pIdentifier, out pNumValues);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetMComboBoxItems(IntPtr graphHandle, string pIdentifier, out int pNumValues);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppGetInput_FloatDelegate(IntPtr graphHandle, string pInputName, float[] values, UInt32 numValues);
|
|
public static void cppGetInput_Float(IntPtr graphHandle, string pInputName, float[] values, UInt32 numValues)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppGetInput_FloatDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetInput_FloatDelegate)) as cppGetInput_FloatDelegate;
|
|
function.Invoke(graphHandle, pInputName, values, numValues);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppGetInput_Float(IntPtr graphHandle, string pInputName, float[] values, UInt32 numValues);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppSetInput_FloatDelegate(IntPtr graphHandle, string pInputName, float[] values, UInt32 numValues);
|
|
public static int cppSetInput_Float(IntPtr graphHandle, string pInputName, float[] values, UInt32 numValues)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return -2;
|
|
|
|
cppSetInput_FloatDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetInput_FloatDelegate)) as cppSetInput_FloatDelegate;
|
|
return (int)function.Invoke(graphHandle, pInputName, values, numValues);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppSetInput_Float(IntPtr graphHandle, string pInputName, float[] values, UInt32 numValues);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppGetInput_IntDelegate(IntPtr graphHandle, string pInputName, int[] values, UInt32 numValues);
|
|
public static void cppGetInput_Int(IntPtr graphHandle, string pInputName, int[] values, UInt32 numValues)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppGetInput_IntDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetInput_IntDelegate)) as cppGetInput_IntDelegate;
|
|
function.Invoke(graphHandle, pInputName, values, numValues);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppGetInput_Int(IntPtr graphHandle, string pInputName, int[] values, UInt32 numValues);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppSetInput_IntDelegate(IntPtr graphHandle, string pInputName, int[] values, UInt32 numValues);
|
|
public static void cppSetInput_Int(IntPtr graphHandle, string pInputName, int[] values, UInt32 numValues)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppSetInput_IntDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetInput_IntDelegate)) as cppSetInput_IntDelegate;
|
|
function.Invoke(graphHandle, pInputName, values, numValues);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppSetInput_Int(IntPtr graphHandle, string pInputName, int[] values, UInt32 numValues);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppSetInput_StringDelegate(IntPtr graphHandle, string pInputName, string value);
|
|
public static int cppSetInput_String(IntPtr graphHandle, string pInputName, string value)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return -2;
|
|
|
|
cppSetInput_StringDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetInput_StringDelegate)) as cppSetInput_StringDelegate;
|
|
return (int)function.Invoke(graphHandle, pInputName, value);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppSetInput_String(IntPtr graphHandle, string pInputName, string value);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetInput_StringDelegate(IntPtr graphHandle, string pInputName);
|
|
public static IntPtr cppGetInput_String(IntPtr graphHandle, string pInputName)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetInput_StringDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetInput_StringDelegate)) as cppGetInput_StringDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle, pInputName);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetInput_String(IntPtr graphHandle, string pInputName);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppSetInput_TextureDelegate(IntPtr graphHandle, string pInputName, int format, int mipCount, int width, int height, IntPtr pixels);
|
|
public static int cppSetInput_Texture(IntPtr graphHandle, string pInputName, int format, int mipCount, int width, int height, IntPtr pixels)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return -2;
|
|
|
|
cppSetInput_TextureDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppSetInput_TextureDelegate)) as cppSetInput_TextureDelegate;
|
|
return (int)function.Invoke(graphHandle, pInputName, format, mipCount, width, height, pixels);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppSetInput_Texture(IntPtr graphHandle, string pInputName, int format, int mipCount, int width, int height, IntPtr pixels);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppProcessQueuedOutputsDelegate();
|
|
public static int cppProcessQueuedOutputs()
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppProcessQueuedOutputsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppProcessQueuedOutputsDelegate)) as cppProcessQueuedOutputsDelegate;
|
|
return (int)function.Invoke();
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppProcessQueuedOutputs();
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC // not used anymore
|
|
public delegate IntPtr cppGetOutputLabelFromHashDelegate(string pAssetPath, UInt32 outputHash);
|
|
public static IntPtr cppGetOutputLabelFromHash(string pAssetPath, UInt32 outputHash)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetOutputLabelFromHashDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetOutputLabelFromHashDelegate)) as cppGetOutputLabelFromHashDelegate;
|
|
return (IntPtr)function.Invoke(pAssetPath, outputHash);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetOutputLabelFromHash(string pAssetPath, UInt32 outputHash);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC // not used anymore
|
|
public delegate IntPtr cppGetOutputIdentifierFromHashDelegate(string pAssetPath, UInt32 outputHash);
|
|
public static IntPtr cppGetOutputIdentifierFromHash(string pAssetPath, UInt32 outputHash)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetOutputIdentifierFromHashDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetOutputIdentifierFromHashDelegate)) as cppGetOutputIdentifierFromHashDelegate;
|
|
return (IntPtr)function.Invoke(pAssetPath, outputHash);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetOutputIdentifierFromHash(string pAssetPath, UInt32 outputHash);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC // not used anymore
|
|
public delegate bool cppIsImageOutputFromHashDelegate(string pAssetPath, UInt32 outputHash);
|
|
public static bool cppIsImageOutputFromHash(string pAssetPath, UInt32 outputHash)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return false;
|
|
|
|
cppIsImageOutputFromHashDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppIsImageOutputFromHashDelegate)) as cppIsImageOutputFromHashDelegate;
|
|
return (bool)function.Invoke(pAssetPath, outputHash);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern bool cppIsImageOutputFromHash(string pAssetPath, UInt32 outputHash);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC // not used anymore
|
|
public delegate IntPtr cppGetOutputChannelStrFromHashDelegate(string pAssetPath, UInt32 outputHash);
|
|
public static IntPtr cppGetOutputChannelStrFromHash(string pAssetPath, UInt32 outputHash)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetOutputChannelStrFromHashDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetOutputChannelStrFromHashDelegate)) as cppGetOutputChannelStrFromHashDelegate;
|
|
return (IntPtr)function.Invoke(pAssetPath, outputHash);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetOutputChannelStrFromHash(string pAssetPath, UInt32 outputHash);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppOnGenerateMipMapsChangedDelegate(IntPtr graphHandle, bool bGenerateMipMaps);
|
|
public static void cppOnGenerateMipMapsChanged(IntPtr graphHandle, bool bGenerateMipMaps)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppOnGenerateMipMapsChangedDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppOnGenerateMipMapsChangedDelegate)) as cppOnGenerateMipMapsChangedDelegate;
|
|
function.Invoke(graphHandle, bGenerateMipMaps);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppOnGenerateMipMapsChanged(IntPtr graphHandle, bool bGenerateMipMaps);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppModifyTexturePackingDelegate(IntPtr graphHandle,
|
|
string pSourceNames, int[] pSourceComponents,
|
|
string pTargetName, int[] pTargetComponents,
|
|
int pNumComponents);
|
|
public static void cppModifyTexturePacking(IntPtr graphHandle,
|
|
string pSourceNames, int[] pSourceComponents,
|
|
string pTargetName, int[] pTargetComponents,
|
|
int pNumComponents)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppModifyTexturePackingDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppModifyTexturePackingDelegate)) as cppModifyTexturePackingDelegate;
|
|
function.Invoke(graphHandle,
|
|
pSourceNames, pSourceComponents,
|
|
pTargetName, pTargetComponents,
|
|
pNumComponents);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppModifyTexturePacking(IntPtr graphHandle,
|
|
string pSourceNames, int[] pSourceComponents,
|
|
string pTargetName, int[] pTargetComponents,
|
|
int pNumComponents);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppGetTextureDimensionsDelegate(IntPtr graphHandle, out int pWidth, out int pHeight);
|
|
public static void cppGetTextureDimensions(IntPtr graphHandle, out int pWidth, out int pHeight)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
{
|
|
pWidth = 256;
|
|
pHeight = 256;
|
|
return;
|
|
}
|
|
|
|
cppGetTextureDimensionsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetTextureDimensionsDelegate)) as cppGetTextureDimensionsDelegate;
|
|
function.Invoke(graphHandle, out pWidth, out pHeight);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppGetTextureDimensions(IntPtr graphHandle, out int pWidth, out int pHeight);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppDuplicateGraphInstanceDelegate(IntPtr graphHandle);
|
|
public static IntPtr cppDuplicateGraphInstance(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppDuplicateGraphInstanceDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppDuplicateGraphInstanceDelegate)) as cppDuplicateGraphInstanceDelegate;
|
|
return (IntPtr)function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppDuplicateGraphInstance(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate void cppRemoveGraphInstanceDelegate(IntPtr graphHandle);
|
|
public static void cppRemoveGraphInstance(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return;
|
|
|
|
cppRemoveGraphInstanceDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppRemoveGraphInstanceDelegate)) as cppRemoveGraphInstanceDelegate;
|
|
function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern void cppRemoveGraphInstance(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppListInputsDelegate(IntPtr graphHandle);
|
|
public static int cppListInputs(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return -2;
|
|
|
|
cppListInputsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppListInputsDelegate)) as cppListInputsDelegate;
|
|
return (int)function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppListInputs(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetChannelNamesDelegate();
|
|
public static IntPtr cppGetChannelNames()
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetChannelNamesDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetChannelNamesDelegate)) as cppGetChannelNamesDelegate;
|
|
return (IntPtr)function.Invoke();
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetChannelNames();
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate uint cppGetOutputHashDelegate(IntPtr graphHandle, int pOutputIndex);
|
|
public static uint cppGetOutputHash(IntPtr graphHandle, int pOutputIndex)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppGetOutputHashDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetOutputHashDelegate)) as cppGetOutputHashDelegate;
|
|
return (uint)function.Invoke(graphHandle, pOutputIndex);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern uint cppGetOutputHash(IntPtr graphHandle, int outputIndex);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate IntPtr cppGetEngineVersionDelegate();
|
|
public static IntPtr cppGetEngineVersion()
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return IntPtr.Zero;
|
|
|
|
cppGetEngineVersionDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetEngineVersionDelegate)) as cppGetEngineVersionDelegate;
|
|
return (IntPtr)function.Invoke();
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern IntPtr cppGetEngineVersion();
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppGetNumberOfDuplicatedGraphsDelegate(IntPtr graphHandle);
|
|
public static int cppGetNumberOfDuplicatedGraphs(IntPtr graphHandle)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppGetNumberOfDuplicatedGraphsDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetNumberOfDuplicatedGraphsDelegate)) as cppGetNumberOfDuplicatedGraphsDelegate;
|
|
return (int)function.Invoke(graphHandle);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppGetNumberOfDuplicatedGraphs(IntPtr graphHandle);
|
|
#endif
|
|
|
|
#if IMPORT_DYNAMIC
|
|
public delegate int cppGetOldFileIdDelegate(string pCharArray, int pTypeConstant);
|
|
|
|
public static int cppComputeOldFileID(string pCharArray, int pTypeConstant)
|
|
{
|
|
string myName = System.Reflection.MethodBase.GetCurrentMethod().Name;
|
|
|
|
if (DLLHelpers.DllHandle == IntPtr.Zero)
|
|
return 0;
|
|
|
|
cppGetOldFileIdDelegate function = DLLHelpers.GetFunction(
|
|
myName, typeof(cppGetOldFileIdDelegate)) as cppGetOldFileIdDelegate;
|
|
return (int)function.Invoke(pCharArray, pTypeConstant);
|
|
}
|
|
#else
|
|
[DllImport(attributeValue)]
|
|
public static extern int cppComputeOldFileID(string pCharArray, int pTypeConstant);
|
|
#endif
|
|
|
|
}
|
|
} |