public ShapesDemo(IntPtr hInstance)
: base(hInstance) {
_vb = null;
_ib = null;
_fx = null;
_tech = null;
_fxWVP = null;
_inputLayout = null;
_wireframeRS = null;
_theta = 1.5f * MathF.PI;
_phi = 0.1f * MathF.PI;
_radius = 15.0f;
MainWindowCaption = "Shapes Demo";
_lastMousePos = new Point(0, 0);
_gridWorld = Matrix.Identity;
_view = Matrix.Identity;
_proj = Matrix.Identity;
_boxWorld = Matrix.Scaling(2.0f, 1.0f, 2.0f) * Matrix.Translation(0, 0.5f, 0);
_centerSphere = Matrix.Scaling(2.0f, 2.0f, 2.0f) * Matrix.Translation(0, 2, 0);
for (int i = 0; i < 5; ++i) {
_cylWorld[i * 2] = Matrix.Translation(-5.0f, 1.5f, -10.0f + i * 5.0f);
_cylWorld[i * 2 + 1] = Matrix.Translation(5.0f, 1.5f, -10.0f + i * 5.0f);
_sphereWorld[i * 2] = Matrix.Translation(-5.0f, 3.5f, -10.0f + i * 5.0f);
_sphereWorld[i * 2 + 1] = Matrix.Translation(5.0f, 3.5f, -10.0f + i * 5.0f);
}
}
/// <summary>
/// Reads a sequence of bytes from the stream and advances the position
/// within the stream by the number of bytes read.
/// </summary>
/// <remarks>
/// Reads a sequence of bytes from the stream and advances the position
/// within the stream by the number of bytes read.
/// </remarks>
/// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many
/// bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
/// <param name="buffer">The buffer.</param>
/// <param name="offset">The buffer offset.</param>
/// <param name="count">The number of bytes to read.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <para><paramref name="offset"/> is less than zero or greater than the length of <paramref name="buffer"/>.</para>
/// <para>-or-</para>
/// <para>The <paramref name="buffer"/> is not large enough to contain <paramref name="count"/> bytes strting
/// at the specified <paramref name="offset"/>.</para>
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// The stream has been disposed.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// The operation was canceled via the cancellation token.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
public int Read(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
#if false // Note: this code will never get called as we always use ReadResponse() instead.
CheckDisposed();
ValidateArguments(buffer, offset, count);
int length = inputEnd - inputIndex;
int n;
if (length < count && length <= ReadAheadSize)
{
ReadAhead(cancellationToken);
}
length = inputEnd - inputIndex;
n = Math.Min(count, length);
Buffer.BlockCopy(input, inputIndex, buffer, offset, n);
inputIndex += n;
return(n);
#else
throw new NotImplementedException();
#endif
}
public void InsertBytes(int offset, byte[] value, int valueOffset, int length)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (valueOffset < 0 || valueOffset >= value.Length)
{
throw new ArgumentOutOfRangeException("offset", "offset can not negative or >=data.Length");
}
if (length < 0 || valueOffset + length > value.Length)
{
throw new ArgumentOutOfRangeException("length", "length can not be negative or combined with offset longer than the array");
}
EnsureAdditionalCapacity(length);
if (offset != this.position)
{
Buff.BlockCopy(this.buffer, offset, this.buffer, offset + length, this.position - offset);
}
Buff.BlockCopy(value, valueOffset, this.buffer, offset, length);
this.position += length;
}
protected override void DoInitialize()
{
{
// particleSimulator-fountain.comp is also OK.
var shaderCode = new ShaderCode(File.ReadAllText(@"shaders\ParticleSimulatorRenderer\particleSimulator.comp"), ShaderType.ComputeShader);
this.computeProgram = shaderCode.CreateProgram();
}
{
Buffer buffer = this.positionBuffer;
Texture texture = buffer.DumpBufferTexture(OpenGL.GL_RGBA32F, autoDispose: false);
texture.Initialize();
this.positionTexture = texture;
}
{
Buffer buffer = this.velocityBuffer;
Texture texture = buffer.DumpBufferTexture(OpenGL.GL_RGBA32F, autoDispose: false);
texture.Initialize();
this.velocityTexture = texture;
}
{
const int length = 64;
UniformBuffer buffer = UniformBuffer.Create(typeof(vec4), length, BufferUsage.DynamicCopy);
buffer.Bind();
OpenGL.BindBufferBase((BindBufferBaseTarget)BufferTarget.UniformBuffer, 0, buffer.BufferId);
buffer.Unbind();
this.attractorBuffer = buffer;
OpenGL.CheckError();
}
}
public Minimap(Device device, DeviceContext dc, int minimapWidth, int minimapHeight, Terrain terrain, CameraBase viewCam) {
_dc = dc;
_minimapViewport = new Viewport(0, 0, minimapWidth, minimapHeight);
CreateMinimapTextureViews(device, minimapWidth, minimapHeight);
_terrain = terrain;
SetupOrthoCamera();
_viewCam = viewCam;
// frustum vb will contain four corners of view frustum, with first vertex repeated as the last
var vbd = new BufferDescription(
VertexPC.Stride * 5,
ResourceUsage.Dynamic,
BindFlags.VertexBuffer,
CpuAccessFlags.Write,
ResourceOptionFlags.None,
0
);
_frustumVB = new Buffer(device, vbd);
_edgePlanes = new[] {
new Plane(1, 0, 0, -_terrain.Width / 2),
new Plane(-1, 0, 0, _terrain.Width / 2),
new Plane(0, 1, 0, -_terrain.Depth / 2),
new Plane(0, -1, 0, _terrain.Depth / 2)
};
ScreenPosition = new Vector2(0.25f, 0.75f);
Size = new Vector2(0.25f, 0.25f);
}
public static bool Insert(Buffer dest, Buffer source)
{
if (dest.BitsLeft() < source.BitsLeft())
return false;
Bitstream.Buffer tmp = new Bitstream.Buffer();
Copy(tmp, source);
while (tmp.BitsLeft() > 0)
{
if (tmp.bitpos > 0)
{
uint bits = (uint)(8 - tmp.bitpos);
if (bits > tmp.BitsLeft())
{
bits = tmp.BitsLeft();
}
Bitstream.PutBits(dest, bits, Bitstream.ReadBits(tmp, bits));
}
if (tmp.BitsLeft() > 32)
Bitstream.PutBits(dest, 32, Bitstream.ReadBits(tmp, 32));
uint left = tmp.BitsLeft();
if (left >= 8)
{
Bitstream.PutBits(dest, 8, Bitstream.ReadBits(tmp, 8));
}
else if (left > 0)
{
Bitstream.PutBits(dest, left, Bitstream.ReadBits(tmp, left));
}
}
return true;
}
private void Read_file(string filename, Action<Buffer> continueWith) {
using (var fileStream = File.Open(filename, FileMode.Open, FileAccess.Read)) {
var buffer = new Buffer();
buffer.LengthUsed = fileStream.Read(buffer.Content, 0, buffer.Content.Length);
continueWith(buffer);
}
}
private void ReadOne(Buffer buffer, LowLevelTcpConnection connection)
{
connection.ReadAsync(buffer.Segment.Array, buffer.Segment.Offset, buffer.Segment.Count,
readBytes =>
{
var readSegment = new ArraySegment<byte>(buffer.Segment.Array, 0, buffer.Segment.Offset + readBytes);
int headersSize;
var headers = TryParse(readSegment, out headersSize);
if (headers != null)
{
FixBuffer(buffer.Segment.Array, headersSize, buffer.Segment.Offset + readBytes);
StartHttp(headers, buffer.Segment.Array, connection);
}
else
{
ReadOne(new Buffer()
{
Segment =
new ArraySegment<byte>(buffer.Segment.Array,
buffer.Segment.Offset + readBytes,
buffer.Segment.Count - readBytes),
}, connection);
}
});
}
public override void MakeBinary(string path)
{
ReadObj(path, out List <Vector3> outPositions, out List <Vector2> outTexCoords, out List <Vector3> outNormals, out List <VertexReference> outVertices);
int vertexCount = outPositions.Count;
byte[] closure = _closures[Name];
Buffer = new byte[10 + vertexCount * Vertex.ByteCount + vertexCount * sizeof(uint) + closure.Length];
Buf.BlockCopy(BitConverter.GetBytes((uint)vertexCount), 0, Buffer, 0, sizeof(uint));
Buf.BlockCopy(BitConverter.GetBytes((uint)vertexCount), 0, Buffer, 4, sizeof(uint));
Buf.BlockCopy(BitConverter.GetBytes((ushort)288), 0, Buffer, 8, sizeof(ushort));
for (int i = 0; i < vertexCount; i++)
{
Vertex vertex = new(outPositions[(int)outVertices[i].PositionReference - 1], outTexCoords[(int)outVertices[i].TexCoordReference - 1], outNormals[(int)outVertices[i].NormalReference - 1]);
byte[] vertexBytes = vertex.ToByteArray();
Buf.BlockCopy(vertexBytes, 0, Buffer, 10 + i * Vertex.ByteCount, Vertex.ByteCount);
}
for (int i = 0; i < vertexCount; i++)
{
Buf.BlockCopy(BitConverter.GetBytes(outVertices[i].PositionReference - 1), 0, Buffer, 10 + vertexCount * Vertex.ByteCount + i * sizeof(uint), sizeof(uint));
}
Buf.BlockCopy(closure, 0, Buffer, 10 + vertexCount * (Vertex.ByteCount + sizeof(uint)), closure.Length);
Size = (uint)Buffer.Length;
}
public MyModel(Project1Game game, VertexPositionColor[] shapeArray, String textureName)
{
this.vertices = Buffer.Vertex.New(game.GraphicsDevice, shapeArray);
this.inputLayout = VertexInputLayout.New<VertexPositionColor>(0);
vertexStride = Utilities.SizeOf<VertexPositionColor>();
modelType = ModelType.Colored;
}
async Task <int> ReadAsync(byte[] buffer, int offset, int count, bool doAsync, CancellationToken cancellationToken)
{
CheckDisposed();
ValidateArguments(buffer, offset, count);
if (Mode != ImapStreamMode.Literal)
{
return(0);
}
count = Math.Min(count, literalDataLeft);
int length = inputEnd - inputIndex;
int n;
if (length < count && length <= ReadAheadSize)
{
await ReadAheadAsync(BlockSize, doAsync, cancellationToken).ConfigureAwait(false);
}
length = inputEnd - inputIndex;
n = Math.Min(count, length);
Buffer.BlockCopy(input, inputIndex, buffer, offset, n);
literalDataLeft -= n;
inputIndex += n;
if (literalDataLeft == 0)
{
Mode = ImapStreamMode.Token;
}
return(n);
}
public BufferPool()
{
for (int i = 0; i < PoolSize; i++)
{
pool[i] = new Buffer(this, BufferLength);
}
}
public void UpdateBufferForBlock(int program, string nameBlock)
{
int index_SLI = GL.GetUniformBlockIndex(program, nameBlock);
if (index_SLI != -1)
{
GL.GetActiveUniformBlock(program, index_SLI, ActiveUniformBlockParameter.UniformBlockDataSize, out blockSizeLightInfo);
byte[] blockBuffer = new byte[blockSizeLightInfo];
string[] names = { nameBlock + ".position_lgh", nameBlock + ".intensity_lgh", nameBlock + ".direction_lgh", nameBlock + ".exponent_lgh", nameBlock + ".cutoff_lgh" };
int[] indices = new int[5];
GL.GetUniformIndices(program, 5, names, indices);
int[] offset = new int[5];
GL.GetActiveUniforms(program, 5, indices, ActiveUniformParameter.UniformOffset, offset);
float[] position_lgh = { Position.X, Position.Y, Position.Z, 0.0f };
float[] intensity_lgh = { DiffusionIntensity.X, DiffusionIntensity.Y, DiffusionIntensity.Z }; //интенсивность света
float[] direction_lgh = { LightVecNormalized.X, LightVecNormalized.Y, LightVecNormalized.Z }; //направление света
float[] exponent = { 1.0f }; // Экспанента углового ослабления света
float[] cutoff = { 30f }; //угол отсечения
Buffer.BlockCopy(position_lgh, 0, blockBuffer, offset[0], position_lgh.Length * sizeof(float));
Buffer.BlockCopy(intensity_lgh, 0, blockBuffer, offset[1], intensity_lgh.Length * sizeof(float));
Buffer.BlockCopy(direction_lgh, 0, blockBuffer, offset[2], direction_lgh.Length * sizeof(float));
Buffer.BlockCopy(exponent, 0, blockBuffer, offset[3], exponent.Length * sizeof(float));
Buffer.BlockCopy(cutoff, 0, blockBuffer, offset[4], cutoff.Length * sizeof(float));
GL.BindBuffer(BufferTarget.UniformBuffer, uboLightInfo);
GL.BufferSubData(BufferTarget.UniformBuffer, (IntPtr)0, blockSizeLightInfo, blockBuffer);
}
}
public byte[] ToArray()
{
byte[] value = new byte[Length];
Buff.BlockCopy(this.buffer, 0, value, 0, Length);
return(value);
}
public void WriteDouble(double value)
{
if (this.position + sizeof(double) >= this.buffer.Length)
{
int curLength = this.buffer.Length;
int newLength = curLength * 2;
while (newLength <= curLength + sizeof(double))
{
newLength *= 2;
}
byte[] newbuffer = new byte[newLength];
Buff.BlockCopy(this.buffer, 0, newbuffer, 0, this.Length);
this.buffer = newbuffer;
}
#if SAFE
Buff.BlockCopy(BitConverter.GetBytes(value), 0, this.buffer, this.position, sizeof(double));
#else
fixed(byte *ub = this.buffer)
* ((double *)(ub + this.position)) = value;
#endif
this.position += sizeof(double);
}
public static Buffer Make(byte[] buffer)
{
Buffer b = new Buffer();
b.buf = buffer;
b.bytesize = (uint)buffer.Length;
return b;
}
public SegmentRenderer()
{
m_program = TriangleProgram.Instance;
m_instances = new List<SegmentInstance>();
m_vao = new VertexArray();
GL.BindVertexArray(m_vao);
GL.UseProgram(m_program);
m_bufferSprite = new Buffer<SegmentData>();
m_bufferTriangle = new Buffer<Vector3>();
m_program.Position.SetValue(m_bufferSprite.GetView<Vector3>("Position"));
m_program.Color.SetValue(m_bufferSprite.GetView<Color4ub>("Color"));
//m_program.Position.SetDivisor(1);
// m_program.Normal.SetValue(m_bufferSprite.GetView<Vector3>("Normal"));
//// m_program.Normal.SetDivisor(1);
// m_program.Transform.SetValue(m_bufferSprite.GetView<Matrix4>("Transform"));
// //m_program.Transform.SetDivisor(1);
// m_program.TextureOrigin.SetValue(m_bufferSprite.GetView<Vector2>("TextureOrigin"));
// //m_program.TextureOrigin.SetDivisor(1);
// m_program.TextureTarget.SetValue(m_bufferSprite.GetView<Vector2>("TextureTarget"));
//m_program.TextureTarget.SetDivisor(1);
GL.BindVertexArray(null);
m_isDirty = true;
}
public void WriteBytes(byte[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
int additionalCapacity = sizeof(int) + value.Length;
if (this.position + additionalCapacity >= this.buffer.Length)
{
int curLength = this.buffer.Length;
int newLength = curLength * 2;
while (newLength <= curLength + additionalCapacity)
{
newLength *= 2;
}
byte[] newbuffer = new byte[newLength];
Buff.BlockCopy(this.buffer, 0, newbuffer, 0, this.Length);
this.buffer = newbuffer;
}
Buff.BlockCopy(BitConverter.GetBytes(value.Length), 0, this.buffer, this.position, sizeof(int));
this.position += sizeof(int);
Buff.BlockCopy(value, 0, this.buffer, this.position, value.Length);
this.position += value.Length;
}
private void OnLoad(object sender, EventArgs e)
{
// initialize shader (load sources, create/compile/link shader program, error checking)
// when using the factory method the shader sources are retrieved from the ShaderSourceAttributes
_program = ProgramFactory.Create<ExampleProgram>();
// this program will be used all the time so just activate it once and for all
_program.Use();
// create vertices for a triangle
var vertices = new[] { new Vector3(-1,-1,0), new Vector3(1,-1,0), new Vector3(0,1,0) };
// create buffer object and upload vertex data
_vbo = new Buffer<Vector3>();
_vbo.Init(BufferTarget.ArrayBuffer, vertices);
// create and bind a vertex array
_vao = new VertexArray();
_vao.Bind();
// set up binding of the shader variable to the buffer object
_vao.BindAttribute(_program.InPosition, _vbo);
// set camera position
Camera.DefaultState.Position = new Vector3(0,0,3);
Camera.ResetToDefault();
// set a nice clear color
GL.ClearColor(Color.MidnightBlue);
}
public SpriteRenderer(SpriteSheet spriteSheet)
{
SpriteSheet = spriteSheet;
m_program = SpriteProgram.Instance;
m_instances = new List<SpriteInstance>();
m_vao = new VertexArray();
GL.BindVertexArray(m_vao);
m_bufferSprite = new Buffer<SpriteData>();
m_bufferQuad = new Buffer<Vector3>();
m_bufferQuad.SetData(new Vector3[] {
new Vector3(0f, 0f, 0f),
new Vector3(0f, 1f, 0f),
new Vector3(1f, 1f, 0f),
new Vector3(1f, 0f, 0f)
});
GL.UseProgram(m_program);
m_program.Position.SetValue(m_bufferQuad.GetView());
m_program.Transform.SetValue(m_bufferSprite.GetView<Matrix4>("Transform"));
m_program.Transform.SetDivisor(1);
m_program.TextureOrigin.SetValue(m_bufferSprite.GetView<Vector2>("TextureOrigin"));
m_program.TextureOrigin.SetDivisor(1);
m_program.TextureTarget.SetValue(m_bufferSprite.GetView<Vector2>("TextureTarget"));
m_program.TextureTarget.SetDivisor(1);
GL.BindVertexArray(null);
m_isDirty = true;
}
/*
* private static NDArray ReadTensorFromImageFile(Bitmap bmp)
* {
* var graph = tf.Graph().as_default();
*
* string file_name = @"E:\Download\faster_rcnn_resnet50_smd_2019_01_29\images\ships1.jpg";
* Tensor file_reader = tf.io.read_file(file_name, "file_reader");
* Tensor decodeFromFile = tf.image.decode_jpeg(file_reader, channels: 3, name: "DecodeJpeg");
*
* NDArray nd = bmp.ToNDArray(discardAlpha: true);
* nd.shape = new int[]{ 1, bmp.Height, bmp.Width, 3 };
* Tensor content = new Tensor(nd,TF_DataType.TF_UINT8);
* return nd;
* var decodeJpeg = tf.image.decode_image(content);
*
* var casted = tf.cast(decodeJpeg, TF_DataType.TF_UINT8);
* var dims_expander = tf.expand_dims(casted, 0);
*
* using (var sess = tf.Session(graph))
* return sess.run(dims_expander);
* }
*/
private static NDArray GetBitmapBytes(Bitmap image, out byte[] RawBytes)
{
// En garde!
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
BitmapData bmpData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, image.PixelFormat);
try
{
unsafe
{
RawBytes = new byte[bmpData.Stride * image.Height];
//Create a 1d vector without filling it's values to zero (similar to np.empty)
var nd = new NDArray(NPTypeCode.Byte, Shape.Vector(bmpData.Stride * image.Height), fillZeros: false);
// Get the respective addresses
byte *src = (byte *)bmpData.Scan0;
byte *dst = (byte *)nd.Unsafe.Address; //we can use unsafe because we just allocated that array and we know for sure it is contagious.
Marshal.Copy(bmpData.Scan0, RawBytes, 0, RawBytes.Length);
// Copy the RGB values into the array.
Buffer.MemoryCopy(src, dst, nd.size, nd.size); //faster than Marshal.Copy
//TODO: replace return with: return nd.reshape(batch_size, height, width, 3);
return(nd);
}
}
finally
{
image.UnlockBits(bmpData);
}
}
public ParticleSystem(GraphicsDevice device, ContentManager content)
{
this.device = device;
// Create vertex buffer used to spawn new particles
this.particleStart = Buffer.Vertex.New<ParticleVertex>(device, MAX_NEW);
// Create vertex buffers to use for updating and drawing the particles alternatively
var vbFlags = BufferFlags.VertexBuffer | BufferFlags.StreamOutput;
this.particleDrawFrom = Buffer.New<ParticleVertex>(device, MAX_PARTICLES, vbFlags);
this.particleStreamTo = Buffer.New<ParticleVertex>(device, MAX_PARTICLES, vbFlags);
this.layout = VertexInputLayout.FromBuffer(0, this.particleStreamTo);
this.effect = content.Load<Effect>("ParticleEffect");
this.texture = content.Load<Texture2D>("Dot");
this.viewParameter = effect.Parameters["_view"];
this.projParameter = effect.Parameters["_proj"];
this.lookAtMatrixParameter = effect.Parameters["_lookAtMatrix"];
this.elapsedSecondsParameter = effect.Parameters["_elapsedSeconds"];
this.camDirParameter = effect.Parameters["_camDir"];
this.gravityParameter = effect.Parameters["_gravity"];
this.textureParameter = effect.Parameters["_texture"];
this.samplerParameter = effect.Parameters["_sampler"];
this.updatePass = effect.Techniques["UpdateTeq"].Passes[0];
this.renderPass = effect.Techniques["RenderTeq"].Passes[0];
}
public void Process(Buffer buffer) {
if (first) {
first = false;
First_Buffer(buffer);
}
All_Buffers(buffer);
}
/// <summary>
/// Replace current PacketStream with some bytes from provided byte array.
/// </summary>
/// <param name="bytes"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <returns></returns>
public PacketStream Replace(Byte[] bytes, Int32 offset, Int32 count)
{
Reserve(count);
SBuffer.BlockCopy(bytes, offset, Buffer, 0, count);
Count = count;
return(this);
}
/// <summary>
/// Reads a sequence of bytes from the stream and advances the position
/// within the stream by the number of bytes read.
/// </summary>
/// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many
/// bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
/// <param name="buffer">The buffer.</param>
/// <param name="offset">The buffer offset.</param>
/// <param name="count">The number of bytes to read.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="buffer"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentOutOfRangeException">
/// <para><paramref name="offset"/> is less than zero or greater than the length of <paramref name="buffer"/>.</para>
/// <para>-or-</para>
/// <para>The <paramref name="buffer"/> is not large enough to contain <paramref name="count"/> bytes strting
/// at the specified <paramref name="offset"/>.</para>
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// The stream has been disposed.
/// </exception>
/// <exception cref="System.InvalidOperationException">
/// The stream is in token mode (see <see cref="ImapStreamMode.Token"/>).
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// The operation was canceled via the cancellation token.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
public int Read(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
CheckDisposed();
ValidateArguments(buffer, offset, count);
if (Mode != ImapStreamMode.Literal)
{
return(0);
}
count = Math.Min(count, literalDataLeft);
int length = inputEnd - inputIndex;
int n;
if (length < count && length <= ReadAheadSize)
{
ReadAhead(BlockSize, cancellationToken);
}
length = inputEnd - inputIndex;
n = Math.Min(count, length);
Buffer.BlockCopy(input, inputIndex, buffer, offset, n);
literalDataLeft -= n;
inputIndex += n;
if (literalDataLeft == 0)
{
Mode = ImapStreamMode.Token;
}
return(n);
}
public Skybox(GraphicsDevice device)
{
float x = 0.525731f;
float z = 0.850651f;
var vertices = new SkyboxVertex[12]
{
new SkyboxVertex(-x, 0f, z), new SkyboxVertex(x, 0f, z),
new SkyboxVertex(-x, 0f, -z), new SkyboxVertex(x, 0f, -z),
new SkyboxVertex(0f, z, x), new SkyboxVertex(0f, z, -x),
new SkyboxVertex(0f, -z, x), new SkyboxVertex(0f, -z, -x),
new SkyboxVertex(z, x, 0f), new SkyboxVertex(-z, x, 0f),
new SkyboxVertex(z, -x, 0f), new SkyboxVertex(-z, -x, 0f),
};
var indices = new int[60]
{
1,4,0, 4,9,0, 4,5,9, 8,5,4, 1,8,4,
1,10,8, 10,3,8, 8,3,5, 3,2,5, 3,7,2,
3,10,7, 10,6,7, 6,11,7, 6,0,11, 6,1,0,
10,1,6, 11,0,9, 2,11,9, 5,2,9, 11,2,7
};
vertexBuffer = Buffer<SkyboxVertex>.New(device, vertices, BufferFlags.VertexBuffer);
indexBuffer = Buffer<int>.New(device, indices, BufferFlags.IndexBuffer);
skyboxEffect = EffectLoader.Load(@"Graphics/Shaders/Skybox.fx");
skyboxTex = Texture2D.Load(device, @"G:\Users\Athrun\Documents\Stratum\trunk\src\Stratum\WorldEngine\Earth\milkyWay.tif");
}
public ConsoleViewModel(
ISyncThingManager syncThingManager,
IConfigurationProvider configurationProvider)
{
this.syncThingManager = syncThingManager;
this.LogMessages = new Queue<string>();
// Display log messages 100ms after the previous message, or every 500ms if they're arriving thick and fast
this.logMessagesBuffer = new Buffer<string>(TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(500));
this.logMessagesBuffer.Delivered += (o, e) =>
{
foreach (var message in e.Items)
{
this.LogMessages.Enqueue(message);
if (this.LogMessages.Count > maxLogMessages)
this.LogMessages.Dequeue();
}
this.NotifyOfPropertyChange(() => this.LogMessages);
};
this.syncThingManager.MessageLogged += (o, e) =>
{
this.logMessagesBuffer.Add(e.LogMessage);
};
}
public Worker(int threadCount, int blockLength, IHash hasher, FileStream stream)
{
mainThread = Thread.CurrentThread;
this.threadCount = threadCount;
this.stream = stream;
this.hasher = hasher;
this.blockLength = blockLength;
threads = new List<Thread>(threadCount);
for (int i = 0; i < threadCount; ++i)
{
var b = new Buffer();
b.raw = new byte[blockLength];
bufferQueue.AddToQueue(b);
}
blockCount = stream.Length / blockLength;
if (stream.Length % blockLength != 0)
{
blockCount++;
}
Console.CancelKeyPress += new ConsoleCancelEventHandler(Cancel);
}
public void WriteString(Encoding encoding, string value)
{
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
if (value == null)
{
Write7BitEncodedInt(-1);
return;
}
byte[] data = encoding.GetBytes(value);
int additionalCapacity = sizeof(int) + data.Length;
if (this.position + additionalCapacity >= this.buffer.Length)
{
int curLength = this.buffer.Length;
int newLength = curLength * 2;
while (newLength <= curLength + additionalCapacity)
{
newLength *= 2;
}
byte[] newbuffer = new byte[newLength];
Buff.BlockCopy(this.buffer, 0, newbuffer, 0, this.Length);
this.buffer = newbuffer;
}
Write7BitEncodedInt(data.Length);
Buff.BlockCopy(data, 0, this.buffer, this.position, data.Length);
this.position += data.Length;
}
//
// This validation logic is a manual port of StrongNameIsValidPublicKey() in the desktop CLR (see clr\src\StrongName\api\StrongNameInternal.cpp)
//
private static bool IsValidPublicKey(byte[] publicKey)
{
uint publicKeyLength = (uint)(publicKey.Length);
// The buffer must be at least as large as the public key structure (for compat with desktop, we actually compare with the size of the header + 4).
if (publicKeyLength < SizeOfPublicKeyBlob + 4)
{
return(false);
}
// Poor man's reinterpret_cast into the PublicKeyBlob structure.
uint[] publicKeyBlob = new uint[3];
Buffer.BlockCopy(publicKey, 0, publicKeyBlob, 0, (int)SizeOfPublicKeyBlob);
uint sigAlgID = publicKeyBlob[0];
uint hashAlgID = publicKeyBlob[1];
uint cbPublicKey = publicKeyBlob[2];
// The buffer must be the same size as the structure header plus the trailing key data
if (cbPublicKey != publicKeyLength - SizeOfPublicKeyBlob)
{
return(false);
}
// The buffer itself looks reasonable, but the public key structure needs to be validated as well
// The ECMA key doesn't look like a valid key so it will fail the below checks. If we were passed that
// key, then we can skip them.
if (ByteArrayEquals(publicKey, s_ecmaKey))
{
return(true);
}
// If a hash algorithm is specified, it must be a sensible value
bool fHashAlgorithmValid = GetAlgClass(hashAlgID) == ALG_CLASS_HASH && GetAlgSid(hashAlgID) == ALG_SID_SHA1;
if (hashAlgID != 0 && !fHashAlgorithmValid)
{
return(false);
}
// If a signature algorithm is specified, it must be a sensible value
bool fSignatureAlgorithmValid = GetAlgClass(sigAlgID) == ALG_CLASS_SIGNATURE;
if (sigAlgID != 0 && !fSignatureAlgorithmValid)
{
return(false);
}
// The key blob must indicate that it is a PUBLICKEYBLOB
if (publicKey[SizeOfPublicKeyBlob] != PUBLICKEYBLOB)
{
return(false);
}
//@todo: Desktop also tries to import the public key blob using the Crypto api as further validation - not clear if there's any non-banned API to do this.
return(true);
}
// Draw_CachePic
public static glpic_t CachePic(string path)
{
for (int i = 0; i < _MenuNumCachePics; i++)
{
cachepic_t p = _MenuCachePics[i];
if (p.name == path) // !strcmp(path, pic->name))
{
return(p.pic);
}
}
if (_MenuNumCachePics == MAX_CACHED_PICS)
{
sys.Error("menu_numcachepics == MAX_CACHED_PICS");
}
cachepic_t pic = _MenuCachePics[_MenuNumCachePics];
_MenuNumCachePics++;
pic.name = path;
//
// load the pic from disk
//
byte[] data = common.LoadFile(path);
if (data == null)
{
sys.Error("Draw_CachePic: failed to load {0}", path);
}
dqpicheader_t header = sys.BytesToStructure <dqpicheader_t>(data, 0);
wad.SwapPic(header);
int headerSize = Marshal.SizeOf(typeof(dqpicheader_t));
// HACK HACK HACK --- we need to keep the bytes for
// the translatable player picture just for the menu
// configuration dialog
if (path == "gfx/menuplyr.lmp")
{
Buffer.BlockCopy(data, headerSize, _MenuPlayerPixels, 0, header.width * header.height);
//memcpy (menuplyr_pixels, dat->data, dat->width*dat->height);
}
glpic_t gl = new glpic_t();
gl.width = header.width;
gl.height = header.height;
//gl = (glpic_t *)pic->pic.data;
gl.texnum = LoadTexture(gl, new ByteArraySegment(data, headerSize));
gl.sl = 0;
gl.sh = 1;
gl.tl = 0;
gl.th = 1;
pic.pic = gl;
return(gl);
}
/**
* Factory method to create an unmodifiable buffer.
* <p>
* If the buffer passed in is already unmodifiable, it is returned.
*
* @param buffer the buffer to decorate, must not be null
* @return an unmodifiable Buffer
* @throws IllegalArgumentException if buffer is null
*/
public static Buffer decorate(Buffer buffer)
{
if (buffer is Unmodifiable)
{
return buffer;
}
return new UnmodifiableBuffer(buffer);
}
public static byte[] ArrayConcat(byte[] a, byte[] b)
{
byte[] c = new byte[a.Length + b.Length];
Buffer.BlockCopy(a, 0, c, 0, a.Length);
Buffer.BlockCopy(b, 0, c, a.Length, b.Length);
return(c);
}
public virtual void Initialize()
{
GraphicsDevice device = Engine.GraphicsContext.Device;
wireFrame = EffectLoader.Load(@"World/Earth/Shaders/DeferredTerrain.fx");
vertexBuffer = Buffer<TerrainVertex>.New<TerrainVertex>(device, SharpDX.Utilities.SizeOf<TerrainVertex>() * 4 * 1000, BufferFlags.VertexBuffer, SharpDX.Direct3D11.ResourceUsage.Dynamic);
}
internal override void Read(ProtocolFormatter formatter, int rows)
{
var itemSize = Marshal.SizeOf <T>();
var bytes = formatter.ReadBytes(itemSize * rows);
Data = new T[rows];
Buffer.BlockCopy(bytes, 0, Data, 0, itemSize * rows);
}
/// <summary>
/// Sets a single constant buffer to be used by the shader stage.
/// </summary>
/// <param name = "slot">Index into the device's zero-based array to which to set the constant buffer.</param>
/// <param name = "constantBuffer">constant buffer to set</param>
public void SetConstantBuffer(int slot, Buffer constantBuffer)
{
var tempPtr = constantBuffer == null ? IntPtr.Zero : constantBuffer.NativePointer;
unsafe
{
SetConstantBuffers(slot, 1, new IntPtr(&tempPtr));
}
}
public int InverseTransform(Buffer buffer, int length)
{
for (int i = 0; i < length; ++i)
{
buffer[i] = (byte)~buffer[i];
}
return length;
}
public int Transform(Buffer buffer, int length)
{
for (int i = buffer.Length - length; i < buffer.Length; ++i)
{
buffer[i] = (byte)~buffer[i];
}
return length;
}
public MyModel(LabGame game, VertexPositionColor[] shapeArray, String textureName, float collisionRadius)
{
this.vertices = Buffer.Vertex.New(game.GraphicsDevice, shapeArray);
this.inputLayout = VertexInputLayout.New<VertexPositionColor>(0);
vertexStride = Utilities.SizeOf<VertexPositionColor>();
modelType = ModelType.Colored;
this.collisionRadius = collisionRadius;
}
public static void Copy(Buffer dst, Buffer src)
{
dst.buf = src.buf;
dst.bufsize = src.bufsize;
dst.bytepos = src.bytepos;
dst.bitpos = src.bitpos;
dst.error = src.error;
}
public ParserGen(Parser parser)
{
tab = parser.tab;
trace = parser.trace;
buffer = parser.scanner.buffer;
errorNr = -1;
usingPos = null;
}
public RadioTower(Vector3 pos)
{
bounds = new Circle(pos, 2);
commCircle = new Circle(pos, 25);
inbox = new Buffer<Message>(20);
outbox = new Buffer<Message>(20);
}
public void AddBuffer(Buffer buffer)
{
buffer.X = this.Left;
buffer.Y = this.Top;
buffer.Width = this.Width;
buffer.Height = this.Height;
this.Buffers.AddLast(buffer);
this.CurrentBufferNode = this.Buffers.Last;
}
public override void Write(ProtocolFormatter formatter, int rows)
{
Debug.Assert(Rows == rows, "Row count mismatch!");
var itemSize = Marshal.SizeOf <T>();
var bytes = new byte[itemSize * rows];
Buffer.BlockCopy(Data, 0, bytes, 0, itemSize * rows);
formatter.WriteBytes(bytes);
}
public static long GetRSAFingerprint(string key)
{
using (var text = new StringReader(key))
{
var reader = new PemReader(text);
var parameter = reader.ReadObject() as RsaKeyParameters;
if (parameter != null)
{
var modulus = parameter.Modulus.ToByteArray();
var exponent = parameter.Exponent.ToByteArray();
if (modulus.Length > 256)
{
var corrected = new byte[256];
Buffer.BlockCopy(modulus, modulus.Length - 256, corrected, 0, 256);
modulus = corrected;
}
else if (modulus.Length < 256)
{
var corrected = new byte[256];
Buffer.BlockCopy(modulus, 0, corrected, 256 - modulus.Length, modulus.Length);
for (int a = 0; a < 256 - modulus.Length; a++)
{
modulus[a] = 0;
}
modulus = corrected;
}
using (var stream = new MemoryStream())
{
var modulusString = TLString.FromBigEndianData(modulus);
var exponentString = TLString.FromBigEndianData(exponent);
modulusString.ToStream(stream);
exponentString.ToStream(stream);
var hash = ComputeSHA1(stream.ToArray());
var fingerprint = (((ulong)hash[19]) << 56) |
(((ulong)hash[18]) << 48) |
(((ulong)hash[17]) << 40) |
(((ulong)hash[16]) << 32) |
(((ulong)hash[15]) << 24) |
(((ulong)hash[14]) << 16) |
(((ulong)hash[13]) << 8) |
((ulong)hash[12]);
return((long)fingerprint);
}
}
}
return(-1);
}
private static void GetByteVertexAndIndexBuffer(out byte[] byteVertexBuffer, out int[] indexBuffer)
{
float[] floatVertexBuffer;
GetFloatVertexAndIndexBuffer(out floatVertexBuffer, out indexBuffer);
// Copy float array into byte array
byteVertexBuffer = new byte[floatVertexBuffer.Length * 4];
Buffer.BlockCopy(floatVertexBuffer, 0, byteVertexBuffer, 0, byteVertexBuffer.Length);
}
public BitStream()
{
m_first = new Buffer();
m_last = m_first;
m_blockingRead = false;
m_streamEnded = false;
m_lock = new object();
Rewind();
}
internal override void Read(ProtocolFormatter formatter, int rows)
{
var itemSize = sizeof(ushort);
var bytes = formatter.ReadBytes(itemSize * rows);
var xdata = new ushort[rows];
Buffer.BlockCopy(bytes, 0, xdata, 0, itemSize * rows);
Data = xdata.Select(x => UnixTimeBase.AddDays(x)).ToArray();
}
internal override void Read(ProtocolFormatter formatter, int rows)
{
var itemSize = Marshal.SizeOf(typeof(Guid));
var bytes = formatter.ReadBytes(itemSize * rows);
var xdata = new Guid[rows];
Buffer.BlockCopy(bytes, 0, xdata, 0, itemSize * rows);
Data = xdata.ToArray();
}
internal override void Read(ProtocolFormatter formatter, int rows)
{
var itemSize = Marshal.SizeOf <uint>();
var bytes = formatter.ReadBytes(itemSize * rows);
var xdata = new uint[rows];
Buffer.BlockCopy(bytes, 0, xdata, 0, itemSize * rows);
Data = xdata.Select(x => UnixTimeBase.AddSeconds(x)).ToArray();
}
public PacketStream Insert(Int32 offset, Byte[] copyArray, Int32 copyArrayOffset, Int32 count)
{
Reserve(Count + count);
// передвигаем данные с позиции offset до позиции offset + count
SBuffer.BlockCopy(Buffer, offset, Buffer, offset + count, Count - offset);
// копируем новый массив данных в позицию offset
SBuffer.BlockCopy(copyArray, copyArrayOffset, Buffer, offset, count);
Count += count;
return(this);
}
public byte[] ReadBytes()
{
int len = ReadInt32();
byte[] b = new byte[len];
Buff.BlockCopy(this.buffer, this.Position, b, 0, len);
this.Position += len;
return(b);
}
//-----------------------------------------------------------------------
/**
* Constructor that wraps (not copies) another buffer, making it bounded
* waiting only up to a maximum amount of time.
*
* @param buffer the buffer to wrap, must not be null
* @param maximumSize the maximum size, must be size one or greater
* @param timeout the maximum amount of time to wait
* @throws IllegalArgumentException if the buffer is null
* @throws IllegalArgumentException if the maximum size is zero or less
*/
protected BoundedBuffer(Buffer buffer, int maximumSize, long timeout)
: base(buffer)
{
if (maximumSize < 1)
{
throw new java.lang.IllegalArgumentException();
}
this.maximumSize = maximumSize;
this.timeout = timeout;
}
public void Write(void *data, nuint length)
{
if (length > Size)
{
ThrowHelper.ThrowArgumentOutOfRangeException(nameof(data), "Cannot write segment larger than ring buffer segment size.");
}
_RingSync.WaitEnterNext();
Buffer.MemoryCopy(data, _Pointer + GetCurrentOffset(), Size, length);
}
public Map(GraphicsDevice device, int width, int height)
{
this.width = width;
this.height = height;
objectMap = new Buffer<GameObject>[width, height];
initGrid();
neighborList = new Buffer<GameObject>(40);
}
async Task <int> ReadAheadAsync(bool doAsync, CancellationToken cancellationToken)
{
int left = inputEnd - inputIndex;
int index, nread;
if (left > 0)
{
if (inputIndex > 0)
{
// move all of the remaining input to the beginning of the buffer
Buffer.BlockCopy(input, inputIndex, input, 0, left);
inputEnd = left;
inputIndex = 0;
}
}
else
{
inputIndex = 0;
inputEnd = 0;
}
left = input.Length - inputEnd;
index = inputEnd;
try {
var network = Stream as NetworkStream;
cancellationToken.ThrowIfCancellationRequested();
if (doAsync)
{
nread = await Stream.ReadAsync(input, index, left, cancellationToken).ConfigureAwait(false);
}
else
{
network?.Poll(SelectMode.SelectRead, cancellationToken);
nread = Stream.Read(input, index, left);
}
if (nread > 0)
{
logger.LogServer(input, index, nread);
inputEnd += nread;
}
else
{
throw new SmtpProtocolException("The SMTP server has unexpectedly disconnected.");
}
} catch {
IsConnected = false;
throw;
}
return(inputEnd - inputIndex);
}
internal override void Read(ProtocolFormatter formatter, int rows)
{
#if FRAMEWORK20 || FRAMEWORK40 || FRAMEWORK45
var itemSize = Marshal.SizeOf(typeof(T));
#else
var itemSize = Marshal.SizeOf <T>();
#endif
var bytes = formatter.ReadBytes(itemSize * rows);
Data = new T[rows];
Buffer.BlockCopy(bytes, 0, Data, 0, itemSize * rows);
}
internal override void Read(ProtocolFormatter formatter, int rows)
{
#if FRAMEWORK20 || FRAMEWORK40 || FRAMEWORK45
var itemSize = sizeof(ushort);
#else
var itemSize = Marshal.SizeOf <ushort>();
#endif
var bytes = formatter.ReadBytes(itemSize * rows);
var xdata = new ushort[rows];
Buffer.BlockCopy(bytes, 0, xdata, 0, itemSize * rows);
Data = xdata.Select(x => UnixTimeBase.AddDays(x)).ToArray();
}
public Byte[] ReadBytes(Int32 count)
{
if (Pos + count > Count)
{
throw new MarshalException();
}
Byte[] result = new Byte[count];
SBuffer.BlockCopy(Buffer, Pos, result, 0, count);
Pos += count;
return(result);
}
public override void Write(ProtocolFormatter formatter, int rows)
{
Debug.Assert(Rows == rows, "Row count mismatch!");
#if FRAMEWORK20 || FRAMEWORK40 || FRAMEWORK45
var itemSize = Marshal.SizeOf(typeof(T));
#else
var itemSize = Marshal.SizeOf <T>();
#endif
var bytes = new byte[itemSize * rows];
Buffer.BlockCopy(Data, 0, bytes, 0, itemSize * rows);
formatter.WriteBytes(bytes);
}
