public void CanAddNonDisposableCasted()
{
object toAdd = new object();
var toTest = new Disposer();
toTest.AddIfDisposable(toAdd);
toTest.Dispose();
}
public void AddDisposeClosure()
{
var ran = false;
var toTest = new Disposer();
toTest.AddAsDisposable(() => { ran = true; });
toTest.Dispose();
Assert.IsTrue(ran);
}
public SynchronizedClock(IBus bus)
{
m_Bus = bus;
m_Disposer = new Disposer();
m_Bus.Subscribe<TimeUpdateMessage>(OnTimeUpdate).AddTo(m_Disposer);
m_NextSync = m_SyncRate;
}
public ClickMarker(SceneNode marker, IBus bus)
{
m_Marker = marker;
m_Bus = bus;
m_Disposer = new Disposer();
m_Bus.Subscribe<SetPathToTargetMessage>(MoveMarker).AddTo(m_Disposer);
m_Bus.Subscribe<SelectObjectAtMessage>(MoveMarker).AddTo(m_Disposer);
}
public void AddCasted()
{
var toCheck = new AssertDisposable();
object toAdd = toCheck;
var toTest = new Disposer();
toTest.AddIfDisposable(toAdd);
toTest.Dispose();
toCheck.AssertDisposed();
}
public static IDisposable Create(Func<IDictionary<string, object>, Task> app, IDictionary<string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException("app");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
var capabilities = properties.Get<IDictionary<string, object>>(OwinKeys.ServerCapabilitiesKey)
?? new Dictionary<string, object>();
var addresses = properties.Get<IList<IDictionary<string, object>>>("host.Addresses")
?? new List<IDictionary<string, object>>();
var servers = new List<INowinServer>();
var endpoints = new List<IPEndPoint>();
foreach (var address in addresses)
{
var builder = ServerBuilder.New().SetOwinApp(app);
int port;
if (!int.TryParse(address.Get<string>("port"), out port)) throw new ArgumentException("port must be number from 0 to 65535");
builder.SetPort(port);
builder.SetOwinCapabilities(capabilities);
var certificate = address.Get<X509Certificate>("certificate");
if (certificate != null)
builder.SetCertificate(certificate);
servers.Add(builder.Build());
endpoints.Add(new IPEndPoint(IPAddress.Loopback,port));
}
var disposer = new Disposer(servers.Cast<IDisposable>().ToArray());
try
{
foreach (var nowinServer in servers)
{
nowinServer.Start();
}
// This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away
foreach (var ipEndPoint in endpoints)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Connect(ipEndPoint);
socket.Close();
}
}
catch (Exception)
{
disposer.Dispose();
throw;
}
return disposer;
}
public Path(double maximumAcceleration, IMotion startingMotion, IBus bus)
{
m_Bus = bus;
m_Disposer = new Disposer();
m_Bus.Subscribe<SetPathToTarget>(OnSetPathToTarget).AddTo(m_Disposer);
m_Acceleration = maximumAcceleration;
m_Path = new List<IMotion>();
m_Path.Add(startingMotion);
}
public DeviceDescription DeserializeDescription(Uri url)
{
if (url == null) throw new ArgumentNullException ("url");
if (disposer != null) throw new InvalidOperationException (
"Deserializers can only be used to deserialize one device description once.");
disposer = new Disposer (url);
UrlBase = url;
return DeserializeDescriptionCore (url);
}
public Scene(IBus bus, SceneManager sceneManager)
{
m_Bus = bus;
m_SceneManager = sceneManager;
m_SceneNodes = new List<NodeWithPosition>();
m_Disposer = new Disposer();
m_Bus.Subscribe<PathMessage>(UpdateMotion).AddTo(m_Disposer);
m_Bus.Subscribe<SelectedObjectMessage>(OnSelected).AddTo(m_Disposer);
m_Bus.Subscribe<DeselectedObjectMessage>(OnDeselected).AddTo(m_Disposer);
}
public void SetDisposesIfShouldDispose()
{
bool disposed = false;
var disposable = new DisposableAction(() => { disposed = true; });
var disposer = new Disposer();
Assert.False(disposed);
disposer.Dispose();
disposer.Set(disposable);
Assert.True(disposed);
}
public void Dispose()
{
Disposer temp;
lock (this)
{
temp = disposer;
disposer = null;
}
if (temp != null)
temp();
}
public FieldDisplay(IBus bus,
ISelectableObjectRepository selectableRepo,
IRenderer renderer,
IPlayerId id,
ITargetedVesselRenderer _)
{
m_Bus = bus;
m_Renderer = renderer;
m_SelectableRepo = selectableRepo;
m_Id = id;
m_Disposer = new Disposer();
m_Bus.Subscribe<AddObjectMessage>(OnAdd).AddTo(m_Disposer);
}
public void EventAsDisposable()
{
var eventObject = new EventObject();
var toTest = new Disposer();
toTest.Event<Action<string>>(e => Assert.Fail("Unexpected"),
e => eventObject.AEvent += e,
e => eventObject.AEvent -= e);
toTest.Event<Action<string, string>>((f, s) => Assert.Fail("Unexpected"),
e => eventObject.OtherEvent += e,
e => eventObject.OtherEvent -= e);
toTest.Event<Action<string, string, string>>((f, s, t) => Assert.Fail("Unexpected"),
e => eventObject.ThirdEvent += e,
e => eventObject.ThirdEvent -= e);
toTest.Dispose();
eventObject.Raise();
}
public SelectableObjectRepository(IBus bus,
IPlayerId id,
IVesselRepository vesselRepository)
{
m_Bus = bus;
m_Id = id;
m_VesselRepository = vesselRepository;
m_Objects = new List< SelectableObject>();
m_Disposer = new Disposer();
m_Bus.Subscribe<SelectObjectAtMessage>(OnSelectObject).AddTo(m_Disposer);
m_Bus.Subscribe<RequestPathMessage>(OnPathRequest).AddTo(m_Disposer);
m_Bus.Subscribe<SetPathToTargetMessage>(OnSetPath).AddTo(m_Disposer);
}
public TargetedVesselRenderer(IBus bus,
ISelectableObjectRepository targets,
IRenderer renderer,
IPlayerId id,
IVesselRepository vesselRepository)
{
m_Disposer = new Disposer();
m_Bus = bus;
m_Targets = targets;
m_Renderer = renderer;
m_Id = id;
m_VesselRepository = vesselRepository;
m_Attacks = new List<Attack>();
m_Bus.Subscribe<HighlightTargetMessage>(OnHighlight).AddTo(m_Disposer);
m_Bus.Subscribe<AttackTargetMessage>(OnAttack).AddTo(m_Disposer);
m_Bus.Subscribe<SelectedObjectMessage>(OnSelection).AddTo(m_Disposer);
m_Bus.Subscribe<TimeUpdateMessage>(OnTick).AddTo(m_Disposer);
}
public InputController(string windowHandle,
Camera camera,
IBus bus,
IClock clock,
IPlayerId id)
{
m_Camera = camera;
m_Bus = bus;
m_Clock = clock;
m_PlayerId = id;
ParamList pl = new ParamList();
pl.Insert("WINDOW", windowHandle);
pl.Insert("w32_mouse", "DISCL_FOREGROUND");
pl.Insert("w32_mouse", "DISCL_NONEXCLUSIVE");
pl.Insert("w32_keyboard", "DISCL_FOREGROUND");
pl.Insert("w32_keyboard", "DISCL_NONEXCLUSIVE");
m_Disposer = new Disposer();
bus.Subscribe<ChangeInputModeMessage>(OnModeChanged).AddTo(m_Disposer);
}
protected override void Dispose(bool disposing)
{
Disposer.Dispose(ref _timer);
base.Dispose();
}
public static void Run(Options options)
{
//In order to playback video opencv_ffmpeg*.dll must be found.
string includePath = Environment.Is64BitProcess ? @".\dll\x64" : @".\dll\x86";
foreach (string file in Directory.EnumerateFiles(includePath, "*.dll"))
{
File.Copy(file, Path.GetFileName(file), true);
}
//define the upper and lower boundaries of the HSV pixel
//intensities to be considered 'skin'
var lower = new Scalar(0, 48, 80);
var upper = new Scalar(20, 255, 255);
//if a video path was not supplied, grab the reference
//to the gray
//otherwise, load the video
VideoCapture camera = string.IsNullOrEmpty(options.Video)
? VideoCapture.FromCamera(CaptureDevice.Any)
: new VideoCapture(Path.GetFullPath(options.Video));
if (!camera.IsOpened())
{
Console.WriteLine("Failed to initialize video");
return;
}
using (camera)
{
//keep looping over the frames in the video
while (true)
{
//grab the current frame
using (var frame = new Mat())
using (var disposer = new Disposer())
{
bool grabbed = camera.Read(frame);
//if we are viewing a video and we did not grab a
//frame, then we have reached the end of the video
if (!grabbed || frame.Width == 0 || frame.Height == 0)
{
if (!string.IsNullOrEmpty(options.Video))
{
break;
}
continue;
}
//resize the frame, convert it to the HSV color space,
//and determine the HSV pixel intensities that fall into
//the speicifed upper and lower boundaries
Mat resizedFrame = ImageUtil.Resize(frame, width: 400);
disposer.Add(resizedFrame);
Mat converted = resizedFrame.CvtColor(ColorConversionCodes.BGR2HSV);
disposer.Add(converted);
Mat skinMask = new Mat();
disposer.Add(skinMask);
Cv2.InRange(converted, lower, upper, skinMask);
//apply a series of erosions and dilations to the mask
//using an elliptical kernel
using (Mat kernel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(11, 11)))
{
skinMask = skinMask.Erode(kernel, iterations: 2);
disposer.Add(skinMask);
skinMask = skinMask.Dilate(kernel, iterations: 2);
disposer.Add(skinMask);
}
//blur the mask to help remove noise, then apply the
//mask to the frame
skinMask = skinMask.GaussianBlur(new Size(3, 3), 0);
disposer.Add(skinMask);
Mat skin = new Mat();
disposer.Add(skin);
Cv2.BitwiseAnd(resizedFrame, resizedFrame, skin, skinMask);
//show the skin in the image along with the mask
Cv2.ImShow("images", resizedFrame);
Cv2.ImShow("mask", skin);
//if the 'q' key is pressed, stop the loop
if ((Cv2.WaitKey(1) & 0xff) == 'q')
{
break;
}
}
}
}
Cv2.DestroyAllWindows();
}
protected virtual void DeferRestoreStateOnLevel(Disposer disposer)
{
}
public ExampleDerived()
{
// IDisposable を継承するクラスの派生クラスでは、ベースクラスの
// Dispose 実行、マネージドリソース及びアンマネージドリソースの
// 解放を行う private メソッドを用意して Disposer コンストラクタに渡す。
disposer = new Disposer(this, ReleaseBase, ReleaseManaged, ReleaseUnmanaged);
}
public SubscriptionDisposerContext(Disposer disposer, IDisposable subscription)
{
_disposer = disposer;
_supscription = subscription;
}
/****************************************************************************************************
*
****************************************************************************************************/
public Demo()
{
_disposer = new Disposer();
RenderHandle = _disposer.Add(new AutoResetEvent(false));
}
public void Dispose()
{
Disposer.Dispose(certificate);
Disposer.Close(listener);
Disposer.Dispose(accepter);
}
public static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Create main disposer
var mainDisposer = new Disposer();
//
var random = new Random(1415926535);
#region demo setup
// show setup dialog and get setup values
var title = "Mash Room by Jolt";
var setupView = new StartupView(title);
var setupModel = new SetupModel();
var presenter = new SetupPresenter(setupView, setupModel);
setupModel.TryLoadSettings();
setupModel.SelectAdapter(0);
var dialogResult = setupView.ShowDialog();
if (dialogResult != DialogResult.OK)
return;
#if DEBUG
setupModel.SaveSettings(); // todo: remove save in release mode
#endif
#endregion
// Create Device and SwapChain
var demo = new Demo().Init(setupModel, title);
var inputHandler = new InputHandler().Bind(demo);
#region audio
//
var audioDeviceType = (setupModel.UseAudio) ? AudioDeviceType.Bass : AudioDeviceType.Silent;
var audioDeviceManager = new AudioDeviceManager();
var audioDevice = mainDisposer.Add(audioDeviceManager.CreateDevice(audioDeviceType));
//
if (setupModel.UseAudio)
{
//
BassNet.Registration(
setupModel.BassRegistrationEmail ?? "",
setupModel.BassRegistrationKey ?? "");
// 140 bpm
// delay 3.428 (dvs 2 takter i 140 bpm)
var bpm = 140;
var audioName = "Mashup_v1.00.mp3";
var audioAsset = mainDisposer.Add(demo.AudioManager[audioName]);
// init and load audio
audioDevice.Init();
audioDevice.Load(audioAsset.Value);
audioDevice.PlayPosition = setupModel.StartTime;
audioDevice.Bpm = bpm;
// use the audio device as timer
demo.Timer = audioDevice;
}
#endregion
#region sync
demo.SyncManager = new SyncManager().Init(setupModel.SyncRecordMode, demo.Timer.Bpm, 4);
demo.SyncManager.TimerDevice = demo.Timer;
#endregion
#region shaders
var planeVertexShader = demo.ShaderManager["plane.vs.cso"].VertexShader;
var planePixelShader = demo.ShaderManager["plane.ps.cso"].PixelShader;
var postPixelShader = demo.ShaderManager["post.ps.cso"].PixelShader;
var postVertexShader = demo.ShaderManager["post.vs.cso"].VertexShader;
var vanillaEffect = mainDisposer.Add(new VanillaEffect(demo).Init());
var vanillaLayout = mainDisposer.Add(vanillaEffect.InputLayout.InputLayout);
#endregion
#region models
// load all models
demo.ModelManager.LoadAll();
// make all models white (todo: why)
foreach (var model in demo.ModelManager)
{
model.Color = new Color(255, 255, 255, 255);
model.ReCreateBuffer(demo.Device);
}
#endregion
#region textures
Texture2D backBuffer = null;
Texture2D depthBuffer = null;
DepthStencilView depthView = null;
// 1D texture for scanline distortion
var distortionTexture = new Texture1D(demo.Device, new Texture1DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
Usage = ResourceUsage.Default,
Width = 1080,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.None
});
var distortionData = new byte[4 * distortionTexture.Description.Width];
var distortionSRV = new ShaderResourceView(demo.Device, distortionTexture);
// foreground texture
var foregroundTexture = new Texture2D(demo.Device, new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8_UNorm,
Usage = ResourceUsage.Default,
Width = 1920,
Height = 1080,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
});
var foregroundSRV = new ShaderResourceView(demo.Device, foregroundTexture);
var foregroundData = new byte[foregroundTexture.Description.Width * foregroundTexture.Description.Height];
// noise texture
var noiseTexture = new Texture2D(demo.Device, new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8_UNorm,
Usage = ResourceUsage.Default,
Width = 1920 / 5,
Height = 1080 / 5,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
});
var noiseSRV = new ShaderResourceView(demo.Device, noiseTexture);
var noiseData = new byte[noiseTexture.Description.Width * noiseTexture.Description.Height];
#endregion
#region acts
var act0 = mainDisposer.Add(new Act0(demo).Init());
#endregion
#region effects
//var fractalCityEffect = mainDisposer.Add(new FractalCityEffect(demo).Init());
//var oceanEffect = mainDisposer.Add(new OceanEffect(demo).Init());
//var dustEffect = mainDisposer.Add(new DustEffect(demo).Init());
//var cloudEffect = mainDisposer.Add(new CloudEffect(demo).Init());
//var mandelbulbEffect = mainDisposer.Add(new MandelbulbEffect(demo).Init());
//var redPlanetEffect = mainDisposer.Add(new Effect(demo).Init(new EffectDescription
//{
// PixelShaderName = "redPlanet.ps.cso",
// TextureNames = "redPlanet0.png,redPlanet1.jpg".Split(',')
//}));
//var pseudoKleinianEffect = mainDisposer.Add(new Effect(demo).Init(new EffectDescription
//{
// PixelShaderName = "pseudoKleinian.ps.cso",
//}));
//var nonameEffect00 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname00.ps.cso", TextureNames = "tex09.jpg".Split(',') }));
//var nonameEffect01 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname01.ps.cso" }));
//var nonameEffect02 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname02.ps.cso", TextureNames = "tex09.jpg,tex07.jpg".Split(',') }));
//var nonameEffect03 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname03.ps.cso" }));
//var nonameEffect04 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname04.ps.cso", TextureNames = "noise256.png".Split(',') }));
//var nonameEffect05 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname05.ps.cso" }));
//var nonameEffect06 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname06.ps.cso" }));
//var nonameEffect07 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname07.ps.cso" }));
//var nonameEffect08 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname08.ps.cso" }));
//var nonameEffect09 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname09.ps.cso" }));
//var nonameEffect10 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname10.ps.cso" }));
#endregion
var fillStateMsaadesc = RasterizerStateDescription.Default();
fillStateMsaadesc.IsMultisampleEnabled = true;
var msaaFillState = new RasterizerState(demo.Device, fillStateMsaadesc);
var fillState = new RasterizerState(demo.Device, RasterizerStateDescription.Default());
var vanillaRenderContext = null as RenderContext;
var postRenderContext = null as RenderContext;
var planeRenderContext = null as RenderContext;
// Main loop
using (var renderDisposer = new Disposer())
{
RenderLoop.Run(demo.Form, () =>
{
if (demo.SyncManager.RowIndex == 0x000006d0)
{
demo.Form.Close();
return;
}
// TODO refactor: move the resize code
#region resize
if (demo.OutputWasResized)
{
demo.OutputWasResized = false;
renderDisposer.DisposeAll();
// dispose old swapchain
if (demo.SwapChain != null)
{
demo.SwapChain.Dispose();
}
// create new swapchain
demo.SwapChain = renderDisposer.Add(new SwapChain(setupModel.Factory, demo.Device, new SwapChainDescription
{
BufferCount = 1,
ModeDescription = setupModel.Mode,
IsWindowed = !setupModel.FullScreen,
OutputHandle = demo.Form.Handle,
//SampleDescription = new SampleDescription(setupModel.MultiSampleCount, setupModel.MultiSampleQuality),
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
}));
if (setupModel.FullScreen)
{
demo.SwapChain.SetFullscreenState(true, setupModel.Output);
}
//
var postOutputRenderTarget = new RenderTarget(demo.Device, demo.SwapChain);
// Get the backbuffer from the swapchain
backBuffer = renderDisposer.Add(demo.SwapChain.GetBackBuffer<Texture2D>(0));
// Setup targets and viewport for rendering
var postInputRenderTarget = new RenderTarget(
device: demo.Device,
width: setupModel.Mode.Width / 1, // todo: introduce a scalefactor
height: setupModel.Mode.Height / 1, // todo: introduce a scalefactor
sampleCount: 1, // todo: use setupModel.MultiSampleCount,
sampleQuality: 0, // todo: use setupModel.MultiSampleQuality,
format: Format.R8G8B8A8_UNorm // todo: use setupModel.Format
);
// Create the depth buffer
depthBuffer = renderDisposer.Add(new Texture2D(demo.Device, new Texture2DDescription
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = postInputRenderTarget.Width,
Height = postInputRenderTarget.Height,
SampleDescription = postInputRenderTarget.Texture.Description.SampleDescription,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
}));
// Create the depth buffer view
depthView = renderDisposer.Add(new DepthStencilView(demo.Device, depthBuffer));
vanillaRenderContext = renderDisposer.Add(new RenderContext
{
PrimitiveTopology = PrimitiveTopology.TriangleList,
InputLayout = vanillaLayout,
VertexShader = null,
PixelShader = null,
RasterizerState = msaaFillState,
DepthStencilView = depthView,
RenderTarget = postInputRenderTarget,
});
postRenderContext = renderDisposer.Add(new RenderContext
{
PrimitiveTopology = PrimitiveTopology.TriangleList,
InputLayout = vanillaLayout,
VertexShader = postVertexShader,
PixelShader = postPixelShader,
RasterizerState = fillState,
DepthStencilView = null,
RenderTarget = postOutputRenderTarget,
});
planeRenderContext = new RenderContext
{
PrimitiveTopology = PrimitiveTopology.TriangleList,
InputLayout = vanillaLayout,
VertexShader = planeVertexShader,
PixelShader = planePixelShader,
RasterizerState = fillState,
DepthStencilView = null,
RenderTarget = postOutputRenderTarget,
};
// todo: remove this hack
if (!setupModel.SyncRecordMode)
{
demo.Timer.StartPlaying();
}
if (setupModel.FullScreen)
{
Cursor.Hide();
}
}
#endregion
// todo: remove
demo.SyncManager.Update(demo.Timer.Time);
var syncRow = new
{
demo.SyncManager.Data.Part,
demo.SyncManager.Data.Lead,
};
// Present!
// a crash here is quite common when VertexShader or PixelShader is null
demo.SwapChain.Present(setupModel.UseVerticalSync ? 1 : 0, PresentFlags.None);
// horizontal distortion and color separation
random.NextBytes(distortionData);
demo.DeviceContext.UpdateSubresource(distortionData, distortionTexture);
// static noise
random.NextBytes(noiseData);
demo.DeviceContext.UpdateSubresource(noiseData, noiseTexture, 0, noiseTexture.Description.Width);
// setup for normal rendering
{
// use normal rendering
demo.DeviceContext.PixelShader.SetShaderResource(0, null);
demo.RenderContext = vanillaRenderContext;
// clear
demo.DeviceContext.ClearDepthStencilView(demo.RenderContext.DepthStencilView, DepthStencilClearFlags.Depth, 1.0f, 0);
demo.DeviceContext.ClearRenderTargetView(demo.RenderContext.RenderTarget.RenderTargetView, Color.Black);
}
// render act
act0.Render();
//
demo.DeviceContext.ClearRenderTargetView(postRenderContext.RenderTarget.RenderTargetView, Color.Black);
// render plane to screen
if (true)
{
// TODO is this really needed ?
demo.DeviceContext.OutputMerger.ResetTargets();
demo.DeviceContext.VertexShader.SetConstantBuffer(0, null);
// use post rendering
demo.RenderContext = postRenderContext;
// set textures
demo.DeviceContext.PixelShader.SetShaderResource(0, vanillaRenderContext.RenderTarget.ShaderResourceView);
demo.DeviceContext.PixelShader.SetShaderResource(1, distortionSRV);
demo.DeviceContext.PixelShader.SetShaderResource(2, noiseSRV);
// use plane model
var model = demo.ModelManager["plane2"];
// todo: make sure we have no z-buffer conflicts (might be hw dependent)
var camera = new NoCamera();
demo.Draw(model, camera);
}
});
}
// dispose
Disposer.Dispose(ref mainDisposer);
}
/****************************************************************************************************
*
****************************************************************************************************/
private RenderTarget()
{
_disposer = new Disposer();
}
protected virtual void DeferRestoreStateOnLevel( Disposer disposer )
{
}
public DelegateDisposable(Disposer disposer)
{
this.disposer = disposer;
}
public void Init()
{
displays = new List<Display>();
disposer = new Disposer();
int numberOfAdapters = 0;
Adl.AdlMainControlCreate(Adl.AdlMainMemoryAlloc, 1);
if (Adl.AdlAdapterNumberOfAdaptersGet != null)
{
Adl.AdlAdapterNumberOfAdaptersGet(ref numberOfAdapters);
}
Adl.AdlMainControlCreate(Adl.AdlMainMemoryAlloc, 1);
if (numberOfAdapters > 0)
{
AdlAdapterInfoArray osAdapterInfoData = new AdlAdapterInfoArray();
if (Adl.AdlAdapterAdapterInfoGet != null)
{
int size = Marshal.SizeOf(osAdapterInfoData);
IntPtr adapterBuffer = Marshal.AllocCoTaskMem(size);
Marshal.StructureToPtr(osAdapterInfoData, adapterBuffer, false);
int adlRet = Adl.AdlAdapterAdapterInfoGet(adapterBuffer, size);
if (adlRet == Adl.AdlSuccess)
{
osAdapterInfoData = (AdlAdapterInfoArray)Marshal.PtrToStructure(adapterBuffer, osAdapterInfoData.GetType());
int isActive = 0;
for (int i = 0; i < numberOfAdapters; i++)
{
AdlAdapterInfo adlAdapterInfo = osAdapterInfoData.ADLAdapterInfo[i];
int adapterIndex = adlAdapterInfo.AdapterIndex;
if (Adl.AdlAdapterActiveGet != null)
{
adlRet = Adl.AdlAdapterActiveGet(adlAdapterInfo.AdapterIndex, ref isActive);
}
if (Adl.AdlSuccess == adlRet)
{
AdlDisplayInfo oneDisplayInfo = new AdlDisplayInfo();
if (Adl.AdlDisplayDisplayInfoGet != null)
{
IntPtr displayBuffer = IntPtr.Zero;
int numberOfDisplays = 0;
adlRet = Adl.AdlDisplayDisplayInfoGet(adlAdapterInfo.AdapterIndex, ref numberOfDisplays, out displayBuffer, 1);
if (Adl.AdlSuccess == adlRet)
{
List<AdlDisplayInfo> displayInfoData = new List<AdlDisplayInfo>();
for (int j = 0; j < numberOfDisplays; j++)
{
oneDisplayInfo = (AdlDisplayInfo)Marshal.PtrToStructure(new IntPtr(displayBuffer.ToInt64() + j * Marshal.SizeOf(oneDisplayInfo)), oneDisplayInfo.GetType());
displayInfoData.Add(oneDisplayInfo);
}
for (int j = 0; j < numberOfDisplays; j++)
{
AdlDisplayInfo adlDisplayInfo = displayInfoData[j];
if (adlDisplayInfo.DisplayID.DisplayLogicalAdapterIndex == -1)
{
continue;
}
displays.Add(new Display
{
DisplayInfo = adlDisplayInfo,
AdapterInfo = adlAdapterInfo,
Index = adapterIndex,
});
}
}
disposer.DisplayBufferList.Add(displayBuffer);
}
}
}
}
disposer.AdapterBuffer = adapterBuffer;
}
}
}
public void Dispose()
{
CurrentProcess = Disposer.Null(CurrentProcess);
}
public void Deinitialize()
{
Disposer.RemoveAndDispose(ref _effect);
Disposer.RemoveAndDispose(ref _inputLayout);
}
static void Main(string[] args)
{
ProgramTools.Setup();
var config = new Config();
//args will always log to stderr because trace flag not loaded yet
ExecutableTools.LogArgs(new StderrWriteLine(), args, (arg) =>
{
ConfigTools.SetProperty(config, arg);
});
AssertTools.NotEmpty(config.EndPoint, "Missing EndPoint");
AssertTools.NotEmpty(config.Root, "Missing Root");
if (!config.Daemon)
{
Logger.TRACE = new StderrWriteLine();
}
var uri = string.Format("http://{0}/", config.EndPoint);
var http = new HttpListener();
http.Prefixes.Add(uri);
http.Start();
var accepter = new Runner(new Runner.Args {
ThreadName = "Accepter"
});
var handler = new Runner(new Runner.Args {
ThreadName = "Handler"
});
accepter.Run(() =>
{
while (http.IsListening)
{
var ctx = http.GetContext();
handler.Run(() =>
{
var request = ctx.Request;
var response = ctx.Response;
var pass = true;
var file = ctx.Request.RawUrl.Substring(1); //remove leading /
if (!PathTools.IsChildPath(config.Root, file))
{
pass = false;
}
var path = PathTools.Combine(config.Root, file);
Logger.Trace("File {0} {1}", file, path);
if (!File.Exists(path))
{
pass = false;
}
if (ctx.Request.HttpMethod != "GET")
{
pass = false;
}
if (pass)
{
var fi = new FileInfo(path);
var fs = new FileStream(path, FileMode.Open, FileAccess.Read);
ctx.Response.StatusCode = (int)HttpStatusCode.OK;
ctx.Response.ContentLength64 = fi.Length;
ctx.Response.ContentType = "application/octet-stream";
var data = new byte[1024];
var count = fs.Read(data, 0, data.Length);
while (count > 0)
{
ctx.Response.OutputStream.Write(data, 0, count);
count = fs.Read(data, 0, data.Length);
}
}
else
{
ctx.Response.StatusCode = (int)HttpStatusCode.NotFound;
ctx.Response.ContentLength64 = 0;
}
ctx.Response.Close();
});
}
});
Stdio.SetStatus("Listeninig on {0}", uri);
using (var disposer = new Disposer())
{
disposer.Push(handler);
disposer.Push(accepter);
disposer.Push(http.Stop);
var line = Stdio.ReadLine();
while (line != null)
{
line = Stdio.ReadLine();
}
}
Logger.Trace("Stdin closed");
Environment.Exit(0);
}
public void Dispose()
{
Disposer.TryDisposeAll(Adapter, Device, OutputDuplication, Texture2D);
GC.SuppressFinalize(this);
}
private void CreateAndBindTargets()
{
this.D3DSurface.SetRenderTargetDX10(null);
Disposer.RemoveAndDispose(ref this.RenderTargetView);
Disposer.RemoveAndDispose(ref this.RenderTarget1View);
Disposer.RemoveAndDispose(ref this.RenderTarget2View);
Disposer.RemoveAndDispose(ref this.OutputRenderTargetView);
Disposer.RemoveAndDispose(ref this.DepthStencilView);
Disposer.RemoveAndDispose(ref this.BlendingState);
Disposer.RemoveAndDispose(ref this.OutputRenderTarget);
Disposer.RemoveAndDispose(ref this.RenderTarget);
Disposer.RemoveAndDispose(ref this.RenderTarget1);
Disposer.RemoveAndDispose(ref this.RenderTarget2);
Disposer.RemoveAndDispose(ref this.ShaderTargetView);
Disposer.RemoveAndDispose(ref this.ShaderTarget1View);
Disposer.RemoveAndDispose(ref this.ShaderTarget2View);
Disposer.RemoveAndDispose(ref this.DepthStencil);
width = Math.Max((int)base.ActualWidth, 100);
height = Math.Max((int)base.ActualHeight, 100);
SampleDescription quality = new SampleDescription(1, 0);
Texture2DDescription colordesc = new Texture2DDescription
{
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
Format = Format.B8G8R8A8_UNorm,
Width = (int)width,
Height = (int)height,
MipLevels = 1,
SampleDescription = quality,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.Shared,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
};
Texture2DDescription depthdesc = new Texture2DDescription
{
BindFlags = BindFlags.DepthStencil,
Format = Format.D32_Float_S8X24_UInt,
Width = (int)width,
Height = (int)height,
MipLevels = 1,
SampleDescription = quality,
Usage = ResourceUsage.Default,
OptionFlags = ResourceOptionFlags.None,
CpuAccessFlags = CpuAccessFlags.None,
ArraySize = 1
};
this.RenderTarget = new Texture2D(this.Device, colordesc);
this.OutputRenderTarget = new Texture2D(this.Device, colordesc);
this.DepthStencil = new Texture2D(this.Device, depthdesc);
RenderTarget1 = new Texture2D(this.Device, new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.B8G8R8A8_UNorm,
Width = (int)width / 2,
Height = (int)height / 2,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.Shared,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
});
RenderTarget2 = new Texture2D(this.Device, new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.B8G8R8A8_UNorm,
Width = (int)width / 2,
Height = (int)height / 2,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.Shared,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default
});
BlendStateDescription stateDesc = new BlendStateDescription
{
SourceBlend = BlendOption.One,
DestinationBlend = BlendOption.One,
BlendOperation = BlendOperation.Add,
SourceAlphaBlend = BlendOption.One,
DestinationAlphaBlend = BlendOption.One,
AlphaBlendOperation = BlendOperation.Add
};
stateDesc.IsBlendEnabled[0] = true;
stateDesc.RenderTargetWriteMask[0] = ColorWriteMaskFlags.All;
stateDesc.IsAlphaToCoverageEnabled = false;
BlendingState = new BlendState(Device, ref stateDesc);
this.DepthStencilView = new DepthStencilView(this.Device, this.DepthStencil);
this.RenderTargetView = new RenderTargetView(this.Device, this.RenderTarget);
this.RenderTarget1View = new RenderTargetView(this.Device, this.RenderTarget1);
this.RenderTarget2View = new RenderTargetView(this.Device, this.RenderTarget2);
this.OutputRenderTargetView = new RenderTargetView(this.Device, this.OutputRenderTarget);
this.ShaderTargetView = new ShaderResourceView(this.Device, this.RenderTarget);
this.ShaderTarget1View = new ShaderResourceView(this.Device, this.RenderTarget1);
this.ShaderTarget2View = new ShaderResourceView(this.Device, this.RenderTarget2);
try
{
this.D3DSurface.SetRenderTargetDX10(this.OutputRenderTarget);
}
catch
{ }
}
public void Dispose()
{
Disposer.Dispose(serial);
Disposer.Dispose(reader);
}
protected static void DeferRestoreStateOnLevel( Disposer disposer, DataGridContext dataGridContext )
{
ToggleColumnSortCommand.ThrowIfNull( disposer, "disposer" );
ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
var parentDataGridContext = dataGridContext.ParentDataGridContext;
// Defer the RestoreState of each DataGridContext of the same level
// to ensure all the DataGridContext will be correctly restored once
// all of them are completely resorted
if( parentDataGridContext != null )
{
foreach( var childContext in parentDataGridContext.GetChildContexts() )
{
disposer.Add( childContext.DeferRestoreState(), DisposableType.DeferRestoreState );
}
}
}
public DisposerEditViewModel(Disposer disposer, IWasteRepository repository, IContainerViewModelFactory containerViewModelFactory, Action removeDisposerAction)
: base(disposer, repository, containerViewModelFactory)
{
DisplayName = TranslationProvider.Translate("TitleDisposerEditViewModel");
m_RemoveDisposer = removeDisposerAction;
}
public ExampleBase()
{
// IDisposable を直接継承するクラスでは、マネージドリソース及び
// アンマネージドリソースの解放を行う private メソッドを用意して
// Disposer コンストラクタに渡す。
disposer = new Disposer(this, ReleaseManaged, ReleaseUnmanaged);
}
/// <summary>
/// Must release swapchain at last after all its created resources have been released.
/// </summary>
public override void DisposeAndClear()
{
base.DisposeAndClear();
Disposer.RemoveAndDispose(ref swapChain);
}
public DelegateDisposable(Disposer disposer)
{
this.disposer = disposer;
}
public static IDisposable Create(Func <IDictionary <string, object>, Task> app, IDictionary <string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException("app");
}
if (properties == null)
{
throw new ArgumentNullException("properties");
}
var capabilities = properties.Get <IDictionary <string, object> >(OwinKeys.ServerCapabilitiesKey)
?? new Dictionary <string, object>();
var addresses = properties.Get <IList <IDictionary <string, object> > >("host.Addresses")
?? new List <IDictionary <string, object> >();
var servers = new List <INowinServer>();
var endpoints = new List <IPEndPoint>();
foreach (var address in addresses)
{
var builder = ServerBuilder.New().SetOwinApp(app);
int port;
if (!int.TryParse(address.Get <string>("port"), out port))
{
throw new ArgumentException("port must be number from 0 to 65535");
}
builder.SetPort(port);
builder.SetOwinCapabilities(capabilities);
var certificate = address.Get <X509Certificate>("certificate");
if (certificate != null)
{
builder.SetCertificate(certificate);
}
servers.Add(builder.Build());
endpoints.Add(new IPEndPoint(IPAddress.Loopback, port));
}
var disposer = new Disposer(servers.Cast <IDisposable>().ToArray());
try
{
foreach (var nowinServer in servers)
{
nowinServer.Start();
}
// This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away
foreach (var ipEndPoint in endpoints)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Connect(ipEndPoint);
socket.Close();
}
}
catch (Exception)
{
disposer.Dispose();
throw;
}
return(disposer);
}
private bool ToggleColumnSort(ColumnBase column, bool resetSort)
{
ToggleColumnSortCommand.ThrowIfNull(column, "column");
this.ValidateToggleColumnSort();
using (var synchronizationContext = this.StartSynchronizing(this.GetSortDescriptionsSyncContext()))
{
this.ValidateSynchronizationContext(synchronizationContext);
using (var disposer = new Disposer())
{
this.DeferRestoreStateOnLevel(disposer);
// This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once!
var sortDescriptions = this.SortDescriptions;
disposer.Add(this.DeferResortHelper(sortDescriptions), DisposableType.DeferResort);
var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection(column.SortDirection);
string columnName = column.FieldName;
int insertionIndex;
if ((resetSort) &&
((column.SortIndex == -1) || (sortDescriptions.Count > 1)))
{
insertionIndex = 0;
if (sortDescriptions.Count > 0)
{
sortDescriptions.Clear();
}
Debug.Assert(sortDescriptions.Count == 0);
}
else
{
for (insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++)
{
if (sortDescriptions[insertionIndex].PropertyName == columnName)
{
break;
}
}
}
if (insertionIndex < sortDescriptions.Count)
{
if (newSortDirection == SortDirection.None)
{
sortDescriptions.RemoveAt(insertionIndex);
}
else
{
sortDescriptions[insertionIndex] = new SortDescription(columnName, ToggleColumnSortCommand.Convert(newSortDirection));
}
}
else if (newSortDirection != SortDirection.None)
{
sortDescriptions.Add(new SortDescription(columnName, ToggleColumnSortCommand.Convert(newSortDirection)));
}
}
}
return(true);
}
public ActionResult Timer(long? timestamp)
{
string title = null;
try
{
byte[] output = null;
using (MemoryStream stream = new MemoryStream())
{
int repeatCount = 0; //repeat forever
DateTime end = Epoch.AddSeconds(timestamp ?? 0);
title = end.ToString();
TimeSpan remaining = end - DateTime.UtcNow;
if (remaining.TotalSeconds < 0)
{
remaining = TimeSpan.FromSeconds(0);
}
if (remaining.TotalSeconds <= 60)
{
repeatCount = -1; //don't repeat
}
using (Image background = Image.FromFile(Server.MapPath(BackgroundPath)))
{
using (Font font = new Font(FontName, FontSize, FontBold ? FontStyle.Bold : FontStyle.Regular, GraphicsUnit.Pixel))
{
using (var disposer = new Disposer())
{
var target = new SynchronizeInvokeStub();
AnimatedGifEncoder encoder = new AnimatedGifEncoder(target);
encoder.RepeatCount = repeatCount;
encoder.OutputStream = stream;
encoder.QuantizerType = GifComponents.Quantizing.QuantizerType.Octree;
{
int count = 0;
while (remaining.TotalSeconds >= 0 && count < 60)
{
Bitmap bitmap = disposer.Track(new Bitmap(background));
using (Graphics g = Graphics.FromImage(bitmap))
{
StringFormat format = new StringFormat();
format.Alignment = StringAlignment.Center;
format.LineAlignment = StringAlignment.Center;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
string days, hours, minutes, seconds;
if (remaining.Days > 99)
{
days = "--";
hours = "--";
minutes = "--";
seconds = "--";
count = 99; //causes the loop to end after this one
}
else
{
days = remaining.Days.ToString("00");
hours = remaining.Hours.ToString("00");
minutes = remaining.Minutes.ToString("00");
seconds = remaining.Seconds.ToString("00");
}
g.DrawString(days, font, Brushes.White, new RectangleF(ImageX, ImageY, ImageWidth / 4, ImageHeight), format);
g.DrawString(hours, font, Brushes.White, new RectangleF(ImageX + (ImageWidth / 4), ImageY, ImageWidth / 4, ImageHeight), format);
g.DrawString(minutes, font, Brushes.White, new RectangleF(ImageX + (2 * ImageWidth / 4), ImageY, ImageWidth / 4, ImageHeight), format);
g.DrawString(seconds, font, Brushes.White, new RectangleF(ImageX + (3 * ImageWidth / 4), ImageY, ImageWidth / 4, ImageHeight), format);
g.DrawString(":", font, Brushes.White, new RectangleF(ImageX + (ImageWidth / 4) - ImageWidth / 8, ImageY, ImageWidth / 4, ImageHeight), format);
g.DrawString(":", font, Brushes.White, new RectangleF(ImageX + (2 * ImageWidth / 4) - ImageWidth / 8, ImageY, ImageWidth / 4, ImageHeight), format);
g.DrawString(":", font, Brushes.White, new RectangleF(ImageX + (3 * ImageWidth / 4) - ImageWidth / 8, ImageY, ImageWidth / 4, ImageHeight), format);
}
var frame = new GifFrame(bitmap);
frame.Delay = 100;
encoder.AddFrame(frame);
count++;
remaining = remaining.Subtract(OneSecond);
}
}
encoder.Start();
encoder.WaitUntilDone();
}
}
}
output = stream.ToArray();
}
return new FileContentResult(output, "image/gif");
}
catch
{
return new FilePathResult(Server.MapPath(BackgroundPath), "image/gif");
}
finally
{
Clicky.TrackRequest(Request, ActionType.PageView, "Timer: " + title);
}
}
public void Dispose()
{
Disposer.RemoveAndDispose(ref _model);
}
private IDisposable DeferResortHelper( DetailConfiguration detailConfiguration )
{
ColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
IDisposable defer;
if( this.TryDeferResort( detailConfiguration, out defer ) )
return defer;
var disposer = new Disposer();
foreach( var dataGridContext in DetailConfigurationUpdateColumnSortCommand.GetDataGridContexts( detailConfiguration ) )
{
disposer.Add( this.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items ), DisposableType.DeferResort );
}
return disposer;
}
//[/LockPositions]
public SimWindow() : base(800, 600, GraphicsMode.Default, "Gravitational n-body simulation")
{
_numBodies = 256*64;
const float clusterScale = 1.0f;
const float velocityScale = 1.0f;
_deltaTime = 0.001f;
_softeningSquared = 0.00125f;
_damping = 0.9995f;
//[CreateWorker]
_worker = Worker.CreateByFunc(Generate);
//[/CreateWorker]
_stopwatch = Stopwatch.StartNew();
_fpsCalcLag = 128;
_frameCounter = 0;
//[CreateSimulatros]
_simulators = new Queue<ISimulator>();
var target = GPUModuleTarget.Worker(_worker);
var simulatorGpuDynamicBlockSizeModule = new GpuDynamicSimulatorModule(target); // need dispose
var simulatorGpuDynamicBlockSize64 = simulatorGpuDynamicBlockSizeModule.Create(64);
var simulatorGpuDynamicBlockSize128 = simulatorGpuDynamicBlockSizeModule.Create(128);
var simulatorGpuDynamicBlockSize256 = simulatorGpuDynamicBlockSizeModule.Create(256);
var simulatorGpuDynamicBlockSize512 = simulatorGpuDynamicBlockSizeModule.Create(512);
var simulatorGpuStaticBlockSizeModule64 = new GpuStaticSimulatorModule64(target); // need dispose
var simulatorGpuStaticBlockSizeModule128 = new GpuStaticSimulatorModule128(target); // need dispose
var simulatorGpuStaticBlockSizeModule256 = new GpuStaticSimulatorModule256(target); // need dispose
var simulatorGpuStaticBlockSizeModule512 = new GpuStaticSimulatorModule512(target); // need dispose
// First, enquene one simulator which is 256 blocksize so we can compare with C code for performance.
_simulators.Enqueue(simulatorGpuStaticBlockSizeModule256);
// Enqueue several dynamic block size simulators.
_simulators.Enqueue(simulatorGpuDynamicBlockSize64);
_simulators.Enqueue(simulatorGpuDynamicBlockSize128);
_simulators.Enqueue(simulatorGpuDynamicBlockSize256);
_simulators.Enqueue(simulatorGpuDynamicBlockSize512);
// Enqueue several static block size simulators.
_simulators.Enqueue(simulatorGpuStaticBlockSizeModule64);
_simulators.Enqueue(simulatorGpuStaticBlockSizeModule128);
_simulators.Enqueue(simulatorGpuStaticBlockSizeModule256);
_simulators.Enqueue(simulatorGpuStaticBlockSizeModule512);
// We do not enqueue any cpu simulator as it is much too slow.
//_simulators.Enqueue(new CpuSimulator(_worker, _numBodies));
_disposeSimulators = () =>
{
simulatorGpuDynamicBlockSizeModule.Dispose();
simulatorGpuStaticBlockSizeModule64.Dispose();
simulatorGpuStaticBlockSizeModule128.Dispose();
simulatorGpuStaticBlockSizeModule256.Dispose();
simulatorGpuStaticBlockSizeModule512.Dispose();
};
_simulator = _simulators.Dequeue();
//[/CreateSimulatros]
//[CreateBuffers]
_buffers = new uint[2];
for (var i = 0; i < _buffers.Length; i++)
{
_buffers[i] = 0;
}
GL.GenBuffers(_buffers.Length, _buffers);
foreach (var buffer in _buffers)
{
GL.BindBuffer(BufferTarget.ArrayBuffer, buffer);
GL.BufferData(BufferTarget.ArrayBuffer,
(IntPtr) (Microsoft.FSharp.Core.Operators.SizeOf<float4>()*_numBodies),
IntPtr.Zero, BufferUsageHint.DynamicDraw);
var size = 0;
unsafe
{
GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, &size);
}
if (size != Microsoft.FSharp.Core.Operators.SizeOf<float4>()*_numBodies)
{
throw new Exception("Pixel Buffer Object allocation failed!");
}
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
CUDAInterop.cuSafeCall(CUDAInterop.cuGLRegisterBufferObject(buffer));
}
_resources = new IntPtr[_buffers.Length];
for (var i = 0; i < _buffers.Length; i++)
{
var res = IntPtr.Zero;
unsafe
{
CUDAInterop.cuSafeCall(CUDAInterop.cuGraphicsGLRegisterBuffer(&res, _buffers[i], 0u));
}
_resources[i] = res;
}
//[/CreateBuffers]
//[FinalizeGL]
_vel = _worker.Malloc<float4>(_numBodies);
float4[] hpos, hvel;
BodyInitializer.Initialize(new BodyInitializer3(), clusterScale, velocityScale, _numBodies,
out hpos, out hvel);
_worker.Scatter(hvel, _vel.Ptr, Microsoft.FSharp.Core.FSharpOption<int>.None,
Microsoft.FSharp.Core.FSharpOption<int>.None);
LockPos(
(pos0, pos1) =>
_worker.Scatter(hpos, pos1, Microsoft.FSharp.Core.FSharpOption<int>.None,
Microsoft.FSharp.Core.FSharpOption<int>.None));
Help();
Description();
//[/FinalizeGL]
}
protected RaceChecker()
{
lockObject = new object();
lockRelease = new Disposer(lockObject);
}
static void Main(string[] args)
{
ProgramTools.Setup();
var config = new Config();
config.IP = "0.0.0.0";
config.Port = 22333;
config.Delay = 5000;
config.Timeout = 5000;
config.Root = ExecutableTools.Relative("Root");
//args will always log to stderr because daemon flag not loaded yet
ExecutableTools.LogArgs(new StderrWriteLine(), args, (arg) =>
{
ConfigTools.SetProperty(config, arg);
});
AssertTools.NotEmpty(config.Root, "Missing Root path");
AssertTools.NotEmpty(config.IP, "Missing IP");
AssertTools.Ip(config.IP, "Invalid IP");
var pid = Process.GetCurrentProcess().Id;
var writers = new WriteLineCollection();
if (!config.Daemon)
{
writers.Add(new StderrWriteLine());
Logger.TRACE = new TimedWriter(writers);
}
Logger.Trace("Root {0}", config.Root);
var dbpath = Path.Combine(config.Root, "SharpDaemon.LiteDb");
var logpath = Path.Combine(config.Root, "SharpDaemon.Log.txt");
var eppath = Path.Combine(config.Root, "SharpDaemon.Endpoint.txt");
var downloads = Path.Combine(config.Root, "Downloads");
Directory.CreateDirectory(downloads); //creates root as well
//acts like mutex for the workspace
var log = new StreamWriter(logpath, true);
writers.Add(new TextWriterWriteLine(log));
ExecutableTools.LogArgs(new TextWriterWriteLine(log), args);
var instance = new Instance(new Instance.Args
{
DbPath = dbpath,
RestartDelay = config.Delay,
Downloads = downloads,
EndPoint = new IPEndPoint(IPAddress.Parse(config.IP), config.Port),
});
Stdio.SetStatus("Listening on {0}", instance.EndPoint);
using (var disposer = new Disposer())
{
//wrap to add to disposable count
disposer.Push(new Disposable.Wrapper(log));
disposer.Push(instance);
disposer.Push(() => Disposing(config.Timeout));
if (config.Daemon)
{
Logger.Trace("Stdin loop...");
var line = Stdio.ReadLine();
while (line != null)
{
Logger.Trace("> {0}", line);
if ("exit!" == line)
{
break;
}
line = Stdio.ReadLine();
}
Logger.Trace("Stdin closed");
}
else
{
Logger.Trace("Stdin loop...");
var shell = instance.CreateShell();
var stream = new ShellStream(new StdoutWriteLine(), new ConsoleReadLine());
//disposer.Push(stream); //stdin.readline wont return even after close/dispose call
var line = stream.ReadLine();
while (line != null)
{
if ("exit!" == line)
{
break;
}
Shell.ParseAndExecute(shell, stream, line);
line = stream.ReadLine();
}
Logger.Trace("Stdin closed");
}
}
Environment.Exit(0);
}
/****************************************************************************************************
*
****************************************************************************************************/
public Effect(Demo demo)
{
_demo = demo;
_disposer = new Disposer();
}
protected override void OnDispose()
{
Disposer.Dispose(ref _particleRenderer);
base.OnDispose();
}
/// <summary>
///
/// </summary>
public virtual void Dispose()
{
Disposer.RemoveAndDispose(ref _mContext);
}
private void IoDispose()
{
Disposer.Dispose(master);
}
public void Dispose()
{
Disposer.Dispose(_shader);
}
public override void Render(RenderContext context, DeviceContextProxy deviceContext)
{
if (!enableReflector)
{
return;
}
if (CreateCubeMapResources())
{
RaiseInvalidateRender();
return; // Skip this frame if texture resized to reduce latency.
}
else if(!(IsDynamicScene || context.UpdateSceneGraphRequested || context.UpdatePerFrameRenderableRequested))
{
return;
}
context.IsInvertCullMode = true;
var camLook = Vector3.Normalize(context.Camera.LookDirection);
Exception exception = null;
#if TEST
for (int index = 0; index < 6; ++index)
#else
Parallel.For(0, 6, (index) =>
#endif
{
try
{
var ctx = contextPool.Get();
ctx.ClearRenderTargetView(cubeRTVs[index], context.RenderHost.ClearColor);
ctx.ClearDepthStencilView(cubeDSVs[index], DepthStencilClearFlags.Depth, 1, 0);
ctx.SetRenderTarget(cubeDSVs[index], cubeRTVs[index]);
ctx.SetViewport(ref viewport);
ctx.SetScissorRectangle(0, 0, FaceSize, FaceSize);
var transforms = new GlobalTransformStruct();
transforms.Projection = cubeFaceCameras.Cameras[index].Projection;
transforms.View = cubeFaceCameras.Cameras[index].View;
transforms.Viewport = new Vector4(FaceSize, FaceSize, 1/FaceSize, 1/FaceSize);
transforms.ViewProjection = transforms.View * transforms.Projection;
modelCB.Upload(ctx, ref transforms);
var frustum = new BoundingFrustum(transforms.ViewProjection);
//Render opaque
for (int i = 0; i < context.RenderHost.PerFrameOpaqueNodes.Count; ++i)
{
var node = context.RenderHost.PerFrameOpaqueNodes[i];
if (node.GUID != this.GUID && !IgnoredGuid.Contains(node.GUID) && node.TestViewFrustum(ref frustum))
{
node.Render(context, ctx);
}
}
//Render particle
for (int i = 0; i < context.RenderHost.PerFrameParticleNodes.Count; ++i)
{
var node = context.RenderHost.PerFrameParticleNodes[i];
if (node.GUID != this.GUID && !IgnoredGuid.Contains(node.GUID) && node.TestViewFrustum(ref frustum))
{
node.Render(context, ctx);
}
}
commands[index] = ctx.FinishCommandList(true);
contextPool.Put(ctx);
}
catch(Exception ex)
{
exception = ex;
}
}
#if !TEST
);
#endif
context.IsInvertCullMode = false;
if (exception != null)
{
throw exception;
}
for (int i = 0; i < commands.Length; ++i)
{
if (commands[i] != null)
{
Device.ImmediateContext.ExecuteCommandList(commands[i], true);
Disposer.RemoveAndDispose(ref commands[i]);
}
}
deviceContext.GenerateMips(CubeMap);
context.UpdatePerFrameData(true, false, deviceContext);
}
private void OpenConnection(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action <Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var callbackInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
var url = (reconnecting ? connection.Url : connection.Url + "connect") + GetReceiveQueryString(connection, data);
connection.Trace(TraceLevels.Events, "SSE: GET {0}", url);
HttpClient.Get(url, req =>
{
_request = req;
connection.PrepareRequest(_request);
_request.Accept = "text/event-stream";
}).ContinueWith(task =>
{
if (task.IsFaulted)
{
Exception exception = task.Exception.Unwrap();
if (!ExceptionHelper.IsRequestAborted(exception))
{
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception);
}
else if (reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
Reconnect(connection, data, disconnectToken);
}
}
requestDisposer.Dispose();
}
else
{
var response = task.Result;
Stream stream = response.GetStream();
var eventSource = new EventSourceStreamReader(connection, stream);
bool retry = true;
var esCancellationRegistration = disconnectToken.SafeRegister(state =>
{
retry = false;
((IRequest)state).Abort();
},
_request);
eventSource.Opened = () =>
{
// If we're not reconnecting, then we're starting the transport for the first time. Trigger callback only on first start.
if (!reconnecting)
{
callbackInvoker.Invoke(initializeCallback);
}
else if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
};
eventSource.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data)
{
if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase))
{
return;
}
bool timedOut;
bool disconnected;
TransportHelper.ProcessResponse(connection, sseEvent.Data, out timedOut, out disconnected);
if (disconnected)
{
retry = false;
connection.Disconnect();
}
}
};
eventSource.Closed = exception =>
{
if (exception != null)
{
// Check if the request is aborted
bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception);
if (!isRequestAborted)
{
// Don't raise exceptions if the request was aborted (connection was stopped).
connection.OnError(exception);
}
}
requestDisposer.Dispose();
esCancellationRegistration.Dispose();
response.Dispose();
if (AbortResetEvent != null)
{
AbortResetEvent.Set();
}
else if (retry)
{
Reconnect(connection, data, disconnectToken);
}
};
eventSource.Start();
}
});
var requestCancellationRegistration = disconnectToken.SafeRegister(state =>
{
if (state != null)
{
// This will no-op if the request is already finished.
((IRequest)state).Abort();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, token) =>
{
#if NET35 || WINDOWS_PHONE
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled));
#else
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token));
#endif
}, errorCallback, disconnectToken);
}
}, _request);
requestDisposer.Set(requestCancellationRegistration);
if (errorCallback != null)
{
TaskAsyncHelper.Delay(ConnectionTimeout).Then(() =>
{
callbackInvoker.Invoke((conn, cb) =>
{
// Abort the request before cancelling
_request.Abort();
// Connection timeout occurred
cb(new TimeoutException());
},
connection,
errorCallback);
});
}
}
private void OpenConnection(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action <Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var callbackInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
Action initializeInvoke = () =>
{
callbackInvoker.Invoke(initializeCallback);
};
var url = connection.Url + (reconnecting ? "reconnect" : "connect") + GetReceiveQueryString(connection, data);
connection.Trace(TraceLevels.Events, "SSE: GET {0}", url);
HttpClient.Get(url, req =>
{
_request = req;
_request.Accept = "text/event-stream";
connection.PrepareRequest(_request);
}, isLongRunning: true).ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
Exception exception;
if (task.IsCanceled)
{
exception = new OperationCanceledException(Resources.Error_TaskCancelledException);
}
else
{
exception = task.Exception.Unwrap();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception);
}
else if (!_stop && reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
Reconnect(connection, data, disconnectToken);
}
requestDisposer.Dispose();
}
else
{
// If the disconnect token is canceled the response to the task doesn't matter.
if (disconnectToken.IsCancellationRequested)
{
return;
}
var response = task.Result;
Stream stream = response.GetStream();
var eventSource = new EventSourceStreamReader(connection, stream);
var esCancellationRegistration = disconnectToken.SafeRegister(state =>
{
_stop = true;
((IRequest)state).Abort();
},
_request);
eventSource.Opened = () =>
{
// This will noop if we're not in the reconnecting state
if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
};
eventSource.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data)
{
if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase))
{
return;
}
bool shouldReconnect;
bool disconnected;
TransportHelper.ProcessResponse(connection, sseEvent.Data, out shouldReconnect, out disconnected, initializeInvoke);
if (disconnected)
{
_stop = true;
connection.Disconnect();
}
}
};
eventSource.Closed = exception =>
{
if (exception != null)
{
// Check if the request is aborted
bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception);
if (!isRequestAborted)
{
// Don't raise exceptions if the request was aborted (connection was stopped).
connection.OnError(exception);
}
}
requestDisposer.Dispose();
esCancellationRegistration.Dispose();
response.Dispose();
if (_stop)
{
AbortHandler.CompleteAbort();
}
else if (AbortHandler.TryCompleteAbort())
{
// Abort() was called, so don't reconnect
}
else
{
Reconnect(connection, data, disconnectToken);
}
};
eventSource.Start();
}
});
var requestCancellationRegistration = disconnectToken.SafeRegister(state =>
{
if (state != null)
{
// This will no-op if the request is already finished.
((IRequest)state).Abort();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, token) =>
{
#if !NET35
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token));
#else
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled));
#endif
}, errorCallback, disconnectToken);
}
}, _request);
requestDisposer.Set(requestCancellationRegistration);
}
private bool ToggleColumnSort( ColumnBase column, bool resetSort )
{
ToggleColumnSortCommand.ThrowIfNull( column, "column" );
this.ValidateToggleColumnSort();
using( var synchronizationContext = this.StartSynchronizing( this.GetSortDescriptionsSyncContext() ) )
{
this.ValidateSynchronizationContext( synchronizationContext );
using( var disposer = new Disposer() )
{
this.DeferRestoreStateOnLevel( disposer );
// This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once!
var sortDescriptions = this.SortDescriptions;
disposer.Add( this.DeferResortHelper( sortDescriptions ), DisposableType.DeferResort );
var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection( column.SortDirection );
string columnName = column.FieldName;
int insertionIndex;
if( ( resetSort ) &&
( ( column.SortIndex == -1 ) || ( sortDescriptions.Count > 1 ) ) )
{
insertionIndex = 0;
if( sortDescriptions.Count > 0 )
{
sortDescriptions.Clear();
}
Debug.Assert( sortDescriptions.Count == 0 );
}
else
{
for( insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++ )
{
if( sortDescriptions[ insertionIndex ].PropertyName == columnName )
break;
}
}
if( insertionIndex < sortDescriptions.Count )
{
if( newSortDirection == SortDirection.None )
{
sortDescriptions.RemoveAt( insertionIndex );
}
else
{
sortDescriptions[ insertionIndex ] = new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) );
}
}
else if( newSortDirection != SortDirection.None )
{
sortDescriptions.Add( new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) ) );
}
}
}
return true;
}
protected override void OnDispose()
{
base.OnDispose();
Disposer.Dispose(ref _wellMaterial);
}
private Task ProcessMessages(ITransportConnection connection, Func <Task> initialize)
{
var disposer = new Disposer();
if (BeforeCancellationTokenCallbackRegistered != null)
{
BeforeCancellationTokenCallbackRegistered();
}
var cancelContext = new ForeverTransportContext(this, disposer);
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
IDisposable registration = ConnectionEndToken.SafeRegister(state => Cancel(state), cancelContext);
var lifetime = new RequestLifetime(this, _requestLifeTime);
var messageContext = new MessageContext(this, lifetime, registration);
if (BeforeReceive != null)
{
BeforeReceive();
}
try
{
// Ensure we enqueue the response initialization before any messages are received
EnqueueOperation(state => InitializeResponse((ITransportConnection)state), connection)
.Catch((ex, state) => OnError(ex, state), messageContext);
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
IDisposable subscription = connection.Receive(LastMessageId,
(response, state) => OnMessageReceived(response, state),
MaxMessages,
messageContext);
disposer.Set(subscription);
if (AfterReceive != null)
{
AfterReceive();
}
// Ensure delegate continues to use the C# Compiler static delegate caching optimization.
initialize().Then(tcs => tcs.TrySetResult(null), InitializeTcs)
.Catch((ex, state) => OnError(ex, state), messageContext);
}
catch (OperationCanceledException ex)
{
InitializeTcs.TrySetCanceled();
lifetime.Complete(ex);
}
catch (Exception ex)
{
InitializeTcs.TrySetCanceled();
lifetime.Complete(ex);
}
return(_requestLifeTime.Task);
}
public override void Dispose()
{
base.Dispose();
Disposer.DisposeAll(ParallaxAnimation, SampleState, TextureResources);
}
private void PollingSetup(IConnection connection,
string data,
CancellationToken disconnectToken,
PollingRequestHandler requestHandler)
{
// These are created new on each poll
var reconnectInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
requestHandler.ResolveUrl = () =>
{
var url = connection.Url;
if (connection.MessageId == null)
{
url += "connect";
}
else if (IsReconnecting(connection))
{
url += "reconnect";
}
else
{
url += "poll";
}
url += GetReceiveQueryString(connection, data);
return(url);
};
requestHandler.PrepareRequest += req =>
{
connection.PrepareRequest(req);
};
requestHandler.OnMessage += message =>
{
var shouldReconnect = false;
var disconnectedReceived = false;
connection.Trace(TraceLevels.Messages, "LP: OnMessage({0})", message);
TransportHelper.ProcessResponse(connection,
message,
out shouldReconnect,
out disconnectedReceived);
if (IsReconnecting(connection))
{
// If the timeout for the reconnect hasn't fired as yet just fire the
// event here before any incoming messages are processed
TryReconnect(connection, reconnectInvoker);
}
if (shouldReconnect)
{
// Transition into reconnecting state
connection.EnsureReconnecting();
}
if (AbortResetEvent != null)
{
AbortResetEvent.Set();
}
else if (disconnectedReceived)
{
connection.Disconnect();
}
};
requestHandler.OnError += exception =>
{
reconnectInvoker.Invoke();
// Transition into reconnecting state
connection.EnsureReconnecting();
// Sometimes a connection might have been closed by the server before we get to write anything
// so just try again and raise OnError.
if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException))
{
connection.OnError(exception);
}
else
{
// If we aborted purposely then we need to stop the request handler
requestHandler.Stop();
}
};
requestHandler.OnPolling += () =>
{
// Capture the cleanup within a closure so it can persist through multiple requests
TryDelayedReconnect(connection, reconnectInvoker);
requestDisposer.Set(disconnectToken.SafeRegister(state =>
{
reconnectInvoker.Invoke();
requestHandler.Stop();
}, null));
};
requestHandler.OnAfterPoll = exception =>
{
requestDisposer.Dispose();
requestDisposer = new Disposer();
reconnectInvoker = new ThreadSafeInvoker();
if (exception != null)
{
// Delay polling by the error delay
return(TaskAsyncHelper.Delay(ErrorDelay));
}
return(TaskAsyncHelper.Empty);
};
}
