public void ArrayBufferWithOffsetConstructorWorks() { var buf = new ArrayBuffer(80); var arr = new Uint16Array(buf, 16); Assert.IsTrue((object)arr is Uint16Array); Assert.IsTrue(arr.Buffer == buf, "buffer"); Assert.AreEqual(arr.Length, 32, "length"); }
public void CopyConstructorWorks() { var source = new Uint16Array(new ushort[] { 3, 8, 4 }); var arr = new Uint16Array(source); Assert.IsTrue(arr != source, "New object"); Assert.IsTrue((object)arr is Uint16Array, "is Uint16Array"); AssertContent(arr, new[] { 3, 8, 4 }, "content"); }
public void SubarrayWithBeginWorks() { var source = new Uint16Array(10); var arr = source.SubArray(3); Assert.False(arr == source, "Should be a new array"); Assert.True(arr.Buffer == source.Buffer, "Should be the same buffer"); Assert.AreEqual(6, arr.ByteOffset, "ByteOffset should be correct"); }
public void CopyConstructorWorks() { var source = new Uint16Array(new ushort[] { 3, 8, 4 }); var arr = new Uint16Array(source); Assert.True(arr != source, "New object"); Assert.True((object)arr is Uint16Array, "is Uint16Array"); AssertContent(arr, new[] { 3, 8, 4 }, "content"); }
public void ArrayBufferConstructorWorks() { var buf = new ArrayBuffer(80); var arr = new Uint16Array(buf); Assert.True((object)arr is Uint16Array); Assert.True(arr.Buffer == buf, "buffer"); Assert.AreEqual(40, arr.Length, "length"); }
public void ArrayBufferWithOffsetAndLengthConstructorWorks() { var buf = new ArrayBuffer(80); var arr = new Uint16Array(buf, 16, 12); Assert.True((object)arr is Uint16Array); Assert.True(arr.Buffer == buf, "buffer"); Assert.AreEqual(12, arr.Length, "length"); }
public void ConstructorFromIntWorks() { var source = new ushort[] { 3, 8, 4 }; var arr = new Uint16Array(source); Assert.IsTrue((object)arr != (object)source, "New object"); Assert.IsTrue((object)arr is Uint16Array, "is Uint16Array"); AssertContent(arr, new[] { 3, 8, 4 }, "content"); }
public void SubarrayWithBeginAndEndWorks() { var source = new Uint16Array(10); var arr = source.Subarray(3, 7); Assert.IsFalse(arr == source, "Should be a new array"); Assert.IsTrue(arr.Buffer == source.Buffer, "Should be the same buffer"); Assert.AreEqual(arr.ByteOffset, 6, "ByteOffset should be correct"); Assert.AreEqual(arr.Length, 4, "Length should be correct"); }
public static IReadable CreateStringReader(string tex) { var buf = new ArrayBuffer(tex.Length * 2); var view = new Uint16Array(buf); for (int i = 0; i < tex.Length; i++) { view[i] = tex[i]; } return(ByteBuffer.FromBuffer(view.As <byte[]>())); }
public void ForeachWorks() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); var l = new List <int>(); foreach (var i in arr) { l.Add(i); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void GetEnumeratorWorks() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); var l = new List <int>(); var enm = arr.GetEnumerator(); while (enm.MoveNext()) { l.Add(enm.Current); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void ForeachWorks_SPI_1401() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); var l = new List <int>(); // #1401 foreach (var i in arr) { l.Add(i); } Assert.AreEqual(l.ToArray(), new[] { 3, 6, 2, 9, 5 }); }
private void AssertContent(Uint16Array actual, int[] expected, string message) { if (actual.Length != expected.Length) { Assert.Fail(message + ": Expected length " + expected.Length + ", actual: " + actual.Length); return; } for (int i = 0; i < expected.Length; i++) { if (actual[i] != expected[i]) { Assert.Fail(message + ": Position " + i + ": expected " + expected[i] + ", actual: " + actual[i]); return; } } Assert.IsTrue(true, message); }
private static UInt16[] CloneArray(UInt16[] indexArray) { int count = indexArray.Length; Uint16Array ui16array = new Uint16Array(count); UInt16[] indexArrayNew = (UInt16[])(object)ui16array; for (int i = 0; i < count; i++) { indexArrayNew[i] = indexArray[i]; } return(indexArrayNew); }
public void TypePropertiesAreCorrect() { Assert.AreEqual(typeof(Uint16Array).FullName, "Uint16Array", "FullName"); var interfaces = typeof(Uint16Array).GetInterfaces(); Assert.AreEqual(interfaces.Length, 3, "Interface count should be 3"); Assert.IsTrue(interfaces.Contains(typeof(IEnumerable<ushort>)), "Interfaces should contain IEnumerable<ushort>"); Assert.IsTrue(interfaces.Contains(typeof(ICollection<ushort>)), "Interfaces should contain ICollection<ushort>"); Assert.IsTrue(interfaces.Contains(typeof(IList<ushort>)), "Interfaces should contain IList<ushort>"); object arr = new Uint16Array(0); Assert.IsTrue(arr is Uint16Array, "Is Uint16Array"); Assert.IsTrue(arr is IEnumerable<ushort>, "Is IEnumerable<ushort>"); Assert.IsTrue(arr is ICollection<ushort>, "Is ICollection<ushort>"); Assert.IsTrue(arr is IList<ushort>, "Is IList<ushort>"); }
private void AssertContent(Uint16Array actual, int[] expected, string message) { if (actual.Length != expected.Length) { Assert.Fail(message + ": Expected length " + expected.Length + ", actual: " + actual.Length); return; } for (int i = 0; i < expected.Length; i++) { if (actual[i] != expected[i]) { Assert.Fail(message + ": Position " + i + ": expected " + expected[i] + ", actual: " + actual[i]); return; } } Assert.True(true, message); }
public void TypePropertiesAreCorrect() { Assert.AreEqual(typeof(Uint16Array).FullName, "Uint16Array", "FullName"); var interfaces = typeof(Uint16Array).GetInterfaces(); Assert.AreEqual(interfaces.Length, 3, "Interface count should be 3"); Assert.IsTrue(interfaces.Contains(typeof(IEnumerable <ushort>)), "Interfaces should contain IEnumerable<ushort>"); Assert.IsTrue(interfaces.Contains(typeof(ICollection <ushort>)), "Interfaces should contain ICollection<ushort>"); Assert.IsTrue(interfaces.Contains(typeof(IList <ushort>)), "Interfaces should contain IList<ushort>"); object arr = new Uint16Array(0); Assert.IsTrue(arr is Uint16Array, "Is Uint16Array"); Assert.IsTrue(arr is IEnumerable <ushort>, "Is IEnumerable<ushort>"); Assert.IsTrue(arr is ICollection <ushort>, "Is ICollection<ushort>"); Assert.IsTrue(arr is IList <ushort>, "Is IList<ushort>"); }
public static void TestUseCase(Assert assert) { assert.Expect(10); var array1 = new Int8Array(1); Bridge550.TestMethod(array1, "Int8Array", assert); var array2 = new Uint8Array(1); Bridge550.TestMethod(array2, "Uint8Array", assert); var array3 = new Uint8ClampedArray(1); Bridge550.TestMethod(array3, "Uint8ClampedArray", assert); var array4 = new Int16Array(1); Bridge550.TestMethod(array4, "Int16Array", assert); var array5 = new Uint16Array(1); Bridge550.TestMethod(array5, "Uint16Array", assert); var array6 = new Int32Array(1); Bridge550.TestMethod(array6, "Int32Array", assert); var array7 = new Uint32Array(1); Bridge550.TestMethod(array7, "Uint32Array", assert); var array8 = new Float32Array(1); Bridge550.TestMethod(array8, "Float32Array", assert); var array9 = new Float64Array(1); Bridge550.TestMethod(array9, "Float64Array", assert); var array10 = new DataView(array9.Buffer); Bridge550.TestMethod(array10, "DataView", assert); }
private void PlatformDrawUserIndexedPrimitives <T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct { ApplyState(true); var count = GetElementCountArray(primitiveType, primitiveCount); var vertexArrayBuffer = ConvertVertices(vertexData, vertexOffset, numVertices, vertexDeclaration); var uintIndexData = new Uint16Array(count.As <uint>());//indexData.As<Uint16Array>(); for (uint i = 0; i < uintIndexData.length; i++) { uintIndexData[i] = indexData[indexOffset + i].As <ushort>(); } var vertexBuffer = gl.createBuffer(); var indexBuffer = gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer); GraphicsExtensions.CheckGLError(); gl.bufferData(gl.ARRAY_BUFFER, vertexArrayBuffer, gl.STATIC_DRAW); GraphicsExtensions.CheckGLError(); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer); GraphicsExtensions.CheckGLError(); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, uintIndexData, gl.STATIC_DRAW); GraphicsExtensions.CheckGLError(); _vertexBuffersDirty = true; _indexBufferDirty = true; var mode = (uint)GraphicsExtensions.GetPrimitiveTypeGL(primitiveType); vertexDeclaration.GraphicsDevice = this; vertexDeclaration.Apply(_vertexShader, vertexOffset, ShaderProgramHash); GraphicsExtensions.CheckGLError(); gl.drawElements(mode, count, gl.UNSIGNED_SHORT, 0); GraphicsExtensions.CheckGLError(); gl.bindBuffer(gl.ARRAY_BUFFER, null); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null); gl.deleteBuffer(vertexBuffer); gl.deleteBuffer(indexBuffer); }
private void BufferData <T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct { GenerateIfRequired(); var elementSizeInByte = (IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4); var bufferSize = IndexCount * elementSizeInByte; gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo); GraphicsExtensions.CheckGLError(); if (options == SetDataOptions.Discard) { // By assigning NULL data to the buffer this gives a hint // to the device to discard the previous content. gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Int16Array(0), _isDynamic ? gl.STREAM_DRAW : gl.STATIC_DRAW); GraphicsExtensions.CheckGLError(); } if (elementSizeInByte == 2) { var arr = new Uint16Array((uint)elementCount); for (uint i = 0; i < elementCount; i++) { arr[i] = data[i + startIndex].As <ushort>(); } gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, arr); } else { var arr = new Uint32Array((uint)elementCount); for (uint i = 0; i < elementCount; i++) { arr[i] = data[i + startIndex].As <uint>(); } gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, arr); } GraphicsExtensions.CheckGLError(); }
public static IEnumerable <object[]> ArrayType_TestData() { _objectPrototype ??= new Function("return Object.prototype.toString;"); yield return(new object[] { _objectPrototype.Call(), "Uint8Array", Uint8Array.From(new byte[10]) }); yield return(new object[] { _objectPrototype.Call(), "Uint8ClampedArray", Uint8ClampedArray.From(new byte[10]) }); yield return(new object[] { _objectPrototype.Call(), "Int8Array", Int8Array.From(new sbyte[10]) }); yield return(new object[] { _objectPrototype.Call(), "Uint16Array", Uint16Array.From(new ushort[10]) }); yield return(new object[] { _objectPrototype.Call(), "Int16Array", Int16Array.From(new short[10]) }); yield return(new object[] { _objectPrototype.Call(), "Uint32Array", Uint32Array.From(new uint[10]) }); yield return(new object[] { _objectPrototype.Call(), "Int32Array", Int32Array.From(new int[10]) }); yield return(new object[] { _objectPrototype.Call(), "Float32Array", Float32Array.From(new float[10]) }); yield return(new object[] { _objectPrototype.Call(), "Float64Array", Float64Array.From(new double[10]) }); yield return(new object[] { _objectPrototype.Call(), "Array", new Array(10) }); }
public void TypePropertiesAreCorrect_SPI_1559() { Assert.AreEqual("Uint16Array", typeof(Uint16Array).FullName, "FullName"); var interfaces = typeof(Uint16Array).GetInterfaces(); Assert.AreEqual(1, interfaces.Length, "Interface count should be 5"); Assert.True(interfaces.Contains(typeof(IEnumerable <ushort>)), "Interfaces should contain IEnumerable<ushort>"); Assert.False(interfaces.Contains(typeof(ICollection <ushort>)), "Interfaces should contain ICollection<ushort>"); Assert.False(interfaces.Contains(typeof(IList <ushort>)), "Interfaces should contain IList<ushort>"); // Not JS API //Assert.True(interfaces.Contains(typeof(IReadOnlyCollection<ushort>)), "Interfaces should contain IReadOnlyCollection<ushort>"); //Assert.True(interfaces.Contains(typeof(IReadOnlyList<ushort>)), "Interfaces should contain IReadOnlyList<ushort>"); object arr = new Uint16Array(0); Assert.True(arr is Uint16Array, "Is Uint16Array"); Assert.True(arr is IEnumerable <ushort>, "Is IEnumerable<ushort>"); Assert.False(arr is ICollection <ushort>, "Is ICollection<ushort>"); Assert.False(arr is IList <ushort>, "Is IList<ushort>"); // Not JS API //Assert.True(arr is IReadOnlyCollection<short>, "Is IReadOnlyCollection<ushort>"); //Assert.True(arr is IReadOnlyList<ushort>, "Is IReadOnlyList<ushort>"); }
public void IndexingWorks() { var arr = new Uint16Array(3); arr[1] = 42; AssertContent(arr, new[] { 0, 42, 0 }, "Content"); Assert.AreEqual(arr[1], 42, "[1]"); }
public void SetNormalArrayWorks() { var arr = new Uint16Array(4); arr.Set(new ushort[] { 3, 6, 7 }); AssertContent(arr, new[] { 3, 6, 7, 0 }, "Content"); }
public void ContainsWorks() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); Assert.IsTrue (arr.Contains(9), "9"); Assert.IsFalse(arr.Contains(1), "1"); }
public void BufferPropertyWorks() { var buf = new ArrayBuffer(100); var arr = new Uint16Array(buf); Assert.IsTrue(arr.Buffer == buf, "Should be correct"); }
public ShortIndexBuffer(Uint16Array indexes) { Buffer = Tile.PrepDevice.createBuffer(); Tile.PrepDevice.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, Buffer); Tile.PrepDevice.bufferData(GL.ELEMENT_ARRAY_BUFFER, indexes, GL.STATIC_DRAW); }
public static void TestUseCase(Assert assert) { var isToStringToTypeNameLogic = !BrowserHelper.IsChrome(); assert.Expect(153); var v1 = new Float32Array(10); assert.Ok(v1 != null, "Float32Array created"); v1[1] = 11; v1[5] = 5; v1[9] = 99; assert.Equal(v1[1], 11, "Float32Array indexier works 1"); assert.Equal(v1[9], 99, "Float32Array indexier works 9"); // Check just a select number of references inside the Prototype inheritance. assert.Ok(v1.Buffer != null, "Float32Array Buffer"); assert.Equal(v1.ByteLength, 40, "Float32Array ByteLength"); assert.Equal(v1.ByteOffset, 0, "Float32Array ByteOffset"); assert.Equal(v1.Length, 10, "Float32Array Length"); /* * Commented out. Reason: Only Firefox implements them. * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array * var mA = v1.Join(); * v1.Reverse(); * var mB = v1.Slice(); * var mC = v1.Sort(); */ var expectedToStringFloat32Array1 = isToStringToTypeNameLogic ? "[object Float32Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v1.ToLocaleString(), expectedToStringFloat32Array1, "Float32Array ToLocaleString"); assert.Equal(v1.ToString(), expectedToStringFloat32Array1, "Float32Array ToString"); // Some browsers do not support SubArray() with no parameters. // At least 'begin' must be provided. var subArray11 = v1.SubArray(1); var expectedToStringFloat32Array2 = isToStringToTypeNameLogic ? "[object Float32Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray11 != null, "Float32Array SubArray1"); assert.Equal(subArray11.Length, 9, "Float32Array SubArray1 Length"); assert.Equal(subArray11.ToString(), expectedToStringFloat32Array2, "Float32Array SubArray1 ToString"); assert.Equal(subArray11.ByteOffset, 4, "Float32Array SubArray1 ByteOffset"); var subArray12 = subArray11.SubArray(2, 6); var expectedToStringFloat32Array3 = isToStringToTypeNameLogic ? "[object Float32Array]" : "0,0,5,0"; assert.Ok(subArray12 != null, "Float32Array SubArray2"); assert.Equal(subArray12.Length, 4, "Float32Array SubArray2 Length"); assert.Equal(subArray12.ToString(), expectedToStringFloat32Array3, "Float32Array SubArray2 ToString"); assert.Equal(subArray12.ByteOffset, 12, "Float32Array SubArray2 ByteOffset"); var v2 = new Float64Array(10); assert.Ok(v2 != null, "Float64Array created"); v2[1] = 11; v2[5] = 5; v2[9] = 99; assert.Equal(v2[1], 11, "Float64Array indexier works 1"); assert.Equal(v2[9], 99, "Float64Array indexier works 9"); assert.Ok(v2.Buffer != null, "Float64Array Buffer"); assert.Equal(v2.ByteLength, 80, "Float64Array ByteLength"); assert.Equal(v2.ByteOffset, 0, "Float64Array ByteOffset"); assert.Equal(v2.Length, 10, "Float64Array Length"); var expectedToStringFloat64Array1 = isToStringToTypeNameLogic ? "[object Float64Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v2.ToLocaleString(), expectedToStringFloat64Array1, "Float64Array ToLocaleString"); assert.Equal(v2.ToString(), expectedToStringFloat64Array1, "Float64Array ToString"); var subArray21 = v2.SubArray(1); var expectedToStringFloat64Array2 = isToStringToTypeNameLogic ? "[object Float64Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray21 != null, "Float64Array SubArray1"); assert.Equal(subArray21.Length, 9, "Float64Array SubArray1 Length"); assert.Equal(subArray21.ToString(), expectedToStringFloat64Array2, "Float64Array SubArray1 ToString"); assert.Equal(subArray21.ByteOffset, 8, "Float64Array SubArray1 ByteOffset"); var subArray22 = subArray21.SubArray(2, 6); var expectedToStringFloat64Array3 = isToStringToTypeNameLogic ? "[object Float64Array]" : "0,0,5,0"; assert.Ok(subArray22 != null, "Float64Array SubArray2"); assert.Equal(subArray22.Length, 4, "Float64Array SubArray2 Length"); assert.Equal(subArray22.ToString(), expectedToStringFloat64Array3, "Float64Array SubArray2 ToString"); assert.Equal(subArray22.ByteOffset, 24, "Float64Array SubArray2 ByteOffset"); var v3 = new Int16Array(10); assert.Ok(v3 != null, "Int16Array created"); v3[1] = 11; v3[5] = 5; v3[9] = 99; assert.Equal(v3[1], 11, "Int16Array indexier works 1"); assert.Equal(v3[9], 99, "Int16Array indexier works 9"); assert.Ok(v3.Buffer != null, "Int16Array Buffer"); assert.Equal(v3.ByteLength, 20, "Int16Array ByteLength"); assert.Equal(v3.ByteOffset, 0, "Int16Array ByteOffset"); assert.Equal(v3.Length, 10, "Int16Array Length"); var expectedToStringInt16Array1 = isToStringToTypeNameLogic ? "[object Int16Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v3.ToLocaleString(), expectedToStringInt16Array1, "Int16Array ToLocaleString"); assert.Equal(v3.ToString(), expectedToStringInt16Array1, "Int16Array ToString"); var subArray31 = v3.SubArray(1); var expectedToStringInt16Array2 = isToStringToTypeNameLogic ? "[object Int16Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray31 != null, "Int16Array SubArray1"); assert.Equal(subArray31.Length, 9, "Int16Array SubArray1 Length"); assert.Equal(subArray31.ToString(), expectedToStringInt16Array2, "Int16Array SubArray1 ToString"); assert.Equal(subArray31.ByteOffset, 2, "Int16Array SubArray1 ByteOffset"); var subArray32 = subArray31.SubArray(2, 6); var expectedToStringInt16Array3 = isToStringToTypeNameLogic ? "[object Int16Array]" : "0,0,5,0"; assert.Ok(subArray32 != null, "Int16Array SubArray2"); assert.Equal(subArray32.Length, 4, "Int16Array SubArray2 Length"); assert.Equal(subArray32.ToString(), expectedToStringInt16Array3, "Int16Array SubArray2 ToString"); assert.Equal(subArray32.ByteOffset, 6, "Int16Array SubArray2 ByteOffset"); var v4 = new Int32Array(10); assert.Ok(v4 != null, "Int32Array created"); v4[1] = 11; v4[5] = 5; v4[9] = 99; assert.Equal(v4[1], 11, "Int32Array indexier works 1"); assert.Equal(v4[9], 99, "Int32Array indexier works 9"); assert.Ok(v4.Buffer != null, "Int32Array Buffer"); assert.Equal(v4.ByteLength, 40, "Int32Array ByteLength"); assert.Equal(v4.ByteOffset, 0, "Int32Array ByteOffset"); assert.Equal(v4.Length, 10, "Int32Array Length"); var expectedToStringInt32Array1 = isToStringToTypeNameLogic ? "[object Int32Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v4.ToLocaleString(), expectedToStringInt32Array1, "Int32Array ToLocaleString"); assert.Equal(v4.ToString(), expectedToStringInt32Array1, "Int32Array ToString"); var subArray41 = v4.SubArray(1); var expectedToStringInt32Array2 = isToStringToTypeNameLogic ? "[object Int32Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray41 != null, "Int32Array SubArray1"); assert.Equal(subArray41.Length, 9, "Int32Array SubArray1 Length"); assert.Equal(subArray41.ToString(), expectedToStringInt32Array2, "Int32Array SubArray1 ToString"); assert.Equal(subArray41.ByteOffset, 4, "Int32Array SubArray1 ByteOffset"); var subArray42 = subArray41.SubArray(2, 6); var expectedToStringInt32Array3 = isToStringToTypeNameLogic ? "[object Int32Array]" : "0,0,5,0"; assert.Ok(subArray42 != null, "Int32Array SubArray2"); assert.Equal(subArray42.Length, 4, "Int32Array SubArray2 Length"); assert.Equal(subArray42.ToString(), expectedToStringInt32Array3, "Int32Array SubArray2 ToString"); assert.Equal(subArray42.ByteOffset, 12, "Int32Array SubArray2 ByteOffset"); var v5 = new Int8Array(10); assert.Ok(v5 != null, "Int8Array created"); v5[1] = 11; v5[5] = 5; v5[9] = 99; assert.Equal(v5[1], 11, "Int8Array indexier works 1"); assert.Equal(v5[9], 99, "Int8Array indexier works 9"); assert.Ok(v5.Buffer != null, "Int8Array Buffer"); assert.Equal(v5.ByteLength, 10, "Int8Array ByteLength"); assert.Equal(v5.ByteOffset, 0, "Int8Array ByteOffset"); assert.Equal(v5.Length, 10, "Int8Array Length"); var expectedToStringInt8Array1 = isToStringToTypeNameLogic ? "[object Int8Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v5.ToLocaleString(), expectedToStringInt8Array1, "Int8Array ToLocaleString"); assert.Equal(v5.ToString(), expectedToStringInt8Array1, "Int8Array ToString"); var subArray51 = v5.SubArray(1); var expectedToStringInt8Array2 = isToStringToTypeNameLogic ? "[object Int8Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray51 != null, "Int8Array SubArray1"); assert.Equal(subArray51.Length, 9, "Int8Array SubArray1 Length"); assert.Equal(subArray51.ToString(), expectedToStringInt8Array2, "Int8Array SubArray1 ToString"); assert.Equal(subArray51.ByteOffset, 1, "Int8Array SubArray1 ByteOffset"); var subArray52 = subArray51.SubArray(2, 6); var expectedToStringInt8Array3 = isToStringToTypeNameLogic ? "[object Int8Array]" : "0,0,5,0"; assert.Ok(subArray52 != null, "Int8Array SubArray2"); assert.Equal(subArray52.Length, 4, "Int8Array SubArray2 Length"); assert.Equal(subArray52.ToString(), expectedToStringInt8Array3, "Int8Array SubArray2 ToString"); assert.Equal(subArray52.ByteOffset, 3, "Int8Array SubArray2 ByteOffset"); var v6 = new Uint16Array(10); assert.Ok(v6 != null, "Uint16Array created"); v6[1] = 11; v6[5] = 5; v6[9] = 99; assert.Equal(v6[1], 11, "Uint16Array indexier works 1"); assert.Equal(v6[9], 99, "Uint16Array indexier works 9"); assert.Ok(v6.Buffer != null, "Uint16Array Buffer"); assert.Equal(v6.ByteLength, 20, "Uint16Array ByteLength"); assert.Equal(v6.ByteOffset, 0, "Uint16Array ByteOffset"); assert.Equal(v6.Length, 10, "Uint16Array Length"); var expectedToStringUint16Array1 = isToStringToTypeNameLogic ? "[object Uint16Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v6.ToLocaleString(), expectedToStringUint16Array1, "Uint16Array ToLocaleString"); assert.Equal(v6.ToString(), expectedToStringUint16Array1, "Uint16Array ToString"); var subArray61 = v6.SubArray(1); var expectedToStringUint16Array2 = isToStringToTypeNameLogic ? "[object Uint16Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray61 != null, "Uint16Array SubArray1"); assert.Equal(subArray61.Length, 9, "Uint16Array SubArray1 Length"); assert.Equal(subArray61.ToString(), expectedToStringUint16Array2, "Uint16Array SubArray1 ToString"); assert.Equal(subArray61.ByteOffset, 2, "Uint16Array SubArray1 ByteOffset"); var subArray62 = subArray61.SubArray(2, 6); var expectedToStringUint16Array3 = isToStringToTypeNameLogic ? "[object Uint16Array]" : "0,0,5,0"; assert.Ok(subArray62 != null, "Uint16Array SubArray2"); assert.Equal(subArray62.Length, 4, "Uint16Array SubArray2 Length"); assert.Equal(subArray62.ToString(), expectedToStringUint16Array3, "Uint16Array SubArray2 ToString"); assert.Equal(subArray62.ByteOffset, 6, "Uint16Array SubArray2 ByteOffset"); var v7 = new Uint32Array(10); assert.Ok(v7 != null, "Uint32Array created"); v7[1] = 11; v7[5] = 5; v7[9] = 99; assert.Equal(v7[1], 11, "Uint32Array indexier works 1"); assert.Equal(v7[9], 99, "Uint32Array indexier works 9"); assert.Ok(v7.Buffer != null, "Uint32Array Buffer"); assert.Equal(v7.ByteLength, 40, "Uint32Array ByteLength"); assert.Equal(v7.ByteOffset, 0, "Uint32Array ByteOffset"); assert.Equal(v7.Length, 10, "Uint32Array Length"); var expectedToStringUint32Array1 = isToStringToTypeNameLogic ? "[object Uint32Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v7.ToLocaleString(), expectedToStringUint32Array1, "Uint32Array ToLocaleString"); assert.Equal(v7.ToString(), expectedToStringUint32Array1, "Uint32Array ToString"); var subArray71 = v7.SubArray(1); var expectedToStringUint32Array2 = isToStringToTypeNameLogic ? "[object Uint32Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray71 != null, "Uint32Array SubArray1"); assert.Equal(subArray71.Length, 9, "Uint32Array SubArray1 Length"); assert.Equal(subArray71.ToString(), expectedToStringUint32Array2, "Uint32Array SubArray1 ToString"); assert.Equal(subArray71.ByteOffset, 4, "Uint32Array SubArray1 ByteOffset"); var subArray72 = subArray71.SubArray(2, 6); var expectedToStringUint32Array3 = isToStringToTypeNameLogic ? "[object Uint32Array]" : "0,0,5,0"; assert.Ok(subArray72 != null, "Uint32Array SubArray2"); assert.Equal(subArray72.Length, 4, "Uint32Array SubArray2 Length"); assert.Equal(subArray72.ToString(), expectedToStringUint32Array3, "Uint32Array SubArray2 ToString"); assert.Equal(subArray72.ByteOffset, 12, "Uint32Array SubArray2 ByteOffset"); var v8 = new Uint8Array(10); assert.Ok(v8 != null, "Uint8Array created"); v8[1] = 11; v8[5] = 5; v8[9] = 99; assert.Equal(v8[1], 11, "Uint8Array indexier works 1"); assert.Equal(v8[9], 99, "Uint8Array indexier works 9"); assert.Ok(v8.Buffer != null, "Uint8Array Buffer"); assert.Equal(v8.ByteLength, 10, "Uint8Array ByteLength"); assert.Equal(v8.ByteOffset, 0, "Uint8Array ByteOffset"); assert.Equal(v8.Length, 10, "Uint8Array Length"); var expectedToStringUint8Array1 = isToStringToTypeNameLogic ? "[object Uint8Array]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v8.ToLocaleString(), expectedToStringUint8Array1, "Uint8Array ToLocaleString"); assert.Equal(v8.ToString(), expectedToStringUint8Array1, "Uint8Array ToString"); var subArray81 = v8.SubArray(1); var expectedToStringUint8Array2 = isToStringToTypeNameLogic ? "[object Uint8Array]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray81 != null, "Uint8Array SubArray1"); assert.Equal(subArray81.Length, 9, "Uint8Array SubArray1 Length"); assert.Equal(subArray81.ToString(), expectedToStringUint8Array2, "Uint8Array SubArray1 ToString"); assert.Equal(subArray81.ByteOffset, 1, "Uint8Array SubArray1 ByteOffset"); var subArray82 = subArray81.SubArray(2, 6); var expectedToStringUint8Array3 = isToStringToTypeNameLogic ? "[object Uint8Array]" : "0,0,5,0"; assert.Ok(subArray82 != null, "Uint8Array SubArray2"); assert.Equal(subArray82.Length, 4, "Uint8Array SubArray2 Length"); assert.Equal(subArray82.ToString(), expectedToStringUint8Array3, "Uint8Array SubArray2 ToString"); assert.Equal(subArray82.ByteOffset, 3, "Uint8Array SubArray2 ByteOffset"); var v9 = new Uint8ClampedArray(10); assert.Ok(v9 != null, "Uint8ClampedArray created"); v9[1] = 11; v9[5] = 5; v9[9] = 99; assert.Equal(v9[1], 11, "Uint8ClampedArray indexier works 1"); assert.Equal(v9[9], 99, "Uint8ClampedArray indexier works 9"); assert.Ok(v9.Buffer != null, "Uint8ClampedArray Buffer"); assert.Equal(v9.ByteLength, 10, "Uint8ClampedArray ByteLength"); assert.Equal(v9.ByteOffset, 0, "Uint8ClampedArray ByteOffset"); assert.Equal(v9.Length, 10, "Uint8ClampedArray Length"); var expectedToStringUint8ClampedArray1 = isToStringToTypeNameLogic ? "[object Uint8ClampedArray]" : "0,11,0,0,0,5,0,0,0,99"; assert.Equal(v9.ToLocaleString(), expectedToStringUint8ClampedArray1, "Uint8ClampedArray ToLocaleString"); assert.Equal(v9.ToString(), expectedToStringUint8ClampedArray1, "Uint8ClampedArray ToString"); var subArray91 = v9.SubArray(1); var expectedToStringUint8ClampedArray2 = isToStringToTypeNameLogic ? "[object Uint8ClampedArray]" : "11,0,0,0,5,0,0,0,99"; assert.Ok(subArray91 != null, "Uint8ClampedArray SubArray1"); assert.Equal(subArray91.Length, 9, "Uint8ClampedArray SubArray1 Length"); assert.Equal(subArray91.ToString(), expectedToStringUint8ClampedArray2, "Uint8ClampedArray SubArray1 ToString"); assert.Equal(subArray91.ByteOffset, 1, "Uint8ClampedArray SubArray1 ByteOffset"); var subArray92 = subArray91.SubArray(2, 6); var expectedToStringUint8ClampedArray3 = isToStringToTypeNameLogic ? "[object Uint8ClampedArray]" : "0,0,5,0"; assert.Ok(subArray92 != null, "Uint8ClampedArray SubArray2"); assert.Equal(subArray92.Length, 4, "Uint8ClampedArray SubArray2 Length"); assert.Equal(subArray92.ToString(), expectedToStringUint8ClampedArray3, "Uint8ClampedArray SubArray2 ToString"); assert.Equal(subArray92.ByteOffset, 3, "Uint8ClampedArray SubArray2 ByteOffset"); }
public override bool CreateGeometry(RenderContext renderContext) { base.CreateGeometry(renderContext); if (GeometryCreated) { return(true); } if (dataset.WcsImage is FitsImage && RenderContext.UseGlVersion2) { FitsImage fitsImage = dataset.WcsImage as FitsImage; texture2d = PrepDevice.createTexture(); PrepDevice.bindTexture(GL.TEXTURE_2D, texture2d); PrepDevice.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_WRAP_S, GL.CLAMP_TO_EDGE); PrepDevice.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_WRAP_T, GL.CLAMP_TO_EDGE); PrepDevice.texImage2D(GL.TEXTURE_2D, 0, GL.R32F, (int)fitsImage.SizeX, (int)fitsImage.SizeY, 0, GL.RED, GL.FLOAT, fitsImage.dataUnit); PrepDevice.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MIN_FILTER, GL.NEAREST); PrepDevice.texParameteri(GL.TEXTURE_2D, GL.TEXTURE_MAG_FILTER, GL.NEAREST); Width = fitsImage.SizeX; Height = fitsImage.SizeY; } else { WcsImage wcsImage = dataset.WcsImage as WcsImage; if (wcsImage != null) { Bitmap bmp = wcsImage.GetBitmap(); texture2d = bmp.GetTexture(); if (bmp.Height != wcsImage.SizeY) { PixelCenterY += bmp.Height - wcsImage.SizeY; } if (renderContext.gl != null) { Height = bmp.Height; Width = bmp.Width; } } else { Height = texture.NaturalHeight; Width = texture.NaturalWidth; } } GeometryCreated = true; for (int i = 0; i < 4; i++) { RenderTriangleLists[i] = new List <RenderTriangle>(); } ComputeMatrix(); double latMin = 0 + (ScaleY * (Height - PixelCenterY)); double latMax = 0 - (ScaleY * PixelCenterY); double lngMin = 0 + (ScaleX * PixelCenterX); double lngMax = 0 - (ScaleX * (Width - PixelCenterX)); TopLeft = GeoTo3dTan(latMin, lngMin); BottomRight = GeoTo3dTan(latMax, lngMax); TopRight = GeoTo3dTan(latMin, lngMax); BottomLeft = GeoTo3dTan(latMax, lngMin); Vector3d topCenter = Vector3d.Lerp(TopLeft, TopRight, .5f); Vector3d bottomCenter = Vector3d.Lerp(BottomLeft, BottomRight, .5f); Vector3d center = Vector3d.Lerp(topCenter, bottomCenter, .5f); Vector3d rightCenter = Vector3d.Lerp(TopRight, BottomRight, .5f); Vector3d leftCenter = Vector3d.Lerp(TopLeft, BottomLeft, .5f); if (renderContext.gl == null) { vertexList = new List <PositionTexture>(); vertexList.Add(PositionTexture.CreatePosSize(TopLeft, 0, 0, Width, Height)); vertexList.Add(PositionTexture.CreatePosSize(TopRight, 1, 0, Width, Height)); vertexList.Add(PositionTexture.CreatePosSize(BottomLeft, 0, 1, Width, Height)); vertexList.Add(PositionTexture.CreatePosSize(BottomRight, 1, 1, Width, Height)); childTriangleList = new List <Triangle>(); if (dataset.BottomsUp) { childTriangleList.Add(Triangle.Create(0, 1, 2)); childTriangleList.Add(Triangle.Create(2, 1, 3)); } else { childTriangleList.Add(Triangle.Create(0, 2, 1)); childTriangleList.Add(Triangle.Create(2, 3, 1)); } int count = 3; while (count-- > 1) { List <Triangle> newList = new List <Triangle>(); foreach (Triangle tri in childTriangleList) { tri.SubDivide(newList, vertexList); } childTriangleList = newList; } double miter = .6 / (Width / 256); foreach (Triangle tri in childTriangleList) { PositionTexture p1 = vertexList[tri.A]; PositionTexture p2 = vertexList[tri.B]; PositionTexture p3 = vertexList[tri.C]; RenderTriangleLists[0].Add(RenderTriangle.CreateWithMiter(p1, p2, p3, texture, Level, miter)); } } else { //process vertex list VertexBuffer = PrepDevice.createBuffer(); PrepDevice.bindBuffer(GL.ARRAY_BUFFER, VertexBuffer); Float32Array f32array = new Float32Array(9 * 5); float[] buffer = (float[])(object)f32array; int index = 0; index = AddVertex(buffer, index, PositionTexture.CreatePos(bottomCenter, .5, 1)); //0 index = AddVertex(buffer, index, PositionTexture.CreatePos(BottomLeft, 0, 1)); //1 index = AddVertex(buffer, index, PositionTexture.CreatePos(BottomRight, 1, 1)); //2 index = AddVertex(buffer, index, PositionTexture.CreatePos(center, .5, .5)); //3 index = AddVertex(buffer, index, PositionTexture.CreatePos(leftCenter, 0, .5)); //4 index = AddVertex(buffer, index, PositionTexture.CreatePos(rightCenter, 1, .5)); //5 index = AddVertex(buffer, index, PositionTexture.CreatePos(topCenter, .5, 0)); //6 index = AddVertex(buffer, index, PositionTexture.CreatePos(TopLeft, 0, 0)); //7 index = AddVertex(buffer, index, PositionTexture.CreatePos(TopRight, 1, 0)); //8 PrepDevice.bufferData(GL.ARRAY_BUFFER, f32array, GL.STATIC_DRAW); // process index buffers for (int i = 0; i < 4; i++) { index = 0; TriangleCount = 2; Uint16Array ui16array = new Uint16Array(TriangleCount * 3); UInt16[] indexArray = (UInt16[])(object)ui16array; switch (i) { case 0: indexArray[index++] = 7; indexArray[index++] = 4; indexArray[index++] = 6; indexArray[index++] = 4; indexArray[index++] = 3; indexArray[index++] = 6; break; case 1: indexArray[index++] = 6; indexArray[index++] = 5; indexArray[index++] = 8; indexArray[index++] = 6; indexArray[index++] = 3; indexArray[index++] = 5; break; case 2: indexArray[index++] = 4; indexArray[index++] = 0; indexArray[index++] = 3; indexArray[index++] = 4; indexArray[index++] = 1; indexArray[index++] = 0; break; case 3: indexArray[index++] = 3; indexArray[index++] = 2; indexArray[index++] = 5; indexArray[index++] = 3; indexArray[index++] = 0; indexArray[index++] = 2; break; } IndexBuffers[i] = PrepDevice.createBuffer(); PrepDevice.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, IndexBuffers[i]); PrepDevice.bufferData(GL.ELEMENT_ARRAY_BUFFER, ui16array, GL.STATIC_DRAW); } } return(true); }
public void IndexOfWorks() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); Assert.AreEqual(arr.IndexOf(9), 3, "9"); Assert.AreEqual(arr.IndexOf(1), -1, "1"); }
private static void SetTypedArrayUShort(JSObject obj) { ushort[] buffer = Enumerable.Repeat((ushort)0x20, 14).ToArray(); obj.SetObjectProperty("typedArray", Uint16Array.From(buffer)); }
public static void CoreTypes() { var arr = new Uint8ClampedArray(50); Assert.Equal(50, arr.Length); Assert.Equal(TypedArrayTypeCode.Uint8ClampedArray, arr.GetTypedArrayType()); var arr1 = new Uint8Array(50); Assert.Equal(50, arr1.Length); Assert.Equal(TypedArrayTypeCode.Uint8Array, arr1.GetTypedArrayType()); var arr2 = new Uint16Array(50); Assert.Equal(50, arr2.Length); Assert.Equal(TypedArrayTypeCode.Uint16Array, arr2.GetTypedArrayType()); var arr3 = new Uint32Array(50); Assert.Equal(50, arr3.Length); Assert.Equal(TypedArrayTypeCode.Uint32Array, arr3.GetTypedArrayType()); var arr4 = new Int8Array(50); Assert.Equal(50, arr4.Length); Assert.Equal(TypedArrayTypeCode.Int8Array, arr4.GetTypedArrayType()); var arr5 = new Int16Array(50); Assert.Equal(50, arr5.Length); Assert.Equal(TypedArrayTypeCode.Int16Array, arr5.GetTypedArrayType()); var arr6 = new Int32Array(50); Assert.Equal(50, arr6.Length); Assert.Equal(TypedArrayTypeCode.Int32Array, arr6.GetTypedArrayType()); var arr7 = new Float32Array(50); Assert.Equal(50, arr7.Length); Assert.Equal(TypedArrayTypeCode.Float32Array, arr7.GetTypedArrayType()); var arr8 = new Float64Array(50); Assert.Equal(50, arr8.Length); Assert.Equal(TypedArrayTypeCode.Float64Array, arr8.GetTypedArrayType()); var sharedArr40 = new SharedArrayBuffer(40); var sharedArr50 = new SharedArrayBuffer(50); var arr9 = new Uint8ClampedArray(sharedArr50); Assert.Equal(50, arr9.Length); var arr10 = new Uint8Array(sharedArr50); Assert.Equal(50, arr10.Length); var arr11 = new Uint16Array(sharedArr50); Assert.Equal(25, arr11.Length); var arr12 = new Uint32Array(sharedArr40); Assert.Equal(10, arr12.Length); var arr13 = new Int8Array(sharedArr50); Assert.Equal(50, arr13.Length); var arr14 = new Int16Array(sharedArr40); Assert.Equal(20, arr14.Length); var arr15 = new Int32Array(sharedArr40); Assert.Equal(10, arr15.Length); var arr16 = new Float32Array(sharedArr40); Assert.Equal(10, arr16.Length); var arr17 = new Float64Array(sharedArr40); Assert.Equal(5, arr17.Length); }
public void GetEnumeratorWorks() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); var l = new List<int>(); var enm = arr.GetEnumerator(); while (enm.MoveNext()) { l.Add(enm.Current); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void LengthConstructorWorks() { var arr = new Uint16Array(13); Assert.IsTrue((object)arr is Uint16Array, "is Uint16Array"); Assert.AreEqual(arr.Length, 13, "Length"); }
public void ByteOffsetPropertyWorks() { var buf = new ArrayBuffer(100); var arr = new Uint16Array(buf, 32); Assert.AreEqual(arr.ByteOffset, 32, "Should be correct"); }
public void LengthWorks() { var arr = new Uint16Array(13); Assert.AreEqual(arr.Length, 13, "Length"); }
private static void CreateGalaxyImage(RenderContext renderContext) { if (milkyWayImage == null) { milkyWayImage = Planets.LoadPlanetTexture("http://cdn.worldwidetelescope.org/webclient/images/milkywaybar.jpg"); } int subdivs = 50; double lat, lng; int index = 0; double latMin = 64; double latMax = -64; double lngMin = -64; double lngMax = 64; //// Create a vertex buffer galaxyImageVertexBuffer = new PositionTextureVertexBuffer((subdivs + 1) * (subdivs + 1)); PositionTexture[] verts = (PositionTexture[])galaxyImageVertexBuffer.Lock(); int x1, y1; double latDegrees = latMax - latMin; double lngDegrees = lngMax - lngMin; double scaleFactor = 60800000.0; double ecliptic = Coordinates.MeanObliquityOfEcliptic(SpaceTimeController.JNow) / 180.0 * Math.PI; Vector3d point; double textureStepX = 1.0f / subdivs; double textureStepY = 1.0f / subdivs; for (y1 = 0; y1 <= subdivs; y1++) { if (y1 != subdivs) { lat = latMax - (textureStepY * latDegrees * (double)y1); } else { lat = latMin; } for (x1 = 0; x1 <= subdivs; x1++) { if (x1 != subdivs) { lng = lngMin + (textureStepX * lngDegrees * (double)x1); } else { lng = lngMax; } index = y1 * (subdivs + 1) + x1; point = Vector3d.Create(lng * scaleFactor, 0, (lat - 28) * scaleFactor); point.RotateY(213.0 / 180 * Math.PI); point.RotateZ((-62.87175) / 180 * Math.PI); point.RotateY((-192.8595083) / 180 * Math.PI); point.RotateX(ecliptic); verts[index] = PositionTexture.CreatePosRaw(point, (float)(1f - x1 * textureStepX), (float)(/*1f - */ (y1 * textureStepY))); //verts[index].Position = point; //verts[index].Tu = (float)(1f - x1 * textureStepX); //verts[index].Tv = (float)(/*1f - */(y1 * textureStepY)); } } galaxyImageVertexBuffer.Unlock(); galaxyImageTriangleCount = (subdivs) * (subdivs) * 2; Uint16Array ui16array = new Uint16Array(subdivs * subdivs * 6); UInt16[] indexArray = (UInt16[])(object)ui16array; for (y1 = 0; y1 < subdivs; y1++) { for (x1 = 0; x1 < subdivs; x1++) { index = (y1 * subdivs * 6) + 6 * x1; // First triangle in quad indexArray[index] = (ushort)(y1 * (subdivs + 1) + x1); indexArray[index + 2] = (ushort)((y1 + 1) * (subdivs + 1) + x1); indexArray[index + 1] = (ushort)(y1 * (subdivs + 1) + (x1 + 1)); // Second triangle in quad indexArray[index + 3] = (ushort)(y1 * (subdivs + 1) + (x1 + 1)); indexArray[index + 5] = (ushort)((y1 + 1) * (subdivs + 1) + x1); indexArray[index + 4] = (ushort)((y1 + 1) * (subdivs + 1) + (x1 + 1)); } } galaxyImageIndexBuffer = Tile.PrepDevice.createBuffer(); Tile.PrepDevice.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, galaxyImageIndexBuffer); Tile.PrepDevice.bufferData(GL.ELEMENT_ARRAY_BUFFER, ui16array, GL.STATIC_DRAW); }
public void LengthWorks() { var arr = new Uint16Array(13); Assert.AreEqual(13, arr.Length, "Length"); }
public static void TestUseCase() { var isSpecialTypeName = BrowserHelper.IsPhantomJs(); var v1 = new Float32Array(1); var thisType = "Float32Array"; Assert.True(v1 != null, thisType + " created"); var thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v1.GetType().FullName, thisType + " class name"); var v2 = new Float64Array(1); thisType = "Float64Array"; Assert.True(v2 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v2.GetType().FullName, thisType + " class name"); var v3 = new Int16Array(1); thisType = "Int16Array"; Assert.True(v3 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v3.GetType().FullName, thisType + " class name"); var v4 = new Int32Array(1); thisType = "Int32Array"; Assert.True(v4 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v4.GetType().FullName, thisType + " class name"); var v5 = new Int8Array(1); thisType = "Int8Array"; Assert.True(v5 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v5.GetType().FullName, thisType + " class name"); var v6 = new Uint16Array(1); thisType = "Uint16Array"; Assert.True(v6 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v6.GetType().FullName, thisType + " class name"); var v7 = new Uint32Array(1); thisType = "Uint32Array"; Assert.True(v7 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v7.GetType().FullName, thisType + " class name"); var v8 = new Uint8Array(1); thisType = "Uint8Array"; Assert.True(v8 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v8.GetType().FullName, thisType + " class name"); var v9 = new Uint8ClampedArray(1); thisType = "Uint8ClampedArray"; Assert.True(v9 != null, thisType + " created"); thisName = isSpecialTypeName ? "Object" : thisType; Assert.AreEqual(thisName, v9.GetType().FullName, thisType + " class name"); }
public void ForeachWorks() { var arr = new Uint16Array(new ushort[] { 3, 6, 2, 9, 5 }); var l = new List<int>(); foreach (var i in arr) { l.Add(i); } Assert.AreEqual(l, new[] { 3, 6, 2, 9, 5 }); }
public void SetNormalArrayWithOffsetWorks() { var arr = new Uint16Array(6); arr.Set(new ushort[] { 3, 6, 7 }, 2); AssertContent(arr, new[] { 0, 0, 3, 6, 7, 0 }, "Content"); }
public void ByteLengthPropertyWorks() { var arr = new Uint16Array(23); Assert.AreEqual(46, arr.ByteLength, "Should be correct"); }
public static Uint16Array Uint16ArrayFrom() { var array = new ushort[50]; return(Uint16Array.From(array)); }
/// <summary> /// Creates a new Uint16Array out of the specified Uint16Array. /// </summary> /// <param name="typedArray">Uint16Array to use as initial contents to the new array.</param> public Uint16Array(Uint16Array typedArray) { }
public override bool CreateGeometry(RenderContext renderContext) { base.CreateGeometry(renderContext); if (GeometryCreated) { return(true); } GeometryCreated = true; for (int i = 0; i < 4; i++) { RenderTriangleLists[i] = new List <RenderTriangle>(); } ComputeMatrix(); Height = texture.NaturalHeight; Width = texture.NaturalWidth; double latMin = 0 + (ScaleY * (Height - PixelCenterY)); double latMax = 0 - (ScaleY * PixelCenterY); double lngMin = 0 + (ScaleX * PixelCenterX); double lngMax = 0 - (ScaleX * (Width - PixelCenterX)); TopLeft = GeoTo3dTan(latMin, lngMin); BottomRight = GeoTo3dTan(latMax, lngMax); TopRight = GeoTo3dTan(latMin, lngMax); BottomLeft = GeoTo3dTan(latMax, lngMin); Vector3d topCenter = Vector3d.Lerp(TopLeft, TopRight, .5f); Vector3d bottomCenter = Vector3d.Lerp(BottomLeft, BottomRight, .5f); Vector3d center = Vector3d.Lerp(topCenter, bottomCenter, .5f); Vector3d rightCenter = Vector3d.Lerp(TopRight, BottomRight, .5f); Vector3d leftCenter = Vector3d.Lerp(TopLeft, BottomLeft, .5f); //Vector3d center = Vector3d.MidPoint(TopLeft, BottomRight); //Vector3d leftCenter = Vector3d.MidPoint(TopLeft, BottomLeft); //Vector3d rightCenter = Vector3d.MidPoint(TopRight, BottomRight); //Vector3d topCenter = Vector3d.MidPoint(TopLeft, TopRight); //Vector3d bottomCenter = Vector3d.MidPoint(BottomLeft, BottomRight); //verts[0].Position = TopLeft; //verts[0].Normal = TopLeft; //verts[0].Tu = 0; //verts[0].Tv = 0; //verts[1].Position = TopRight; //verts[1].Normal = TopRight; //verts[1].Tu = 1; //verts[1].Tv = 0; //verts[2].Position = BottomRight; //verts[2].Normal = BottomRight; //verts[2].Tu = 1; //verts[2].Tv = 1; //verts[3].Position = BottomLeft; //verts[3].Normal = BottomLeft; //verts[3].Tu = 0; //verts[3].Tv = 1; if (renderContext.gl == null) { //RenderTriangleLists[0].Add(RenderTriangle.Create(PositionTexture.CreatePosSize(TopLeft, 0, 0, Width, Height), PositionTexture.CreatePosSize(BottomLeft, 0, 1, Width, Height), PositionTexture.CreatePosSize(TopRight, 1, 0, Width, Height), texture, Level)); //RenderTriangleLists[0].Add(RenderTriangle.Create(PositionTexture.CreatePosSize(BottomLeft, 0, 1, Width, Height), PositionTexture.CreatePosSize(BottomRight, 1, 1, Width, Height), PositionTexture.CreatePosSize(TopRight, 1, 0, Width, Height), texture, Level)); vertexList = new List <PositionTexture>(); vertexList.Add(PositionTexture.CreatePosSize(TopLeft, 0, 0, Width, Height)); vertexList.Add(PositionTexture.CreatePosSize(TopRight, 1, 0, Width, Height)); vertexList.Add(PositionTexture.CreatePosSize(BottomLeft, 0, 1, Width, Height)); vertexList.Add(PositionTexture.CreatePosSize(BottomRight, 1, 1, Width, Height)); childTriangleList = new List <Triangle>(); if (dataset.BottomsUp) { childTriangleList.Add(Triangle.Create(0, 1, 2)); childTriangleList.Add(Triangle.Create(2, 1, 3)); } else { childTriangleList.Add(Triangle.Create(0, 2, 1)); childTriangleList.Add(Triangle.Create(2, 3, 1)); } int count = 3; while (count-- > 1) { List <Triangle> newList = new List <Triangle>(); foreach (Triangle tri in childTriangleList) { tri.SubDivide(newList, vertexList); } childTriangleList = newList; } double miter = .6 / (Width / 256); foreach (Triangle tri in childTriangleList) { PositionTexture p1 = vertexList[tri.A]; PositionTexture p2 = vertexList[tri.B]; PositionTexture p3 = vertexList[tri.C]; RenderTriangleLists[0].Add(RenderTriangle.CreateWithMiter(p1, p2, p3, texture, Level, miter)); } } else { //process vertex list VertexBuffer = PrepDevice.createBuffer(); PrepDevice.bindBuffer(GL.ARRAY_BUFFER, VertexBuffer); Float32Array f32array = new Float32Array(9 * 5); float[] buffer = (float[])(object)f32array; int index = 0; index = AddVertex(buffer, index, PositionTexture.CreatePos(bottomCenter, .5, 1)); //0 index = AddVertex(buffer, index, PositionTexture.CreatePos(BottomLeft, 0, 1)); //1 index = AddVertex(buffer, index, PositionTexture.CreatePos(BottomRight, 1, 1)); //2 index = AddVertex(buffer, index, PositionTexture.CreatePos(center, .5, .5)); //3 index = AddVertex(buffer, index, PositionTexture.CreatePos(leftCenter, 0, .5)); //4 index = AddVertex(buffer, index, PositionTexture.CreatePos(rightCenter, 1, .5)); //5 index = AddVertex(buffer, index, PositionTexture.CreatePos(topCenter, .5, 0)); //6 index = AddVertex(buffer, index, PositionTexture.CreatePos(TopLeft, 0, 0)); //7 index = AddVertex(buffer, index, PositionTexture.CreatePos(TopRight, 1, 0)); //8 PrepDevice.bufferData(GL.ARRAY_BUFFER, f32array, GL.STATIC_DRAW); // process index buffers for (int i = 0; i < 4; i++) { index = 0; TriangleCount = 2; Uint16Array ui16array = new Uint16Array(TriangleCount * 3); UInt16[] indexArray = (UInt16[])(object)ui16array; switch (i) { case 0: indexArray[index++] = 7; indexArray[index++] = 4; indexArray[index++] = 6; indexArray[index++] = 4; indexArray[index++] = 3; indexArray[index++] = 6; break; case 1: indexArray[index++] = 6; indexArray[index++] = 5; indexArray[index++] = 8; indexArray[index++] = 6; indexArray[index++] = 3; indexArray[index++] = 5; break; case 2: indexArray[index++] = 4; indexArray[index++] = 0; indexArray[index++] = 3; indexArray[index++] = 4; indexArray[index++] = 1; indexArray[index++] = 0; break; case 3: indexArray[index++] = 3; indexArray[index++] = 2; indexArray[index++] = 5; indexArray[index++] = 3; indexArray[index++] = 0; indexArray[index++] = 2; break; } IndexBuffers[i] = PrepDevice.createBuffer(); PrepDevice.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, IndexBuffers[i]); PrepDevice.bufferData(GL.ELEMENT_ARRAY_BUFFER, ui16array, GL.STATIC_DRAW); } } return(true); }
public void ByteLengthPropertyWorks() { var arr = new Uint16Array(23); Assert.AreEqual(arr.ByteLength, 46, "Should be correct"); }