public static Color InterpolateColor(UInt4[] values, int weight, int plane2Weight, int plane2ColorComponent)
{
var weightValue1 = new UInt4(weight, weight, weight, weight);
switch (plane2ColorComponent)
{
case 0:
weightValue1.x = plane2Weight;
break;
case 1:
weightValue1.y = plane2Weight;
break;
case 2:
weightValue1.z = plane2Weight;
break;
case 3:
weightValue1.w = plane2Weight;
break;
}
var weightValue0 = new UInt4(64, 64, 64, 64) - weightValue1;
// TODO: LDR_SRGB decoding (simple >> 8)
var color = values[0] * weightValue0 + values[1] * weightValue1 + new UInt4(32, 32, 32, 32);
return(color >> 6);
}
public void Should_SerializeUInt4()
{
UInt4 value = UInt4.MaxValue; // range 0 to 15
Assert.AreEqual(1, value.GetBit(0));
Assert.AreEqual(1, value.GetBit(1));
Assert.AreEqual(1, value.GetBit(2));
Assert.AreEqual(1, value.GetBit(3));
Assert.AreEqual(new Bit[] { 1, 1, 1, 1 }, value.GetBits());
value = (UInt4)2;
Assert.AreEqual(0, value.GetBit(0));
Assert.AreEqual(1, value.GetBit(1));
Assert.AreEqual(0, value.GetBit(2));
Assert.AreEqual(0, value.GetBit(3));
Assert.AreEqual(new Bit[] { 0, 1, 0, 0 }, value.GetBits());
// test overflow
value = (UInt4)20;
Assert.AreEqual(4, value);
Assert.AreEqual(0, value.GetBit(0));
Assert.AreEqual(0, value.GetBit(1));
Assert.AreEqual(1, value.GetBit(2));
Assert.AreEqual(0, value.GetBit(3));
Assert.AreEqual(new Bit[] { 0, 0, 1, 0 }, value.GetBits());
}
protected override void OnTick()
{
if (ctrl.active)
{
count = (count + 1) % interval;
if (count == 0)
{
value = (UInt4)((value + 1) % uint4_max);
}
}
output.value = value;
}
/// <summary>
/// Clears a read-write Texture. This texture must have been created with read-write/unordered access.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">texture</exception>
/// <exception cref="System.ArgumentException">Expecting texture supporting UAV;texture</exception>
public unsafe void ClearReadWrite(Texture texture, UInt4 value)
{
if (texture is null)
{
throw new ArgumentNullException(nameof(texture));
}
if (texture.NativeUnorderedAccessView is null)
{
throw new ArgumentException("Expecting texture supporting UAV.", nameof(texture));
}
NativeDeviceContext.ClearUnorderedAccessView(texture.NativeUnorderedAccessView, *(RawInt4 *)&value);
}
/// <summary>
/// Clears a read-write Buffer. This buffer must have been created with read-write/unordered access.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">buffer</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;buffer</exception>
public unsafe void ClearReadWrite(Buffer buffer, UInt4 value)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (buffer.NativeUnorderedAccessView == null)
{
throw new ArgumentException("Expecting buffer supporting UAV", nameof(buffer));
}
NativeDeviceContext.ClearUnorderedAccessView(buffer.NativeUnorderedAccessView, *(RawInt4 *)&value);
}
/// <summary>
/// Clears a read-write Texture. This texture must have been created with read-write/unordered access.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">texture</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;texture</exception>
public unsafe void ClearReadWrite(Texture texture, UInt4 value)
{
if (texture == null)
{
throw new ArgumentNullException("texture");
}
if (texture.NativeUnorderedAccessView == null)
{
throw new ArgumentException("Expecting buffer supporting UAV", "texture");
}
NativeDeviceContext.ClearUnorderedAccessView(texture.NativeUnorderedAccessView, *(RawInt4 *)&value);
}
launch_classifyVoxel(int[] gridDim, int[] threadsDim, Mem voxelVerts, Mem voxelOccupied, Mem volume,
uint chunkSizeReal, UInt4 chunkSizeShiftPlus, UInt4 volumeChunkShiftPlus, UInt4 volumeChunkMask,
float isoValue)
{
classifyVoxelKernel.SetArg(0, voxelVerts);
classifyVoxelKernel.SetArg(1, voxelOccupied);
classifyVoxelKernel.SetArg(2, volume);
classifyVoxelKernel.SetArg(3, chunkSizeReal);
classifyVoxelKernel.SetArg(4, chunkSizeShiftPlus);
classifyVoxelKernel.SetArg(5, volumeChunkShiftPlus);
classifyVoxelKernel.SetArg(6, volumeChunkMask);
classifyVoxelKernel.SetArg(7, isoValue);
OCLComQueue.EnqueueNDRangeKernel(classifyVoxelKernel, gridDim.Length, null, gridDim, threadsDim);
}
public void uint4_create()
{
var x0 = (UInt4)0;
byte y0 = x0;
var z0 = (byte)0;
Claim.eq(y0, z0);
var x1 = (UInt4)5;
byte y1 = x1;
var z1 = (byte)5;
Claim.eq(y1, z1);
var x2 = UInt4.FromBits(1, 0, 1, 1);
byte y2 = x2;
var z2 = (byte)0b1101;
Claim.eq(y2, z2);
var x3 = UInt4.FromBits(Bit.On, Bit.Off, Bit.On, Bit.On);
byte y3 = x3;
var z3 = (byte)0b1101;
Claim.eq(y3, z3);
var x4 = UInt4.FromByte(0);
Claim.eq(x4, (byte)0);
byte y4 = x4;
var z4 = (byte)0;
Claim.eq(y4, z4);
var x5 = UInt4.FromBitSeq(gbits.bitseq((byte)5));
var y5 = (UInt4)5;
Claim.eq(x5, y5);
}
launch_generateTriangles2(int[] gridDim, int[] threadsDim,
Mem pos, Mem norm01, Mem norm2t, Mem compactedVoxelArray, Mem numVertsScanned, Mem volume,
uint chunkSizeReal, uint chunkSizeMask, UInt4 chunkSizeShiftPlus, UInt4 volumeChunkShiftPlus, UInt4 volumeChunkMask,
float isoValue, uint nActiveVoxels, uint nMaxVerts)
{
int i = 0;
generateTriangles2Kernel.SetArg(i++, pos);
generateTriangles2Kernel.SetArg(i++, norm01);
generateTriangles2Kernel.SetArg(i++, norm2t);
generateTriangles2Kernel.SetArg(i++, compactedVoxelArray);
generateTriangles2Kernel.SetArg(i++, numVertsScanned);
generateTriangles2Kernel.SetArg(i++, volume);
generateTriangles2Kernel.SetArg(i++, chunkSizeReal);
generateTriangles2Kernel.SetArg(i++, chunkSizeMask);
generateTriangles2Kernel.SetArg(i++, chunkSizeShiftPlus);
generateTriangles2Kernel.SetArg(i++, volumeChunkShiftPlus);
generateTriangles2Kernel.SetArg(i++, volumeChunkMask);
generateTriangles2Kernel.SetArg(i++, isoValue);
generateTriangles2Kernel.SetArg(i++, nActiveVoxels);
generateTriangles2Kernel.SetArg(i++, nMaxVerts);
OCLComQueue.EnqueueNDRangeKernel(generateTriangles2Kernel, gridDim.Length, null, gridDim, threadsDim);
}
/// <summary>
/// Clears a read-write Texture. This texture must have been created with read-write/unordered access.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">texture</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;texture</exception>
public unsafe void ClearReadWrite(Texture texture, UInt4 value)
{
if (texture == null) throw new ArgumentNullException("texture");
if (texture.NativeUnorderedAccessView == null) throw new ArgumentException("Expecting buffer supporting UAV", "texture");
NativeDeviceContext.ClearUnorderedAccessView(texture.NativeUnorderedAccessView, *(RawInt4*)&value);
}
private IList <Color> DecodeMultiPartition(BitReader br, BlockMode blockMode, int partitions)
{
var colorEndpointModes = DecodeColorEndpointModes(br, blockMode, partitions);
var colorValueCount = colorEndpointModes.Sum(x => x.EndpointValueCount);
if (colorValueCount > 18 || colorEndpointModes.Any(x => x.IsHdr != blockMode.IsHdr))
{
return(ErrorColors);
}
var colorBits = ColorHelper.CalculateColorBits(partitions, blockMode.WeightBitCount, blockMode.IsDualPlane);
var quantizationLevel = ColorHelper.QuantizationModeTable[colorValueCount >> 1][colorBits];
if (quantizationLevel < 4)
{
return(ErrorColors);
}
br.Position = 19 + Constants.PartitionBits;
var colorValues = IntegerSequenceEncoding.Decode(br, quantizationLevel, colorValueCount);
var colorEndpoints = new UInt4[partitions][];
for (var i = 0; i < partitions; i++)
{
colorEndpoints[i] = ColorUnquantization.DecodeColorEndpoints(colorValues, colorEndpointModes[i].Format, quantizationLevel);
}
br.Position = 13;
var partitionIndex = br.ReadBits <uint>(10);
var elementsInBlock = _x * _y * _z;
var partitionIndices = new int[elementsInBlock];
for (int z = 0; z < _z; z++)
{
for (int y = 0; y < _y; y++)
{
for (int x = 0; x < _x; x++)
{
partitionIndices[x * y * z] =
PartitionSelection.SelectPartition(partitionIndex, x, y, z, partitions, elementsInBlock < 32);
}
}
}
var result = new Color[elementsInBlock];
if (blockMode.IsDualPlane)
{
// TODO: Should those 2 bits below the weights be here for multi partition due to encodedType high part?
br.Position = 128 - blockMode.WeightBitCount - 2;
var plane2ColorComponent = br.ReadBits <int>(2);
var indices = IntegerSequenceEncoding.Decode(br, blockMode.QuantizationMode, blockMode.WeightCount);
for (var i = 0; i < blockMode.WeightCount; i++)
{
var plane1Weight = WeightUnquantization.WeightUnquantizationTable[blockMode.QuantizationMode][indices[i * 2]];
var plane2Weight = WeightUnquantization.WeightUnquantizationTable[blockMode.QuantizationMode][indices[i * 2 + 1]];
result[i] = ColorHelper.InterpolateColor(colorEndpoints[partitionIndices[i]], plane1Weight, plane2Weight, plane2ColorComponent);
}
}
else
{
var indices = IntegerSequenceEncoding.Decode(br, blockMode.QuantizationMode, blockMode.WeightCount);
for (var i = 0; i < blockMode.WeightCount; i++)
{
var weight = WeightUnquantization.WeightUnquantizationTable[blockMode.QuantizationMode][indices[i]];
result[i] = ColorHelper.InterpolateColor(colorEndpoints[partitionIndices[i]], weight, -1, -1);
}
}
return(result);
}
launch_compactVoxels(int[] gridDim, int[] threadsDim, Mem compVoxelArray, Mem voxelOccupied, Mem voxelOccupiedScan, UInt4 chunkSizeShiftPlus)
{
compactVoxelsKernel.SetArg(0, compVoxelArray);
compactVoxelsKernel.SetArg(1, voxelOccupied);
compactVoxelsKernel.SetArg(2, voxelOccupiedScan);
compactVoxelsKernel.SetArg(3, chunkSizeShiftPlus);
OCLComQueue.EnqueueNDRangeKernel(compactVoxelsKernel, gridDim.Length, null, gridDim, threadsDim);
}
/// <summary>
/// Clears a read-write Texture. This texture must have been created with read-write/unordered access.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">texture</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;texture</exception>
public void ClearReadWrite(Texture texture, UInt4 value)
{
NullHelper.ToImplement();
}
/// <summary>
/// Clears a read-write Buffer. This buffer must have been created with read-write/unordered access.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">buffer</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;buffer</exception>
public void ClearReadWrite(Buffer buffer, UInt4 value)
{
NullHelper.ToImplement();
}
public unsafe void ClearReadWrite(Buffer buffer, UInt4 value)
{
#if DEBUG
GraphicsDevice.EnsureContextActive();
#endif
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
Internal.Refactor.ThrowNotImplementedException();
#else
if ((buffer.ViewFlags & BufferFlags.UnorderedAccess) != BufferFlags.UnorderedAccess)
throw new ArgumentException("Buffer does not support unordered access");
GL.BindBuffer(buffer.BufferTarget, buffer.BufferId);
GL.ClearBufferData(buffer.BufferTarget, buffer.TextureInternalFormat, buffer.TextureFormat, All.UnsignedInt8888, ref value);
GL.BindBuffer(buffer.BufferTarget, 0);
#endif
}
/// <summary>
/// Clears a read-write Texture. This texture must have been created with read-write/unordered access.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">texture</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;texture</exception>
public void ClearReadWrite(Texture texture, UInt4 value)
{
throw new NotImplementedException();
}
/// <summary>
/// Clears a read-write Buffer. This buffer must have been created with read-write/unordered access.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">buffer</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;buffer</exception>
public void ClearReadWrite(Buffer buffer, UInt4 value)
{
throw new NotImplementedException();
}
public unsafe void ClearReadWrite(Texture texture, UInt4 value)
{
#if DEBUG
GraphicsDevice.EnsureContextActive();
#endif
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
Internal.Refactor.ThrowNotImplementedException();
#else
if (activeTexture != 0)
{
activeTexture = 0;
GL.ActiveTexture(TextureUnit.Texture0);
}
GL.BindTexture(texture.TextureTarget, texture.TextureId);
GL.ClearTexImage(texture.TextureId, 0, texture.TextureFormat, texture.TextureType, ref value);
GL.BindTexture(texture.TextureTarget, 0);
boundShaderResourceViews[0] = null;
#endif
}
/// <summary>
/// Clears a read-write Buffer. This buffer must have been created with read-write/unordered access.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">buffer</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;buffer</exception>
public void ClearReadWrite(Buffer buffer, UInt4 value)
{
throw new NotImplementedException();
}
/// <summary>
/// Clears a read-write Texture. This texture must have been created with read-write/unordered access.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="value">The value.</param>
/// <exception cref="System.ArgumentNullException">texture</exception>
/// <exception cref="System.ArgumentException">Expecting buffer supporting UAV;texture</exception>
public void ClearReadWrite(Texture texture, UInt4 value)
{
throw new NotImplementedException();
}
