public override void Read(BinaryReader file, uint size)
{
CVariable parsedvar = null;
var varsize = file.ReadUInt32();
var buffer = file.ReadBytes((int)varsize - 4);
using (var ms = new MemoryStream(buffer))
using (var br = new BinaryReader(ms))
{
var typeId = br.ReadUInt16();
var nameId = br.ReadUInt16();
if (nameId == 0)
{
return;
}
var typename = cr2w.names[typeId].Str;
var varname = cr2w.names[nameId].Str;
parsedvar = CR2WTypeManager.Get().GetByName(typename, varname, cr2w);
parsedvar.Read(br, size);
parsedvar.nameId = nameId;
parsedvar.typeId = typeId;
}
variable = parsedvar;
}
public CVariable ReadVariable(BinaryReader file)
{
var nameId = file.ReadUInt16();
if (nameId == 0)
{
return(null);
}
var typepos = file.BaseStream.Position;
var typeId = file.ReadUInt16();
var size = file.ReadUInt32() - 4;
var typename = strings[typeId].str;
var varname = strings[nameId].str;
var parsedvar = CR2WTypeManager.Get().GetByName(typename, varname, this);
parsedvar.Read(file, size);
parsedvar.nameId = nameId;
parsedvar.typeId = typeId;
return(parsedvar);
}
public static void SetFromDictionary(this IEditableVariable cvar, Dictionary <string, object> dictionary)
{
if (cvar is IREDVariant var)
{
var type = dictionary["Type"] as string;
var name = "Variant";
if (dictionary.ContainsKey("Name"))
{
name = dictionary["Name"] as string;
}
var jvalue = dictionary["Variant"];
var variant = CR2WTypeManager.Create(type, name, cvar.Cr2wFile as IRed4EngineFile, cvar as CVariable);
variant.IsSerialized = true;
variant.SetFromJObject(jvalue);
var.SetVariant(variant);
return;
}
foreach (var(propertyName, value) in dictionary)
{
var redProperty = GetRedProperty(cvar, propertyName);
if (redProperty == null)
{
throw new InvalidParsingException("not a CVariable");
}
redProperty.SetFromJObject(value);
}
}
private void addVariableToolStripMenuItem_Click(object sender, EventArgs e)
{
var node = (VariableListNode)treeView.SelectedObject;
if (node?.Variable == null || !node.Variable.CanAddVariable(null))
{
return;
}
CVariable newvar = null;
if (node.Variable is CArray)
{
var nodearray = (CArray)node.Variable;
newvar = CR2WTypeManager.Get().GetByName(nodearray.elementtype, "", Chunk.cr2w, false);
if (newvar == null)
{
return;
}
}
else
{
var frm = new frmAddVariable();
if (frm.ShowDialog() != DialogResult.OK)
{
return;
}
newvar = CR2WTypeManager.Get().GetByName(frm.VariableType, frm.VariableName, Chunk.cr2w, false);
if (newvar == null)
{
return;
}
newvar.Name = frm.VariableName;
newvar.Type = frm.VariableType;
}
if (newvar is CHandle)
{
var result = MessageBox.Show("Add as chunk handle? (Yes for chunk handle, No for normal handle)",
"Adding handle.", MessageBoxButtons.YesNoCancel);
if (result == DialogResult.Cancel)
{
return;
}
((CHandle)newvar).ChunkHandle = result == DialogResult.Yes;
}
node.Variable.AddVariable(newvar);
var subnode = AddListViewItems(newvar, node);
node.Children.Add(subnode);
treeView.RefreshObject(node);
treeView.RefreshObject(subnode);
}
public CVariable CreateVariable(string type, string varname = "")
{
var var = CR2WTypeManager.Get().GetByName(type, varname, this, false);
var.Type = type;
var.Name = varname;
return(var);
}
public void CreateDefaultData()
{
data = CR2WTypeManager.Get().GetByName(Type, "", cr2w, false);
if (data == null)
{
// default chunks to vector type
data = new CVector(cr2w);
}
data.Name = Name;
}
public frmAddVariable()
{
InitializeComponent();
var mng = CR2WTypeManager.Get();
var types = mng.AvailableTypes;
types.Sort();
txType.Items.AddRange(types.ToArray());
}
public AddChunkDialogView()
{
InitializeComponent();
var mng = CR2WTypeManager.Get();
var types = mng.AvailableTypes;
types.Sort();
comboBoxEditType.Properties.Items.AddRange(types.ToArray());
}
public static void SetFromDictionary(this IEditableVariable cvar, Dictionary <string, object> dictionary)
{
if (cvar is IREDVariant var)
{
var type = dictionary["Type"] as string;
var name = "Variant";
if (dictionary.ContainsKey("Name"))
{
name = dictionary["Name"] as string;
}
var jvalue = dictionary["Variant"];
var variant = CR2WTypeManager.Create(type, name, cvar.Cr2wFile as IRed4EngineFile, cvar as CVariable);
variant.IsSerialized = true;
variant.SetFromJObject(jvalue);
var.SetVariant(variant);
return;
}
if (cvar is ICurveDataAccessor curve)
{
var interpolation = dictionary["InterpolationType"];
var interpolationByte = int.Parse(interpolation.ToString());
curve.SetInterpolationType((EInterpolationType)interpolationByte);
var link = dictionary["LinkType"];
var linkByte = int.Parse(link.ToString());
curve.SetLinkType((ESegmentsLinkType)linkByte);
curve.SetFromJObject(dictionary["Elements"]);
return;
}
foreach (var(propertyName, value) in dictionary)
{
var redProperty = GetRedProperty(cvar, propertyName);
if (redProperty == null)
{
throw new InvalidParsingException("not a CVariable");
}
redProperty.SetFromJObject(value);
}
}
public CVariable ReadVariable(BinaryReader file)
{
var num1 = file.ReadUInt16();
if (num1 == (ushort)0)
{
return((CVariable)null);
}
var position = file.BaseStream.Position;
var num2 = file.ReadUInt16();
var size = file.ReadUInt32() - 4U;
var byName = CR2WTypeManager.Get().GetByName(strings[num2].str, strings[num1].str, this, true);
byName.Read(file, size);
byName.nameId = num1;
byName.typeId = num2;
return(byName);
}
public CVariable ReadVariable(BinaryReader file)
{
// Read Name
var nameId = file.ReadUInt16();
if (nameId == 0)
{
return(null);
}
var varname = names[nameId].Str;
// Read Type
var typeId = file.ReadUInt16();
var typename = names[typeId].Str;
// Read Size
var sizepos = file.BaseStream.Position;
var size = file.ReadUInt32();
// Read Value
var parsedvar = CR2WTypeManager.Get().GetByName(typename, varname, this);
parsedvar.Read(file, size - 4);
var afterVarPos = file.BaseStream.Position;
var bytesleft = size - (afterVarPos - sizepos);
if (bytesleft > 0)
{
var unreadBytes = file.ReadBytes((int)bytesleft);
//Debugger.Break();
}
else if (bytesleft < 0)
{
throw new InvalidParsingException("Parsing Variable read too far.");
}
parsedvar.nameId = nameId;
parsedvar.typeId = typeId;
return(parsedvar);
}
public frmAddChunk(List <string> list = null)
{
InitializeComponent();
if (list != null)
{
var types = list;
types.Sort();
txType.Items.AddRange(types.ToArray());
}
else
{
var mng = CR2WTypeManager.Get();
var types = mng.AvailableTypes;
types.Sort();
txType.Items.AddRange(types.ToArray());
}
}
private void treeView_CellEditStarting(object sender, CellEditEventArgs e)
{
if (!(e.RowObject is IEditableVariable editableVariable))
{
return;
}
switch (e.Column.AspectName)
{
//var variable = (e.RowObject as VariableListNode).Variable;
case "REDValue":
{
// if variant is null, ask the user to create a new wrapped cvar
if (editableVariable is IVariantAccessor ivariant && ivariant.Variant == null)
{
var availableTypes = CR2WManager.GetAvailableTypes(nameof(IReferencable)).Select(_ => _.Name);
var variantType = new Utility.ProductionWindowFactory().ShowAddChunkFormModal(availableTypes);
var variant = CR2WTypeManager.Create(variantType, "Variant", editableVariable.cr2w,
(CVariable)editableVariable);
variant.IsSerialized = true;
ivariant.Variant = variant;
editableVariable.IsSerialized = true;
}
e.Control = EditorHandler.GetEditor(editableVariable);
if (e.Control != null)
{
e.Control.Location = new Point(e.CellBounds.Location.X, e.CellBounds.Location.Y - 1);
e.Control.Width = e.CellBounds.Width;
// update references for pointer type variables
if (editableVariable is IChunkPtrAccessor iptr && e.Control is ComboBox editor)
{
editor.SelectedIndexChanged += delegate(object o, EventArgs _e)
{
var ptrcomboitem = (PtrComboItem)((ComboBox)o).SelectedItem;
if (ptrcomboitem != null)
{
if (ptrcomboitem.Text == $"<Add new chunk ...>")
{
// raise event
viewModel.AddNewChunkFor(iptr);
// select item
editor.UpdateComboBoxWith(iptr);
}
else
{
iptr.Reference = ptrcomboitem.Value;
}
}
};
}
if (e.Control is ByteArrayEditor byteArrayEditor)
{
byteArrayEditor.RequestBytesOpen += ByteArrayEditor_RequestBytesOpen;
}
if (e.Control is ArrayEditor arrayEditor)
{
arrayEditor.parentref = this;
arrayEditor.RequestBytesOpen += ByteArrayEditor_RequestBytesOpen;
}
}
e.Cancel = e.Control == null;
break;
}
case "REDName":
//Normal textbox is good for this.
break;
default:
e.Cancel = true;
break;
}
}
public bool WriteMatToMesh(ref CR2WFile cr2w, string _matData, List <Archive> archives)
{
if (cr2w == null || !cr2w.Chunks.Select(_ => _.Data).OfType <CMesh>().Any() || !cr2w.Chunks.Select(_ => _.Data).OfType <rendRenderMeshBlob>().Any() || cr2w.Buffers.Count < 1)
{
return(false);
}
var matData = JsonConvert.DeserializeObject <MatData>(_matData);
var materialbuffer = new MemoryStream();
List <UInt32> offsets = new List <UInt32>();
List <UInt32> sizes = new List <UInt32>();
List <string> names = new List <string>();
if (matData.Materials.Count < 1)
{
return(false);
}
Dictionary <string, CMaterialTemplate> mts = new Dictionary <string, CMaterialTemplate>();
for (int i = 0; i < matData.Materials.Count; i++)
{
var mat = matData.Materials[i];
names.Add(mat.Name);
CR2WFile mi = new CR2WFile();
{
var chunk = new CMaterialInstance(mi, null, "CMaterialInstance")
{
IsSerialized = true
};
chunk.CookingPlatform = new CEnum <Enums.ECookingPlatform>(mi, chunk, "cookingPlatform")
{
IsSerialized = true, Value = Enums.ECookingPlatform.PLATFORM_PC
};
chunk.CookingPlatform.EnumValueList.Add("PLATFORM_PC");
chunk.EnableMask = new CBool(mi, chunk, "enableMask")
{
IsSerialized = true, Value = true
};
chunk.ResourceVersion = new CUInt8(mi, chunk, "resourceVersion")
{
IsSerialized = true, Value = 4
};
chunk.BaseMaterial = new rRef <IMaterial>(mi, chunk, "baseMaterial")
{
IsSerialized = true, DepotPath = mat.BaseMaterial
};
chunk.CMaterialInstanceData = new CArray <CVariantSizeNameType>(mi, chunk, "CMaterialInstanceData")
{
IsSerialized = true
};
CMaterialTemplate mt = null;
if (mts.ContainsKey(mat.MaterialTemplate))
{
mt = mts[mat.MaterialTemplate];
}
else
{
ulong hash = FNV1A64HashAlgorithm.HashString(mat.MaterialTemplate);
foreach (Archive ar in archives)
{
if (ar.Files.ContainsKey(hash))
{
var ms = new MemoryStream();
ModTools.ExtractSingleToStream(ar, hash, ms);
mt = _wolvenkitFileService.TryReadRED4File(ms).Chunks.Select(_ => _.Data).OfType <CMaterialTemplate>().First();
mts.Add(mat.MaterialTemplate, mt);
break;
}
}
}
var keys = matData.Materials[i].Data.Keys.ToList();
if (mt != null)
{
for (int j = 0; j < keys.Count; j++)
{
string typename = null;
for (int k = 0; k < mt.Parameters[2].Count; k++)
{
var refer = mt.Parameters[2][k].GetReference().Data;
if ((refer.ChildrEditableVariables[0] as CName).Value == keys[j])
{
if (refer.ChildrEditableVariables.Count > 2)
{
typename = refer.ChildrEditableVariables[2].REDType;
}
}
}
if (typename != null)
{
// remove when setfromobj deserialization is fixed
if (typename == "Color")
{
CColor_ value0 = new CColor_(new CR2WFile(), null, keys[j]);
value0.IsSerialized = true;
value0.SetFromJObject(matData.Materials[i].Data[keys[j]]);
var variant = new CVariantSizeNameType(mi, chunk.CMaterialInstanceData, keys[j]);
CColor value = new CColor(mi, variant, keys[j]);
value.IsSerialized = true;
value.Red = new CUInt8(mi, value, "Red")
{
IsSerialized = true, Value = value0.Red.Value
};
value.Green = new CUInt8(mi, value, "Green")
{
IsSerialized = true, Value = value0.Green.Value
};
value.Blue = new CUInt8(mi, value, "Blue")
{
IsSerialized = true, Value = value0.Blue.Value
};
value.Alpha = new CUInt8(mi, value, "Alpha")
{
IsSerialized = true, Value = value0.Alpha.Value
};
variant.SetVariant(value);
chunk.CMaterialInstanceData.Add(variant);
}
else
{
var variant = new CVariantSizeNameType(mi, chunk.CMaterialInstanceData, keys[j]);
var value = CR2WTypeManager.Create(typename, keys[j], mi, variant);
value.IsSerialized = true;
value.SetFromJObject(matData.Materials[i].Data[keys[j]]);
variant.SetVariant(value);
chunk.CMaterialInstanceData.Add(variant);
}
}
}
}
mi.CreateChunk(chunk, 0);
}
offsets.Add((UInt32)materialbuffer.Position);
var m = new MemoryStream();
var b = new BinaryWriter(m);
mi.Write(b);
materialbuffer.Write(m.ToArray(), 0, (int)m.Length);
sizes.Add((UInt32)m.Length);
}
var blob = cr2w.Chunks.Select(_ => _.Data).OfType <CMesh>().First();
// remove existing data
while (blob.MaterialEntries.Count != 0)
{
blob.MaterialEntries.Remove(blob.MaterialEntries[blob.MaterialEntries.Count - 1]);
}
while (blob.LocalMaterialBuffer.RawDataHeaders.Count != 0)
{
blob.LocalMaterialBuffer.RawDataHeaders.Remove(blob.LocalMaterialBuffer.RawDataHeaders[blob.LocalMaterialBuffer.RawDataHeaders.Count - 1]);
}
while (blob.PreloadLocalMaterialInstances.Count != 0)
{
blob.PreloadLocalMaterialInstances.Remove(blob.PreloadLocalMaterialInstances[blob.PreloadLocalMaterialInstances.Count - 1]);
}
while (blob.PreloadExternalMaterials.Count != 0)
{
blob.PreloadExternalMaterials.Remove(blob.PreloadExternalMaterials[blob.PreloadExternalMaterials.Count - 1]);
}
while (blob.ExternalMaterials.Count != 0)
{
blob.ExternalMaterials.Remove(blob.ExternalMaterials[blob.ExternalMaterials.Count - 1]);
}
while (blob.LocalMaterialInstances.Count != 0)
{
blob.LocalMaterialInstances.Remove(blob.LocalMaterialInstances[blob.LocalMaterialInstances.Count - 1]);
}
//
for (int i = 0; i < names.Count; i++)
{
var c = new CMeshMaterialEntry(cr2w, blob.MaterialEntries, Convert.ToString(i))
{
IsSerialized = true,
};
c.IsLocalInstance = new CBool(cr2w, c, "isLocalInstance")
{
Value = true, IsSerialized = true
};
c.Name = new CName(cr2w, c, "name")
{
Value = names[i], IsSerialized = true
};
c.Index = new CUInt16(cr2w, c, "index")
{
Value = (UInt16)i, IsSerialized = true
};
blob.MaterialEntries.Add(c);
var m = new meshLocalMaterialHeader(cr2w, blob.LocalMaterialBuffer.RawDataHeaders, Convert.ToString(i))
{
IsSerialized = true
};
m.Offset = new CUInt32(cr2w, m, "offset")
{
Value = offsets[i], IsSerialized = true
};
m.Size = new CUInt32(cr2w, m, "size")
{
Value = sizes[i], IsSerialized = true
};
blob.LocalMaterialBuffer.RawDataHeaders.Add(m);
}
var compressed = new MemoryStream();
using var buff = new BinaryWriter(compressed);
var(zsize, crc) = buff.CompressAndWrite(materialbuffer.ToArray());
bool check = false;
check = blob.LocalMaterialBuffer.RawData.IsSerialized;
if (!check)
{
blob.LocalMaterialBuffer.RawData = new DataBuffer(cr2w, blob.LocalMaterialBuffer, "rawData")
{
IsSerialized = true
};
blob.LocalMaterialBuffer.RawData.Buffer = new CUInt16(cr2w, blob.LocalMaterialBuffer.RawData, "Buffer")
{
Value = (UInt16)(cr2w.Buffers.Count + 1), IsSerialized = true
};
uint idx = (uint)cr2w.Buffers.Count;
cr2w.Buffers.Add(new CR2WBufferWrapper(new CR2WBuffer()
{
flags = 0,
index = idx,
offset = 0,
diskSize = zsize,
memSize = (UInt32)materialbuffer.Length,
crc32 = crc
}));
cr2w.Buffers[(int)idx].ReadData(new BinaryReader(compressed));
cr2w.Buffers[(int)idx].Offset = cr2w.Buffers[(int)idx - 1].Offset + cr2w.Buffers[(int)idx - 1].DiskSize;
}
else
{
UInt16 p = (blob.LocalMaterialBuffer.RawData.Buffer.Value);
cr2w.Buffers[p - 1].DiskSize = zsize;
cr2w.Buffers[p - 1].Crc32 = crc;
cr2w.Buffers[p - 1].MemSize = (UInt32)materialbuffer.Length;
var off = cr2w.Buffers[p - 1].Offset;
cr2w.Buffers[p - 1].Offset = 0;
cr2w.Buffers[p - 1].ReadData(new BinaryReader(compressed));
cr2w.Buffers[p - 1].Offset = off;
}
return(true);
}
