protected override void CapacityChanged()
{
unsafe
{
m_Ptr = (Vector2 *)m_AlignedPtr.ToPointer();
}
}
public static unsafe void TestRasterize()
{
Rasterizer.StartRasterize(CRenderSettings.ResolutionF);
RenderBuffer <float> tex0 = new RenderBuffer <float>(CRenderSettings.Resolution, 3);
CharRenderBuffer <float> texChar = new CharRenderBuffer <float>(tex0);
Vector2 *points = stackalloc Vector2[4];
for (float i = 0; i < JMath.PI_TWO; i += .02f)
{
Vector2 dir = new Vector2(MathF.Cos(i) * .3f, MathF.Sin(i) * .3f);
Vector2 orthoDir = new Vector2(-dir.Y, dir.X);
points[0] = new Vector2(.5f, .5f) + dir;
points[1] = new Vector2(.5f, .5f) - dir;
points[2] = new Vector2(.5f, .5f) + orthoDir;
points[3] = new Vector2(.5f, .5f) - orthoDir;
LinePrimitive *line = stackalloc LinePrimitive[1] {
new LinePrimitive(points, null, 0)
};
Rasterizer.Rasterize <Line, LinePrimitive>(line);
tex0.WritePixel(Rasterizer.ContriveResult(), new GenericVector <float>(3)
{
1f, 1f, 1f
});
CRenderer.Render(texChar);
tex0.Clear();
Thread.Sleep(16);
}
Rasterizer.EndRasterize();
}
public static unsafe void Line()
{
if (_pointsPtr[0] == _pointsPtr[1])
{
return;
}
float xSub = (_pointsPtr[1].X - _pointsPtr[0].X) * _resolution.X,
ySub = (_pointsPtr[1].Y - _pointsPtr[0].Y) * _resolution.Y;
//0: X-major 1:Y-major
int dir, otherDir;
int dirStep, otherDirStep;
float slopeAbs;
if ((xSub > 0 ? xSub : -xSub) >= (ySub > 0 ? ySub : -ySub))
{
dir = 0;
dirStep = xSub > 0 ? 1 : -1;
otherDirStep = ySub > 0 ? 1 : -1;
slopeAbs = ySub / xSub;
}
else
{
dir = 1;
dirStep = ySub > 0 ? 1 : -1;
otherDirStep = xSub > 0 ? 1 : -1;
slopeAbs = xSub / ySub;
}
otherDir = 1 - dir;
if (slopeAbs < 0)
{
slopeAbs = -slopeAbs;
}
Vector2Int resultPoint = new Vector2Int(JMath.RoundToInt(_pointsPtr[0].X * _resolution.X), JMath.RoundToInt(_pointsPtr[0].Y * _resolution.Y));
if (resultPoint.X == _resolution.X)
{
resultPoint.X--;
}
if (resultPoint.Y == _resolution.Y)
{
resultPoint.Y--;
}
//End coordinate in Int
int end = JMath.RoundToInt(_pointsPtr[1][dir] * _resolution[dir]);
for (float otherDirFrac = slopeAbs; resultPoint[dir] != end; otherDirFrac += slopeAbs, resultPoint[dir] += dirStep)
{
_rasterizeBufferPtr[_rasterizeBufferUsed++] = resultPoint;
if (otherDirFrac >= 1f)
{
resultPoint[otherDir] += otherDirStep;
otherDirFrac--;
}
}
_pointsPtr += 2;
}
private unsafe void FillDownSampler4X4(int srcWidth, int srcHeight, Vector2 *pter, bool shift = true)
{
int idx = 0;
float tU = 1.0f / (float)srcWidth;
float tV = 1.0f / (float)srcHeight;
for (float y = 0; y < 4; y++)
{
for (float x = 0; x < 4; x++)
{
if (shift)
{
pter[idx].X = (x - 1.0f) * tU;
pter[idx].Y = (y - 1.0f) * tV;
}
else
{
pter[idx].X = x * tU;
pter[idx].Y = y * tV;
}
idx++;
}
}
}
private int AssemblePrimitive(Model model, Vector2 *screenCoords)
{
int[] indices = model.Indices;
int i, j;
switch (_assembleMode)
{
case PrimitiveAssembleMode.Line:
for (i = indices.Length - 2, j = i / 2, _linePrimitives.AddEmpty(j + 1); i > -1; i -= 2, j--)
{
AssemblePrimitve(model, screenCoords, i, _linePrimitives.GetPointer(j));
}
return(indices.Length / 2);
case PrimitiveAssembleMode.Triangle:
for (i = indices.Length - 3, j = i / 3, _trianglePrimitives.AddEmpty(j + 1); i > -1; i -= 3, j--)
{
AssemblePrimitve(model, screenCoords, i, _trianglePrimitives.GetPointer(j));
}
return(indices.Length / 3);
case PrimitiveAssembleMode.LineTriangle:
for (i = indices.Length - 3, j = i, _linePrimitives.AddEmpty(j + 3); i > -1; i -= 3, j -= 3)
{
AssemblePrimitve(model, screenCoords, i, _linePrimitives.GetPointer(j));
AssemblePrimitve(model, screenCoords, i + 1, _linePrimitives.GetPointer(j + 1));
AssemblePrimitve(model, screenCoords, i + 2, _linePrimitives.GetPointer(j + 2));
}
return(indices.Length);
}
return(0);
}
private static void selectDiagonal(Vector3 *points, int num, Vector3 *maxColor, Vector3 *minColor)
{
Vector3 center = (*maxColor + *minColor) * 0.5f;
Vector3 t;
Vector2 *tp = (Vector2 *)&t;
Vector2 covariance = new Vector2();
for (uint i = 0; i < num; i++)
{
t = points[i] - center;
covariance += *tp * t._z;
}
float x0 = maxColor->_x;
float y0 = maxColor->_y;
float x1 = minColor->_x;
float y1 = minColor->_y;
if (covariance._x < 0)
{
VoidPtr.Swap(&x0, &x1);
}
if (covariance._y < 0)
{
VoidPtr.Swap(&y0, &y1);
}
maxColor->_x = x0;
maxColor->_y = y0;
minColor->_x = x1;
minColor->_y = y1;
}
public VertexCodec(Vector2 *sPtr, int count)
{
_srcCount = count;
_srcElements = 2;
_pData = (float *)sPtr;
Evaluate(false);
}
/// <summary>
/// Gets offset and velocity.
/// </summary>
/// <param name="offset"> [in,out] If non-, the offset. </param>
/// <param name="velocity"> [in,out] If non-, the velocity. </param>
public unsafe void GetOffsetAndVelocity(Vector2 *offset, Vector2 *velocity)
{
Random2.Default.NextUnitVector(velocity);
switch (Random2.Default.Next(4))
{
case 0:
{
offset->X = Width * -0.5f;
offset->Y = Random2.Default.NextSingle(Height * -0.5f, Height * 0.5f);
break;
}
case 1:
{
offset->X = Random2.Default.NextSingle(Width * -0.5f, Width * 0.5f);
offset->Y = Height * -0.5f;
break;
}
case 2:
{
offset->X = Width * 0.5f;
offset->Y = Random2.Default.NextSingle(Height * -0.5f, Height * 0.5f);
break;
}
default: // catch 3
{
offset->X = Random2.Default.NextSingle(Width * -0.5f, Width * 0.5f);
offset->Y = Height * 0.5f;
break;
}
}
}
private unsafe void DrawDisconnectedIndicator()
{
MyPlayer player;
MyPlayer.PlayerId?savedPlayer = (base.Entity as MyCharacter).SavedPlayer;
if (((savedPlayer != null) && (savedPlayer.Value.SerialId == 0)) && !MySession.Static.Players.TryGetPlayerById(savedPlayer.Value, out player))
{
Vector3D vectord = (base.Entity.PositionComp.GetPosition() + (base.Entity.PositionComp.LocalAABB.Height * base.Entity.PositionComp.WorldMatrix.Up)) + (base.Entity.PositionComp.WorldMatrix.Up * 0.20000000298023224);
double num = Vector3D.Distance(MySector.MainCamera.Position, vectord);
if (num <= MAX_DISCONNECT_ICON_DISTANCE)
{
Color white = Color.White;
Color *colorPtr1 = (Color *)ref white;
colorPtr1.A = (byte)(white.A * ((float)Math.Min(1.0, Math.Max((double)0.0, (double)((MAX_DISCONNECT_ICON_DISTANCE - num) / 10.0)))));
MyGuiDrawAlignEnum drawAlign = MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_BOTTOM;
MyGuiPaddedTexture texture = MyGuiConstants.TEXTURE_DISCONNECTED_PLAYER;
Vector3D vectord2 = Vector3D.Transform(vectord, MySector.MainCamera.ViewMatrix * MySector.MainCamera.ProjectionMatrix);
if (vectord2.Z < 1.0)
{
Vector2 hudPos = new Vector2((float)vectord2.X, (float)vectord2.Y);
hudPos = (hudPos * 0.5f) + (0.5f * Vector2.One);
Vector2 *vectorPtr1 = (Vector2 *)ref hudPos;
vectorPtr1->Y = 1f - hudPos.Y;
Vector2 normalizedCoord = MyGuiScreenHudBase.ConvertHudToNormalizedGuiPosition(ref hudPos);
MyGuiManager.DrawSpriteBatch(texture.Texture, normalizedCoord, (texture.SizeGui * 0.5f) * (1f - (((float)num) / ((float)MAX_DISCONNECT_ICON_DISTANCE))), white, drawAlign, false, true);
}
}
}
}
private void setUV(Vector2 *xy, Vector2 *uv)
{
for (int i = 0; i < 6; ++i)
{
uv[i] = (xy[i] + Vector2.one * 0.5f) / textureSize;
}
}
internal unsafe void GetWitnessPoints(Vector2 *pA, Vector2 *pB)
{
switch (_count)
{
case 0:
break;
case 1:
*pA = _v1.wA;
*pB = _v1.wB;
break;
case 2:
*pA = _v1.a * _v1.wA + _v2.a * _v2.wA;
*pB = _v1.a * _v1.wB + _v2.a * _v2.wB;
break;
case 3:
*pA = _v1.a * _v1.wA + _v2.a * _v2.wA + _v3.a * _v3.wA;
*pB = *pA;
break;
default:
break;
}
}
private unsafe void UpdateStream(int index)
{
index += 4;
if (_manager._faceData[index] == null || !_enabled[index - 4])
{
return;
}
//Set starting address
byte *pDst = (byte *)_renderBuffer.Address;
for (int i = 4; i < index; i++)
{
if (_manager._faceData[i] != null && _enabled[i - 4])
{
pDst += 8;
}
}
Vector2 *pSrc = (Vector2 *)_manager._faceData[index].Address;
for (int i = 0; i < _manager._pointCount; i++, pDst += _stride)
{
*(Vector2 *)pDst = *pSrc++;
}
}
private unsafe void GetWindowSize(ImGuiViewportPtr vp, Vector2 *outSize)
{
VeldridImGuiWindow window = (VeldridImGuiWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
Rectangle bounds = window.Window.Bounds;
*outSize = new Vector2(bounds.Width, bounds.Height);
}
public void Execute(int i)
{
Vector2 *resultV = result + i;
byte * off = input + i * byteStride;
*resultV = *(Vector2 *)off;
(*resultV).y = 1 - (*resultV).y;
}
private unsafe void Move(float deltaPos)
{
Vector2 anchoredPosition = this.contentRoot.anchoredPosition;
Vector2 *vectorPtr1 = &anchoredPosition;
vectorPtr1->x -= deltaPos;
this.contentRoot.anchoredPosition = anchoredPosition;
}
private unsafe static extern bool ProcessImage(
Vector2 *resultArray,
Color32[] rawImage,
Vector2 userInput,
int width,
int height,
bool rotated
);
public void Execute(int i)
{
Vector2 *resultV = (Vector2 *)(((byte *)result) + (i * outputByteStride));
byte * off = input + (i * inputByteStride);
*resultV = *(Vector2 *)off;
(*resultV).y = 1 - (*resultV).y;
}
public override unsafe void RenderSprites(RenderingTextureAllocator textureAllocator, bool linearFilter, params Sprite[] sprites)
{
Vector2 textureScaling = new Vector2(16777216.0f) / new Vector2(textureAllocator.Size.X, textureAllocator.Size.Y);
// Build vertex buffer
int vertexCount = sprites.Length * 6;
int bufferSize = vertexCount * (sizeof(Vector2) + sizeof(ulong));
fixed(byte *data = new byte[bufferSize])
{
Vector2 *positions = (Vector2 *)(data);
ulong * uvws = (ulong *)(data + vertexCount * sizeof(Vector2));
// Setup vertices
int count = sprites.Length;
for (int i = 0; i < count; ++i)
{
Sprite sprite = sprites[i];
VectorInt3 texPos = textureAllocator.Get(sprite.Texture);
VectorInt2 texSize = sprite.Texture.To - sprite.Texture.From;
positions[i * 6 + 0] = sprite.Pos00;
positions[i * 6 + 2] = positions[i * 6 + 3] = sprite.Pos10;
positions[i * 6 + 1] = positions[i * 6 + 4] = sprite.Pos01;
positions[i * 6 + 5] = sprite.Pos11;
uvws[i * 6 + 1] = uvws[i * 6 + 4] = Dx11RenderingDevice.CompressUvw(texPos, textureScaling, new Vector2(0.5f, 0.5f));
uvws[i * 6 + 5] = Dx11RenderingDevice.CompressUvw(texPos, textureScaling, new Vector2(texSize.X - 0.5f, 0.5f));
uvws[i * 6 + 0] = Dx11RenderingDevice.CompressUvw(texPos, textureScaling, new Vector2(0.5f, texSize.Y - 0.5f));
uvws[i * 6 + 2] = uvws[i * 6 + 3] = Dx11RenderingDevice.CompressUvw(texPos, textureScaling, new Vector2(texSize.X - 0.5f, texSize.Y - 0.5f));
}
// Create GPU resources
using (var VertexBuffer = new Buffer(Device.Device, new IntPtr(data),
new BufferDescription(bufferSize, ResourceUsage.Immutable, BindFlags.VertexBuffer,
CpuAccessFlags.None, ResourceOptionFlags.None, 0)))
{
var VertexBufferBindings = new VertexBufferBinding[] {
new VertexBufferBinding(VertexBuffer, sizeof(Vector2), (int)((byte *)positions - data)),
new VertexBufferBinding(VertexBuffer, sizeof(ulong), (int)((byte *)uvws - data))
};
// Render
Bind();
Device.SpriteShader.Apply(Device.Context);
Device.Context.PixelShader.SetSampler(0, linearFilter ? Device.SamplerDefault : Device.SamplerRoundToNearest);
Device.Context.PixelShader.SetShaderResources(0, ((Dx11RenderingTextureAllocator)(textureAllocator)).TextureView);
Device.Context.InputAssembler.SetVertexBuffers(0, VertexBufferBindings);
Device.Context.OutputMerger.SetDepthStencilState(Device.DepthStencilNoZBuffer);
// Render
Device.Context.Draw(vertexCount, 0);
// Reset state
Device.Context.OutputMerger.SetDepthStencilState(Device.DepthStencilDefault);
}
}
}
public unsafe static Vector2[] GetUVsFloatInterleaved(
ref byte[] bytes,
int start,
int count,
int byteStride
)
{
Profiler.BeginSample("GetUVsFloatInterleaved");
var res = new Vector2[count];
int elementSize = Marshal.SizeOf(typeof(Vector2));
#if BUFFER_MEMORY_COPY
fixed(Vector2 *dest = &(res[0]))
{
Vector2 *destV = dest;
fixed(byte *src = &(bytes[start]))
{
byte *off = src;
for (int i = 0; i < count; i++)
{
System.Buffer.MemoryCopy(
off,
destV,
elementSize,
elementSize
);
off += byteStride;
destV += 1;
}
}
}
#else
var gcRes = GCHandle.Alloc(res, GCHandleType.Pinned);
int off = start;
var dest = gcRes.AddrOfPinnedObject();
for (int i = 0; i < count; i++)
{
Marshal.Copy(bytes, off, dest, elementSize);
off += byteStride;
dest += elementSize;
}
gcRes.Free();
#endif
for (var i = 0; i < count; i++)
{
res[i].y = 1 - res[i].y;
}
Profiler.EndSample();
return(res);
}
private static unsafe float XIntercept(Vector2 *p, Vector2 *q, float y)
{
if (Math.Abs(p->Y - q->Y) < float.Epsilon)
{
throw new ArgumentException("unexpected horizontal segment");
}
return(q->X - ((q->Y - y) * ((p->X - q->X) / (p->Y - q->Y))));
}
private unsafe void Start()
{
RectTransform component = this.inputField.InputField.gameObject.GetComponent <RectTransform>();
Vector2 pivot = component.pivot;
Vector2 * vectorPtr1 = &pivot;
vectorPtr1->y += this.yPivotOffset;
component.pivot = pivot;
}
private void setXY(float baseX, float baseY, float width, float height, Vector2 *xy)
{
xy[0] = new Vector2(baseX + width, /**/ baseY);
xy[1] = new Vector2(baseX, /**/ baseY + height);
xy[2] = new Vector2(baseX + 2 * width, /**/ baseY + height);
xy[3] = new Vector2(baseX + 2 * width + spacing, baseY + height);
xy[4] = new Vector2(baseX + 3 * width + spacing, baseY);
xy[5] = new Vector2(baseX + width + spacing, /**/ baseY);
}
private unsafe void Awake()
{
this.nextUpgrade.SetActive(this.showNextUpgradeValue);
RectTransform component = this.upgradeGlow.GetComponent <RectTransform>();
Vector2 sizeDelta = component.sizeDelta;
Vector2 * vectorPtr1 = &sizeDelta;
vectorPtr1->x *= 100f / ((float)UpgradablePropertiesUtils.MAX_LEVEL);
component.sizeDelta = sizeDelta;
}
private unsafe void GetWindowPos(ImGuiViewportPtr vp, Vector2 *outPos)
{
VeldridImGuiWindow?window = (VeldridImGuiWindow?)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
if (window == null)
{
throw new NullReferenceException();
}
*outPos = new Vector2(window.Window.Bounds.X, window.Window.Bounds.Y);
}
/// <summary>
/// Gets offset and velocity.
/// </summary>
/// <param name="offset"> [in,out] If non-, the offset. </param>
/// <param name="velocity"> [in,out] If non-, the velocity. </param>
public unsafe void GetOffsetAndVelocity(Vector2 *offset, Vector2 *velocity)
{
offset->X = 0;
offset->Y = 0;
double angle = Math.Atan2(Direction.Y, Direction.X);
angle = Random2.Default.NextDouble(angle - Spread, angle + Spread);
velocity->X = (float)Math.Cos(angle);
velocity->Y = (float)Math.Sin(angle);
}
public static void Main(string[] args)
{
Console.WriteLine("Hello, world!");
Vector2 result;
Vector2 *resultP = ReturnsVec2(out result);
Console.WriteLine($"ReturnsVec2 = {result} ({resultP == &result})");
CdeclCallbackTest(TestCallback);
StdcallCallbackTest(TestCallback);
Console.WriteLine("Done.");
Console.ReadLine();
}
private unsafe Matrix4x4 GetOrthographicProjectionMatrix(Vector2 offset)
{
float orthographicSize = base.context.camera.orthographicSize;
float num2 = orthographicSize * base.context.camera.aspect;
Vector2 *vectorPtr1 = &offset;
vectorPtr1->x *= num2 / (0.5f * base.context.width);
Vector2 *vectorPtr2 = &offset;
vectorPtr2->y *= orthographicSize / (0.5f * base.context.height);
return(Matrix4x4.Ortho(offset.x - num2, offset.x + num2, offset.y - orthographicSize, offset.y + orthographicSize, base.context.camera.nearClipPlane, base.context.camera.farClipPlane));
}
private static void WriteUVs(string name, Vector2 *pData, int count, int set, XmlWriter writer)
{
bool first = true;
//Position source
writer.WriteStartElement("source");
writer.WriteAttributeString("id", name + "_UVs" + set.ToString());
//Array start
writer.WriteStartElement("float_array");
writer.WriteAttributeString("id", name + "_UVArr" + set.ToString());
writer.WriteAttributeString("count", (count * 2).ToString());
for (int i = 0; i < count; i++)
{
if (first)
{
first = false;
}
else
{
writer.WriteString(" ");
}
//Reverse T component to a top-down form
writer.WriteString(String.Format("{0} {1}", pData->_x, 1.0 - pData->_y));
pData++;
}
writer.WriteEndElement(); //int_array
//Technique
writer.WriteStartElement("technique_common");
writer.WriteStartElement("accessor");
writer.WriteAttributeString("source", "#" + name + "_UVArr" + set.ToString());
writer.WriteAttributeString("count", count.ToString());
writer.WriteAttributeString("stride", "2");
writer.WriteStartElement("param");
writer.WriteAttributeString("name", "S");
writer.WriteAttributeString("type", "float");
writer.WriteEndElement(); //param
writer.WriteStartElement("param");
writer.WriteAttributeString("name", "T");
writer.WriteAttributeString("type", "float");
writer.WriteEndElement(); //param
writer.WriteEndElement(); //accessor
writer.WriteEndElement(); //technique_common
writer.WriteEndElement(); //source
}
public void Execute()
{
Vector2 *resultV = result;
byte * off = input;
for (int i = 0; i < count; i++)
{
*resultV = *(Vector2 *)off;
off += byteStride;
resultV += 1;
}
}
private unsafe void GetWindowSize(ImGuiViewportPtr vp, Vector2 *outSize)
{
VeldridImGuiWindow?window = (VeldridImGuiWindow?)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
if (window == null)
{
throw new NullReferenceException();
}
Rectangle bounds = window.Window.Bounds;
*outSize = new Vector2(bounds.Width, bounds.Height);
}
