public static IINode BabylonContainerHelper(this IIContainerObject containerObject)
{
IINode babylonHelper = null;
foreach (IINode directChild in containerObject.ContainerNode.DirectChildren())
{
if (directChild.IsBabylonContainerHelper())
{
babylonHelper = directChild;
}
}
if (babylonHelper == null)
{
IDummyObject dummy = Loader.Global.DummyObject.Create();
babylonHelper = Loader.Core.CreateObjectNode(dummy, $"BabylonContainerHelper_{Random.Next(0, 99999)}");
babylonHelper.SetUserPropBool("babylonjs_ContainerHelper", true);
Loader.Core.SetQuietMode(true);
containerObject.ContainerNode.AttachChild(babylonHelper, false);
Loader.Core.SetQuietMode(false);
containerObject.AddNodeToContent(babylonHelper);
}
return(babylonHelper);
}
public void SetUp()
{
proxyGenerator = new ProxyGenerator();
aspect = new LogExceptionAspect();
proxy = (IDummyObject)proxyGenerator.CreateInterfaceProxyWithTarget(
typeof(IDummyObject),
new ExceptionThrowingDomainObject(new NotSupportedException("FOOBAR")),
aspect);
logSpy = new LogSpy();
logSpy.Attach();
}
public void CanDecorateAnInterfaceType()
{
var dummyObjectFactory = new DummyObject.Factory();
IDummyObject dummyObject = dummyObjectFactory.Create();
var proxy = (DummyObject)classUnderTest.Decorate(typeof(DummyObject), dummyObject);
proxy.SetValue(7);
Assert.AreEqual(1, aspectStub.CallCount);
proxy.GetValue();
Assert.AreEqual(2, aspectStub.CallCount);
}
public static IINode BabylonContainerHelper(this IIContainerObject containerObject)
{
IINode babylonHelper = containerObject.ContainerNode.FindChildNode("BabylonAnimationHelper");
if (babylonHelper == null)
{
IDummyObject dummy = Loader.Global.DummyObject.Create();
babylonHelper = Loader.Core.CreateObjectNode(dummy, "BabylonAnimationHelper");
Loader.Core.SetQuietMode(true);
containerObject.ContainerNode.AttachChild(babylonHelper, false);
Loader.Core.SetQuietMode(false);
containerObject.AddNodeToContent(babylonHelper);
}
return(babylonHelper);
}
public static IINode BabylonContainerHelper(this IIContainerObject containerObject)
{
IINode babylonHelper = containerObject.ContainerNode.FindChildNode("BabylonAnimationHelper");
if (babylonHelper == null)
{
MessageBox.Show($"Container {containerObject.ContainerNode.Name} has no Babylon Animation Helper, " +
$"a default one has been created, this process should be done on the container source");
IDummyObject dummy = Loader.Global.DummyObject.Create();
babylonHelper = Loader.Core.CreateObjectNode(dummy, "BabylonAnimationHelper");
Loader.Core.SetQuietMode(true);
containerObject.ContainerNode.AttachChild(babylonHelper, false);
Loader.Core.SetQuietMode(false);
containerObject.AddNodeToContent(babylonHelper);
}
return(babylonHelper);
}
public void ShouldReturnInterfaceProxy()
{
var dummyObjectFactory = new DummyObject.Factory();
IDummyObject dummyObject = dummyObjectFactory.Create();
mockInvocation.Method.Returns(
MethodInfoUtil.GetMethodInfo(() => dummyObjectFactory.Create()));
mockInvocation.ReturnValue.Returns(dummyObject);
Assert.AreEqual(dummyObject, mockInvocation.ReturnValue);
classUnderTest.Intercept(mockInvocation);
Assert.AreNotEqual(dummyObject, mockInvocation.ReturnValue);
IDummyObject proxy = mockInvocation.ReturnValue as IDummyObject;
Assert.NotNull(proxy);
Assert.AreEqual(0, aspect.CallCount);
proxy.SetValue(0);
Assert.AreEqual(1, aspect.CallCount);
}
public static IINode BabylonAnimationHelper()
{
IINode babylonHelper = null;
foreach (IINode directChild in Loader.Core.RootNode.DirectChildren())
{
if (directChild.IsBabylonAnimationHelper())
{
babylonHelper = directChild;
}
}
if (babylonHelper == null)
{
IDummyObject dummy = Loader.Global.DummyObject.Create();
babylonHelper = Loader.Core.CreateObjectNode(dummy, $"BabylonAnimationHelper_{Random.Next(0, 99999)}");
babylonHelper.SetUserPropBool("babylonjs_AnimationHelper", true);
}
return(babylonHelper);
}
public void SetUp()
{
proxyGenerator = new ProxyGenerator();
defaultOptions = new ProxyGenerationOptions();
dummyObject = new DummyObject();
}
//number of atomic objects assumed equal to object count
private void getAtomic()
{
for (int i = 0; i < OLCFG[0]; ++i)
{
//skip atomic and child struct headers (24 bytes)
datIndex += 24;
int fIndex = ReadInt32();
//set associated geometry index
frameList[fIndex].geoIndex = ReadUInt32();
//skip two unknowns
datIndex += 8;
//skip extension
if (ReadUInt32() == (uint)secIDs.EXTENSION)
{
int temp = ReadInt32();
datIndex += temp + 4;
}
else
{
datIndex -= 4;
}
}
//read omnilight data
for (int ind = 0; ind < OLCFG[1]; ++ind)
{
//get index of light object from struct section
datIndex += 12;
int temp = ReadInt32();
frameList[temp].geoIndex = 0xfffffffe; //light
frameList[temp].theLight = (ILightObject)ip.CreateInstance(SClass_ID.Light, global.Class_ID.Create((uint)BuiltInClassIDA.OMNI_LIGHT_CLASS_ID, 0));
datIndex += 24; //skip light section header and constituent struct
frameList[temp].theLight.SetAtten(0, 0, ReadSingle());
frameList[temp].theLight.SetRGBColor(0, global.Point3.Create(255.0 * ReadSingle(), 255.0 * ReadSingle(), 255.0 * ReadSingle()));
frameList[temp].theLight.SetFallsize(0, ReadSingle());
datIndex += 8; //skip light section header
temp = ReadInt32();
datIndex += temp + 4;
}
//read camera data //not yet tested
for (int ind = 0; ind < OLCFG[2]; ++ind)
{
//get index of camera object from struct section
datIndex += 12;
frameList[ReadInt32()].geoIndex = 0xfffffffd; //camera
datIndex += 4; //skip light section identifier
int temp = ReadInt32();
datIndex += temp + 4;
}
//create objects and establish hierarchy
for (int i = 0; i < OLCFG[3]; ++i)
{
switch (frameList[i].geoIndex)
{
case 0xffffffff:
{
IDummyObject leDummy = (IDummyObject)ip.CreateInstance(SClass_ID.Helper, global.Class_ID.Create((uint)BuiltInClassIDA.DUMMY_CLASS_ID, 0));
frameList[i].node = ip.CreateObjectNode(leDummy);
frameList[i].node.Scale(0, frameList[i].frameTM, global.Point3.Create(10, 10, 10), true, false, (int)PivotMode.ObjectOnly, true);
}
break;
case 0xfffffffe:
{
frameList[i].node = ip.CreateObjectNode(frameList[i].theLight);
}
break;
case 0xfffffffd:
break;
default:
{
frameList[i].node = ip.CreateObjectNode(eMeshList[frameList[i].geoIndex]);
frameList[i].node.Mtl = mtlList[frameList[i].geoIndex];
}
break;
}
frameList[i].node.SetNodeTM(0, frameList[i].frameTM);
frameList[i].node.Name = frameList[i].frameName;
}
//establish hierarchy
for (int i = 0; i < OLCFG[3]; ++i)
{
if (frameList[i].parent < OLCFG[3])
{
frameList[frameList[i].parent].node.AttachChild(frameList[i].node, false);
}
}
}
