public override void OnRebuild(VoidPtr address, int length, bool force)
{
//Build common header
base.OnRebuild(address, length, force);
//Reset addresses
_lightAddress = null;
_specularAddress = null;
//Don't write anything if this node is null
if (_name == "<null>")
{
return;
}
//Write header information
SCN0Light *header = (SCN0Light *)address;
header->_nonSpecLightId = NonSpecularLightID;
header->_userDataOffset = 0;
header->_distFunc = _distFunc;
header->_spotFunc = _spotFunc;
int newFlags = 0;
//Encode keyframe data
for (int i = 0, index = 0; i < 14; i++)
{
if (!(i == 3 || i == 7 || i == 10 || i == 12))
{
_dataAddrs[0] += EncodeKeyframes(
Keyframes[index],
_dataAddrs[0],
header->_startPoint._x.Address + i * 4,
ref newFlags,
(int)_ordered[index++]);
}
}
_dataAddrs[1] += WriteColors(
ref newFlags,
(int)FixedFlags.ColorConstant,
_solidColors[0],
_lightColor,
_constants[0],
FrameCount,
header->_lightColor.Address,
ref _lightAddress,
_matches[0] == null ? null : _matches[0]._lightAddress,
(RGBAPixel *)_dataAddrs[1]);
//Only bother writing if specular is enabled
if (SpecularEnabled)
{
_dataAddrs[1] += WriteColors(
ref newFlags,
(int)FixedFlags.SpecColorConstant,
_solidColors[1],
_specColor,
_constants[1],
FrameCount,
header->_specularColor.Address,
ref _specularAddress,
_matches[1] == null ? null : _matches[1]._specularAddress,
(RGBAPixel *)_dataAddrs[1]);
}
else
{
//The value is set to 0
header->_specularColor = new RGBAPixel();
//The flag, while unused, seems to be set to the same state as the color constant flag
if (_constants[0])
{
newFlags |= (int)FixedFlags.SpecColorConstant;
}
else
{
newFlags &= (int)~FixedFlags.SpecColorConstant;
}
}
if (!ConstantVisibility && _entryCount != 0)
{
header->_visOffset = (int)_dataAddrs[2] - (int)header->_visOffset.Address;
Marshal.Copy(_data, 0, (IntPtr)_dataAddrs[2], _data.Length);
_dataAddrs[2] = ((VoidPtr)_dataAddrs[2] + EntryCount.Align(32) / 8);
}
else
{
newFlags |= (int)FixedFlags.EnabledConstant;
}
//Set newly calculated flags
header->_fixedFlags = (ushort)(_fixedFlags = (FixedFlags)newFlags);
header->_usageFlags = _typeUsageFlags._data;
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
lightAddress = null;
specularAddress = null;
SCN0Light *header = (SCN0Light *)address;
if (_name != "<null>")
{
header->_nonSpecLightId = NonSpecularLightID;
header->_part2Offset = _part2Offset;
header->_visOffset = _enableOffset;
header->_distFunc = _distFunc;
header->_spotFunc = _spotFunc;
int newFlags = 0;
if (_lightColor.Count > 1)
{
lightAddress = lightAddr;
if (match2 == null)
{
*((bint *)header->_lightColor.Address) = (int)lightAddr - (int)header->_lightColor.Address;
for (int x = 0; x <= FrameCount; x++)
{
if (x < _lightColor.Count)
{
*lightAddr++ = _lightColor[x];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
}
else
{
*((bint *)header->_lightColor.Address) = (int)match1.lightAddress - (int)header->_lightColor.Address;
}
}
else
{
newFlags |= (int)FixedFlags.ColorConstant;
header->_lightColor = _solidColors[0];
}
if (_specColor.Count > 1)
{
specularAddress = lightAddr;
if (match2 == null)
{
*((bint *)header->_specularColor.Address) = (int)lightAddr - (int)header->_specularColor.Address;
for (int x = 0; x <= FrameCount; x++)
{
if (x < _specColor.Count)
{
*lightAddr++ = _specColor[x];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
}
else
{
*((bint *)header->_specularColor.Address) = (int)match2.specularAddress - (int)header->_specularColor.Address;
}
}
else
{
newFlags |= (int)FixedFlags.SpecColorConstant;
header->_specularColor = _solidColors[1];
}
if (!SetConstant && _entryCount != 0)
{
header->_visOffset = (int)visAddr - (int)header->_visOffset.Address;
Marshal.Copy(_data, 0, (IntPtr)visAddr, _data.Length);
visAddr = ((VoidPtr)visAddr + EntryCount.Align(32) / 8);
}
else
{
newFlags |= (int)FixedFlags.EnabledConstant;
}
bint *values = (bint *)&header->_startPoint;
int index = 0;
for (int i = 0; i < 14; i++)
{
if (!(i == 3 || i == 7 || i == 10 || i == 12))
{
EncodeFrames(GetKeys(index), ref keyframeAddr, &values[i], ref newFlags, (int)_ordered[index++]);
}
}
header->_fixedFlags = _flags1 = (ushort)newFlags;
header->_usageFlags = _flags2;
}
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
SCN0Light *header = (SCN0Light *)address;
base.OnRebuild(address, length, force);
if (_name != "<null>")
{
header->_unk1 = _unk1;
header->_unk2 = _unk2;
header->_unk5 = _unk5;
header->_unk6 = _unk6;
header->_unk7 = _unk7;
header->_unk8 = _unk8;
header->_unk9 = _unk9;
header->_unk10 = _unk10;
header->_unk12 = _unk12;
if (_lighting1.Count > 1)
{
*((bint *)header->_lighting1.Address) = (int)lightAddr - (int)header->_lighting1.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _lighting1.Count)
{
*lightAddr++ = _lighting1[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
_flags1[6] = false;
}
else
{
_flags1[6] = true;
if (_lighting1.Count == 1)
{
header->_lighting1 = _lighting1[0];
}
else
{
header->_lighting1 = new RGBAPixel();
}
}
if (_lighting2.Count > 1)
{
*((bint *)header->_lighting2.Address) = (int)lightAddr - (int)header->_lighting2.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _lighting2.Count)
{
*lightAddr++ = _lighting2[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
_flags1[14] = false;
}
else
{
_flags1[14] = true;
if (_lighting2.Count == 1)
{
header->_lighting2 = _lighting2[0];
}
else
{
header->_lighting2 = new RGBAPixel();
}
}
if (xEnds.Count > 1)
{
*((bint *)header->_vec1._x.Address) = (int)keyframeAddr - (int)header->_vec1._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)xEnds.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < xEnds.Count; i++)
{
*addr++ = xEnds[i];
}
keyframeAddr += 4 + xEnds.Count * 12;
_flags1[3] = false;
}
else
{
_flags1[3] = true;
if (xEnds.Count == 1)
{
header->_vec1._x = xEnds[0]._value;
}
else
{
header->_vec1._x = 0;
}
}
if (yEnds.Count > 1)
{
*((bint *)header->_vec1._y.Address) = (int)keyframeAddr - (int)header->_vec1._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)yEnds.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < yEnds.Count; i++)
{
*addr++ = yEnds[i];
}
keyframeAddr += 4 + yEnds.Count * 12;
_flags1[4] = false;
}
else
{
_flags1[4] = true;
if (yEnds.Count == 1)
{
header->_vec1._y = yEnds[0]._value;
}
else
{
header->_vec1._y = 0;
}
}
if (zEnds.Count > 1)
{
*((bint *)header->_vec1._z.Address) = (int)keyframeAddr - (int)header->_vec1._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)zEnds.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < zEnds.Count; i++)
{
*addr++ = zEnds[i];
}
keyframeAddr += 4 + zEnds.Count * 12;
_flags1[5] = false;
}
else
{
_flags1[5] = true;
if (zEnds.Count == 1)
{
header->_vec1._z = zEnds[0]._value;
}
else
{
header->_vec1._z = 0;
}
}
if (xStarts.Count > 1)
{
*((bint *)header->_vec2._x.Address) = (int)keyframeAddr - (int)header->_vec2._x.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)xStarts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < xStarts.Count; i++)
{
*addr++ = xStarts[i];
}
keyframeAddr += 4 + xStarts.Count * 12;
_flags1[7] = false;
}
else
{
_flags1[7] = true;
if (xStarts.Count == 1)
{
header->_vec2._x = xStarts[0]._value;
}
else
{
header->_vec2._x = 0;
}
}
if (yStarts.Count > 1)
{
*((bint *)header->_vec2._y.Address) = (int)keyframeAddr - (int)header->_vec2._y.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)yStarts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < yStarts.Count; i++)
{
*addr++ = yStarts[i];
}
keyframeAddr += 4 + yStarts.Count * 12;
_flags1[8] = false;
}
else
{
_flags1[8] = true;
if (yStarts.Count == 1)
{
header->_vec2._y = yStarts[0]._value;
}
else
{
header->_vec2._y = 0;
}
}
if (zStarts.Count > 1)
{
*((bint *)header->_vec2._z.Address) = (int)keyframeAddr - (int)header->_vec2._z.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)zStarts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < zStarts.Count; i++)
{
*addr++ = zStarts[i];
}
keyframeAddr += 4 + zStarts.Count * 12;
_flags1[9] = false;
}
else
{
_flags1[9] = true;
if (zStarts.Count == 1)
{
header->_vec2._z = zStarts[0]._value;
}
else
{
header->_vec2._z = 0;
}
}
header->_flags1 = _flags1.data;
header->_flags2 = _flags2.data;
}
}
