public static void RotateM2(float[] m, int mOffset, float a, float x, float y, float z)
{
float[] temp = new float[32];
SetRotateM(temp, 0, a, x, y, z);
MultiplyMM(temp, 16, m, mOffset, temp, 0);
JSArrayEx.Copy(temp, 16, m, mOffset, 16);
}
// Calculates a crc checksum-sequence over an array.
public static byte BlockSequenceCRCByte(byte[] b, int offset, int length, int sequence)
{
if (sequence < 0)
{
throw new Exception("InvalidOperationException: sequence < 0, this shouldn't happen\n");
}
//p_ndx = (sequence % (sizeof(chktbl) - 4));
int p_ndx = (sequence % (1024 - 4));
//memcpy(chkb, base, length);
length = Math.Min(60, length);
JSArrayEx.Copy(b, offset, chkb, 0, length);
chkb[length] = chktbl[p_ndx + 0];
chkb[length + 1] = chktbl[p_ndx + 1];
chkb[length + 2] = chktbl[p_ndx + 2];
chkb[length + 3] = chktbl[p_ndx + 3];
length += 4;
// unsigned short
int crc = CRC_Block(chkb, length);
int x = 0;
for (int n = 0; n < length; n++)
{
x += chkb[n] & 0xFF;
}
crc ^= x;
return((byte)(crc & 0xFF));
}
// MD4 block update operation.
// Continues an MD4 message digest operation, by filling the buffer, transform(ing) data in 512-bit message block(s), updating the variables
// application and count, and leaving (buffering) the remaining bytes in buffer for the next update or finish.
//
// @param input input block
// @param offset start of meaningful bytes in input
// @param len count of bytes in input block to consider
public void Update(byte[] input, int offset, int len)
{
// make sure we don't exceed input's allocated size/length
if (offset < 0 || len < 0 || (long)offset + len > input.Length)
{
throw new Exception("IndexOutOfRangeException:");
}
// compute number of bytes still unhashed; ie. present in buffer
int bufferNdx = (int)(count % BLOCK_LENGTH);
count += len; // update number of bytes
int partLen = BLOCK_LENGTH - bufferNdx;
int i = 0;
if (len >= partLen)
{
JSArrayEx.Copy(input, offset, buffer, bufferNdx, partLen);
Transform(buffer, 0);
for (i = partLen; i + BLOCK_LENGTH - 1 < len; i += BLOCK_LENGTH)
{
Transform(input, offset + i);
}
bufferNdx = 0;
}
// buffer remaining input
if (i < len)
{
JSArrayEx.Copy(input, offset + i, buffer, bufferNdx, len - i);
}
}
// Materialf (GLenum face, GLenum pname, GLfloat param);
// Materialfv (GLenum face, GLenum pname, const GLfloat *params);
public virtual void MultMatrixf(float[] m) //, int ofs)
{
int ofs = 0;
MathMatrix.MultiplyMM(_tmpMatrix, 0, _currentMatrix, 0, m, ofs);
JSArrayEx.Copy(_tmpMatrix, 0, _currentMatrix, 0, 16);
_mvpDirty = true;
}
public void Clear()
{
if (Data != null)
{
JSArrayEx.Clear(Data, 0, Data.Length);
}
Length = 0;
HasOverflowed = false;
}
public override void WriteByte(int b)
{
if (_buffer.Length == _length)
{
byte[] newBuf = new byte[_buffer.Length * 3 / 2];
JSArrayEx.Copy(_buffer, 0, newBuf, 0, (int)_length);
_buffer = newBuf;
}
_buffer[_length++] = (byte)b;
}
// Returns a copy of this MD object.
public object Clone()
{
Md4Slim md4 = new Md4Slim();
// This constructor is here to implement cloneability of this class.
application = new uint[md4.application.Length];
JSArrayEx.Copy(md4.application, 0, application, 0, application.Length);
buffer = new byte[md4.buffer.Length];
JSArrayEx.Copy(md4.buffer, 0, buffer, 0, buffer.Length);
count = md4.count;
return(md4);
}
public override void SetLength(long value)
{
if (_buffer.Length != value)
{
byte[] newBuf = new byte[value * 3 / 2];
JSArrayEx.Copy(_buffer, 0, newBuf, 0, (int)_length);
_buffer = newBuf;
while (_length < value)
{
_buffer[_length++] = 0;
}
}
_length = value;
}
public void Print(string data2)
{
//Com.dprintln("SZ.print():<" + data2 + ">");
int length = data2.Length;
byte[] str = JSConvert.StringToBytes(data2);
if (Length != 0)
{
if (Data[Length - 1] != 0)
{
JSArrayEx.Copy(str, 0, Data, GetSpace(length + 1), length);
}
else
{
JSArrayEx.Copy(str, 0, Data, GetSpace(length) - 1, length);
}
}
else
{
// first print.
JSArrayEx.Copy(str, 0, Data, GetSpace(length), length);
}
Data[Length - 1] = 0;
}
public void Append3(byte[] data, int offset, int length)
{
JSArrayEx.Copy(data, offset, data, GetSpace(length), length);
}
public void Append2(byte[] data, int length)
{
JSArrayEx.Copy(data, 0, data, GetSpace(length), length);
}
public void Append(byte[] data)
{
int length = data.Length;
JSArrayEx.Copy(data, 0, data, GetSpace(length), length);
}
public byte[] ToArray()
{
byte[] result = new byte[_length];
JSArrayEx.Copy(_buffer, 0, result, 0, (int)_length);
return(result);
}
public virtual void PushMatrix()
{
float[] copy = new float[16];
JSArrayEx.Copy(_currentMatrix, 0, copy, 0, 16);
_currentMatrixStack.Push(copy);
}
// PolygonOffsetx (GLfixed factor, GLfixed units);
public virtual void PopMatrix()
{
float[] top = (float[])_currentMatrixStack.Pop();
JSArrayEx.Copy(top, 0, _currentMatrix, 0, 16);
_mvpDirty = true;
}
