public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
RGBAPixel p = new RGBAPixel();
string s = value.ToString();
string[] arr = s.Split(delims, StringSplitOptions.RemoveEmptyEntries);
if (arr.Length == 4)
{
byte.TryParse(arr[0], out p.R);
byte.TryParse(arr[1], out p.G);
byte.TryParse(arr[2], out p.B);
byte.TryParse(arr[3], out p.A);
}
d.Color = Color.FromArgb(p.A, p.R, p.G, p.B);
if (!d.Visible && d.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
p = new RGBAPixel()
{
R = d.Color.R, G = d.Color.G, B = d.Color.B, A = d.Color.A
}
}
;
return(p);
}
}
private List <ARGBPixel> GetCopiedPixels()
{
List <ARGBPixel> pixels = new List <ARGBPixel>();
string s = Clipboard.GetText();
string[] str = s.Split('\r', '\n').Where(x => !string.IsNullOrEmpty(x)).ToArray();
for (int i = 0; i < str.Length; i++)
{
int x = 0;
s = "";
foreach (char c in str[i])
{
if (_allowed.IndexOf(c) >= 0)
{
s += c;
x++;
}
if (x >= 8)
{
break;
}
}
pixels.Add(RGBAPixel.Parse(s));
}
return(pixels);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
RGBAPixel p = new RGBAPixel();
string s = value?.ToString() ?? "";
string[] arr = s.Split(Delims, StringSplitOptions.RemoveEmptyEntries);
if (arr.Length == 4)
{
byte.TryParse(arr[0], out p.R);
byte.TryParse(arr[1], out p.G);
byte.TryParse(arr[2], out p.B);
byte.TryParse(arr[3], out p.A);
}
else if (arr.Length == 1 && byte.TryParse(arr[0], out byte px))
{
p.R = px;
p.G = px;
p.B = px;
p.A = px;
}
return(p);
}
protected void ReadColors(
uint flags,
uint bit,
ref RGBAPixel solidColor,
ref List <RGBAPixel> colors,
int frameCount,
VoidPtr address,
ref bool constant,
ref int numEntries)
{
colors = new List <RGBAPixel>();
if (constant = (flags & bit) != 0)
{
solidColor = *(RGBAPixel *)address;
numEntries = 0;
}
else
{
numEntries = frameCount + 1;
RGBAPixel *addr = (RGBAPixel *)(address + *(bint *)address);
for (int x = 0; x < numEntries; x++)
{
colors.Add(*addr++);
}
}
}
public void MakeSolid(RGBAPixel color)
{
_numEntries = 0;
_constantColor = true;
_solidColor = color;
SignalPropertyChange();
}
public void SetColor(int index, int id, ARGBPixel color)
{
if (_numEntries == 0)
{
_solidColor = (RGBAPixel)color;
}
else
{
_colors[index] = (RGBAPixel)color;
}
SignalPropertyChange();
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
_matchAddr = null;
SCN0AmbientLight *header = (SCN0AmbientLight *)address;
header->_header._length = _length = SCN0AmbientLight.Size;
if (_name != "<null>")
{
header->_fixedFlags = 128;
header->_pad1 = 0;
header->_pad2 = 0;
header->_flags = usageFlags;
if (_numEntries != 0)
{
header->_fixedFlags = 0;
_matchAddr = lightAddr;
if (_match == null)
{
*((bint *)header->_lighting.Address) = (int)lightAddr - (int)header->_lighting.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _colors.Count)
{
*lightAddr++ = (RGBAPixel)_colors[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
}
else
{
*((bint *)header->_lighting.Address) = (int)_match._matchAddr - (int)header->_lighting.Address;
}
}
else
{
header->_lighting = (RGBAPixel)_solidColor;
}
}
}
public int WriteColors(ref int flags,
int bit,
RGBAPixel solidColor,
List <RGBAPixel> colors,
bool constant,
int frameCount,
VoidPtr valueAddr,
ref VoidPtr thisMatchAddr,
VoidPtr thatMatchAddr,
RGBAPixel *dataAddr)
{
if (!constant)
{
flags &= ~bit;
thisMatchAddr = dataAddr;
if (thatMatchAddr == null)
{
VoidPtr start = dataAddr;
*((bint *)valueAddr) = (int)dataAddr - (int)valueAddr;
for (int x = 0; x <= frameCount; x++)
{
if (x < colors.Count)
{
*dataAddr++ = colors[x];
}
else
{
*dataAddr++ = new RGBAPixel();
}
}
return((int)(dataAddr - start));
}
else
{
*((bint *)valueAddr) = (int)thatMatchAddr - (int)valueAddr;
return(0);
}
}
else
{
flags |= bit;
*((RGBAPixel *)valueAddr) = solidColor;
return(0);
}
}
/*
* w("{0}float4 " + I_POSNORMALMATRIX + "[6];\n", WriteLocation(ctx));
* w("{0}float4 " + I_PROJECTION + "[4];\n", WriteLocation(ctx));
* w("{0}float4 " + I_MATERIALS + "[4];\n", WriteLocation(ctx));
* w("{0}float4 " + I_LIGHTS + "[40];\n", WriteLocation(ctx));
*
* //Tex effect matrices
* w("{0}float4 " + I_TEXMATRICES + "[24];\n", WriteLocation(ctx)); // also using tex matrices
*
* w("{0}float4 " + I_TRANSFORMMATRICES + "[64];\n", WriteLocation(ctx));
* w("{0}float4 " + I_NORMALMATRICES + "[32];\n", WriteLocation(ctx));
* w("{0}float4 " + I_POSTTRANSFORMMATRICES + "[64];\n", WriteLocation(ctx));
* w("{0}float4 " + I_DEPTHPARAMS + ";\n", WriteLocation(ctx));
*
* //24
* //16
* //16
* //160
* //96
* //256
* //128
* //256
* //4
*/
public void SetLightUniforms(int programHandle)
{
int currUniform = GL.GetUniformLocation(programHandle, I_LIGHTS);
if (currUniform > -1)
{
int frame = UsableMaterialNode.renderFrame;
List <float> values = new List <float>();
foreach (SCN0LightNode l in UsableMaterialNode._lightSet._lights)
{
//float4 col; float4 cosatt; float4 distatt; float4 pos; float4 dir;
RGBAPixel p = (RGBAPixel)l.GetColor(frame, 0);
values.Add((float)p.R * RGBAPixel.ColorFactor);
values.Add((float)p.G * RGBAPixel.ColorFactor);
values.Add((float)p.B * RGBAPixel.ColorFactor);
values.Add((float)p.A * RGBAPixel.ColorFactor);
Vector3 v = l.GetLightSpot(frame);
values.Add(v._x);
values.Add(v._y);
values.Add(v._z);
values.Add(1.0f);
v = l.GetLightDistAttn(frame);
values.Add(v._x);
values.Add(v._y);
values.Add(v._z);
values.Add(1.0f);
v = l.GetStart(frame);
values.Add(v._x);
values.Add(v._y);
values.Add(v._z);
values.Add(1.0f);
Vector3 v2 = l.GetEnd(frame);
Vector3 dir = Matrix.AxisAngleMatrix(v, v2).GetAngles();
values.Add(dir._x);
values.Add(dir._y);
values.Add(dir._z);
values.Add(1.0f);
}
GL.Uniform4(currUniform, 40, values.ToArray());
}
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
SCN0AmbientLight *header = (SCN0AmbientLight *)address;
if (_name != "<null>")
{
header->_fixedFlags = fixedFlags;
header->_unk2 = 0;
header->_unk3 = 0;
header->_unk4 = unk4;
if (_lighting.Count > 1)
{
*((bint *)header->_lighting.Address) = (int)lightAddr - (int)header->_lighting.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _lighting.Count)
{
*lightAddr++ = _lighting[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
}
else if (_lighting.Count == 1)
{
header->_lighting = _lighting[0];
}
else
{
header->_lighting = new RGBAPixel();
}
}
}
protected void ReadPixelData(BinaryReader reader, Frame frame)
{
int size = Width * Height;
RawPixelData = new Pixel[size];
switch (frame.File.Header.ColorDepth)
{
case ColorDepth.RGBA:
for (int i = 0; i < size; i++)
{
byte[] color = reader.ReadBytes(4);
RawPixelData[i] = new RGBAPixel(frame, color);
}
break;
case ColorDepth.Grayscale:
for (int i = 0; i < size; i++)
{
byte[] color = reader.ReadBytes(2);
RawPixelData[i] = new GrayscalePixel(frame, color);
}
break;
case ColorDepth.Indexed:
for (int i = 0; i < size; i++)
{
byte color = reader.ReadByte();
RawPixelData[i] = new IndexedPixel(frame, color);
}
break;
}
}
public CLR0MaterialEntry(RGBAPixel mask, RGBAPixel color)
{
_colorMask = mask;
_data._data = *(int *)&color;
}
protected internal override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
SCN0Fog *header = (SCN0Fog *)address;
if (colors.Count > 1)
{
*((bint *)header->_color.Address) = (int)lightAddr - (int)header->_color.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < colors.Count)
{
*lightAddr++ = colors[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
flags &= ~SCN0FogFlags.FixedColor;
}
else
{
flags |= SCN0FogFlags.FixedColor;
if (colors.Count == 1)
{
header->_color = colors[0];
}
else
{
header->_color = new RGBAPixel();
}
}
if (starts.Count > 1)
{
*((bint *)header->_start.Address) = (int)keyframeAddr - (int)header->_start.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)starts.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < starts.Count; i++)
{
*addr++ = starts[i];
}
keyframeAddr += 4 + starts.Count * 12;
flags &= ~SCN0FogFlags.FixedStart;
}
else
{
flags |= SCN0FogFlags.FixedStart;
if (starts.Count == 1)
{
header->_start = starts[0]._value;
}
else
{
header->_start = 0;
}
}
if (ends.Count > 1)
{
*((bint *)header->_end.Address) = (int)keyframeAddr - (int)header->_end.Address;
((SCN0KeyframesHeader *)keyframeAddr)->_numFrames = (ushort)ends.Count;
SCN0KeyframeStruct *addr = ((SCN0KeyframesHeader *)keyframeAddr)->Data;
for (int i = 0; i < ends.Count; i++)
{
*addr++ = ends[i];
}
keyframeAddr += 4 + ends.Count * 12;
flags &= ~SCN0FogFlags.FixedEnd;
}
else
{
flags |= SCN0FogFlags.FixedEnd;
if (ends.Count == 1)
{
header->_end = ends[0]._value;
}
else
{
header->_end = 0;
}
}
header->_flags = (byte)flags;
header->_density = density;
}
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;
}
}
public void SetRGBA(int index, RGBAPixel value)
{
((RGBAPixel *)_values.Address)[index] = value;
}
internal unsafe void Precalc(MDL0PolygonNode parent, IMatrixNode[] nodes)
{
//If already calculated, and no weights, skip?
bool hasNodes = parent.Model._linker.NodeCache.Length > 0;
if ((_precVertices != null) && hasNodes)
{
return;
}
Vector3[] verts, norms = null;
Vector3 * vPtr = null, nPtr = null;
RGBAPixel[][] colors = new RGBAPixel[2][];
Vector2[][] uvs = new Vector2[8][];
uint * ptrCache = stackalloc uint[10];
//Points
verts = parent._vertexNode.Vertices;
if (_precVertices == null)
{
_precVertices = new UnsafeBuffer(_elementCount * 12);
}
vPtr = (Vector3 *)_precVertices.Address;
//Normals
if (parent._normalNode != null)
{
norms = parent._normalNode.Normals;
if (_precNormals == null)
{
_precNormals = new UnsafeBuffer(_elementCount * 12);
}
nPtr = (Vector3 *)_precNormals.Address;
}
else if (_precNormals != null)
{
_precNormals.Dispose();
_precNormals = null;
}
////Colors
//for (int i = 0; i < 1; i++)
//{
// if (parent._colorSet[i] != null)
// {
// colors[i] = parent._colorSet[i].Colors;
// if (_precColors == null)
// _precColors = new UnsafeBuffer(_elementCount * 4);
// ptrCache[i] = (uint)_precColors.Address;
// }
// else if (_precColors != null)
// {
// _precColors.Dispose();
// _precColors = null;
// }
//}
//UVs
for (int i = 0; i < 8; i++)
{
if (parent._uvSet[i] != null)
{
uvs[i] = parent._uvSet[i].Points;
if (_precUVs[i] == null)
{
_precUVs[i] = new UnsafeBuffer(_elementCount * 8);
}
ptrCache[i + 2] = (uint)_precUVs[i].Address;
}
else if (_precUVs[i] != null)
{
_precUVs[i].Dispose();
_precUVs[i] = null;
}
}
int count = _vertices.Count;
for (int x = 0; x < count; x++)
{
Vertex3 vert = _vertices[x];
////Vertices
//if (hasNodes)
// *vPtr++ = nodes[vert.Influence.NodeIndex].Matrix.Multiply(verts[vert.Position]);
//else
// *vPtr++ = verts[vert.Position];
////Normals
//if (nPtr != null)
//{
// if (hasNodes)
// *nPtr++ = nodes[vert.Influence.NodeIndex].Matrix.Multiply(norms[vert.Normal]);
// else
// *nPtr++ = norms[vert.Normal.Length];
//}
////Colors
//for (int i = 0; i < 1; i++)
//{
// RGBAPixel* cPtr = (RGBAPixel*)ptrCache[i];
// if (cPtr != null)
// cPtr[x] = colors[i][vert.Color[i]];
//}
////UVs
//for (int i = 0; i < 8; i++)
//{
// Vector2* uPtr = (Vector2*)ptrCache[i + 2];
// if (uPtr != null)
// uPtr[x] = uvs[i][vert.UV[i]];
//}
}
}
public CLR0Material(CLR0EntryFlags flags, RGBAPixel mask, RGBAPixel color)
{
_stringOffset = 0;
_flags = (uint)flags;
}
private void FinishMDL0(MDL0Node model)
{
Error = "There was a problem creating a default material and shader.";
if (model._matList.Count == 0 && model._objList.Count != 0)
{
MDL0MaterialNode mat = new MDL0MaterialNode()
{
_name = "Default",
};
(mat.ShaderNode = new MDL0ShaderNode()).AddChild(new MDL0TEVStageNode()
{
RasterColor = ColorSelChan.LightChannel0,
AlphaSelectionD = AlphaArg.RasterAlpha,
ColorSelectionD = ColorArg.RasterColor,
});
model._shadGroup.AddChild(mat.ShaderNode);
model._matGroup.AddChild(mat);
foreach (MDL0ObjectNode obj in model._objList)
{
if (obj._drawCalls.Count == 0)
{
obj._drawCalls.Add(new DrawCall(obj));
}
obj._drawCalls[0].MaterialNode = mat;
}
}
Error = "There was a problem removing original color buffers.";
//Remove original color buffers if option set
if (_importOptions._ignoreColors)
{
if (model._objList != null && model._objList.Count != 0)
{
foreach (MDL0ObjectNode p in model._objList)
{
for (int x = 2; x < 4; x++)
{
if (p._manager._faceData[x] != null)
{
p._manager._faceData[x].Dispose();
p._manager._faceData[x] = null;
}
}
}
}
}
Error = "There was a problem adding default color values.";
//Add color buffers if option set
if (_importOptions._addClrs)
{
RGBAPixel pixel = _importOptions._dfltClr;
//Add a color buffer to objects that don't have one
if (model._objList != null && model._objList.Count != 0)
{
foreach (MDL0ObjectNode p in model._objList)
{
if (p._manager._faceData[2] == null)
{
RGBAPixel *pIn = (RGBAPixel *)(p._manager._faceData[2] = new UnsafeBuffer(4 * p._manager._pointCount)).Address;
for (int i = 0; i < p._manager._pointCount; i++)
{
*pIn++ = pixel;
}
}
}
}
}
Error = "There was a problem initializing materials.";
//Apply defaults to materials
if (model._matList != null)
{
foreach (MDL0MaterialNode mat in model._matList)
{
mat._activeStages = mat.ShaderNode.Stages;
if (_importOptions._mdlType == ImportOptions.MDLType.Stage)
{
mat._lightSetIndex = 0;
mat._fogIndex = 0;
}
}
}
Error = "There was a problem remapping materials.";
//Remap materials if option set
if (_importOptions._rmpMats && model._matList != null && model._objList != null)
{
foreach (MDL0ObjectNode obj3 in model._objList)
{
MDL0MaterialNode mat = obj3._drawCalls[0].MaterialNode;
foreach (MDL0MaterialNode m in model._matList)
{
if (m.Children.Count > 0 &&
m.Children[0] != null &&
mat != null &&
mat.Children.Count > 0 &&
mat.Children[0] != null &&
m.Children[0].Name == mat.Children[0].Name &&
m.C1ColorMaterialSource == mat.C1ColorMaterialSource)
{
obj3._drawCalls[0].MaterialNode = m;
break;
}
}
}
//Remove unused materials
for (int i = 0; i < model._matList.Count; i++)
{
if (((MDL0MaterialNode)model._matList[i])._objects.Count == 0)
{
model._matList.RemoveAt(i--);
}
}
}
Error = "There was a problem writing the model.";
//Clean the model and then build it!
if (model != null)
{
model.FinishImport();
}
}
public CLR0MaterialEntry(RGBAPixel mask, int offset)
{
_colorMask = mask;
_data = offset;
}
public override void OnRebuild(VoidPtr address, int length, bool force)
{
base.OnRebuild(address, length, force);
_matchAddr = null;
SCN0Fog *header = (SCN0Fog *)address;
flags = SCN0FogFlags.None;
if (_colors.Count > 1)
{
_matchAddr = lightAddr;
if (_match == null)
{
*((bint *)header->_color.Address) = (int)lightAddr - (int)header->_color.Address;
for (int i = 0; i <= ((SCN0Node)Parent.Parent).FrameCount; i++)
{
if (i < _colors.Count)
{
*lightAddr++ = (RGBAPixel)_colors[i];
}
else
{
*lightAddr++ = new RGBAPixel();
}
}
}
else
{
*((bint *)header->_color.Address) = (int)_match._matchAddr - (int)header->_color.Address;
}
}
else
{
flags |= SCN0FogFlags.FixedColor;
header->_color = (RGBAPixel)_solidColor;
}
if (_startKeys._keyCount > 1)
{
*((bint *)header->_start.Address) = (int)keyframeAddr - (int)header->_start.Address;
EncodeFrames(_startKeys, ref keyframeAddr);
}
else
{
flags |= SCN0FogFlags.FixedStart;
if (_startKeys._keyCount == 1)
{
header->_start = _startKeys._keyRoot._next._value;
}
else
{
header->_start = 0;
}
}
if (_endKeys._keyCount > 1)
{
*((bint *)header->_end.Address) = (int)keyframeAddr - (int)header->_end.Address;
EncodeFrames(_endKeys, ref keyframeAddr);
}
else
{
flags |= SCN0FogFlags.FixedEnd;
if (_endKeys._keyCount == 1)
{
header->_end = _endKeys._keyRoot._next._value;
}
else
{
header->_end = 0;
}
}
header->_flags = (byte)flags;
header->_type = type;
}
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;
}
}
