You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
934 lines
25 KiB
934 lines
25 KiB
|
|
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Reflection;
|
|
|
|
namespace UltraControls
|
|
{
|
|
public class ControlInfo
|
|
{
|
|
internal bool m_has_range;
|
|
internal Type m_type;
|
|
internal string m_name;
|
|
internal object m_value_default;
|
|
internal object m_value_min;
|
|
internal object m_value_max;
|
|
}
|
|
|
|
public class Factroy
|
|
{
|
|
public static ControlInfo CreateInfo< T > (string name, T value)
|
|
{
|
|
Type type = typeof(T);
|
|
if (!Utils.IsSupport(type))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ControlInfo info = new ControlInfo();
|
|
info.m_value_default = value;
|
|
info.m_type = type;
|
|
info.m_has_range = false;
|
|
info.m_name = name;
|
|
return info;
|
|
}
|
|
|
|
public static ControlInfo CreateInfo<T>(string name, T value, T min, T max)
|
|
{
|
|
Type type = typeof(T);
|
|
if (!Utils.IsSupport(type))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ControlInfo info = new ControlInfo();
|
|
info.m_value_default = value;
|
|
info.m_type = type;
|
|
info.m_value_min = min;
|
|
info.m_value_max = max;
|
|
info.m_has_range = true;
|
|
info.m_name = name;
|
|
return info;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public class ParameterBase
|
|
{
|
|
internal Control m_ctrl;
|
|
internal PropertyInfo m_prop;
|
|
|
|
public object val
|
|
{
|
|
set
|
|
{
|
|
m_prop.SetValue(m_ctrl, value, null);
|
|
}
|
|
|
|
get
|
|
{
|
|
return m_prop.GetValue(m_ctrl, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Parameter < T > : ParameterBase
|
|
{
|
|
internal Parameter(Control ctrl)
|
|
{
|
|
m_ctrl = ctrl;
|
|
string name_prop = "";
|
|
Type type = typeof(T);
|
|
if (type != ctrl.realType)
|
|
{
|
|
throw new Exception("Control[" + ctrl.name + "]: ParamControl<" + type.ToString() + "> is not fit the type : " + ctrl.realType.ToString() + ".");
|
|
}
|
|
|
|
if (type == typeof(string))
|
|
{
|
|
name_prop = "text";
|
|
}
|
|
else if (type == typeof(bool))
|
|
{
|
|
name_prop = "valBool";
|
|
}
|
|
else if (type == typeof(int))
|
|
{
|
|
name_prop = "valInt";
|
|
}
|
|
else if (type == typeof(float))
|
|
{
|
|
name_prop = "valFloat";
|
|
}
|
|
else if (type == typeof(UnityEngine.Vector2))
|
|
{
|
|
name_prop = "valVector2";
|
|
}
|
|
else if (type == typeof(UnityEngine.Vector3))
|
|
{
|
|
name_prop = "valVector3";
|
|
}
|
|
else if (type == typeof(UnityEngine.Vector4))
|
|
{
|
|
name_prop = "valVector4";
|
|
}
|
|
else if (type == typeof(UnityEngine.Color))
|
|
{
|
|
name_prop = "valColor";
|
|
}
|
|
else if (type == typeof(UnityEngine.Color32))
|
|
{
|
|
name_prop = "valColor32";
|
|
}
|
|
|
|
if (name_prop == "")
|
|
{
|
|
throw new Exception("Control[" + ctrl.name + "]: ParamControl<" + type.ToString() + "> is not support.");
|
|
}
|
|
|
|
m_prop = typeof(Control).GetProperty(name_prop);
|
|
if (m_prop == null)
|
|
{
|
|
throw new Exception("Control[" + ctrl.name + "]: The property[" + name_prop + "] of Control is not exist.");
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ParamSetter< T >
|
|
{
|
|
private Parameter<T> m_param;
|
|
internal ParamSetter(Parameter<T> param)
|
|
{
|
|
m_param = param;
|
|
}
|
|
|
|
public T val
|
|
{
|
|
set
|
|
{
|
|
m_param.val = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ParamGetter<T>
|
|
{
|
|
private Parameter<T> m_param;
|
|
internal ParamGetter(Parameter<T> param)
|
|
{
|
|
m_param = param;
|
|
}
|
|
|
|
public T val
|
|
{
|
|
get
|
|
{
|
|
return (T)m_param.val;
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum CtrlType: uint
|
|
{
|
|
Bool = 0,
|
|
Event = 1,
|
|
Float = 10,
|
|
Text = 100,
|
|
Int = 200,
|
|
Vec2F = 500,
|
|
Vec3F = 510,
|
|
Vec4F = 520,
|
|
Color = 600,
|
|
ColorF = 610,
|
|
Mat33F = 900,
|
|
Mat44F = 950,
|
|
Unknown = 0xDEADBEEF
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct RawCtrl
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
|
|
public string name;
|
|
public uint type;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 236)]
|
|
public byte[] data;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public sealed class CtrlValues
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public float[] val;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public float[] min;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public float[] max;
|
|
}
|
|
|
|
public sealed class Control
|
|
{
|
|
[Flags]
|
|
enum DirtyFlag
|
|
{
|
|
None = 0x00,
|
|
Data = 0x01,
|
|
Values = 0x02,
|
|
All = Data | Values,
|
|
}
|
|
|
|
[Flags]
|
|
enum FeatureFlag
|
|
{
|
|
None = 0x00,
|
|
HasRange = 0x01,
|
|
IsAlive = 0x02,
|
|
}
|
|
|
|
private string m_name;
|
|
private CtrlType m_type;
|
|
private byte[] m_data;
|
|
private CtrlValues m_values;
|
|
private string m_text;
|
|
private DirtyFlag m_dirty;
|
|
private FeatureFlag m_feature;
|
|
private Type m_realType;
|
|
|
|
internal Control(ref RawCtrl raw_ctrl)
|
|
{
|
|
m_name = raw_ctrl.name;
|
|
m_type = (CtrlType)raw_ctrl.type;
|
|
m_data = raw_ctrl.data;
|
|
m_feature = FeatureFlag.IsAlive;
|
|
if (m_type == CtrlType.Text)
|
|
{
|
|
int count = 0;
|
|
while (m_data[count] != 0)
|
|
{
|
|
++count;
|
|
}
|
|
|
|
m_text = System.Text.Encoding.UTF8.GetString(m_data, 0, count);
|
|
m_realType = typeof(string);
|
|
}
|
|
else
|
|
{
|
|
m_values = Utils.BytesToStructure<CtrlValues>(m_data);
|
|
bool has_range = !(m_values.min[0] == 0.0f && m_values.min[1] == 0.0f && m_values.min[2] == 0.0f && m_values.min[3] == 0.0f &&
|
|
m_values.max[0] == 0.0f && m_values.max[1] == 0.0f && m_values.max[2] == 0.0f && m_values.max[3] == 0.0f);
|
|
|
|
if (has_range)
|
|
{
|
|
m_feature |= FeatureFlag.HasRange;
|
|
}
|
|
|
|
switch (m_type)
|
|
{
|
|
case CtrlType.Bool: m_realType = typeof(bool); break;
|
|
case CtrlType.Float: m_realType = typeof(float); break;
|
|
case CtrlType.Int: m_realType = typeof(int); break;
|
|
case CtrlType.Vec2F: m_realType = typeof(UnityEngine.Vector2); break;
|
|
case CtrlType.Vec3F: m_realType = typeof(UnityEngine.Vector3); break;
|
|
case CtrlType.Vec4F: m_realType = typeof(UnityEngine.Vector4); break;
|
|
case CtrlType.Color: m_realType = typeof(UnityEngine.Color32); break;
|
|
case CtrlType.ColorF: m_realType = typeof(UnityEngine.Color); break;
|
|
|
|
default:
|
|
UnityEngine.Debug.LogError("The type is not support");
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_dirty = DirtyFlag.None;
|
|
}
|
|
|
|
public void Die()
|
|
{
|
|
m_feature &= ~FeatureFlag.IsAlive;
|
|
}
|
|
|
|
public bool IsValue() { return m_values != null; }
|
|
public bool IsBool() { return m_type == CtrlType.Bool; }
|
|
public bool IsFloat() { return m_type == CtrlType.Float; }
|
|
public bool IsString() { return m_type == CtrlType.Text; }
|
|
public bool IsInt() { return m_type == CtrlType.Int; }
|
|
public bool IsVector2() { return m_type == CtrlType.Vec2F; }
|
|
public bool IsVector3() { return m_type == CtrlType.Vec3F; }
|
|
public bool IsVector4() { return m_type == CtrlType.Vec4F; }
|
|
public bool IsColor32() { return m_type == CtrlType.Color; }
|
|
public bool IsColor() { return m_type == CtrlType.ColorF; }
|
|
//public bool IsEvent() { return m_type == CtrlType.Event; }
|
|
//public bool IsMatrix4x4() { return m_type == CtrlType.Mat44F; }
|
|
|
|
public ParamSetter<T> CreateParamSetter<T>()
|
|
{
|
|
Parameter<T> param = mf_CreateParam<T>();
|
|
if (param == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new ParamSetter<T>(param);
|
|
}
|
|
|
|
public ParamGetter<T> CreateParamGetter<T>()
|
|
{
|
|
Parameter<T> param = mf_CreateParam<T>();
|
|
if (param == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return new ParamGetter<T>(param);
|
|
}
|
|
|
|
public void UpdateDirty()
|
|
{
|
|
//if (m_dirty == DirtyFlag.None)
|
|
//{
|
|
// return;
|
|
//}
|
|
//
|
|
if (IsValue())
|
|
{
|
|
if ((m_dirty & DirtyFlag.Values) != 0)
|
|
{
|
|
Utils.StructureToBytes(m_values, m_data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Array.Clear(m_data, 0, m_data.Length);
|
|
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(m_text);
|
|
Buffer.BlockCopy(bytes, 0, m_data, 0, Math.Min(bytes.Length, m_data.Length));
|
|
m_data[m_data.Length - 1] = 0;
|
|
}
|
|
|
|
m_dirty = DirtyFlag.None;
|
|
}
|
|
|
|
public CtrlType ctrlType
|
|
{
|
|
get { return m_type; }
|
|
}
|
|
|
|
public Type realType
|
|
{
|
|
get { return m_realType; }
|
|
}
|
|
|
|
public bool isDirty
|
|
{
|
|
get
|
|
{
|
|
return m_dirty != DirtyFlag.None;
|
|
}
|
|
}
|
|
|
|
public bool isAlive
|
|
{
|
|
get
|
|
{
|
|
return (m_feature & FeatureFlag.IsAlive) != 0;
|
|
}
|
|
}
|
|
|
|
public bool hasRange
|
|
{
|
|
get
|
|
{
|
|
return (m_feature & FeatureFlag.HasRange) != 0;
|
|
}
|
|
}
|
|
|
|
|
|
public string name
|
|
{
|
|
get
|
|
{
|
|
return m_name;
|
|
}
|
|
}
|
|
|
|
public bool valBool
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set valBool - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.val[0] = value? 1.0f: 0.0f;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get valBool - is not value!!!");
|
|
return false;
|
|
}
|
|
|
|
return m_values.val[0] > 0.0f? true: false;
|
|
}
|
|
}
|
|
|
|
public string text
|
|
{
|
|
set
|
|
{
|
|
if (!IsString())
|
|
{
|
|
mf_TraceWarning("set text - is not string!!!");
|
|
return;
|
|
}
|
|
|
|
m_text = value;
|
|
m_dirty |= DirtyFlag.Data;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsString())
|
|
{
|
|
mf_TraceWarning("get text - is not string!!!");
|
|
return "";
|
|
}
|
|
|
|
return m_text;
|
|
}
|
|
}
|
|
|
|
public float valFloat
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set valFloat - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.val[0] = value;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get valFloat - is not value!!!");
|
|
return 0.0f;
|
|
}
|
|
|
|
return m_values.val[0];
|
|
}
|
|
}
|
|
|
|
public float minFloat
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set minFloat - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.min[0] = value;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get minFloat - is not value!!!");
|
|
return 0.0f;
|
|
}
|
|
|
|
return m_values.min[0];
|
|
}
|
|
}
|
|
|
|
public float maxFloat
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set maxFloat - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.min[0] = value;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get maxFloat - is not value!!!");
|
|
return 0.0f;
|
|
}
|
|
|
|
return m_values.max[0];
|
|
}
|
|
}
|
|
|
|
public int valInt
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set valInt - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.val[0] = value;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get valInt - is not value!!!");
|
|
return 0;
|
|
}
|
|
|
|
return (int)m_values.val[0];
|
|
}
|
|
}
|
|
|
|
public int minInt
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set minInt - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.min[0] = value;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get minInt - is not value!!!");
|
|
return 0;
|
|
}
|
|
|
|
return (int)m_values.min[0];
|
|
}
|
|
}
|
|
|
|
public int maxInt
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("set maxInt - is not value!!!");
|
|
return;
|
|
}
|
|
|
|
m_values.min[0] = value;
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
get
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
mf_TraceWarning("get maxFloat - is not value!!!");
|
|
return 0;
|
|
}
|
|
|
|
return (int)m_values.max[0];
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector2 valVector2
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec2(value, m_values.val);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec2(m_values.val) : UnityEngine.Vector2.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector2 minVector2
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec2(value, m_values.min);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec2(m_values.min) : UnityEngine.Vector2.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector2 maxVector2
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec2(value, m_values.max);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec2(m_values.max) : UnityEngine.Vector2.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector3 valVector3
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec3(value, m_values.val);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec3(m_values.val) : UnityEngine.Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector3 minVector3
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec3(value, m_values.min);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec3(m_values.min) : UnityEngine.Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector3 maxVector3
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec3(value, m_values.max);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec3(m_values.max) : UnityEngine.Vector3.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector4 valVector4
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec4(value, m_values.val);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec4(m_values.val) : UnityEngine.Vector4.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector4 minVector4
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec4(value, m_values.min);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec4(m_values.min) : UnityEngine.Vector4.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Vector4 maxVector4
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetVec4(value, m_values.max);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetVec4(m_values.max): UnityEngine.Vector4.zero;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Color valColor
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetColor(value, m_values.val);
|
|
}
|
|
|
|
get
|
|
{
|
|
return IsValue() ? mf_GetColor(m_values.val) : UnityEngine.Color.black;
|
|
}
|
|
}
|
|
|
|
public UnityEngine.Color32 valColor32
|
|
{
|
|
set
|
|
{
|
|
if (!IsValue())
|
|
{
|
|
return;
|
|
}
|
|
|
|
mf_SetColor32(value);
|
|
}
|
|
|
|
get
|
|
{
|
|
if (IsValue())
|
|
{
|
|
return new UnityEngine.Color32(m_data[0], m_data[1], m_data[2], m_data[3]);
|
|
}
|
|
else
|
|
{
|
|
return new UnityEngine.Color32(0, 0, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
public byte[] data
|
|
{
|
|
set
|
|
{
|
|
m_data = value;
|
|
if (m_type == CtrlType.Text)
|
|
{
|
|
int count = 0;
|
|
while (m_data[count] != 0)
|
|
{
|
|
++count;
|
|
}
|
|
|
|
m_text = System.Text.Encoding.UTF8.GetString(m_data, 0, count);
|
|
}
|
|
else
|
|
{
|
|
m_values = Utils.BytesToStructure<CtrlValues>(m_data);
|
|
}
|
|
}
|
|
|
|
get
|
|
{
|
|
UpdateDirty();
|
|
return m_data;
|
|
}
|
|
}
|
|
|
|
private void mf_SetVec2(UnityEngine.Vector2 vec2, float[] ary_f)
|
|
{
|
|
Utils.SetVec2(vec2, ary_f);
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
private void mf_SetVec3(UnityEngine.Vector3 vec3, float[] ary_f)
|
|
{
|
|
Utils.SetVec3(vec3, ary_f);
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
private void mf_SetVec4(UnityEngine.Vector4 vec4, float[] ary_f)
|
|
{
|
|
Utils.SetVec4(vec4, ary_f);
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
private void mf_SetColor(UnityEngine.Color clr, float[] ary_f)
|
|
{
|
|
Utils.SetColor(clr, ary_f);
|
|
m_dirty |= DirtyFlag.All;
|
|
}
|
|
|
|
private void mf_SetColor32(UnityEngine.Color32 clr32)
|
|
{
|
|
Utils.SetColor32(clr32, m_data);
|
|
m_dirty |= DirtyFlag.Data;
|
|
}
|
|
|
|
private UnityEngine.Vector2 mf_GetVec2(float[] ary_f) { return new UnityEngine.Vector2(ary_f[0], ary_f[1]); }
|
|
private UnityEngine.Vector3 mf_GetVec3(float[] ary_f) { return new UnityEngine.Vector3(ary_f[0], ary_f[1], ary_f[2]); }
|
|
private UnityEngine.Vector4 mf_GetVec4(float[] ary_f) { return new UnityEngine.Vector4(ary_f[0], ary_f[1], ary_f[2], ary_f[3]); }
|
|
private UnityEngine.Color mf_GetColor(float[] ary_f) { return new UnityEngine.Color(ary_f[0], ary_f[1], ary_f[2], ary_f[3]); }
|
|
|
|
private void mf_TraceWarning(string msg)
|
|
{
|
|
UnityEngine.Debug.LogWarning("[WARNING] UltraControls::Control name = " + m_name + " : " + msg);
|
|
}
|
|
|
|
private Parameter<T> mf_CreateParam<T>()
|
|
{
|
|
Parameter<T> param;
|
|
try
|
|
{
|
|
param = new Parameter<T>(this);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
UnityEngine.Debug.LogError("UltraControls::Control[" + m_name + "] CreateParam(): " + ex.Message);
|
|
param = null;
|
|
}
|
|
return param;
|
|
}
|
|
}
|
|
|
|
public sealed class NativeLib
|
|
{
|
|
//Imports
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpInitLib")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpInitLib")]
|
|
public static extern int Init();
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpTermLib")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpTermLib")]
|
|
public static extern void Term();
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpCreateHandle")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpCreateHandle")]
|
|
public static extern int CreateHandle([In] string in_name, [In] uint in_max_num_ctrls, [Out] out uint out_handle);
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpDestroyHandle")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpCreateHandle")]
|
|
public static extern int DestroyHandle([In] uint in_handle);
|
|
|
|
//[Setter]///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpFindGetter")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpFindGetter")]
|
|
public static extern int FindGetter([In] uint in_handle, [In, Out] RawCtrl[] out_p_ary, [In] uint in_max_cnt, [Out] out uint out_p_cnt);
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpSetControls")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpSetControls")]
|
|
public static extern int SetControls([In] uint in_handle, [In, Out] RawCtrl[] in_p_ary, [In] uint in_max_cnt);
|
|
|
|
//[Getter]///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpCreateGetter")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpCreateGetter")]
|
|
public static extern int CreateGetter([In] uint in_handle, [In] RawCtrl[] out_p_ary, [In] uint in_max_cnt);
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpGetControls")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpGetControls")]
|
|
public static extern int GetControls([In] uint in_handle, [In, Out] RawCtrl[] out_p_ary, [In] uint in_max_cnt, [Out] out uint out_p_cnt);
|
|
|
|
[DllImport("NativeUltraControlsPluginD", EntryPoint = "nucpCheckControls")]
|
|
//[DllImport("NativeUltraControlsPlugin", EntryPoint = "nucpCheckControls")]
|
|
public static extern int CheckControls([In] uint in_handle, [In, Out] RawCtrl[] out_p_ary, [In] uint in_max_cnt, [Out] out uint out_p_cnt);
|
|
}
|
|
} |