public void Read(out Support.BitSet data)
{
System.Diagnostics.Debug.Assert(Reading);
data = null;
if (CoreObject.Pointer == IntPtr.Zero)
{
return;
}
unsafe
{
int bitCount = 0;
XndSDK.XNDAttrib_Read(CoreObject, (IntPtr)(&bitCount), sizeof(int));
data = new Support.BitSet();
int byteCount = 0;
XndSDK.XNDAttrib_Read(CoreObject, (IntPtr)(&byteCount), sizeof(int));
byte[] bitData = new byte[byteCount];
fixed(byte *p = &bitData[0])
{
XndSDK.XNDAttrib_Read(CoreObject, (IntPtr)(p), sizeof(System.Byte) * byteCount);
}
data.Init((UInt32)bitCount, bitData);
}
}
protected static Support.BitSet ReadSaveFields(TypeDescGenerator.TypeDesc tDesc, IReader pkg)
{
var bitSet = new Support.BitSet();
var byteArray = TypeDescGenerator.Instance.GetSerializer(typeof(byte[]));
byte[] bits = byteArray.ReadValue(pkg) as byte[];
bitSet.Init((UInt32)tDesc.Members.Count, bits);
return(bitSet);
}
private int FindBitSetIndex(Support.BitSet bs)
{
for (int i = 0; i < mBitSets.Count; i++)
{
if (mBitSets[i] == bs)
{
return(i);
}
}
return(-1);
}
public bool TryCombine(PVSVoxel vx, int tolerance)
{
int flagNumber = 0;
var combine = Support.BitSet.BitOr(CombineBits, vx.Bits, ref flagNumber);
if (flagNumber - OriFlagNumber < tolerance)
{
CombineBits = combine;
return(true);
}
return(false);
}
public void Write(Support.BitSet v)
{
unsafe
{
var bitCount = v.BitCount;
WritePtr(&bitCount, sizeof(int));
byte[] bitData = v.Data;
int byteCount = bitData.Length;
WritePtr(&byteCount, sizeof(int));
fixed(byte *p = &bitData[0])
{
WritePtr(p, sizeof(System.Byte) * byteCount);
}
}
}
public GActorBits()
{
BitSet = new Support.BitSet((UInt32)EBitDefine.Count);
SetBit(EBitDefine.Visible, true);
SetBit(EBitDefine.CastShadow, true);
SetBit(EBitDefine.Navgation, false);
SetBit(EBitDefine.NeedRefreshNavgation, true);
SetBit(EBitDefine.NeedTick, true);
SetBit(EBitDefine.Selected, false);
SetBit(EBitDefine.InPVS, true);
SetBit(EBitDefine.BoundVolume, true);
SetBit(EBitDefine.HideInGame, false);
SetBit(EBitDefine.OnlyForGame, false);
SetBit(EBitDefine.AcceptLights, true);
SetBit(EBitDefine.StaticObject, true);
}
public void Read(out Support.BitSet v)
{
unsafe
{
int bitCount = 0;
ReadPtr(&bitCount, sizeof(int));
v = new Support.BitSet();
int byteCount = 0;
ReadPtr(&byteCount, sizeof(int));
byte[] bitData = new byte[byteCount];
fixed(byte *p = &bitData[0])
{
ReadPtr(p, sizeof(System.Byte) * byteCount);
}
v.Init((UInt32)bitCount, bitData);
}
}
protected static Support.BitSet WriteSaveFields(ISerializer obj, TypeDescGenerator.TypeDesc tDesc, IWriter pkg)
{
var bitSet = new Support.BitSet();
bitSet.Init((UInt16)tDesc.Members.Count);
for (int i = 0; i < tDesc.Members.Count; i++)
{
bool cmp = tDesc.IsDefaultValue(obj, tDesc.Members[i].PropInfo);
if (cmp == false)
{
bitSet.SetBit((UInt32)i, true);
}
}
var byteArray = TypeDescGenerator.Instance.GetSerializer(typeof(byte[]));
byteArray.WriteValue(bitSet.Data, pkg);
return(bitSet);
}
public void Write(Support.BitSet data)
{
System.Diagnostics.Debug.Assert(Writing);
if (CoreObject.Pointer == IntPtr.Zero)
{
return;
}
unsafe
{
var bitCount = data.BitCount;
XndSDK.XNDAttrib_Write(CoreObject, (IntPtr)(&bitCount), sizeof(int));
byte[] bitData = data.Data;
int byteCount = bitData.Length;
XndSDK.XNDAttrib_Write(CoreObject, (IntPtr)(&byteCount), sizeof(int));
fixed(byte *p = &bitData[0])
{
XndSDK.XNDAttrib_Write(CoreObject, (IntPtr)(p), sizeof(System.Byte) * byteCount);
}
}
}
private int FindBitSet(Support.BitSet bs, UInt32 hash)
{
for (int i = 0; i < mBitSets.Count; i++)
{
if (hash != mBitSetExts[i].Hash)
{
continue;
}
if (mBitSets[i].IsSame(bs))
{
return(i);
}
//if (TryMerge(i, bs))
// return i;
}
mBitSets.Add(bs);
var ext = new BitExtData();
ext.Hash = hash;
mBitSetExts.Add(ext);
return(mBitSets.Count - 1);
}
private bool TryMerge(Support.BitSet bs1, Support.BitSet bs2)
{
if (bs1.BitCount != bs2.BitCount)
{
return(false);
}
UInt32 actorNum = bs1.BitCount / 2;
for (UInt32 i = 0; i < actorNum; i++)
{
int b1 = bs1.IsBit(i * 2) ? 1 : 0;
int b2 = bs1.IsBit(i * 2 + 1) ? 1 : 0;
int v1 = b1 | (b2 << 1);
b1 = bs2.IsBit(i * 2) ? 1 : 0;
b2 = bs2.IsBit(i * 2 + 1) ? 1 : 0;
int v2 = b1 | (b2 << 1);
if (v1 == 0 && v2 != 0)
{
return(false);
}
if (v2 == 0 && v1 != 0)
{
return(false);
}
if (v1 < v2)
{
bs1.SetBit(i * 2, b1 == 0 ? false : true);
bs1.SetBit(i * 2 + 1, b2 == 0 ? false : true);
}
}
return(true);
}
public CombineVoxel(PVSVoxel vx)
{
OriFlagNumber = vx.Bits.FlagNumber;
CombineBits = new Support.BitSet();
CombineBits.Init(vx.Bits.BitCount, vx.Bits.Data);
}
