void handleMouseButtonUp(VariantMap eventData)
{
isAdding = false;
bunnyType++;
bunnyType %= 5;
currentTexture = bunnyTextures [bunnyType];
}
void RenderMenu(VariantMap args)
{
if (ImGui.BeginMenu("SamplePlugin"))
{
ImGui.TextUnformatted("C# says hello");
ImGui.EndMenu();
}
}
public void HandleUpdate(StringHash eventType, IntPtr eventData)
{
VariantMap data = new VariantMap(eventData);
// Take the frame time step, which is stored as a float
float timeStep = data["TimeStep"].GetFloat();
// Move the camera, scale movement with time step
MoveCamera(timeStep);
}
private Application(IntPtr nativeInstance, Context context) : base(nativeInstance, context)
{
SetupHandle = Setup;
StartHandle = Start;
StopHandle = Stop;
engineParameters_ = new VariantMap(ApplicationEXT_GetEngineParametersPtr(NativeInstance));
ApplicationEXT_SetCallback_Setup(NativeInstance, SetupHandle);
ApplicationEXT_SetCallback_Start(NativeInstance, StartHandle);
ApplicationEXT_SetCallback_Stop(NativeInstance, StopHandle);
}
public void SubscribeToEvent(StringHash e, Object sender, Action <StringHash, VariantMap> eventHandler)
{
var eventCallback = new EventCallbackDelegate((eventHash, argMap) =>
{
eventHandler(new StringHash(eventHash), VariantMap.wrap(argMap, false));
});
var handle = GCHandle.ToIntPtr(GCHandle.Alloc(eventCallback));
var callback = Marshal.GetFunctionPointerForDelegate(eventCallback);
Urho3D_Object_SubscribeToEvent(swigCPtr, getCPtr(sender), e.Hash, callback, handle);
}
protected override void OnMouseUp(System.Windows.Forms.MouseEventArgs e)
{
Capture = false;
this.Unfocus();
VariantMap eventData = new VariantMap();
SendEvent("CaptureEnded", eventData);
eventData.Set("Button", new Variant((int)e.Button));
SendEvent("MouseButtonUp", eventData);
base.OnMouseUp(e);
}
public void OnNodeSelected(uint hash, VariantMap eventData)
{
Node node = eventData.Get("Node").GetNode();
Component comp = eventData.Get("Component").GetComponent();
if (comp != null)
{
Selection = new object[] { comp };
}
else if (node != null)
{
Selection = new object[] { node };
}
}
public void OnSceneLoaded(uint eventType, VariantMap eventData)
{
Scene = eventData.Get("Scene").GetScene();
if (SceneChanged != null)
{
SceneChanged(Scene, new EventArgs {
});
}
if (TreeRootChanged != null)
{
TreeRootChanged(this, new EventArgs {
});
}
}
protected override void OnKeyUp(System.Windows.Forms.KeyEventArgs e)
{
if (Capture)
{
VariantMap eventData = new VariantMap();
eventData.Set("Raw", new Variant((uint)e.KeyCode));
eventData.Set("ScanCode", new Variant(e.KeyValue));
eventData.Set("Key", new Variant(e.KeyValue));
SendEvent("KeyUp", eventData);
}
else
{
base.OnKeyUp(e);
}
}
private void OnRender(VariantMap args)
{
OnRenderMenubar();
var screenSize = ui.GetIO().DisplaySize;
var dockPos = new System.Numerics.Vector2(0, MenubarSize);
var dockSize = new System.Numerics.Vector2(screenSize.X, screenSize.Y - MenubarSize);
ImGuiDock.RootDock(dockPos, dockSize);
foreach (var tab in _tabs)
{
tab.OnRender();
}
}
protected override void OnMouseDown(System.Windows.Forms.MouseEventArgs e)
{
this.Focus();
Capture = true;
lastPosition.x = e.X;
lastPosition.y = e.Y;
VariantMap eventData = new VariantMap();
SendEvent("CaptureStarted", eventData);
eventData.Set("Button", new Variant((int)e.Button));
SendEvent("MouseButtonDown", eventData);
base.OnMouseDown(e);
}
private void OnUpdate(VariantMap args)
{
if (IsDockActive && _isMouseHoveringViewport)
{
_view.Camera.GetComponent <DebugCameraController>().Update(args[Update.TimeStep].Float);
if (!_wasFocused)
{
_wasFocused = true;
_eventArgs.Clear();
_eventArgs[InspectHierarchy.HierarchyProvider] = Variant.FromObject(this);
SendEvent <InspectHierarchy>(_eventArgs);
}
}
else
{
_wasFocused = false;
}
}
public bool WriteObject(Variant value, bool withType = false)
{
if (withType)
{
Write(AMF0_OBJECT);
}
foreach (var item in _keysOrder.Where(x => value.Children.ContainsKey(x)).ToArray())
{
WriteShortString(item);
WriteVariant(value[item]);
value.Children.Remove(item);
}
foreach (var item in value.Children)
{
WriteShortString(item.Key.StartsWith(Defines.VAR_INDEX_VALUE) ? VariantMap.IndexStringToIntString(item.Key) : item.Key);
WriteVariant(item.Value);
}
Write(_endofObject);
return(true);
}
public static void Fill(VariantMap map, VariantMapList values)
{
string[] varNames = Enum.GetNames(typeof(VariantType));
foreach (VariantMapRecord rec in values)
{
Variant var = new Variant();
string keyname = rec.Key;
string name = varNames[(int)rec.Type];
string value = rec.Value;
var.FromString(varNames[(int)rec.Type], rec.Value);
if (rec.Key != null)
{
map.Set(rec.Key, var);
}
else
{
map.Set(rec.ExplicitKey, var);
}
}
}
protected override void OnMouseWheel(System.Windows.Forms.MouseEventArgs e)
{
VariantMap eventData = new VariantMap();
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
eventData.Set("Buttons", new UrhoBackend.Variant((int)0));
}
if (e.Button == System.Windows.Forms.MouseButtons.Right)
{
eventData.Set("Buttons", new UrhoBackend.Variant((int)1));
}
if (e.Button == System.Windows.Forms.MouseButtons.Middle)
{
eventData.Set("Buttons", new UrhoBackend.Variant((int)2));
}
eventData.Set("Wheel", new Variant(e.Delta));
SendEvent("MouseWheel", eventData);
base.OnMouseWheel(e);
}
private Variant ToPrimitives(List <DirtyInfo> info)
{
var vm = GlobalPool <VariantMap> .GetObject();
var result = Variant.Get(vm);
vm.IsArray = true;
vm.ArrayLength = info.Count;
for (var i = 0; i < vm.ArrayLength; i++)
{
var primitive = Variant.GetMap(new VariantMapHelper {
{ Defines.RM_SHAREDOBJECTPRIMITIVE_TYPE, info[i].Type }
});
switch (info[i].Type)
{
case Defines.SOT_SC_UPDATE_DATA_ACK:
case Defines.SOT_SC_DELETE_DATA:
primitive[Defines.RM_SHAREDOBJECTPRIMITIVE_PAYLOAD] = Variant.GetList(info[i].PropertyName);
break;
case Defines.SOT_SC_UPDATE_DATA:
primitive[Defines.RM_SHAREDOBJECTPRIMITIVE_PAYLOAD] = Variant.GetMap(new VariantMapHelper
{
{ info[i].PropertyName, Payload[info[i].PropertyName].Clone() }
});
break;
case Defines.SOT_SC_INITIAL_DATA:
case Defines.SOT_SC_CLEAR_DATA:
break;
default:
Logger.ASSERT("Unable to handle primitive type:{0}", info[i].Type);
break;
}
vm[VariantMap.GetIndexString(i)] = primitive;
}
return(result);
}
public static VariantMapList Get(object src, PropertyDescriptor desc, VariantMap map)
{
Scene scene = src as Scene;
if (scene == null)
{
Node nd = src as Node;
if (nd == null)
{
UrhoBackend.Component cp = src as UrhoBackend.Component;
scene = cp.GetScene();
}
else
{
scene = nd.GetScene();
}
}
VariantMapList keys = new VariantMapList(desc, src);
List <string> varNames = new List <string>(Enum.GetNames(typeof(VariantType)));
List <StringHash> hashes = map.Keys();
foreach (StringHash sh in hashes)
{
Variant v = map.Get(sh);
string value = v.ToString();
VariantType vt = (VariantType)varNames.IndexOf(v.GetVarType());
VariantMapRecord rec = new VariantMapRecord(keys)
{
ExplicitKey = sh, Type = (VariantType)v.GetVarTypeID(), Value = v.ToString()
};
if (scene != null)
{
rec.Key = VariableUtils.GetVariableName(scene, rec.ExplicitKey);
}
rec.Enabled = true;
keys.Add(rec);
}
return(keys);
}
public void OnNodeDeleted(uint hash, VariantMap eventData)
{
Node node = eventData.Get("Node").GetNode();
Component comp = eventData.Get("Component").GetComponent();
if (comp != null)
{
if (NodeDeleted != null)
{
NodeDeleted(comp, new EventArgs {
});
}
}
else if (node != null)
{
if (NodeDeleted != null)
{
NodeDeleted(node, new EventArgs {
});
}
}
}
public Variant(VariantMap value)
{
Value = value;
ValueType = VariantType.Map;
}
//TODO: Should be BeginRendering event
private void HandleRenderUpdate(VariantMap obj)
{
}
private void HandleNodeCollision(VariantMap args)
{
//RigidBody body = args.Body;
//RigidBody otherBody = args.OtherBody;
//Node node = body.Node;
//String name = node.Name;
//Node otherNode = otherBody.Node;
//String otherName = otherNode.Name;
//// Detect if there is ground within stepping range
//if (args.Trigger)
//{
// if (name == "DropDetect")
// {
// dropDetected_ = false;
// return;
// }
// if (name == "StandDetect")
// {
// okToStand_ = false;
// return;
// }
// if (name == "GroundDetect")
// {
// nearGround_ = true;
// return;
// }
//}
//// Filter out collisions with DropDetect as otherNode, for some reason this can cause a crouch-jump glitch ?
//if (otherName == "DropDetect")
//{
// // dropDetected_ = false;
// return;
//}
//if (otherName == "StandDetect")
// return;
//if (otherName == "GroundDetect")
// return;
///*if (name != "Character")
// return;*/
//Vector3 vel = body.LinearVelocity;
//float YY = (Node.Position.Y);
//CollisionShape colShape = Node.GetComponent<CollisionShape>();
//float height = colShape.Position.Y;
//foreach (var contacts in args.Contacts)
//{
// Vector3 contactPosition = contacts.ContactPosition;
// Vector3 contactNormal = contacts.ContactNormal;
// float contactDistance = contacts.ContactDistance;
// float contactImpulse = contacts.ContactImpulse;
// // Prevent bounce from corner impact
// if (contactImpulse > 200.0f)
// highImpulseDetected_ = true;
// // If contact is below node center and mostly vertical, assume it's a ground contact
// if (contactPosition.Y < YY + height)
// {
// float level = Math.Abs(contactNormal.Y);
// if (level > 0.75)
// onGround_ = true;
// }
//}
}
void handleMouseButtonDown(VariantMap eventData)
{
isAdding = true;
}
public void SetValue(VariantMap value)
{
Value = value;
ValueType = VariantType.Map;
}
private static void EventHandlerCallback(IntPtr actionHandle, uint eventHash, IntPtr argMap)
{
var eventHandler = (Action <StringHash, VariantMap>)GCHandle.FromIntPtr(actionHandle).Target;
eventHandler(new StringHash(eventHash), VariantMap.wrap(argMap, false));
}
protected void OnInspect(VariantMap args)
{
_inspectable = (IInspectable)args[InspectItem.Inspectable].Object;
}
public void SendEvent <T>(VariantMap args)
{
SendEvent(GetEventType <T>(), args);
}
public void SetValue(IList<Variant> array)
{
var vm = new VariantMap();
Value = vm;
ValueType = VariantType.Map;
vm.IsArray = true;
vm.ArrayLength = array.Count;
for (var i = 0; i < vm.ArrayLength; i++)
{
vm[VariantMap.GetIndexString(i)] = array[i];
}
}
void handleUpdate(VariantMap eventData)
{
if (isAdding)
{
var scale = new Vector2();
var initPos = new Vector2(minX, maxY);
for (var i = 0; i < amount; i++)
{
var bunny = new Bunny();
bunnies.Add(bunny);
var node = scene.CreateChild();
bunny.node = node;
var sprite = (StaticSprite2D)node.CreateComponent("StaticSprite2D");
sprite.BlendMode = BlendMode.BLEND_ALPHA;
sprite.Sprite = currentTexture;
node.Position2D = bunny.position = initPos;
bunny.speed.x = (float)(random.NextDouble() * 10);
bunny.speed.y = (float)(random.NextDouble() * 10) - 5;
scale.x = scale.y = (0.5f + ((float)random.NextDouble()) * 0.5f);
node.Scale2D = scale;
node.Rotation2D = (((float)random.NextDouble()) - 0.5f);
}
}
foreach (var bunny in bunnies)
{
var px = bunny.position.x;
var py = bunny.position.y;
var speedX = bunny.speed.x;
var speedY = bunny.speed.y;
px += speedX * .002f;
py += speedY * .002f;
if (px > maxX)
{
speedX *= -1;
px = maxX;
}
else if (px < minX)
{
speedX *= -1;
px = minX;
}
if (py > maxY)
{
speedY = 0;
py = maxY;
}
else if (py < minY)
{
speedY *= -0.95f;
if (((float)random.NextDouble()) > 0.5f)
{
speedY -= ((float)random.NextDouble()) * 6f;
}
py = minY;
}
bunny.speed.x = speedX;
bunny.speed.y = speedY + gravity;
bunny.position.x = px;
bunny.position.y = py;
bunny.node.Position2D = bunny.position;
;
}
}
private void OnInspect(VariantMap args)
{
_hierarchyProvider = (IHierarchyProvider)args[InspectHierarchy.HierarchyProvider].Object;
}
internal static void HandleEventWithoutType(IntPtr gcHandle, uint type, IntPtr args)
{
var callback = (Action <VariantMap>)GCHandle.FromIntPtr(gcHandle).Target;
callback.Invoke(VariantMap.GetManagedInstance(args, false));
}
