public EngineScene(EngineScene s)
{
_shadowObjects = s._shadowObjects;
_visibleObjects = s._visibleObjects;
_objects = s._objects;
_sceneGraph = s._sceneGraph;
}
public EngineScene()
{
//инит ФизиХ-а
var coreDesc = new CoreDescription();
var output = new UserOutput();
Core = new Core(coreDesc, output);
Core.SetParameter(PhysicsParameter.ContinuousCollisionDetection, false);
Core.SetParameter(PhysicsParameter.ContinuousCollisionDetectionEpsilon, 0.01f);
var sceneDesc = new SceneDescription
{
SimulationType = SimulationType.Software, //Hardware,
MaximumBounds = new Bounds3(-1000, -1000, -1000, 1000, 1000, 1000),
UpAxis = 2,
Gravity = new StillDesign.PhysX.MathPrimitives.Vector3(0.0f, -9.81f * 1.7f, 0.0f),
GroundPlaneEnabled = false
};
Scene = Core.CreateScene(sceneDesc);
//для обработки столкновений
Scene.UserContactReport = new ContactReport(MyGame.Instance);
_objects = new MyContainer<PivotObject>(100, 10, true);
_visibleObjects = new MyContainer<PivotObject>(100, 2);
_shadowObjects = new MyContainer<PivotObject>(100, 2);
_sceneGraph = new SceneGraph.SceneGraph(this);
}
public GameScene()
{
objects = new MyContainer<PivotObject>(100, 10);
VisibleObjects = new MyContainer<PivotObject>(100, 2);
ShadowObjects = new MyContainer<PivotObject>(100, 2);
sceneGraph = new SceneGraph.SceneGraph(this);
idgenertor = new IdGenerator(0);
}
public void AddObjects(MyContainer<PivotObject> newobjects)
{
foreach (PivotObject t in newobjects)
{
_objects.Add(t);
_sceneGraph.AddObject(t);
}
}
public GameScene(GameScene s, uint generatorId = 0)
{
ShadowObjects = s.ShadowObjects;
VisibleObjects = s.VisibleObjects;
objects = s.objects;
sceneGraph = s.sceneGraph;
idgenertor = new IdGenerator(generatorId);
}
public void Read_IntegerTimeout_Reads()
{
var c = new MyContainer(_store);
int timeout = c.Timeout;
Assert.Equal(2, timeout);
}
public void TestCollect()
{
int repeated = 2;
MyContainer container = new MyContainer(repeated);
Assert.AreEqual<int>(repeated,container.ArtifactLinks.Count);
ArtifactLinkCollector target = new ArtifactLinkCollector();
target.Collect(container);
Assert.AreEqual<int>(1, target.ArtifactLinks.Count);
}
public void AddObjects(MyContainer<PivotObject> newobjects)
{
foreach(PivotObject t in newobjects) {
t.editorAspect.id = idgenertor.NewId();
objects.Add(t);
sceneGraph.AddObject(t);
}
}
// добавление элементов в таблицу. Параеметр: список объектов
public void ObjectsAdded(MyContainer<PivotObject> newObjects)
{
Console.WriteLine("ObjectsAdded");
int masLen = newObjects.Count;
for (int i = 0; i < masLen; ++i)
{
levelform.AddObject(newObjects[i].editorAspect.id.ToString(), newObjects[i].editorAspect.DescriptionName, newObjects[i].editorAspect.objtype.ToString(), newObjects[i].editorAspect.isActive);
}
}
public void AddObjects(MyContainer<PivotObject> objects, bool back = false)
{
gameScene.AddObjects(objects);
if (!back)
{
var action = new AddObjectPivotAction(new ObjectContainer(objects));
actions.AddNewAction(action);
}
GameEngine.levelController.ObjectsAdded(objects);
}
public void DeleteObjects(MyContainer<PivotObject> deletingobjects)
{
foreach(PivotObject t in deletingobjects) {
objects.Remove(t);
sceneGraph.DeleteObject(t);
}
// счетчик идов будет начинать все делать с 0
if(objects.Count == 0) {
idgenertor.ClearIdsCounter(); ;
}
}
public GameEngine(MyGame game)
{
lightDir.Normalize();
DeviceManager = new GraphicsDeviceManager( game );
//разме рэкрана1158; 708
DeviceManager.PreferredBackBufferWidth = 1158;
DeviceManager.PreferredBackBufferHeight = 708;
objectstoadd = new MyContainer<PivotObject>();
gameLevel = new EngineLevel();
databaseManager = ResourceCollector.Logic.DatabaseManager.Manager;
}
public void when_registering_a_type_in_any_order_should_return_valid_resolve()
{
var ioc = new MyContainer(typeof(Foo));
List <object> instances = new List <object>();
for (int i = 0; i < 5; i++)
{
instances.Add(ioc.Resolve <IFoo>());
}
Assert.True(instances.TrueForAll(i => i.Equals(instances.FirstOrDefault())));
}
private static void createChild(XmlNode canvas, MyContainer myContainer)
{
int count = canvas.ChildNodes.Count;
for (int i = 0; i < count; i++)
{
LayoutData layoutData = new LayoutData();
XmlNode element = canvas.ChildNodes.Item(i);
layoutData.textBackground = Convert.ToInt32(element.Attributes[14].Value);
layoutData.textColor = Convert.ToInt32(element.Attributes[13].Value);
layoutData.textSize = Convert.ToInt32(element.Attributes[12].Value);
layoutData.backgroundColor = Convert.ToInt32(element.Attributes[11].Value);
layoutData.sceneTime = Convert.ToInt32(element.Attributes[10].Value);
layoutData.stretchModel = Convert.ToInt32(element.Attributes[9].Value);
layoutData.imageSwitch = Convert.ToInt32(element.Attributes[8].Value);
layoutData.canvasTop = double.Parse(element.Attributes[7].Value);
layoutData.canvasLeft = double.Parse(element.Attributes[6].Value);
layoutData.text = element.Attributes[5].Value;
layoutData.angle = double.Parse(element.Attributes[4].Value);
layoutData.sourcePath = element.Attributes[3].Value;
layoutData.width = double.Parse(element.Attributes[2].Value);
layoutData.height = double.Parse(element.Attributes[1].Value);
layoutData.tag = element.Attributes[0].Value;
switch (layoutData.tag)
{
case "Text":
MyText myText = new MyText();
myText.initLayout(layoutData);
myContainer.Children.Add(myText);
break;
case "Media":
MyMedia myMedia = new MyMedia();
myMedia.initLayout(layoutData);
myContainer.Children.Add(myMedia);
break;
case "Image":
MyImage myImage = new MyImage();
myImage.initLayout(layoutData);
myContainer.Children.Add(myImage);
break;
case "Office":
MyOffice myOffice = new MyOffice();
myOffice.initLayout(layoutData);
myContainer.Children.Add(myOffice);
break;
}
layoutData = null;
}
}
static void Main(string[] args)
{
IContainer container = new MyContainer();
container.RegisterType <IContext, DbContext>();
container.RegisterType <IStudentRepository, StudentRepository>();
container.RegisterType <IStudentService, StudentService>();
IResolver resolver = new MyResolver(container);
var studentService = resolver.GetInstance(typeof(IStudentService));
Console.Read();
}
public PlayerWindow(string path)
{
//MyContainer myContainer = new MyContainer();
scenesList = getScenesList(path);
if (scenesList.Count > 0)
{
MyContainer myContainer = new MyContainer();
CreateLayout.showScene(myContainer, scenesList[0]);
this.Content = myContainer;
int time = myContainer.layoutData.sceneTime;
setTimer(time, 0);
}
}
static void Main(string[] args)
{
var container = new MyContainer();
var application1 = container.Resolve();
var application2 = container.Resolve();
Console.WriteLine($"application1.Transient.Name: {application1.Transient.Name}");
Console.WriteLine($"application2.Transient.Name: {application2.Transient.Name}");
Console.WriteLine();
Console.WriteLine($"application1.Singleton.Name: {application1.Singleton.Name}");
Console.WriteLine($"application2.Singleton.Name: {application2.Singleton.Name}");
Console.ReadKey();
}
public void TestMyContainer()
{
MyContainer container = new MyContainer(new string[] { "a", "aaa", "aaaaa", "aba", "ababa", "bb", "bbbb", "bbbbbb" });
var result = container.GetValidWordPositions("aaaaaa", 0);
Assert.IsTrue(result.All(e => e % 2 == 0));
result = container.GetValidWordPositions("bbbbbb", 0);
Assert.IsTrue(result.All(e => e % 2 == 1));
result = container.GetValidWordPositions("tt", 0);
Assert.IsTrue(result.All(e => e % 2 == 0));
}
public void TestMyContainerV2()
{
MyContainer container = new MyContainer(new string[] { "a", "aaa", "aaaaa", "aba", "ababa", "bb", "bbbb", "bbbbbb" }.Select(e => e.ToUpper()).ToArray());
var result = container.GetValidWordPositions("aaaaaa".ToUpper(), 0);
Assert.IsTrue(result.All(e => e % 2 == 0));
result = container.GetValidWordPositions("bbbbbb".ToUpper(), 0);
Assert.IsTrue(result.All(e => e % 2 == 1));
result = container.GetValidWordPositions("tt".ToUpper(), 0);
Assert.IsTrue(result.All(e => e % 2 == 0));
}
public void OnGet(int galleryId, string newg, string attr, string descrs)
{
GalleryIdSelected = galleryId;
System.Security.Claims.ClaimsPrincipal currentUser = this.User;
if (!string.IsNullOrEmpty(newg))
{
ItemGallery mygallery = new ItemGallery();
mygallery.NewGallery("NoName_" + DateTime.Now.ToString("yyyyMMdd"), "NoDescription_" + DateTime.Now.ToString("yyyyMMdd"), newg, attr);
GalleryIdSelected = this.MyContainer.myGalleries.SaveGallery(mygallery, descrs, userManager.GetUserId(currentUser));
MyContainer = new MyContainer(ijpContext, userManager.GetUserId(currentUser));
}
}
// удаление элементов из таблицы. Параметр: список удаляемых объектов
public void ObjectsDeleted(MyContainer<PivotObject> deletingobjects)
{
if (deletingobjects.Count == 0)
{
return;
}
Console.WriteLine("ObjectsDeleted");
foreach (PivotObject deletingobject in deletingobjects)
{
levelform.RemoveObject(deletingobject.editorAspect.id);
}
}
public static MyContainer previewCanvasContent(MyContainer myContainer)
{
MyContainer previewCanvas = new MyContainer();
previewCanvas.initLayout(myContainer.layoutData);
int count = myContainer.Children.Count;
for (int i = 0; i < count; i++)
{
ContentControl temp = myContainer.Children[i] as ContentControl;
switch (temp.Tag as string)
{
case "Text":
MyText text = new MyText();
MyText tempText = (MyText)temp;
text.Tag = "preview";
text.initLayout(tempText.layoutData);
previewCanvas.Children.Add(text);
//AttributeLayout.SetAttrTree(tag, this);
break;
case "Image":
MyImage image = new MyImage();
MyImage tempImage = (MyImage)temp;
image.Tag = "preview";
image.initLayout(tempImage.layoutData);
previewCanvas.Children.Add(image);
//AttributeLayout.SetAttrTree(tag, this);
break;
case "Media":
MyMedia media = new MyMedia();
MyMedia tempMedia = (MyMedia)temp;
media.Tag = "preview";
media.initLayout(tempMedia.layoutData);
previewCanvas.Children.Add(media);
//AttributeLayout.SetAttrTree(tag, this);
break;
case "Office":
MyOffice myOffice = new MyOffice();
MyOffice tempOffice = (MyOffice)temp;
myOffice.Tag = "preview";
myOffice.initLayout(tempOffice.layoutData);
previewCanvas.Children.Add(myOffice);
//AttributeLayout.SetAttrTree(tag, this);
break;
}
}
return(previewCanvas);
}
private void previewButton_Click(object sender, RoutedEventArgs e)
{
MyContainer previewCanvas = CreateLayout.previewCanvasContent(this.myContainer);
preViewWindow = new Window();
preViewWindow.Background = Brushes.Black;
preViewWindow.Content = previewCanvas;
//window.WindowStyle = WindowStyle.None;
preViewWindow.WindowState = WindowState.Maximized;
preViewWindow.Show();
//window.ShowDialog();
setTimer(this.myContainer.Timer);
}
private void playNextScene(int i)
{
if (scenesList.Count > i + 1)
{
MyContainer myContainer = new MyContainer();
CreateLayout.showScene(myContainer, scenesList[i + 1]);
this.Content = myContainer;
int time = myContainer.layoutData.sceneTime;
setTimer(time, i + 1);
}
else
{
//deleteTempFolder();
}
}
public TrayNotify(FetchAndPublish fetcher)
{
MyContainer components = new MyContainer();
notifyIcon = new NotifyIcon(components)
{
Icon = Properties.Resources.main,
Text = "BBC Ingest",
BalloonTipText = "BBC Ingest",
Visible = showicon
};
fetcher.listenForTerseMessages(new TerseMessageDelegate(terse));
fetcher.listenForChattyMessages(new ChattyMessageDelegate(chatty));
fetcher.listenForEditionStatus(new ShowEditionStatusDelegate(chatty));
}
static void Main()
{
MyContainer <long> lContainer = new MyContainer <long>();
MyContainer <int> iContainer = new MyContainer <int>();
lContainer.Add(1);
lContainer.Add(2);
iContainer.Add(3);
iContainer.Add(4);
lContainer.Add(iContainer, EntryPoint.IntToLongConverter);
foreach (long l in lContainer)
{
Console.WriteLine(l);
}
}
static void Main(string[] args)
{
MyNode n = new MyNode();
MyContainer c = new MyContainer();
c.AddChild(n);
MySubNode s = new MySubNode();
//
// This does not work because it tries to fill the generic in the
// extension method with <MySubNode, MyContainer>, which does not
// fulfil the constraint "where Container : Node".
//
//c.AddChild(s);
OtherNode o = new OtherNode();
o.AddChild(o);
}
public void TestMethod1()
{
var client = new Client();
// this does NOT work due to constraints
var locationId = "location";
var container = new MyContainer { Location = locationId };
var content = new ContentA();
container.Add(content);
client.DoSomething<MyContainer, ContentA>(container, content);
Assert.AreEqual(locationId, content.Location);
}
public static void CreateControlByTag(string tag, DragEventArgs e, MyContainer canvas, MainWindow mWindow)
{
Point position = e.GetPosition(canvas);
//MyContainer canvas = new MyContainer();
switch (tag)
{
case "Text":
MyText myText = new MyText();
Canvas.SetLeft(myText, Math.Max(0, position.X - myText.Width / 2));
Canvas.SetTop(myText, Math.Max(0, position.Y - myText.Height / 2));
canvas.Children.Add(myText);
myText.updateLayoutDate();
AttributeLayout.SetAttrTree(myText, mWindow);
break;
case "Media":
MyMedia myMedia = new MyMedia();
Canvas.SetLeft(myMedia, Math.Max(0, position.X - myMedia.Width / 2));
Canvas.SetTop(myMedia, Math.Max(0, position.Y - myMedia.Height / 2));
canvas.Children.Add(myMedia);
myMedia.updateLayoutDate();
AttributeLayout.SetAttrTree(myMedia, mWindow);
break;
case "Image":
MyImage myImage = new MyImage();
Canvas.SetLeft(myImage, Math.Max(0, position.X - myImage.Width / 2));
Canvas.SetTop(myImage, Math.Max(0, position.Y - myImage.Height / 2));
canvas.Children.Add(myImage);
myImage.updateLayoutDate();
AttributeLayout.SetAttrTree(myImage, mWindow);
break;
case "Word":
MyOffice myOffice = new MyOffice();
Canvas.SetLeft(myOffice, Math.Max(0, position.X - myOffice.Width / 2));
Canvas.SetTop(myOffice, Math.Max(0, position.Y - myOffice.Height / 2));
canvas.Children.Add(myOffice);
myOffice.updateLayoutDate();
AttributeLayout.SetAttrTree(myOffice, mWindow);
break;
}
//return canvas;
}
static void Main(string[] args)
{
var container = new MyContainer();
//依赖注入 瞬时默认
container.RegisterType <ILanguage, Chinese>();
var language1 = container.Resolve <ILanguage>();
var language2 = container.Resolve <ILanguage>();
Console.WriteLine($"-----------------------瞬时默认-------------------------");
Console.WriteLine($"language1 与 language2：{ReferenceEquals(language1, language2)}\r\n");
//线程单例
Console.WriteLine($"-----------------------线程单例-------------------------");
container.RegisterType <ILanguage, Chinese>(TypeLifeTime.PerThread);
ILanguage tlanguage1 = null;
var task1 = Task.Run(() => {
tlanguage1 = container.Resolve <ILanguage>();
Console.WriteLine($"tlanguage1 线程id：{Thread.CurrentThread.ManagedThreadId}");
});
ILanguage tlanguage2 = null;
ILanguage tlanguage3 = null;
var task2 = Task.Run(() => {
tlanguage2 = container.Resolve <ILanguage>();
tlanguage3 = container.Resolve <ILanguage>();
Console.WriteLine($"tlanguage2 线程id：{Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine($"tlanguage3 线程id：{Thread.CurrentThread.ManagedThreadId}");
});
task1.Wait();
task2.Wait();
Console.WriteLine($"tlanguage1 与 tlanguage2 ：{ReferenceEquals(tlanguage1, tlanguage2)}");
Console.WriteLine($"tlanguage2 与 tlanguage3 ：{ReferenceEquals(tlanguage2, tlanguage3)}\r\n");
//单例模式
container.RegisterType <ILanguage, Chinese>(TypeLifeTime.Singleton);
var slanguage1 = container.Resolve <ILanguage>();
var slanguage2 = container.Resolve <ILanguage>();
Console.WriteLine($"-----------------------单例模式-------------------------");
Console.WriteLine($"slanguage1 与 slanguage2：{ReferenceEquals(slanguage1, slanguage2)}");
Console.Read();
}
public static void showScene(MyContainer myContainer, string path)
{
myContainer.Children.Clear();
string parentDir = "temp\\" + System.IO.Directory.GetParent(path).Name;
XmlDocument doc = new XmlDocument();
string sceneData = "";
try
{
StreamReader sr = new StreamReader(path);
string line;
while ((line = sr.ReadLine()) != null)
{
sceneData += line;
}
sr.Close();
}
catch (System.Exception ex)
{
return;
}
doc.LoadXml(sceneData);
XmlNode scenePage = doc.GetElementsByTagName("scenePage")[0];
XmlNode canvas = scenePage.ChildNodes[0];
LayoutData layoutData = new LayoutData();
layoutData.backgroundColor = Convert.ToInt32(canvas.Attributes[11].Value);
layoutData.sceneTime = Convert.ToInt32(canvas.Attributes[10].Value);
layoutData.stretchModel = Convert.ToInt32(canvas.Attributes[9].Value);
layoutData.imageSwitch = Convert.ToInt32(canvas.Attributes[8].Value);
layoutData.canvasTop = double.Parse(canvas.Attributes[7].Value);
layoutData.canvasLeft = double.Parse(canvas.Attributes[6].Value);
layoutData.text = canvas.Attributes[5].Value;
layoutData.angle = double.Parse(canvas.Attributes[4].Value);
layoutData.sourcePath = parentDir + "\\" + canvas.Attributes[3].Value;
layoutData.width = double.Parse(canvas.Attributes[2].Value);
layoutData.height = double.Parse(canvas.Attributes[1].Value);
layoutData.tag = canvas.Attributes[0].Value;
myContainer.initLayout(layoutData);
createChild(canvas, myContainer, parentDir);
}
protected override void Ambient()
{
var timer = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), Self, new Decompose(), Self);
var times = 0;
base.Ambient();
Receive <Decompose>(msg =>
{
MyContainer.Tell(new ContainerNotify($"{Name} is decomposing", Self));
times++;
if (times == 3)
{
timer.Cancel();
MyContainer.Tell(new ContainerNotify($"{Name} has turned to dust", Self));
MyContainer.Tell(new ContainerRemove(Self));
Context.Stop(Self);
}
});
}
public static void setCanvasAttrbute(object sender, MyContainer myContainer)
{
TextBox txb = sender as TextBox;
if (!txb.IsFocused)
{
return;
}
string tag = txb.Tag as string;
switch (tag)
{
case "SceneHeight":
String height = txb.Text;
if (height == "")
{
break;
}
myContainer.Height = Convert.ToDouble(height);
break;
case "SceneWidth":
String width = txb.Text;
if (width == "")
{
break;
}
;
myContainer.Width = Convert.ToDouble(width);
break;
case "SceneTime":
String time = txb.Text;
if (time == "")
{
break;
}
;
myContainer.Timer = Convert.ToInt32(time);
break;
}
UpdateCanvasLayoutDate(myContainer);
}
protected void BecomeDead()
{
MyContainer.Tell(new ContainerNotify($"{Name} has died!", Self));
Self.Tell(new Notify($"You have died!"));
Sender.Tell(new Died());
HP = 0;
IsAlive = false;
var corpse = Context.System.ActorOf(Props.Create(() => new Corpse($"Corpse of {Name}")));
corpse.Tell(new SetContainer(MyContainer));
MyContent.TellAll(new SetContainer(MyContainer));
//remove self from container
MyContainer.Tell(new ContainerRemove(Self));
Context.Stop(Self);
//Become(() =>
//{
// Ambient();
// Dead();
//});
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
GlobalConfiguration.Configure(WebApiConfig.ResponseFormater);
//Inicializando configuração do Simple Injector
var container = new MyContainer().Initialize();
//Verificando o simple injector
container.Verify();
//Fazer criação de dependency resolver
GlobalConfiguration.Configuration.DependencyResolver =
new SimpleInjectorWebApiDependencyResolver(container);
//ExpressMapper
var express = new Express();
express.Mapper();
}
public void TestImmediateContainer()
{
var env = new Environment();
var res = new MyContainer(env);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
var put = res.Put(1);
Assert.IsTrue(put.IsTriggered);
Assert.AreEqual(1, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
var get = res.Get(1);
Assert.IsTrue(get.IsTriggered);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
get = res.Get(1);
Assert.IsFalse(get.IsTriggered);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(1, res.GetQueueLength);
put = res.Put(1);
Assert.IsTrue(put.IsTriggered);
Assert.AreEqual(1, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(1, res.GetQueueLength);
env.Run();
Assert.IsTrue(get.IsTriggered);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
}
private static void Collect(MyContainer container)
{
var properties = container.GetType().GetProperties();
foreach (var property in properties)
{
if (property.PropertyType.IsGenericType &&
property.PropertyType.GetGenericTypeDefinition() == typeof(IList <>) &&
typeof(Shape).IsAssignableFrom(property.PropertyType.GetGenericArguments()[0]))
{
var t = property.GetValue(container, null) as IEnumerable <Shape>;
if (t != null)
{
foreach (Shape shape in t)
{
Console.WriteLine(shape.Area);
}
}
}
}
}
static void Main(string[] args)
{
try
{
Console.WriteLine("\nRegular Serialization of an array of strings with some empty elements:");
String[] x = { "AAA", "BBB", "", "DDD", "", "FFF" };
XmlSerializer s1 = new XmlSerializer(typeof(String[]));
string s = s1.SerializeToString(x);
Console.WriteLine(s);
Console.WriteLine("\nSerialization of an array of strings with some empty elements, via a Container:");
MyContainer c = new MyContainer();
c.a = x;
XmlSerializer s2 = new XmlSerializer(typeof(MyContainer));
s = s2.SerializeToString(c);
Console.WriteLine(s);
}
catch (System.Exception exc1)
{
Console.WriteLine("uncaught exception:\n{0}", exc1);
}
}
public static void Main(string[] args)
{
Person person1 = new Person();
person1.name = "Max";
person1.alter = 20;
Frau frau1 = new Frau();
Mann mann1 = new Mann();
Person[] instanzenArray = new Person[3];
instanzenArray[0] = person1;
instanzenArray[1] = frau1;
instanzenArray[2] = mann1;
MyContainer container = new MyContainer();
container.Add(instanzenArray);
container.GetAt(0);
foreach (Person instanz in instanzenArray)
{
Console.WriteLine(instanz.GetAnrede());
}
}
public void Register_SingleType_Succeeds()
{
var c = new MyContainer();
c.Register <Calculator>();
}
public MyContainerUnitTests()
{
_myContainer = new MyContainer();
}
public void AddObjectToPipeline(MyContainer<PivotObject> AddedObjects)
{
foreach (PivotObject AddedObject in AddedObjects)
{
RenderObject ro = AddedObject.HaveRenderAspect();
if(ro!=null)
ArraysPerTehnique[ro.PictureTehnique].Objects.Add(AddedObject);
}
foreach (PivotObject AddedObject in AddedObjects)
debugRenderArray.Add(AddedObject);
}
public RenderPipeline(GraphicsDevice dev, Camera c)
{
Device = dev;
Camera = c;
_visualizationEffect = new BasicEffect(this.Device)
{
VertexColorEnabled = true
};
frustumForShadow = new BoundingFrustum(Matrix.Identity);
debugRenderer = new DebugRender.DebugRenderer(Device, _visualizationEffect);
debugRenderArray = new MyContainer<PivotObject>(10, 3);
EnableShadows = SmoothShadows = EnableGrass = true;
EnableDebugRender = true;
rs = createNewState(RasterizerState.CullClockwise);
rs.CullMode = CullMode.None;
Device.RasterizerState = rs;
//EnableShadows = false;
//SmoothShadows = false;
if (EnableShadows)
{
if (dev.GraphicsProfile == GraphicsProfile.HiDef)
{
shadowRenderTarget = new RenderTarget2D(Device,
shadowMapWidthHeight,
shadowMapWidthHeight,
false,
SurfaceFormat.Single,
DepthFormat.Depth16);
}
else
{
if (GraphicsAdapter.DefaultAdapter.IsProfileSupported(GraphicsProfile.HiDef))
{
shadowRenderTarget = new RenderTarget2D(Device,
shadowMapWidthHeight,
shadowMapWidthHeight,
false,
SurfaceFormat.Color,
DepthFormat.None, 0, RenderTargetUsage.DiscardContents);
}
else
{
//TODO to cofig
shadowRenderTarget = new RenderTarget2D(Device,
dev.PresentationParameters.BackBufferWidth,
dev.PresentationParameters.BackBufferHeight,
false,
SurfaceFormat.Color,
DepthFormat.None);
}
SmoothShadows = false;
}
}
arrays = new List<string>();
if (dev.GraphicsProfile == GraphicsProfile.Reach)
{
Shader.AnimRenderSM = "AnimRenderSMR";
Shader.NotAnimRenderSM = "NotAnimRenderSMR";
Shader.AnimRenderSMSmooth = Shader.AnimRenderSM;
Shader.NotAnimRenderSMSmooth = Shader.NotAnimRenderSM;
Shader.CreateStaticShadowMap = "CreateStaticShadowMapR";
Shader.CreateAnimShadowMap = "CreateAnimShadowMapR";
}
arrays.Add(Shader.AnimRenderNoSM);
arrays.Add(Shader.NotAnimRenderNoSM);
arrays.Add(Shader.AnimRenderSM);
arrays.Add(Shader.NotAnimRenderSM);
arrays.Add(Shader.AnimRenderSMSmooth);
arrays.Add(Shader.NotAnimRenderSMSmooth);
arrays.Add(Shader.CreateStaticShadowMap);
arrays.Add(Shader.CreateAnimShadowMap);
ArraysPerTehnique.Add(Shader.AnimRenderNoSM, new RenderArray(Shader.AnimRenderNoSM));
ArraysPerTehnique.Add(Shader.NotAnimRenderNoSM, new RenderArray(Shader.NotAnimRenderNoSM));
ArraysPerTehnique.Add(Shader.AnimRenderSM, new RenderArray(Shader.AnimRenderSM));
ArraysPerTehnique.Add(Shader.NotAnimRenderSM, new RenderArray(Shader.NotAnimRenderSM));
if (dev.GraphicsProfile == GraphicsProfile.HiDef)
{
ArraysPerTehnique.Add(Shader.AnimRenderSMSmooth, new RenderArray(Shader.AnimRenderSMSmooth));
ArraysPerTehnique.Add(Shader.NotAnimRenderSMSmooth, new RenderArray(Shader.NotAnimRenderSMSmooth));
}
ArraysPerTehnique.Add(Shader.CreateStaticShadowMap, new RenderArray(Shader.CreateStaticShadowMap));
ArraysPerTehnique.Add(Shader.CreateAnimShadowMap, new RenderArray(Shader.CreateAnimShadowMap));
}
public GameLevelDescription()
{
objectInformation = new MyContainer<ObjectElement>(100, 2);
}
public void Read_NoInit_Acceptable()
{
var c = new MyContainer(_store);
Assert.Equal("MyApp.NoInitTimeout", c.NoInitTimeout.Name);
}
public void AddObjectToShadow(MyContainer<PivotObject> AddedObjects)
{
foreach (PivotObject AddedObject in AddedObjects)
{
RenderObject ro = AddedObject.HaveRenderAspect();
if (ro != null && ro.ShadowTehnique != null)
ArraysPerTehnique[ro.ShadowTehnique].Objects.Add(AddedObject);
}
}
public RenderPipeline(GraphicsDevice dev, Camera c)
{
_device = dev;
camera = c;
_visualizationEffect = new BasicEffect(this._device)
{
VertexColorEnabled = true
};
/// <summary>
/// added
/// </summary>
sprite = new SpriteBatch(this._device);
frustumForShadow = new BoundingFrustum(Matrix.Identity);
debugRenderer = new DebugRender.DebugRenderer(_device, _visualizationEffect);
debugRenderArray = new MyContainer<PivotObject>(10, 3);
EnableShadows = Config.Instance["_enableShadows"];
SmoothShadows = Config.Instance["_smoothShadows"];
EnableDebugRender = Config.Instance["_enableDebugRender"];
int size = Config.Instance["_shadowMapSize"];
if (size != 0)
shadowMapWidthHeight = size;
instancingTechnique = Config.Instance["_useHardwareInstancing"] ? InstancingTechnique.HardwareInstancing : InstancingTechnique.NoInstancing;
if (EnableShadows)
{
if (dev.GraphicsProfile == GraphicsProfile.HiDef)
{
shadowRenderTarget = new RenderTarget2D(_device,
shadowMapWidthHeight,
shadowMapWidthHeight,
false,
SurfaceFormat.Single,
DepthFormat.Depth16);
}
else
{
if (!Config.Instance["_ultraLowRender"])
{
shadowRenderTarget = new RenderTarget2D(_device,
shadowMapWidthHeight,
shadowMapWidthHeight,
false,
SurfaceFormat.Color,
DepthFormat.None, 0, RenderTargetUsage.DiscardContents);
}
else
{
shadowRenderTarget = new RenderTarget2D(_device,
dev.PresentationParameters.BackBufferWidth,
dev.PresentationParameters.BackBufferHeight,
false,
SurfaceFormat.Color,
DepthFormat.None);
}
SmoothShadows = false;
}
}
arrays = new List<string>();
{//основные
arrays.Add(Shader.AnimRenderNoSM);
arrays.Add(Shader.NotAnimRenderNoSM);
arrays.Add(Shader.AnimRenderSM);
arrays.Add(Shader.NotAnimRenderSM);
}
{//шмапа
arrays.Add(Shader.CreateStaticShadowMap);
arrays.Add(Shader.CreateAnimShadowMap);
}
{//прозрачные
arrays.Add(Shader.TransparentSM);
arrays.Add(Shader.TransparentSelfIlmnNoSM);
arrays.Add(Shader.TransparentNoSM);
}
{//инстансные
//инст с шм
arrays.Add(Shader.InstancedNoSM);
arrays.Add(Shader.InstancedSM);
//инстанс прозр с шм
arrays.Add(Shader.InstancedTransparentNoSM);
arrays.Add(Shader.InstancedTransparentSM);
//инстанс прозр самосвет
arrays.Add(Shader.InstancedTransparentSelfIlmnNoSM);
}
//если хайдеф, то и сгладенная шмапа
if (dev.GraphicsProfile == GraphicsProfile.HiDef)
{
arrays.Add(Shader.AnimRenderSMSmooth);
arrays.Add(Shader.NotAnimRenderSMSmooth);
arrays.Add(Shader.TransparentSMSmooth);
arrays.Add(Shader.InstancedTransparentSMSmooth);
arrays.Add(Shader.InstancedSMSmooth);
}
foreach (string s in arrays)
ArraysPerTehnique.Add(s, new RenderArray(s));
}
public LevelContent()
{
loadedformat = forsavingformat = ElementType.LevelContent;
objectInformation = new MyContainer<ObjectElement>(100, 2);
}
public GameLevel(EngineScene __scene)
{
_scene = __scene;
_allLogicObjects = new MyContainer<BaseLogicController>();
_objectsForRemove = new MyContainer<BaseLogicController>();
}
public override void CancelAction(GameEditor Editor)
{
MyContainer<PivotObject> objects = new MyContainer<PivotObject>(operatingObject.Length, 1);
objects.AddRange(operatingObject.objects.ToArray());
Editor.AddObjects(objects, true);
}
public void Read_NoInit_Acceptable()
{
var c = new MyContainer(_store);
Assert.Equal("MyApp.NoInitTimeout", c.NoInitTimeout.Name);
}
// метод вызывается при нажатии на delete, происходит удаление объекта со сцены
public void DeleteSelectedObjects()
{
if (activeObject.Length != 0)
{
var deletingObjects = new MyContainer<PivotObject>(activeObject.Length, 1);
deletingObjects.AddRange(activeObject.objects.ToArray());
SetActiveObjects(new ObjectContainer(), true);
DeleteObjects(deletingObjects, false);
}
}
public CalculatorTests()
{
var provider = MyContainer.Initialize();
calculator = new Calculator(provider);
}
public void AddObjectToPipeline(MyContainer<PivotObject> AddedObjects)
{
foreach (PivotObject AddedObject in AddedObjects)
ArraysPerTehnique[AddedObject.HaveRenderAspect().PictureTehnique].Objects.Add(AddedObject);
foreach (PivotObject AddedObject in AddedObjects)
debugRenderArray.Add(AddedObject);
}
public void Read_ByGetProperty_SameResult()
{
var c = new MyContainer(_store);
var value = c.NoInitTimeout.Value;
}
public void TestImmediateContainer()
{
var env = new Environment();
var res = new MyContainer(env);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
var put = res.Put(1);
Assert.IsTrue(put.IsTriggered);
Assert.AreEqual(1, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
var get = res.Get(1);
Assert.IsTrue(get.IsTriggered);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
get = res.Get(1);
Assert.IsFalse(get.IsTriggered);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(1, res.GetQueueLength);
put = res.Put(1);
Assert.IsTrue(put.IsTriggered);
Assert.AreEqual(1, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(1, res.GetQueueLength);
env.Run();
Assert.IsTrue(get.IsTriggered);
Assert.AreEqual(0, res.Level);
Assert.AreEqual(0, res.PutQueueLength);
Assert.AreEqual(0, res.GetQueueLength);
}
