//public abstract void OnButtonClick(T_button_id id);
//public abstract void OnButtonDoubleClick(T_button_id id);
public ButtonObserverConnector(IButtonObserver<T_button_id> impl)
{
__impl = impl;
// Wir bauen uns das Interface im Speicher.
// - 1 Pointer zur Virtual Method Table
// - danach, weil ein Interface keine Member hat, gleich die Pointer
// auf unsere Delegates (1 VTBL + 2 Delegate = 3 Pointer)
NativePointer = Marshal.AllocHGlobal(IntPtr.Size * 3);
// Die VTBL zeigt auf die Adresse danach und wird an die erste
// Stelle geschrieben.
IntPtr vtblPtr = PtrHelper.Add(NativePointer, IntPtr.Size);
Marshal.WriteIntPtr(NativePointer, vtblPtr);
// Nun hintereinander weg die einzelnen Funktionen.
_downCallBack = new OnButtonDownCallBack(OnButtonDown);
Marshal.WriteIntPtr(vtblPtr,
PtrHelper.GetFunctionPointerForDelegate<OnButtonDownCallBack>
(_downCallBack, out _onButtonDownBinder));
_upCallBack = new OnButtonUpCallBack(OnButtonUp);
Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size),
PtrHelper.GetFunctionPointerForDelegate<OnButtonUpCallBack>
(_upCallBack, out _onButtonUpBinder));
//_clickCallBack = new onButtonClickCallBack(onButtonClick);
//Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size * 2),
// PtrHelper.GetFunctionPointerForDelegate<onButtonClickCallBack>
// (_clickCallBack, out _onButtonClickBinder));
//_doubleClickCallBack = new onButtonDoubleClickCallBack(onButtonDoubleClick);
//Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size * 3),
// PtrHelper.GetFunctionPointerForDelegate<onButtonDoubleClickCallBack>
// (_doubleClickCallBack, out _onButtonDoubleClickBinder));
}
private IBuffer GetGlBuffer(ref IBuffer glBuffer, BufferTarget target, int offset)
{
if (!dirty)
{
return(glBuffer);
}
var nonDynamic = rawDataResource.Volatility != ResourceVolatility.Volatile;
var resourcePtr = rawDataResource.Map();
var resourceOffsetPtr = resourcePtr + offset;
var glBufferSize = rawDataResource.Size - offset;
if (glBuffer == null || glBuffer.SizeInBytes != glBufferSize)
{
glBuffer?.Dispose();
var usage = nonDynamic
? BufferUsageHint.StaticDraw
: BufferUsageHint.DynamicDraw;
// todo: target for index buffer
glBuffer = infra.GlContext.Create.Buffer(target, glBufferSize, usage, resourceOffsetPtr);
}
else if (nonDynamic)
{
glBuffer.SetData(resourceOffsetPtr);
}
else
{
var bufferPtr = glBuffer.Map(0, glBufferSize, MapAccess.Write | MapAccess.InvalidateBuffer);
PtrHelper.CopyBulk((byte *)bufferPtr, (byte *)resourceOffsetPtr, glBufferSize);
glBuffer.Unmap();
}
rawDataResource.Unmap(false);
dirty = false;
return(glBuffer);
}
public AvatarAdapterConnector(IAvatarAdapter impl)
{
_impl = impl;
NativePointer = Marshal.AllocHGlobal(IntPtr.Size * 5);
IntPtr vtblPtr = PtrHelper.Add(NativePointer, IntPtr.Size);
Marshal.WriteIntPtr(NativePointer, vtblPtr);
_setTargetVelocityCallBack = new setTargetVelocityCallBack(setTargetVelocity);
Marshal.WriteIntPtr(vtblPtr,
PtrHelper.GetFunctionPointerForDelegate <setTargetVelocityCallBack>
(_setTargetVelocityCallBack, out _setTargetVelocityCallBackBinder));
_setTargetTurnVelocityCallBack = new setTargetTurnVelocityCallBack(setTargetTurnVelocity);
Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size),
PtrHelper.GetFunctionPointerForDelegate <setTargetTurnVelocityCallBack>
(_setTargetTurnVelocityCallBack, out _setTargetTurnVelocityCallBackBinder));
_getVelocityCallBack = new getVelocityCallBack(getVelocity);
Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size * 2),
PtrHelper.GetFunctionPointerForDelegate <getVelocityCallBack>
(_getVelocityCallBack, out _getVelocityCallBackBinder));
_getTurnVelocityCallBack = new getTurnVelocityCallBack(getTurnVelocity);
Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size * 3),
PtrHelper.GetFunctionPointerForDelegate <getTurnVelocityCallBack>
(_getTurnVelocityCallBack, out _getTurnVelocityCallBackBinder));
}
public unsafe void SetData(T data)
{
var stackBuffer = stackalloc byte[buffer.SizeInBytes];
PtrHelper.Write(stackBuffer, data);
buffer.SetData((IntPtr)stackBuffer);
}
public RawDataResource(ResourceVolatility volatility, IntPtr data, int size)
: base(volatility)
{
Size = size;
permanentArray = new UnmanagedArray(size);
PtrHelper.CopyBulk((byte *)permanentArray.Data, (byte *)data, size);
getStream = () => new UnmanagedMemoryStream((byte *)permanentArray.Data, size);
}
protected Error Convert(IList[] dataList, Func <IntPtr, Int32, Error> externCall)
{
var data = PtrHelper.RefLists(dataList);
var count = dataList.Sum(e => e.Count);
var result = externCall(data, count);
PtrHelper.FreeLists(data, dataList);
return(result);
}
public unsafe IVertexArray GetVao()
{
if (!isDirty && NumPoints == lastPointCount)
{
return(vao);
}
if (aspect.VisualBorderCurve == null || aspect.VisualBorderCurve.Count == 0)
{
return(null);
}
if (vao == null)
{
vao = glContext.Create.VertexArray();
}
var newPointCount = NumPoints;
if (vertexBuffer == null || bufferPointCapacity < newPointCount)
{
vertexBuffer?.Dispose();
while (bufferPointCapacity < newPointCount)
{
bufferPointCapacity *= 2;
}
vertexBuffer = glContext.Create.Buffer(BufferTarget.Array, bufferPointCapacity * sizeof(Vector4), BufferUsageHint.DynamicDraw);
vao.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, sizeof(Vector4), 0);
}
var rawData = aspect.BorderComplete
? aspect.VisualBorderCurve.Concat(aspect.VisualBorderCurve.First().EnumSelf()).Select(xy => new Vector4(xy, 0, 1)).ToArray()
: aspect.VisualBorderCurve.Select(xy => new Vector4(xy, 0, 1)).ToArray();
var sizeInBytes = rawData.Length * sizeof(Vector4);
var dst = vertexBuffer.Map(0, vertexBuffer.SizeInBytes, MapAccess.Write | MapAccess.InvalidateBuffer);
fixed(Vector4 *src = rawData)
PtrHelper.CopyBulk((byte *)dst, (byte *)src, sizeInBytes);
vertexBuffer.Unmap();
lastPointCount = newPointCount;
isDirty = false;
return(vao);
}
public AnalogObserverConnector(IAnalogObserver<T_analog_id, T_analog_data> impl)
{
_impl = impl;
NativePointer = Marshal.AllocHGlobal(IntPtr.Size * 3);
IntPtr vtblPtr = PtrHelper.Add(NativePointer, IntPtr.Size);
Marshal.WriteIntPtr(NativePointer, vtblPtr);
// Warum diese Methoden hier andersrum stehen als im C++-Interface
// könnte mal jemand klären...
_changedCallBack = new OnAnalogChangedCallBack(OnAnalogChanged);
Marshal.WriteIntPtr(vtblPtr,
PtrHelper.GetFunctionPointerForDelegate<OnAnalogChangedCallBack>
(_changedCallBack, out _onChangedBinder));
_changedChannelCallBack = new OnAnalogChannelChangedCallBack(OnAnalogChannelChanged);
Marshal.WriteIntPtr(PtrHelper.Add(vtblPtr, IntPtr.Size),
PtrHelper.GetFunctionPointerForDelegate<OnAnalogChannelChangedCallBack>
(_changedChannelCallBack, out _onChannelChangedBinder));
}
public void Draw()
{
var sketches = sketchService.GetSketches();
var totalPointCount = sketches.Sum(x => x.Count);
if (totalPointCount == 0)
{
return;
}
if (data == null || totalPointCount > data.Length)
{
vertexBuffer?.Dispose();
var size = data?.Length ?? 1024;
while (size < totalPointCount)
{
size *= 2;
}
data = new Vector2[size];
vertexBuffer = glContext.Create.Buffer(BufferTarget.Array, data.Length * sizeof(Vector2), BufferUsageHint.DynamicDraw);
vao.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, sizeof(Vector2), 0);
}
int offset = 0;
foreach (var sketch in sketches)
{
foreach (var point in sketch)
{
data[offset++] = point;
}
}
var sketchSize = totalPointCount * sizeof(Vector2);
var map = vertexBuffer.Map(0, sketchSize, MapAccess.Write | MapAccess.InvalidateRange);
fixed(Vector2 *pData = data)
PtrHelper.CopyBulk((byte *)map, (byte *)pData, sketchSize);
vertexBuffer.Unmap();
glContext.Bindings.Program.Set(shaderProgram);
glContext.Bindings.VertexArray.Set(vao);
glContext.States.DepthStencil.DepthTestEnable.Set(false);
glContext.States.DepthStencil.DepthMask.Set(false);
OpenTK.Graphics.OpenGL4.GL.LineWidth(6f);
offset = 0;
foreach (var sketch in sketches)
{
glContext.Actions.Draw.Arrays(BeginMode.LineStrip, offset, sketch.Count);
offset += sketch.Count;
}
OpenTK.Graphics.OpenGL4.GL.LineWidth(1f);
glContext.States.DepthStencil.DepthTestEnable.Set(true);
glContext.States.DepthStencil.DepthMask.Set(true);
}
public UniformBufferSugar(IContext glContext)
{
buffer = glContext.Create.Buffer(BufferTarget.Uniform, PtrHelper.SizeOf <T>(), BufferUsageHint.DynamicDraw);
}
