internal PCMStream(FileMap map)
{
_sourceMap = map;
RIFFHeader* header = (RIFFHeader*)_sourceMap.Address;
_bps = header->_fmtChunk._bitsPerSample;
_numChannels = header->_fmtChunk._channels;
_frequency = (int)header->_fmtChunk._samplesSec;
_numSamples = (int)(header->_dataChunk._chunkSize / header->_fmtChunk._blockAlign);
_source = (short*)(_sourceMap.Address + header->GetSize());
_samplePos = 0;
}
internal ImageExports(MappedImage mappedImage)
{
_mappedImage = mappedImage;
_dataDirectory = mappedImage.GetDataEntry(ImageDataEntry.Export);
_exportDirectory = mappedImage.GetExportDirectory();
if (_exportDirectory != null)
{
_addressTable = (int*)mappedImage.RvaToVa(_exportDirectory->AddressOfFunctions);
_namePointerTable = (int*)mappedImage.RvaToVa(_exportDirectory->AddressOfNames);
_ordinalTable = (short*)mappedImage.RvaToVa(_exportDirectory->AddressOfNameOrdinals);
}
}
internal PCMStream(WaveInfo* pWAVE, VoidPtr dataAddr)
{
_frequency = pWAVE->_sampleRate;
_numSamples = pWAVE->NumSamples;
_numChannels = pWAVE->_format._channels;
_bps = pWAVE->_format._encoding == 0 ? 8 : 16;
if (_numSamples <= 0) return;
_loopStart = (int)pWAVE->LoopSample;
_loopEnd = _numSamples;
_source = (short*)dataAddr;
_samplePos = 0;
}
public static extern void glColor4sv(short *v);
private static nuint FSE_readNCount_body(short *normalizedCounter, uint *maxSVPtr, uint *tableLogPtr, void *headerBuffer, nuint hbSize)
{
byte *istart = (byte *)(headerBuffer);
byte *iend = istart + hbSize;
byte *ip = istart;
int nbBits;
int remaining;
int threshold;
uint bitStream;
int bitCount;
uint charnum = 0;
uint maxSV1 = *maxSVPtr + 1;
int previous0 = 0;
if (hbSize < 8)
{
sbyte *buffer = stackalloc sbyte[8];
memset(buffer, 0, sizeof(sbyte) * 8);
memcpy((void *)(buffer), (headerBuffer), (hbSize));
{
nuint countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr, (void *)buffer, (nuint)(8));
if ((FSE_isError(countSize)) != 0)
{
return(countSize);
}
if (countSize > hbSize)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)));
}
return(countSize);
}
}
assert(hbSize >= 8);
memset((void *)(normalizedCounter), (0), ((*maxSVPtr + 1) * (nuint)(sizeof(short))));
bitStream = MEM_readLE32((void *)ip);
nbBits = (int)((bitStream & 0xF) + 5);
if (nbBits > 15)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_tableLog_tooLarge)));
}
bitStream >>= 4;
bitCount = 4;
*tableLogPtr = (uint)nbBits;
remaining = (1 << nbBits) + 1;
threshold = 1 << nbBits;
nbBits++;
for (;;)
{
if (previous0 != 0)
{
int repeats = (int)(FSE_ctz(~bitStream | 0x80000000) >> 1);
while (repeats >= 12)
{
charnum += (uint)(3 * 12);
if ((ip <= iend - 7))
{
ip += 3;
}
else
{
bitCount -= (int)(8 * (iend - 7 - ip));
bitCount &= 31;
ip = iend - 4;
}
bitStream = MEM_readLE32((void *)ip) >> bitCount;
repeats = (int)(FSE_ctz(~bitStream | 0x80000000) >> 1);
}
charnum += (uint)(3 * repeats);
bitStream >>= 2 * repeats;
bitCount += 2 * repeats;
assert((bitStream & 3) < 3);
charnum += bitStream & 3;
bitCount += 2;
if (charnum >= maxSV1)
{
break;
}
if ((ip <= iend - 7) || (ip + (bitCount >> 3) <= iend - 4))
{
assert((bitCount >> 3) <= 3);
ip += bitCount >> 3;
bitCount &= 7;
}
else
{
bitCount -= (int)(8 * (iend - 4 - ip));
bitCount &= 31;
ip = iend - 4;
}
bitStream = MEM_readLE32((void *)ip) >> bitCount;
}
{
int max = (2 * threshold - 1) - remaining;
int count;
if ((bitStream & (uint)((threshold - 1))) < (uint)(max))
{
count = (int)(bitStream & (uint)((threshold - 1)));
bitCount += nbBits - 1;
}
else
{
count = (int)(bitStream & (uint)((2 * threshold - 1)));
if (count >= threshold)
{
count -= max;
}
bitCount += nbBits;
}
count--;
if (count >= 0)
{
remaining -= count;
}
else
{
assert(count == -1);
remaining += count;
}
normalizedCounter[charnum++] = (short)(count);
previous0 = (count == 0 ? 1 : 0);
assert(threshold > 1);
if (remaining < threshold)
{
if (remaining <= 1)
{
break;
}
nbBits = (int)(BIT_highbit32((uint)remaining) + 1);
threshold = 1 << (nbBits - 1);
}
if (charnum >= maxSV1)
{
break;
}
if ((ip <= iend - 7) || (ip + (bitCount >> 3) <= iend - 4))
{
ip += bitCount >> 3;
bitCount &= 7;
}
else
{
bitCount -= (int)(8 * (iend - 4 - ip));
bitCount &= 31;
ip = iend - 4;
}
bitStream = MEM_readLE32((void *)ip) >> bitCount;
}
}
if (remaining != 1)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)));
}
if (charnum > maxSV1)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_maxSymbolValue_tooSmall)));
}
if (bitCount > 32)
{
return(unchecked ((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected)));
}
*maxSVPtr = charnum - 1;
ip += (bitCount + 7) >> 3;
return((nuint)(ip - istart));
}
public static vImageError ConvolveMultiKernelARGB8888(ref vImageBuffer src,
ref vImageBuffer dest,
IntPtr tempBuffer,
vImagePixelCount srcOffsetToROI_X,
vImagePixelCount srcOffsetToROI_Y,
short [][] kernels, // must be 4
uint kernel_height,
uint kernel_width,
int [] divisors, // must be 4
int [] biases, // must be 4
Pixel8888 backgroundColor,
vImageFlags flags)
{
if (kernels == null)
throw new ArgumentNullException ("kernels");
if (divisors == null)
throw new ArgumentNullException ("divisors");
if (biases == null)
throw new ArgumentNullException ("biases");
if (kernels.Length < 4)
throw new ArgumentException ("Must contain at least four elements", "kernels");
if (divisors.Length < 4)
throw new ArgumentException ("Must contain at least four elements", "divisors");
if (biases.Length < 4)
throw new ArgumentException ("Must contain at least four elements", "biases");
unsafe {
fixed (short* f1 = kernels [0]) {
fixed (short* f2 = kernels [1]) {
fixed (short* f3 = kernels [2]) {
fixed (short* f4 = kernels [3]) {
var ptrs = new short* [4];
ptrs [0] = f1;
ptrs [1] = f2;
ptrs [2] = f3;
ptrs [3] = f4;
return (vImageError) (long) vImageConvolveMultiKernel_ARGB8888 (ref src, ref dest, tempBuffer, srcOffsetToROI_X, srcOffsetToROI_Y, ptrs, kernel_height, kernel_width, divisors, biases, backgroundColor, flags);
}
}
}
}
}
}
public static unsafe Vector128 <short> LoadVector128(short *address) => throw new PlatformNotSupportedException();
private static nuint FSE_readNCount_body_bmi2(short *normalizedCounter, uint *maxSVPtr, uint *tableLogPtr, void *headerBuffer, nuint hbSize)
{
return(FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize));
}
static void jpeg_idct_ifast(jpeg_decompress cinfo, jpeg_component_info compptr, short[] coef_block, byte[][] output_buf, uint output_row, uint output_col)
{
int[] workspace = new int[DCTSIZE2]; // buffers data between passes
unsafe
{
// Pass 1: process columns from input, store into work array.
fixed(int *wsptr_ = workspace, quantptr_ = compptr.dct_table)
{
int *wsptr = wsptr_, quantptr = quantptr_;
fixed(short *inptr_ = coef_block)
{
short *inptr = inptr_;
for (int ctr = DCTSIZE; ctr > 0; ctr--)
{
// Due to quantization, we will usually find that many of the input
// coefficients are zero, especially the AC terms. We can exploit this
// by short-circuiting the IDCT calculation for any column in which all
// the AC terms are zero. In that case each output is equal to the
// DC coefficient (with scale factor as needed).
// With typical images and quantization tables, half or more of the
// column DCT calculations can be simplified this way.
if (inptr[DCTSIZE * 1] == 0 && inptr[DCTSIZE * 2] == 0 && inptr[DCTSIZE * 3] == 0 && inptr[DCTSIZE * 4] == 0 &&
inptr[DCTSIZE * 5] == 0 && inptr[DCTSIZE * 6] == 0 && inptr[DCTSIZE * 7] == 0)
{
// AC terms all zero
int dcval = inptr[0] * quantptr[0];
wsptr[0] = dcval;
wsptr[DCTSIZE * 1] = dcval;
wsptr[DCTSIZE * 2] = dcval;
wsptr[DCTSIZE * 3] = dcval;
wsptr[DCTSIZE * 4] = dcval;
wsptr[DCTSIZE * 5] = dcval;
wsptr[DCTSIZE * 6] = dcval;
wsptr[DCTSIZE * 7] = dcval;
inptr++; // advance pointers to next column
quantptr++;
wsptr++;
continue;
}
// Even part
int tmp0 = inptr[0] * quantptr[0];
int tmp1 = inptr[DCTSIZE * 2] * quantptr[DCTSIZE * 2];
int tmp2 = inptr[DCTSIZE * 4] * quantptr[DCTSIZE * 4];
int tmp3 = inptr[DCTSIZE * 6] * quantptr[DCTSIZE * 6];
int tmp10 = tmp0 + tmp2; // phase 3
int tmp11 = tmp0 - tmp2;
int tmp13 = tmp1 + tmp3; // phases 5-3
int tmp12 = (((tmp1 - tmp3) * FIX_1_414213562) >> 8) - tmp13; // 2*c4
tmp0 = tmp10 + tmp13; // phase 2
tmp3 = tmp10 - tmp13;
tmp1 = tmp11 + tmp12;
tmp2 = tmp11 - tmp12;
// Odd part
int tmp4 = inptr[DCTSIZE * 1] * quantptr[DCTSIZE * 1];
int tmp5 = inptr[DCTSIZE * 3] * quantptr[DCTSIZE * 3];
int tmp6 = inptr[DCTSIZE * 5] * quantptr[DCTSIZE * 5];
int tmp7 = inptr[DCTSIZE * 7] * quantptr[DCTSIZE * 7];
int z13 = tmp6 + tmp5; // phase 6
int z10 = tmp6 - tmp5;
int z11 = tmp4 + tmp7;
int z12 = tmp4 - tmp7;
tmp7 = z11 + z13; // phase 5
tmp11 = ((z11 - z13) * FIX_1_414213562) >> 8; // 2*c4
int z5 = ((z10 + z12) * FIX_1_847759065) >> 8; // 2*c2
tmp10 = ((z12 * FIX_1_082392200) >> 8) - z5; // 2*(c2-c6)
tmp12 = ((z10 * -FIX_2_613125930) >> 8) + z5; // -2*(c2+c6)
tmp6 = tmp12 - tmp7; // phase 2
tmp5 = tmp11 - tmp6;
tmp4 = tmp10 + tmp5;
wsptr[0] = tmp0 + tmp7;
wsptr[DCTSIZE * 7] = tmp0 - tmp7;
wsptr[DCTSIZE * 1] = tmp1 + tmp6;
wsptr[DCTSIZE * 6] = tmp1 - tmp6;
wsptr[DCTSIZE * 2] = tmp2 + tmp5;
wsptr[DCTSIZE * 5] = tmp2 - tmp5;
wsptr[DCTSIZE * 4] = tmp3 + tmp4;
wsptr[DCTSIZE * 3] = tmp3 - tmp4;
inptr++; // advance pointers to next column
quantptr++;
wsptr++;
} // for(...)
} // fixed(short* inptr_=coef_block)
// Pass 2: process rows from work array, store into output array.
wsptr = wsptr_;
for (int ctr = 0; ctr < DCTSIZE; ctr++)
{
fixed(byte *outptr = &output_buf[output_row + ctr][output_col])
{
//byte* outptr=outptr_+output_col;
// Rows of zeroes can be exploited in the same way as we did with columns.
// However, the column calculation has created many nonzero AC terms, so
// the simplification applies less often (typically 5% to 10% of the time).
// On machines with very fast multiplication, it's possible that the
// test takes more time than it's worth. In that case this section
// may be commented out.
#if !NO_ZERO_ROW_TEST
if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 && wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0)
{
// AC terms all zero
int dc = CENTERJSAMPLE + (wsptr[0] >> 5); byte dcval = (byte)((dc >= MAXJSAMPLE)?MAXJSAMPLE:((dc < 0)?0:dc));
outptr[0] = dcval;
outptr[1] = dcval;
outptr[2] = dcval;
outptr[3] = dcval;
outptr[4] = dcval;
outptr[5] = dcval;
outptr[6] = dcval;
outptr[7] = dcval;
wsptr += DCTSIZE; // advance pointer to next row
continue;
}
#endif
// Even part
int tmp10 = wsptr[0] + wsptr[4];
int tmp11 = wsptr[0] - wsptr[4];
int tmp13 = wsptr[2] + wsptr[6];
int tmp12 = (((wsptr[2] - wsptr[6]) * FIX_1_414213562) >> 8) - tmp13;
int tmp0 = tmp10 + tmp13;
int tmp3 = tmp10 - tmp13;
int tmp1 = tmp11 + tmp12;
int tmp2 = tmp11 - tmp12;
// Odd part
int z13 = wsptr[5] + wsptr[3];
int z10 = wsptr[5] - wsptr[3];
int z11 = wsptr[1] + wsptr[7];
int z12 = wsptr[1] - wsptr[7];
int tmp7 = z11 + z13; // phase 5
tmp11 = ((z11 - z13) * FIX_1_414213562) >> 8; // 2*c4
int z5 = ((z10 + z12) * FIX_1_847759065) >> 8; // 2*c2
tmp10 = ((z12 * FIX_1_082392200) >> 8) - z5; // 2*(c2-c6)
tmp12 = ((z10 * -FIX_2_613125930) >> 8) + z5; // -2*(c2+c6)
int tmp6 = tmp12 - tmp7; // phase 2
int tmp5 = tmp11 - tmp6;
int tmp4 = tmp10 + tmp5;
// Final output stage: scale down by a factor of 8 and range-limit
int x;
x = CENTERJSAMPLE + ((tmp0 + tmp7) >> 5); outptr[0] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp0 - tmp7) >> 5); outptr[7] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp1 + tmp6) >> 5); outptr[1] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp1 - tmp6) >> 5); outptr[6] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp2 + tmp5) >> 5); outptr[2] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp2 - tmp5) >> 5); outptr[5] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp3 + tmp4) >> 5); outptr[4] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
x = CENTERJSAMPLE + ((tmp3 - tmp4) >> 5); outptr[3] = (byte)((x >= MAXJSAMPLE)?MAXJSAMPLE:((x < 0)?0:x));
wsptr += DCTSIZE; // advance pointer to next row
} // fixed(byte* outptr=&output_buf[output_row+ctr][output_col])
} // for(...)
} // fixed(int* wsptr_=workspace, quantptr_=compptr.dct_table)
} // unsafe
}
public unsafe override void DSPCallback(int handle, int channel, IntPtr buffer, int length, IntPtr user)
{
if (base.IsBypassed)
{
return;
}
if (base.ChannelBitwidth == 16)
{
short *ptr = (short *)((void *)buffer);
for (int i = 0; i < length / 2; i++)
{
this._d = (double)ptr[i] * (1.0 - this._wetDry) + this.ProcessSample((double)ptr[i]) * this._wetDry;
if (this._useDithering)
{
this._d = Utils.SampleDither(this._d, this._ditherFactor, 32768.0);
}
else
{
this._d = Math.Round(this._d);
}
if (this._d > 32767.0)
{
ptr[i] = short.MaxValue;
}
else if (this._d < -32768.0)
{
ptr[i] = short.MinValue;
}
else
{
ptr[i] = (short)this._d;
}
}
return;
}
if (base.ChannelBitwidth == 32)
{
float *ptr2 = (float *)((void *)buffer);
for (int j = 0; j < length / 4; j++)
{
ptr2[j] = (float)((double)ptr2[j] * (1.0 - this._wetDry) + this.ProcessSample((double)ptr2[j]) * this._wetDry);
}
return;
}
byte *ptr3 = (byte *)((void *)buffer);
for (int k = 0; k < length; k++)
{
this._d = (double)((int)(ptr3[k] - 128) * 256);
this._d = this._d * (1.0 - this._wetDry) + this.ProcessSample(this._d) * this._wetDry;
if (this._useDithering)
{
this._d = Utils.SampleDither(this._d, this._ditherFactor, 32768.0);
}
else
{
this._d = Math.Round(this._d);
}
if (this._d > 32767.0)
{
ptr3[k] = byte.MaxValue;
}
else if (this._d < -32768.0)
{
ptr3[k] = 0;
}
else
{
ptr3[k] = (byte)((int)this._d / 256 + 128);
}
}
}
protected override unsafe int Poll()
{
short[] cache = (short[])_cacheReader.Cache;
int k = 0;
foreach (PDUArea area in _rangeList)
{
byte[] rcvBytes = _plcReader.ReadBytes(area.Start, (ushort)area.Len);//从PLC读取数据
if (rcvBytes == null)
{
_plcReader.Connect();
return(-1);
}
else
{
int len = rcvBytes.Length / 2;
fixed(byte *p1 = rcvBytes)
{
short *prcv = (short *)p1;
int index = area.StartIndex;//index指向_items中的Tag元数据
int count = index + area.Count;
while (index < count)
{
DeviceAddress addr = _items[index].Address;
int iShort = addr.CacheIndex;
int iShort1 = iShort - k;
if (addr.VarType == DataType.BOOL)
{
int tmp = prcv[iShort1] ^ cache[iShort];
DeviceAddress next = addr;
if (tmp != 0)
{
while (addr.Start == next.Start)
{
if ((tmp & (1 << next.Bit)) > 0)
{
_changedList.Add(index);
}
if (++index < count)
{
next = _items[index].Address;
}
else
{
break;
}
}
}
else
{
while (addr.Start == next.Start && ++index < count)
{
next = _items[index].Address;
}
}
}
else
{
if (addr.DataSize <= 2)
{
if (prcv[iShort1] != cache[iShort])
{
_changedList.Add(index);
}
}
else
{
int size = addr.DataSize / 2;
for (int i = 0; i < size; i++)
{
if (prcv[iShort1 + i] != cache[iShort + i])
{
_changedList.Add(index);
break;
}
}
}
index++;
}
}
for (int j = 0; j < len; j++)
{
cache[j + k] = prcv[j];
}//将PLC读取的数据写入到CacheReader中
}
k += len;
}
}
return(1);
}
public static unsafe Mesh LoadMesh(string filename, Mesh mesh, SkinnedMeshRenderer rend, Transform transform)
{
byte[] filedata;
bool ret = OpenFile(filename, out filedata);
if (!ret)
{
return(null);
}
mesh_head_t head = (mesh_head_t)BytesToStruct(filedata, typeof(mesh_head_t));
fixed(byte *data = &filedata[0])
{
//mesh_head_t *head2 = (mesh_head_t *)data;
}
if (head.filemask != 0x4D455348)
{
return(null);
}
if (head.pos_offset == 0 || head.tex1_offset == 0 || head.index_buffer_offset == 0)
{
return(null);
}
#region meshinfo
////create the original mesh
int mesh_option = 0;
//if (!skin_info.d3dsi && (gpu().get_creation_parameters().vertex_processing_method == _gpu_vertex_processing_method_hardware_ || gpu().get_creation_parameters().vertex_processing_method == _gpu_vertex_processing_method_purehardware_))
// mesh_option |= D3DXMESH_MANAGED; //non-skinned && hardware-vp
//else
// mesh_option |= D3DXMESH_SYSTEMMEM; //skinned or soft-vp
if (head.vertex_count > 0x0000ffff)
{
mesh_option |= D3DXMESH_32BIT;
}
//LPD3DXMESH d3dmesh = 0;
//if (FAILED(D3DXCreateMeshFVF(head.face_count, head.vertex_count, mesh_option, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1, gpu().d3ddevice(), &d3dmesh)))
//{
// clear();
// return;
//}
//head.face_count;
//head.vertex_count;
//load data
//vertex buffer
Debug.Log(head);
Debug.LogWarning(string.Format("vertex_count = {0}", head.vertex_count));
List <Vector3> ves = new List <Vector3>();
fixed(byte *v = &filedata[head.pos_offset])
{
float3 *ff = (float3 *)v;
for (int i = 0; i < head.vertex_count; i++, ff++)
{
//Debug.Log(string.Format("{0},{1},{2}", ff->x, ff->y, ff->z));
//mesh.vertices[i] = new Vector3(ff->x, ff->y, ff->z);
ves.Add(new Vector3(ff->x, ff->y, ff->z));
}
}
mesh.SetVertices(ves);
Debug.LogWarning(string.Format("vertex_count = {0}", head.vertex_count));
mesh.uv = new Vector2[head.vertex_count];
List <Vector2> uvs = new List <Vector2>();
fixed(byte *v = &filedata[head.tex1_offset])
{
float3 *ff = (float3 *)v;
for (int i = 0; i < head.vertex_count; i++, ff++)
{
//Debug.Log(string.Format("{0},{1},{2}", ff->x, ff->y, ff->z));
mesh.uv[i] = new Vector2(ff->x, ff->y);
uvs.Add(new Vector2(ff->x, 1 - ff->y));
}
}
mesh.SetUVs(0, uvs);
if (head.normal_offset != 0)
{
Debug.LogWarning(string.Format("normal = {0}", head.vertex_count));
List <Vector3> normal = new List <Vector3>();
fixed(byte *v = &filedata[head.normal_offset])
{
float3 *ff = (float3 *)v;
for (int i = 0; i < head.vertex_count; i++, ff++)
{
//Debug.Log(string.Format("{0},{1},{2}", ff->x, ff->y, ff->z));
normal.Add(new Vector2(ff->x, ff->y));
}
}
mesh.SetNormals(normal);
}
//float3* uv = (float3*)((byte*)filedata[head.tex1_offset]);
//float3* normal = (float3*)(filedata[head.normal_offset]);
//int bNormal = head.normal_offset == 0 ? 1 : 0;
//xyz_normal_uv_t* vb_v;
//d3dmesh.LockVertexBuffer(0, (void**)&vb_v);
//for (int i = 0; i < head.vertex_count; i++)
//{
// vb_v[i].xyz = v[i];
// vb_v[i].uv.x = uv[i].x;
// vb_v[i].uv.y = uv[i].y;
// if (bNormal == 1)
// vb_v[i].normal = normal[i];
//}
//d3dmesh.UnlockVertexBuffer();
//if (!normal)
//{
// D3DXComputeNormals(d3dmesh, 0);
//}
// Build basic mesh
//Mesh mesh = new Mesh();
//index buffer
Debug.LogWarning(string.Format("Face Count = {0}", head.face_count));
int triCount = head.face_count * 3;
mesh.triangles = new int[triCount];
int[] trs = new int[triCount];
int[] trs2 = new int[triCount];
fixed(byte *v = &filedata[head.index_buffer_offset])
{
short *b2 = (short *)v;
int * b4 = (int *)v;
for (int i = 0; i < triCount; i++, b2++, b4++)
{
int t = 0;
if ((mesh_option & D3DXMESH_32BIT) == 0)
{
t = *b4;
}
else
{
t = *b2;
}
//Debug.Log(string.Format("{0} {1}",i, t));
mesh.triangles[i] = t;
trs[i] = t;
}
}
for (int i = 0; i < triCount; i++)
{
trs2[i] = trs[triCount - i - 1];
}
mesh.SetTriangles(trs2, 0, true);
//void* ib_f;
//d3dmesh.LockIndexBuffer(0, (void**)&ib_f);
//if ((mesh_option & D3DXMESH_32BIT) == 0)
// memcpy(ib_f, f, head.face_count * 3 * 4);
//else
//{
// for (int i = 0; i < head.face_count * 3; i++)
// {
// ((byte2*)ib_f)[i] = (byte2)f[i];
// }
//}
//d3dmesh.UnlockIndexBuffer();
mesh.RecalculateNormals(); //todo: head.normal_offset
mesh.RecalculateBounds();
mesh.RecalculateTangents();
////attribute buffer
//int* ab_ss = 0;
//d3dmesh.LockAttributeBuffer(0, (int**)&ab_ss);
//if (!head.attri_buffer_offset)
//{
// memset(ab_ss, 0, head.face_count * 4);
//}
//else
//{
// int* ss = (int*)((byte*)filedata.GetBufferPointer() + head.attri_buffer_offset);
// memcpy(ab_ss, ss, head.face_count * 4);
//}
//d3dmesh.UnlockAttributeBuffer();
////end of creating original mesh
////generate geo info
//geo_info = new mesh_geo_info_t;
////clear ptrs
//geo_info.vb = 0;
//geo_info.ib = 0;
//geo_info.decl = 0;
//geo_info.attri_table_buf = 0;
//if (!skin_info.d3dsi) //non-skinned
//{
// //optimize & generate the attribute table
// int* adj = new int[head.face_count * 3];
// d3dmesh.GenerateAdjacency(0, adj);
// d3dmesh.OptimizeInplace(D3DXMESHOPT_ATTRSORT, adj, 0, 0, 0);
// SAFE_DELETE_ARRAY(adj);
// //retrieve datas
// d3dmesh.GetVertexBuffer(&geo_info.vb);
// geo_info.stride = d3dmesh.GetNumBytesPerVertex();
// d3dmesh.GetIndexBuffer(&geo_info.ib);
// geo_info.fvf = d3dmesh.GetFVF();
// d3dmesh.GetAttributeTable(0, &geo_info.subset_count);
// D3DXCreateBuffer(geo_info.subset_count * sizeof(D3DXATTRIBUTERANGE), &geo_info.attri_table_buf);
// d3dmesh.GetAttributeTable((D3DXATTRIBUTERANGE*)geo_info.attri_table_buf.GetBufferPointer(), &geo_info.subset_count);
// geo_info.palette_count = 0;
// geo_info.max_infl_count = 0;
//}
//else //skinned
//{
// //generate adjacency
// int* adj = new int[head.face_count * 3];
// d3dmesh.GenerateAdjacency(0, adj);
// //generate blended mesh
// LPD3DXMESH blended_mesh = 0;
// //pal count
// switch (gpu().get_creation_parameters().vertex_processing_method)
// {
// case _gpu_vertex_processing_method_software_:
// case _gpu_vertex_processing_method_mixed_:
// geo_info.palette_count = min((int)skin_info.real_bone_index_vec.size(), (256 - 17) / 3);
// break;
// default:
// geo_info.palette_count = min((int)skin_info.real_bone_index_vec.size(), (gpu().get_hardware_caps().max_vertex_shader_const - 17) / 3);
// }
// int flags = D3DXMESHOPT_VERTEXCACHE;
// switch (gpu().get_creation_parameters().vertex_processing_method)
// {
// case _gpu_vertex_processing_method_software_:
// case _gpu_vertex_processing_method_mixed_:
// flags |= D3DXMESH_SYSTEMMEM; //if the hardware indexed skinning is avaiable, we won't use mixed or software vertex processing method
// break;
// default:
// flags |= D3DXMESH_MANAGED;
// }
// //convert
// if (FAILED(skin_info.d3dsi.ConvertToIndexedBlendedMesh(d3dmesh,
// flags,
// geo_info.palette_count,
// adj,
// 0, 0, 0,
// (int*)&geo_info.max_infl_count,
// (int*)&geo_info.subset_count,
// &geo_info.attri_table_buf,
// &blended_mesh)) ||
// geo_info.max_infl_count > 4)
// {
// SAFE_DELETE_ARRAY(adj);
// SAFE_DELETE(geo_info);
// SAFE_RELEASE(d3dmesh);
// clear();
// return;
// }
// //retrieve datas
// blended_mesh.GetVertexBuffer(&geo_info.vb);
// geo_info.stride = blended_mesh.GetNumBytesPerVertex();
// blended_mesh.GetIndexBuffer(&geo_info.ib);
// //fvf
// geo_info.fvf = blended_mesh.GetFVF();
// //decl will be generated later
// SAFE_DELETE_ARRAY(adj);
// SAFE_RELEASE(blended_mesh);
//}
#endregion
#region bone
//skin_info = new mesh_skin_info_t;
//skin_info.d3dsi = 0;
// bindPoses was created earlier and was updated with the required matrix.
// The bindPoses array will now be assigned to the bindposes in the Mesh.
byte[] buff = new byte[30];
Transform[] bones;
Matrix4x4[] bindPoses;
BoneWeight[] boneweights = new BoneWeight[head.vertex_count];
Dictionary <string, GameObject> BoneList = new Dictionary <string, GameObject>();
Dictionary <string, Matrix4x4> MatrixList = new Dictionary <string, Matrix4x4>();
Dictionary <string, int> PoseList = new Dictionary <string, int>();
fixed(byte *ptrb = &filedata[head.skin_info_offset])
{
char *ptr = (char *)ptrb;
int bone_size = *(int *)ptr;
Debug.Log("Bone Size : " + bone_size);
bones = new Transform[bone_size];
bindPoses = new Matrix4x4[bone_size];
ptr += 4 / 2;
for (int i = 0; i < bone_size; i++)
{
//bone.name = (char *)ptr;
//Marshal.Copy(new IntPtr(ptr), buff, 0, 30);
//string name = Encoding.Default.GetString(buff);
string name = Marshal.PtrToStringAnsi(new IntPtr(ptr));
Debug.Log(name);
ptr += 30 / 2;
//bone.parent_name = (char *)ptr;
//Marshal.Copy(new IntPtr(ptr), buff, 0, 30);
string parent_anme = Marshal.PtrToStringAnsi(new IntPtr(ptr));
//Debug.Log(parent_anme);
ptr += 30 / 2;
int num_child = *(int *)ptr;
ptr += (4 + num_child * 30) / 2;
//bone_vec[i].offset_matrix = *(matrix*)ptr;
//matrix offset_matrix = new matrix();
//Marshal.Copy(new IntPtr(ptr), offset_matrix, 0, sizeof(matrix));
matrix offset_matrix = (matrix)Marshal.PtrToStructure(new IntPtr(ptr), typeof(matrix));
Matrix4x4 om = (Matrix4x4)Marshal.PtrToStructure(new IntPtr(ptr), typeof(Matrix4x4));
//om = om.inverse;
Debug.Log(om);
//om = om.inverse;
if (!om.ValidTRS())
{
Debug.LogError("Not TRS");
}
ptr += sizeof(matrix) / 2;
Matrix4x4 bm = (Matrix4x4)Marshal.PtrToStructure(new IntPtr(ptr), typeof(Matrix4x4));
//Debug.Log(bm);
//om = bm;
ptr += sizeof(matrix) / 2;
int num_infl = *(int *)ptr;
ptr += 4 / 2;
//Debug.Log("num_infl : " + num_infl);
// weights
char *ptr1 = ptr;
char *ptr2 = ptr + num_infl * sizeof(int) / 2;
for (int w = 0; w < num_infl; w++)
{
//real_bone_index_vec.push_back(i);
//skin_info.d3dsi.SetBoneInfluence((int)skin_info.real_bone_index_vec.size() - 1, num_infl, (int*)ptr, (float*)(ptr + 4 * num_infl));
int vecIdx = *(int *)ptr1;
ptr1 += sizeof(int) / 2;
float weight = *(float *)ptr2;
ptr2 += sizeof(float) / 2;
//Debug.Log(string.Format("{0}, {1}, {2}", w, vecIdx, weight));
if (boneweights[vecIdx].weight0 == 0)
{
boneweights[vecIdx].boneIndex0 = i;
boneweights[vecIdx].weight0 = weight;
}
else if (boneweights[vecIdx].weight1 == 0)
{
boneweights[vecIdx].boneIndex1 = i;
boneweights[vecIdx].weight1 = weight;
}
else if (boneweights[vecIdx].weight2 == 0)
{
boneweights[vecIdx].boneIndex2 = i;
boneweights[vecIdx].weight2 = weight;
}
else if (boneweights[vecIdx].weight3 == 0)
{
boneweights[vecIdx].boneIndex3 = i;
boneweights[vecIdx].weight3 = weight;
}
else
{
Debug.LogWarning("Bone Weight Count Error!!!");
}
}
ptr += (num_infl * (sizeof(int) + sizeof(float))) / 2;
bones[i] = new GameObject(name).transform;
bones[i].parent = transform;
// Set the position relative to the parent
bones[i].localRotation = Quaternion.identity; // om.ExtractRotation();//
bones[i].localPosition = new Vector3(0, 0, 0); //om.ExtractPosition();//
//bones[i].localScale = om.ExtractScale();
BoneList.Add(name, bones[i].gameObject);
BoneTree.Add(name, parent_anme);
MatrixList.Add(name, om);
PoseList.Add(name, i);
// The bind pose is bone's inverse transformation matrix
// In this case the matrix we also make this matrix relative to the root
// So that we can move the root game object around freely
bindPoses[i] = Matrix4x4.identity;
//bindPoses[i] = bones[i].worldToLocalMatrix * transform.localToWorldMatrix;
//bindPoses[i] = om * transform.localToWorldMatrix;
//bindPoses[i] = om.inverse;
}
}
Debug.LogWarning("----------------------------------------------");
foreach (var item in BoneTree)
{
string name = item.Key;
string parent = item.Value;
GameObject go;
GameObject goParent;
if (BoneList.TryGetValue(name, out go) && BoneList.TryGetValue(parent, out goParent))
{
go.transform.SetParent(goParent.transform);
}
}
List <Transform> childs = new List <Transform>();
childs.Add(transform);
while (childs.Count > 0)
{
Transform trans = childs[0];
childs.Remove(trans);
for (int i = 0; i < trans.childCount; i++)
{
childs.Add(trans.GetChild(i));
}
string name = trans.name;
string parent;
if (!BoneTree.TryGetValue(name, out parent))
{
continue;
}
Debug.Log(string.Format("2 {0} -> {1}", name, parent));
GameObject go;
GameObject goParent;
if (BoneList.TryGetValue(name, out go))
{
Matrix4x4 om = MatrixList[name];
Debug.Log(om);
int pose = PoseList[name];
go.transform.localPosition = om.ExtractPosition();
go.transform.localRotation = om.ExtractRotation();
//go.transform.localScale = om.ExtractScale();
bindPoses[pose] = go.transform.ToMatrix4x4().inverse;
if (parent != "Scene Root" && BoneList.TryGetValue(parent, out goParent))
{
//Matrix4x4 im = goParent.transform.ToMatrix4x4().inverse;
//go.transform.localRotation = (om * im).ExtractRotation();//Quaternion.identity;//
//go.transform.localPosition = (om * im).ExtractPosition();//new Vector3(0, 0, 0);//
//go.transform.localScale = om.ExtractScale();
//bindPoses[pose] = go.transform.worldToLocalMatrix * goParent.transform.localToWorldMatrix;
}
else
{
Debug.Log(string.Format("{0} no parent", name));
//go.transform.localPosition = om.ExtractPosition();
//go.transform.localRotation = om.ExtractRotation();
//go.transform.localScale = om.ExtractScale();
//bindPoses[pose] = go.transform.worldToLocalMatrix * transform.localToWorldMatrix;
}
}
}
mesh.boneWeights = boneweights;
mesh.bindposes = bindPoses;
// Assign bones and bind poses
rend.bones = bones;
rend.sharedMesh = mesh;
////non-skinned mesh
//if (!head.skin_info_offset)
// return;
////skinned mesh
//byte* ptr = (byte*)filedata.GetBufferPointer() + head.skin_info_offset;
//skin_info.bone_vec.resize(*(int*)ptr);
//ptr += 4;
//if (!skin_info.bone_vec.empty())
//{
// //create d3dx skin info (may be larger than needed)
// if (FAILED(D3DXCreateSkinInfoFVF(head.vertex_count, D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1, (int)skin_info.bone_vec.size(), &skin_info.d3dsi)))
// {
// SAFE_DELETE(skin_info);
// clear();
// return;
// }
//}
//for (int i = 0; i < skin_info.bone_vec.size(); i++)
//{
// strcpy(skin_info.bone_vec[i].name, (char*)ptr);
// ptr += 30;
// skin_info.bone_vec[i].parent_name = (char*)ptr;
// ptr += 30;
// int num_child = *(int*)ptr;
// ptr += 4 + num_child * 30;
// skin_info.bone_vec[i].offset_matrix = *(matrix*)ptr;
// ptr += 2 * sizeof(matrix);
// int num_infl = *(int*)ptr;
// ptr += 4;
// if (num_infl > 0)
// {
// skin_info.real_bone_index_vec.push_back(i);
// skin_info.d3dsi.SetBoneInfluence((int)skin_info.real_bone_index_vec.size() - 1, num_infl, (int*)ptr, (float*)(ptr + 4 * num_infl));
// ptr += num_infl * (sizeof(int) + sizeof(float));
// }
//}
//if (skin_info.real_bone_index_vec.empty())
//{
// //non-skinned in fact
// SAFE_RELEASE(skin_info.d3dsi);
//}
////compute derived bone members
////parent index
//for (int i = 0; i < skin_info.bone_vec.size(); i++)
//{
// skin_info.bone_vec[i].parent_index = -1;
// for (int j = 0; j < skin_info.bone_vec.size(); j++)
// {
// if (strcmp(skin_info.bone_vec[i].parent_name.c_str(), skin_info.bone_vec[j].name) == 0)
// {
// skin_info.bone_vec[i].parent_index = j;
// skin_info.bone_vec[i].parent_name.clear();
// break;
// }
// }
//}
////soft type
//for (int i = 0; i < skin_info.bone_vec.size(); i++)
//{
// if (strncmp(skin_info.bone_vec[i].name, "FL_", 3) == 0)
// skin_info.bone_vec[i].soft_type = _bone_soft_type_soft_;
// else if (strncmp(skin_info.bone_vec[i].name, "GL_", 3) == 0)
// skin_info.bone_vec[i].soft_type = _bone_soft_type_gravity_;
// else if (strncmp(skin_info.bone_vec[i].name, "AL_", 3) == 0)
// skin_info.bone_vec[i].soft_type = _bone_soft_type_adjsoft_;
// else
// skin_info.bone_vec[i].soft_type = _bone_soft_type_normal_;
//}
////soft level
//for (int i = 0; i < skin_info.bone_vec.size(); i++)
// skin_info.bone_vec[i].soft_level = -1;
//for (int i = 0; i < skin_info.bone_vec.size(); i++)
// _compute_bone_soft_level_recursive(skin_info, i);
////inv-offset matrix & relative matrix
//for (int i = 0; i < skin_info.bone_vec.size(); i++)
//{
// D3DXMatrixInverse(&skin_info.bone_vec[i].inv_offset_matrix, 0, &skin_info.bone_vec[i].offset_matrix);
// if (skin_info.bone_vec[i].parent_index != -1)
// skin_info.bone_vec[i].relative_matrix = skin_info.bone_vec[i].inv_offset_matrix * skin_info.bone_vec[skin_info.bone_vec[i].parent_index].offset_matrix;
// else
// skin_info.bone_vec[i].relative_matrix = skin_info.bone_vec[i].inv_offset_matrix;
//}
////end of computing derived bone members
////sockets
//skin_info.socket_vec.resize(*(int*)ptr);
//ptr += 4;
//for (int i = 0; i < skin_info.socket_vec.size(); i++)
//{
// strcpy(skin_info.socket_vec[i].name, (char*)ptr);
// ptr += 30;
// skin_info.socket_vec[i].parent_bone_name = (char*)ptr;
// ptr += 30;
// skin_info.socket_vec[i].relative_matrix = *(matrix*)ptr;
// ptr += sizeof(matrix);
//}
////compute derived socket members
//for (int i = 0; i < skin_info.socket_vec.size(); i++)
//{
// skin_info.socket_vec[i].parent_bone_index = -1;
// for (int j = 0; j < skin_info.bone_vec.size(); j++)
// {
// if (strcmp(skin_info.socket_vec[i].parent_bone_name.c_str(), skin_info.bone_vec[j].name) == 0)
// {
// skin_info.socket_vec[i].parent_bone_index = j;
// skin_info.socket_vec[i].parent_bone_name.clear();
// break;
// }
// }
//}
#endregion
//SAFE_RELEASE(d3dmesh);
//SAFE_RELEASE(skin_info.d3dsi);
//SAFE_RELEASE(filedata);
return(mesh);
}
public static extern void glRectsv(short *v1, short *v2);
public static extern void glTexCoord3sv(short *v);
public static extern void glRasterPos4sv(short *v);
public static extern void glNormal3sv(short *v);
public static extern void glIndexsv(short *c);
/// <summary>
/// <para>
/// Find the best (longest) string in the window matching the
/// string starting at strstart.
/// </para>
/// <para>
/// Preconditions:
/// <code>
/// strstart + DeflaterConstants.MAX_MATCH <= window.length.</code>
/// </para>
/// </summary>
/// <param name="curMatch">The current match.</param>
/// <returns>True if a match greater than the minimum length is found</returns>
private bool FindLongestMatch(int curMatch)
{
int match;
int scan = this.strstart;
// scanMax is the highest position that we can look at
int scanMax = scan + Math.Min(DeflaterConstants.MAX_MATCH, this.lookahead) - 1;
int limit = Math.Max(scan - DeflaterConstants.MAX_DIST, 0);
int chainLength = this.maxChain;
int niceLength = Math.Min(this.niceLength, this.lookahead);
int matchStrt = this.matchStart;
this.matchLen = Math.Max(this.matchLen, DeflaterConstants.MIN_MATCH - 1);
int matchLength = this.matchLen;
if (scan + matchLength > scanMax)
{
return(false);
}
byte *pinnedWindow = this.pinnedWindowPointer;
int scanStart = this.strstart;
byte scanEnd1 = pinnedWindow[scan + matchLength - 1];
byte scanEnd = pinnedWindow[scan + matchLength];
// Do not waste too much time if we already have a good match:
if (matchLength >= this.goodLength)
{
chainLength >>= 2;
}
short *pinnedPrev = this.pinnedPrevPointer;
do
{
match = curMatch;
scan = scanStart;
if (pinnedWindow[match + matchLength] != scanEnd ||
pinnedWindow[match + matchLength - 1] != scanEnd1 ||
pinnedWindow[match] != pinnedWindow[scan] ||
pinnedWindow[++match] != pinnedWindow[++scan])
{
continue;
}
// scan is set to strstart+1 and the comparison passed, so
// scanMax - scan is the maximum number of bytes we can compare.
// below we compare 8 bytes at a time, so first we compare
// (scanMax - scan) % 8 bytes, so the remainder is a multiple of 8
// n & (8 - 1) == n % 8.
switch ((scanMax - scan) & 7)
{
case 1:
if (pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
case 2:
if (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
case 3:
if (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
case 4:
if (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
case 5:
if (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
case 6:
if (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
case 7:
if (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match])
{
break;
}
break;
}
if (pinnedWindow[scan] == pinnedWindow[match])
{
// We check for insufficient lookahead only every 8th comparison;
// the 256th check will be made at strstart + 258 unless lookahead is
// exhausted first.
do
{
if (scan == scanMax)
{
++scan; // advance to first position not matched
++match;
break;
}
}while (pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match] &&
pinnedWindow[++scan] == pinnedWindow[++match]);
}
if (scan - scanStart > matchLength)
{
matchStrt = curMatch;
matchLength = scan - scanStart;
if (matchLength >= niceLength)
{
break;
}
scanEnd1 = pinnedWindow[scan - 1];
scanEnd = pinnedWindow[scan];
}
}while ((curMatch = pinnedPrev[curMatch & DeflaterConstants.WMASK] & 0xFFFF) > limit && --chainLength != 0);
this.matchStart = matchStrt;
this.matchLen = matchLength;
return(matchLength >= DeflaterConstants.MIN_MATCH);
}
/*public static object GetType(ILContext ctx, object instance, object[] param, IType[] genericArguments)
* {
* var t = ctx.AppDomain.GetType((string)param[0]);
* if (t != null)
* return t.ReflectionType;
* else
* return null;
* }*/
public unsafe static StackObject *InitializeArray(ILIntepreter intp, StackObject *esp, List <object> mStack, CLRMethod method, bool isNewObj)
{
var ret = esp - 1 - 1;
AppDomain domain = intp.AppDomain;
var param = esp - 1;
byte[] data = StackObject.ToObject(param, domain, mStack) as byte[];
intp.Free(param);
param = esp - 1 - 1;
object array = StackObject.ToObject(param, domain, mStack);
intp.Free(param);
if (data == null)
{
return(ret);
fixed(byte *p = data)
{
if (array is int[])
{
int[] arr = array as int[];
int * ptr = (int *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is byte[])
{
byte[] arr = array as byte[];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = p[i];
}
}
else if (array is sbyte[])
{
sbyte[] arr = array as sbyte[];
sbyte * ptr = (sbyte *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is short[])
{
short[] arr = array as short[];
short * ptr = (short *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is ushort[])
{
ushort[] arr = array as ushort[];
ushort * ptr = (ushort *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is char[])
{
char[] arr = array as char[];
char * ptr = (char *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is uint[])
{
uint[] arr = array as uint[];
uint * ptr = (uint *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is Int64[])
{
long[] arr = array as long[];
long * ptr = (long *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is UInt64[])
{
ulong[] arr = array as ulong[];
ulong * ptr = (ulong *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is float[])
{
float[] arr = array as float[];
float * ptr = (float *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is double[])
{
double[] arr = array as double[];
double * ptr = (double *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else if (array is bool[])
{
bool[] arr = array as bool[];
bool * ptr = (bool *)p;
for (int i = 0; i < arr.Length; i++)
{
arr[i] = ptr[i];
}
}
else
{
throw new NotImplementedException("array=" + array.GetType());
}
}
return(ret);
}
public static extern unsafe short th03_get_version(short *version, short port);
private static unsafe string EncodeObject(ref object data, EventData *dataDescriptor, byte *dataBuffer)
/*++
*
* Routine Description:
*
* This routine is used by WriteEvent to unbox the object type and
* to fill the passed in ETW data descriptor.
*
* Arguments:
*
* data - argument to be decoded
*
* dataDescriptor - pointer to the descriptor to be filled
*
* dataBuffer - storage buffer for storing user data, needed because cant get the address of the object
*
* Return Value:
*
* null if the object is a basic type other than string. String otherwise
*
* --*/
{
dataDescriptor->Reserved = 0;
string sRet = data as string;
if (sRet != null)
{
dataDescriptor->Size = (uint)((sRet.Length + 1) * 2);
return(sRet);
}
if (data == null)
{
dataDescriptor->Size = 0;
dataDescriptor->DataPointer = 0;
}
else if (data is IntPtr)
{
dataDescriptor->Size = (uint)sizeof(IntPtr);
IntPtr *intptrPtr = (IntPtr *)dataBuffer;
* intptrPtr = (IntPtr)data;
dataDescriptor->DataPointer = (ulong)intptrPtr;
}
else if (data is int)
{
dataDescriptor->Size = (uint)sizeof(int);
int *intptrPtr = (int *)dataBuffer;
* intptrPtr = (int)data;
dataDescriptor->DataPointer = (ulong)intptrPtr;
}
else if (data is long)
{
dataDescriptor->Size = (uint)sizeof(long);
long *longptr = (long *)dataBuffer;
* longptr = (long)data;
dataDescriptor->DataPointer = (ulong)longptr;
}
else if (data is uint)
{
dataDescriptor->Size = (uint)sizeof(uint);
uint *uintptr = (uint *)dataBuffer;
* uintptr = (uint)data;
dataDescriptor->DataPointer = (ulong)uintptr;
}
else if (data is UInt64)
{
dataDescriptor->Size = (uint)sizeof(ulong);
UInt64 *ulongptr = (ulong *)dataBuffer;
* ulongptr = (ulong)data;
dataDescriptor->DataPointer = (ulong)ulongptr;
}
else if (data is char)
{
dataDescriptor->Size = (uint)sizeof(char);
char *charptr = (char *)dataBuffer;
* charptr = (char)data;
dataDescriptor->DataPointer = (ulong)charptr;
}
else if (data is byte)
{
dataDescriptor->Size = (uint)sizeof(byte);
byte *byteptr = (byte *)dataBuffer;
* byteptr = (byte)data;
dataDescriptor->DataPointer = (ulong)byteptr;
}
else if (data is short)
{
dataDescriptor->Size = (uint)sizeof(short);
short *shortptr = (short *)dataBuffer;
* shortptr = (short)data;
dataDescriptor->DataPointer = (ulong)shortptr;
}
else if (data is sbyte)
{
dataDescriptor->Size = (uint)sizeof(sbyte);
sbyte *sbyteptr = (sbyte *)dataBuffer;
* sbyteptr = (sbyte)data;
dataDescriptor->DataPointer = (ulong)sbyteptr;
}
else if (data is ushort)
{
dataDescriptor->Size = (uint)sizeof(ushort);
ushort *ushortptr = (ushort *)dataBuffer;
* ushortptr = (ushort)data;
dataDescriptor->DataPointer = (ulong)ushortptr;
}
else if (data is float)
{
dataDescriptor->Size = (uint)sizeof(float);
float *floatptr = (float *)dataBuffer;
* floatptr = (float)data;
dataDescriptor->DataPointer = (ulong)floatptr;
}
else if (data is double)
{
dataDescriptor->Size = (uint)sizeof(double);
double *doubleptr = (double *)dataBuffer;
* doubleptr = (double)data;
dataDescriptor->DataPointer = (ulong)doubleptr;
}
else if (data is bool)
{
dataDescriptor->Size = (uint)sizeof(bool);
bool *boolptr = (bool *)dataBuffer;
* boolptr = (bool)data;
dataDescriptor->DataPointer = (ulong)boolptr;
}
else if (data is Guid)
{
dataDescriptor->Size = (uint)sizeof(Guid);
Guid *guidptr = (Guid *)dataBuffer;
* guidptr = (Guid)data;
dataDescriptor->DataPointer = (ulong)guidptr;
}
else if (data is decimal)
{
dataDescriptor->Size = (uint)sizeof(decimal);
decimal *decimalptr = (decimal *)dataBuffer;
* decimalptr = (decimal)data;
dataDescriptor->DataPointer = (ulong)decimalptr;
}
else if (data is Boolean)
{
dataDescriptor->Size = (uint)sizeof(Boolean);
Boolean *booleanptr = (Boolean *)dataBuffer;
* booleanptr = (Boolean)data;
dataDescriptor->DataPointer = (ulong)booleanptr;
}
else
{
//To our eyes, everything else is a just a string
sRet = data.ToString();
dataDescriptor->Size = (uint)((sRet.Length + 1) * 2);
return(sRet);
}
return(null);
}
public static extern short TC08GetSingle(short handle,
float[] temp,
short *overflow_flags,
TempUnit units
);
/*
* Returns the position of the last non-zero coeff plus one
* (and 0 if there's no coeff at all)
*/
/* for const-casting */
//typedef const uint8_t (*ProbaArray)[NUM_CTX] [NUM_PROBAS];
//static int GetCoeffs(BOOL_DECODER* br, ProbaArray prob, int ctx, int n,
// int16_t*out)
static int GetCoeffs(BOOL_DECODER br, byte *prob, int ctx, int n, short * @out)
{
int bigSlice = NUM_CTX * NUM_PROBAS;
int smallSlice = NUM_PROBAS;
//const uint8_t *p = prob[n][ctx];
byte *p = prob + n * bigSlice + ctx * smallSlice;
if (VP8GetBit(ref br, p[0]) == 0)
{ /* first EOB is more a 'CBP' bit. */
return(0);
}
while (true)
{
++n;
if (VP8GetBit(ref br, p[1]) == 0)
{
//p = prob[kBands[n]][0];
p = prob + kBands[n] * bigSlice;
}
else
{ /* non zero coeff */
int v, j;
if (VP8GetBit(ref br, p[2]) == 0)
{
//p = prob[kBands[n]][1];
p = prob + kBands[n] * bigSlice + smallSlice;
v = 1;
}
else
{
if (VP8GetBit(ref br, p[3]) == 0)
{
if (VP8GetBit(ref br, p[4]) == 0)
{
v = 2;
}
else
{
v = 3 + VP8GetBit(ref br, p[5]);
}
}
else
{
if (VP8GetBit(ref br, p[6]) == 0)
{
if (VP8GetBit(ref br, p[7]) == 0)
{
v = 5 + VP8GetBit(ref br, 159);
}
else
{
v = 7 + 2 * VP8GetBit(ref br, 165);
v += VP8GetBit(ref br, 145);
}
}
else
{
byte *tab;
int bit1 = VP8GetBit(ref br, p[8]);
int bit0 = VP8GetBit(ref br, p[9 + bit1]);
int cat = 2 * bit1 + bit0;
v = 0;
fixed(byte *ptab = kCat3456[cat])
{
for (tab = ptab; *tab > 0; ++tab)
{
v += v + VP8GetBit(ref br, *tab);
}
}
v += 3 + (8 << cat);
}
}
//p = prob[kBands[n]][2];
p = prob + kBands[n] * bigSlice + 2 * smallSlice;
}
j = kZigzag[n - 1];
@out[j] = (short)GetSigned(br, v);
if (n == 16 || VP8GetBit(ref br, p[0]) == 0)
{ /* EOB */
return(n);
}
}
if (n == 16)
{
return(16);
}
}
}
public static void Swap(short *p1, short *p2)
{
short f = *p1; *p1 = *p2; *p2 = f;
}
public static int vp8_decode_mb_tokens(VP8D_COMP dx, MACROBLOCKD x)
{
BOOL_DECODER bc = x.current_bc;
FRAME_CONTEXT fc = dx.common.fc;
//char* eobs = x->eobs;
sbyte[] eobs = x.eobs;
int i;
int nonzeros;
int eobtotal = 0;
//short* qcoeff_ptr;
//ProbaArray coef_probs;
//int coefIndex = entropy.COEF_BANDS * entropy.PREV_COEF_CONTEXTS * entropy.ENTROPY_NODES;
//ENTROPY_CONTEXT* a_ctx = ((ENTROPY_CONTEXT*)x->above_context);
//ENTROPY_CONTEXT* l_ctx = ((ENTROPY_CONTEXT*)x->left_context);
//ENTROPY_CONTEXT* a;
//ENTROPY_CONTEXT* l;
int blockSlice = entropy.COEF_BANDS * entropy.PREV_COEF_CONTEXTS * entropy.ENTROPY_NODES;
fixed(byte *pCoefProbs = fc.coef_probs)
{
byte *coef_probs = null;
fixed(sbyte *pAboveCtx = x.above_context.get().y1, pLeftContext = x.left_context.y1)
{
ENTROPY_CONTEXT *a_ctx = pAboveCtx;
ENTROPY_CONTEXT *l_ctx = pLeftContext;
ENTROPY_CONTEXT *a;
ENTROPY_CONTEXT *l;
int skip_dc = 0;
//qcoeff_ptr = x.qcoeff[0];
fixed(short *pQcoeff = x.qcoeff)
{
short *qcoeff_ptr = pQcoeff;
if (x.mode_info_context.get().mbmi.is_4x4 == 0)
{
a = a_ctx + 8;
l = l_ctx + 8;
//coef_probs = fc.coef_probs[1];
coef_probs = pCoefProbs + blockSlice;
nonzeros = GetCoeffs(bc, coef_probs, (*a + *l), 0, qcoeff_ptr + 24 * 16);
*a = *l = (sbyte)(nonzeros > 0 ? 1 : 0);
eobs[24] = (sbyte)nonzeros;
eobtotal += nonzeros - 16;
//coef_probs = fc.coef_probs[0];
coef_probs = pCoefProbs;
skip_dc = 1;
}
else
{
//coef_probs = fc.coef_probs[3];
coef_probs = pCoefProbs + 3 * blockSlice;
skip_dc = 0;
}
for (i = 0; i < 16; ++i)
{
a = a_ctx + (i & 3);
l = l_ctx + ((i & 0xc) >> 2);
nonzeros = GetCoeffs(bc, coef_probs, (*a + *l), skip_dc, qcoeff_ptr);
*a = *l = (sbyte)(nonzeros > 0 ? 1 : 0);
nonzeros += skip_dc;
eobs[i] = (sbyte)nonzeros;
eobtotal += nonzeros;
qcoeff_ptr += 16;
}
//coef_probs = fc.coef_probs[2];
coef_probs = pCoefProbs + 2 * blockSlice;
a_ctx += 4;
l_ctx += 4;
for (i = 16; i < 24; ++i)
{
a = a_ctx + ((i > 19 ? 1 : 0) << 1) + (i & 1);
l = l_ctx + ((i > 19 ? 1 : 0) << 1) + ((i & 3) > 1 ? 1 : 0);
nonzeros = GetCoeffs(bc, coef_probs, (*a + *l), 0, qcoeff_ptr);
*a = *l = (sbyte)(nonzeros > 0 ? 1 : 0);
eobs[i] = (sbyte)nonzeros;
eobtotal += nonzeros;
qcoeff_ptr += 16;
}
}
}
}
return(eobtotal);
}
public int get_IsHidden([NativeTypeName("VARIANT_BOOL *")] short *pVal)
{
return(((delegate * unmanaged <IFsiDirectoryItem2 *, short *, int>)(lpVtbl[15]))((IFsiDirectoryItem2 *)Unsafe.AsPointer(ref this), pVal));
}
public static void VertexAttribI4sv(uint index, short *v)
{
glVertexAttribI4sv(index, (IntPtr)v);
}
/*! FSE_readNCount():
* Read compactly saved 'normalizedCounter' from 'rBuffer'.
* @return : size read from 'rBuffer',
* or an errorCode, which can be tested using FSE_isError().
* maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
public static nuint FSE_readNCount(short *normalizedCounter, uint *maxSVPtr, uint *tableLogPtr, void *headerBuffer, nuint hbSize)
{
return(FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, 0));
}
public static readonly bool IsReady = true; // always
static Normalization ()
{
fixed (byte* tmp = propsArr) {
props = tmp;
}
fixed (int* tmp = mappedCharsArr) {
mappedChars = tmp;
}
fixed (short* tmp = charMapIndexArr) {
charMapIndex = tmp;
}
fixed (short* tmp = helperIndexArr) {
helperIndex = tmp;
}
fixed (ushort* tmp = mapIdxToCompositeArr) {
mapIdxToComposite = tmp;
}
fixed (byte* tmp = combiningClassArr) {
combiningClass = tmp;
}
}
/// <summary>
/// Creates a new CudaRegisteredHostMemory_short from an existing IntPtr. IntPtr must be page size aligned (4KBytes)!
/// </summary>
/// <param name="hostPointer">must be page size aligned (4KBytes)</param>
/// <param name="size">In elements</param>
public CudaRegisteredHostMemory_short(IntPtr hostPointer, SizeT size)
{
_intPtr = hostPointer;
_size = size;
_typeSize = (SizeT)Marshal.SizeOf(typeof(short));
_ptr = (short*)_intPtr;
}
/// <summary>
/// Generic convertor SHORT
/// </summary>
public static void ConvertorFloatToShortGeneric(IntPtr inputInterleavedBuffer, IntPtr[] asioOutputBuffers, int nbChannels, int nbSamples)
{
unsafe
{
float* inputSamples = (float*)inputInterleavedBuffer;
// Use a trick (short instead of int to avoid any convertion from 16Bit to 32Bit)
short*[] samples = new short*[nbChannels];
for (int i = 0; i < nbChannels; i++)
{
samples[i] = (short*)asioOutputBuffers[i];
}
for (int i = 0; i < nbSamples; i++)
{
for (int j = 0; j < nbChannels; j++)
{
*(samples[i]++) = clampToShort(*inputSamples++);
}
}
}
}
private static unsafe uint SearchLZFast(
MKDS_Course_Modifier.Converters.Compression.MI_Compress.LZCompressInfo *info,
byte *nextp,
uint remainSize,
ushort *offset,
uint maxLength)
{
ushort num1 = 0;
uint num2 = 2;
short *lzOffsetTable = info->LZOffsetTable;
ushort windowPos = info->windowPos;
ushort windowLen = info->windowLen;
if (remainSize < 3U)
{
return(0);
}
int index = (int)info->LZByteTable[*nextp];
while (index != -1)
{
byte *numPtr1 = index >= (int)windowPos ? nextp - (int)windowLen - (int)windowPos + index : nextp - (int)windowPos + index;
if ((int)numPtr1[1] != (int)nextp[1] || (int)numPtr1[2] != (int)nextp[2])
{
index = (int)lzOffsetTable[index];
}
else if (nextp - numPtr1 >= 2L)
{
uint num3 = 3;
byte *numPtr2 = numPtr1 + 3;
byte *numPtr3 = nextp + 3;
while ((uint)(numPtr3 - nextp) < remainSize && (int)*numPtr3 == (int)*numPtr2)
{
++numPtr3;
++numPtr2;
++num3;
if ((int)num3 == (int)maxLength)
{
break;
}
}
if (num3 > num2)
{
num2 = num3;
num1 = (ushort)(nextp - numPtr1);
if ((int)num2 == (int)maxLength || (int)num2 == (int)remainSize)
{
break;
}
}
index = (int)lzOffsetTable[index];
}
else
{
break;
}
}
if (num2 < 3U)
{
return(0);
}
*offset = num1;
return(num2);
}
public static extern void glVertex4sv(short *v);
unsafe private static extern short dpGetDriverType(short *type);
unsafe private static extern short dpGetDriverGangSupport(short *pdwDriverGangSupport);
static Normalization ()
{
IntPtr p1, p2, p3, p4, p5, p6;
lock (forLock) {
load_normalization_resource (out p1, out p2, out p3, out p4, out p5, out p6);
props = (byte*) p1;
mappedChars = (int*) p2;
charMapIndex = (short*) p3;
helperIndex = (short*) p4;
mapIdxToComposite = (ushort*) p5;
combiningClass = (byte*) p6;
}
isReady = true;
}
unsafe private static extern int dpGetNumHwDevices(short *num);
/// <summary>
/// Generic convertor for SHORT
/// </summary>
public static void ConvertorShortToIntGeneric(IntPtr inputInterleavedBuffer, IntPtr[] asioOutputBuffers, int nbChannels, int nbSamples)
{
unsafe
{
short* inputSamples = (short*)inputInterleavedBuffer;
// Use a trick (short instead of int to avoid any convertion from 16Bit to 32Bit)
short*[] samples = new short*[nbChannels];
for (int i = 0; i < nbChannels; i++)
{
samples[i] = (short*)asioOutputBuffers[i];
// Point to upper 16 bits of the 32Bits.
samples[i]++;
}
for (int i = 0; i < nbSamples; i++)
{
for (int j = 0; j < nbChannels; j++)
{
*samples[i] = *inputSamples++;
samples[i] += 2;
}
}
}
}
//--------------------------------------------------------------------
public unsafe override void Generate(RGBA_Bytes *span, int x, int y, uint len)
{
ISpanInterpolator spanInterpolator = base.interpolator();
spanInterpolator.Begin(x + base.filter_dx_dbl(), y + base.filter_dy_dbl(), len);
int *fg = stackalloc int[3];
byte *fg_ptr;
fixed(short *pWeightArray = filter().weight_array())
{
int diameter = (int)base.filter().diameter();
int filter_scale = diameter << (int)image_subpixel_scale_e.Shift;
short *weight_array = pWeightArray;
do
{
int rx;
int ry;
int rx_inv = (int)image_subpixel_scale_e.Scale;
int ry_inv = (int)image_subpixel_scale_e.Scale;
spanInterpolator.Coordinates(out x, out y);
spanInterpolator.LocalScale(out rx, out ry);
base.AdjustScale(ref rx, ref ry);
rx_inv = (int)image_subpixel_scale_e.Scale * (int)image_subpixel_scale_e.Scale / rx;
ry_inv = (int)image_subpixel_scale_e.Scale * (int)image_subpixel_scale_e.Scale / ry;
int radius_x = (diameter * rx) >> 1;
int radius_y = (diameter * ry) >> 1;
int len_x_lr =
(diameter * rx + (int)image_subpixel_scale_e.Mask) >>
(int)(int)image_subpixel_scale_e.Shift;
x += base.filter_dx_int() - radius_x;
y += base.filter_dy_int() - radius_y;
fg[0] = fg[1] = fg[2] = (int)image_filter_scale_e.Scale / 2;
int y_lr = y >> (int)(int)image_subpixel_scale_e.Shift;
int y_hr = (((int)image_subpixel_scale_e.Mask - (y & (int)image_subpixel_scale_e.Mask)) *
ry_inv) >>
(int)(int)image_subpixel_scale_e.Shift;
int total_weight = 0;
int x_lr = x >> (int)(int)image_subpixel_scale_e.Shift;
int x_hr = (((int)image_subpixel_scale_e.Mask - (x & (int)image_subpixel_scale_e.Mask)) *
rx_inv) >>
(int)(int)image_subpixel_scale_e.Shift;
int x_hr2 = x_hr;
fg_ptr = base.source().Span(x_lr, y_lr, (uint)len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
(int)image_filter_scale_e.Scale / 2) >>
downscale_shift;
fg[0] += *fg_ptr++ *weight;
fg[1] += *fg_ptr++ *weight;
fg[2] += *fg_ptr++ *weight;
total_weight += weight;
x_hr += rx_inv;
if (x_hr >= filter_scale)
{
break;
}
fg_ptr = base.source().NextX();
}
y_hr += ry_inv;
if (y_hr >= filter_scale)
{
break;
}
fg_ptr = base.source().NextY();
}
fg[0] /= total_weight;
fg[1] /= total_weight;
fg[2] /= total_weight;
if (fg[0] < 0)
{
fg[0] = 0;
}
if (fg[1] < 0)
{
fg[1] = 0;
}
if (fg[2] < 0)
{
fg[2] = 0;
}
if (fg[0] > fg[0])
{
fg[0] = fg[0];
}
if (fg[1] > fg[1])
{
fg[1] = fg[1];
}
if (fg[2] > fg[2])
{
fg[2] = fg[2];
}
span->R_Byte = (byte)fg[OrderR];
span->G_Byte = (byte)fg[OrderG];
span->B_Byte = (byte)fg[OrderB];
span->A_Byte = (byte)base_mask;
++span;
interpolator().Next();
} while(--len != 0);
}
}
