private void AddTextureInfo(ExporterVersion version,
SortedDictionary <string, int> texAndInd,
TextureValuesAggregator aggregator)
{
if (version < ExporterVersion.Ver16Alpha1)
{
return;
}
aggregator.AddAlphaTexture(texAndInd);
aggregator.AddUvDistortionTexture(texAndInd);
if (aggregator.IsBlendTextureEnabled)
{
aggregator.AddBlendTexture(texAndInd);
aggregator.AddBlendAlphaTexture(texAndInd);
aggregator.AddBlendUvDistortionTexture(texAndInd);
}
else
{
aggregator.AddInt(-1);
aggregator.AddInt(-1);
aggregator.AddInt(-1);
}
}
public void AddMaterialData(ExporterVersion version,
Data.RendererCommonValues value,
TextureValuesAggregator aggregator,
SortedDictionary <string, int> texToIndex,
SortedDictionary <string, int> distortionToIndex,
SortedDictionary <string, int> normalToIndex,
SortedDictionary <string, int> materialToIndex)
{
switch (value.Material.Value)
{
case Data.RendererCommonValues.MaterialType.Default:
AddAsDefaultMaterial(version, texToIndex, value, aggregator);
break;
case Data.RendererCommonValues.MaterialType.BackDistortion:
AddAsBackDistortion(version, distortionToIndex, value, aggregator);
break;
case Data.RendererCommonValues.MaterialType.Lighting:
AddAsLighting(version, texToIndex, normalToIndex, value, aggregator);
break;
default:
AddAsFile(aggregator, value, texToIndex, normalToIndex, materialToIndex);
break;
}
}
private void AddAsBackDistortion(ExporterVersion version,
SortedDictionary <string, int> distortionToIndex,
Data.RendererCommonValues value,
TextureValuesAggregator aggregator)
{
aggregator.AddTexIdAndStoreSize(value.ColorTexture, 1, distortionToIndex);
aggregator.AddInt(-1);
AddTextureInfo(version, distortionToIndex, aggregator);
}
private void AddAsLighting(ExporterVersion version,
SortedDictionary <string, int> texToIndex,
SortedDictionary <string, int> normalTexToIndex,
Data.RendererCommonValues value,
TextureValuesAggregator aggregator)
{
aggregator.AddTexIdAndStoreSize(value.ColorTexture, 1, texToIndex);
aggregator.AddTexIdAndStoreSize(value.NormalTexture, 2, normalTexToIndex);
AddTextureInfo(version, texToIndex, aggregator);
}
private static void AddModelData(
Data.RendererValues value,
SortedDictionary <string, int> model_and_index,
Dictionary <ProceduralModelParameter, int> pmodel_and_index,
ExporterVersion version,
List <byte[]> data)
{
var param = value.Model;
if (version >= ExporterVersion.Ver16Alpha3)
{
var refType = (int)value.Model.ModelReference.Value;
data.Add((refType).GetBytes());
}
AddModelReference();
data.Add(param.Billboard);
data.Add(((int)param.Culling.Value).GetBytes());
// 全体色
OutputStandardColor(data, param.Color, param.Color_Fixed, param.Color_Random, param.Color_Easing,
param.Color_FCurve);
void AddModelReference()
{
if (value.Model.ModelReference.Value == Data.ModelReferenceType.File)
{
data.Add((1.0f).GetBytes());
if (param.Model.RelativePath != string.Empty)
{
var relativePath = Utils.GetModelPath(param.Model);
data.Add(model_and_index[relativePath].GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
}
else if (value.Model.ModelReference.Value == Data.ModelReferenceType.ProceduralModel)
{
if (value.Model.Reference.Value != null)
{
var ind = pmodel_and_index[value.Model.Reference.Value];
data.Add(ind.GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
}
}
}
public static byte[] GetBytes(Data.AlphaCutoffParameter value, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
data.Add(value.Type.GetValueAsInt().GetBytes());
if (value.Type == Data.AlphaCutoffParameter.ParameterType.Fixed)
{
var refBuf = value.Fixed.Threshold.DynamicEquation.Index.GetBytes();
var mainBuf = value.Fixed.Threshold.GetBytes();
data.Add((mainBuf.Count() + refBuf.Count()).GetBytes());
data.Add(refBuf);
data.Add(mainBuf);
}
else if (value.Type == Data.AlphaCutoffParameter.ParameterType.FourPointInterpolation)
{
List <byte[]> _data = new List <byte[]>();
_data.Add(value.FourPointInterpolation.BeginThreshold.Max.GetBytes());
_data.Add(value.FourPointInterpolation.BeginThreshold.Min.GetBytes());
_data.Add(value.FourPointInterpolation.TransitionFrameNum.Max.GetBytes());
_data.Add(value.FourPointInterpolation.TransitionFrameNum.Min.GetBytes());
_data.Add(value.FourPointInterpolation.No2Threshold.Max.GetBytes());
_data.Add(value.FourPointInterpolation.No2Threshold.Min.GetBytes());
_data.Add(value.FourPointInterpolation.No3Threshold.Max.GetBytes());
_data.Add(value.FourPointInterpolation.No3Threshold.Min.GetBytes());
_data.Add(value.FourPointInterpolation.TransitionFrameNum2.Max.GetBytes());
_data.Add(value.FourPointInterpolation.TransitionFrameNum2.Min.GetBytes());
_data.Add(value.FourPointInterpolation.EndThreshold.Max.GetBytes());
_data.Add(value.FourPointInterpolation.EndThreshold.Min.GetBytes());
var __data = _data.ToArray().ToArray();
data.Add(__data.Count().GetBytes());
data.Add(__data);
}
else if (value.Type == Data.AlphaCutoffParameter.ParameterType.Easing)
{
Utils.ExportEasing(value.Easing, 1.0f, data, version);
}
else if (value.Type == Data.AlphaCutoffParameter.ParameterType.FCurve)
{
var _data = value.FCurve.GetBytes();
data.Add(_data.Count().GetBytes());
data.Add(_data);
}
data.Add(value.EdgeParam.EdgeThreshold.GetBytes());
data.Add((byte[])value.EdgeParam.EdgeColor);
data.Add(BitConverter.GetBytes(value.EdgeParam.EdgeColorScaling));
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.RingShapeParameter value, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
data.Add(BitConverter.GetBytes((int)value.Type.Value));
if (value.Type.Value == Data.RingShapeType.Donut)
{
}
else if (value.Type.Value == Data.RingShapeType.Crescent)
{
data.Add(BitConverter.GetBytes(value.Crescent.StartingFade.Value));
data.Add(BitConverter.GetBytes(value.Crescent.EndingFade.Value));
data.Add(((int)value.Crescent.StartingAngle.Value).GetBytes());
if (value.Crescent.StartingAngle.Value == Data.FixedRandomEasingType.Fixed)
{
data.Add(value.Crescent.StartingAngle_Fixed.Value.GetBytes());
}
else if (value.Crescent.StartingAngle.Value == Data.FixedRandomEasingType.Random)
{
data.Add(value.Crescent.StartingAngle_Random.Max.GetBytes());
data.Add(value.Crescent.StartingAngle_Random.Min.GetBytes());
}
if (value.Crescent.StartingAngle.Value == Data.FixedRandomEasingType.Easing)
{
Utils.ExportEasing(value.Crescent.StartingAngle_Easing, 1.0f, data, version, version >= ExporterVersion.Ver16Alpha9);
}
data.Add(((int)value.Crescent.EndingAngle.Value).GetBytes());
if (value.Crescent.EndingAngle.Value == Data.FixedRandomEasingType.Fixed)
{
data.Add(value.Crescent.EndingAngle_Fixed.Value.GetBytes());
}
else if (value.Crescent.EndingAngle.Value == Data.FixedRandomEasingType.Random)
{
data.Add(value.Crescent.EndingAngle_Random.Max.GetBytes());
data.Add(value.Crescent.EndingAngle_Random.Min.GetBytes());
}
if (value.Crescent.EndingAngle.Value == Data.FixedRandomEasingType.Easing)
{
Utils.ExportEasing(value.Crescent.EndingAngle_Easing, 1.0f, data, version, version >= ExporterVersion.Ver16Alpha9);
}
}
return(data.SelectMany(_ => _).ToArray());
}
private static IEnumerable <byte[]> GetTextureValues(
Data.RendererCommonValues value,
AdvancedRenderCommonValues advanceValue,
SortedDictionary <string, int> texture_and_index,
SortedDictionary <string, int> normalTexture_and_index,
SortedDictionary <string, int> distortionTexture_and_index,
SortedDictionary <string, int> material_and_index,
ExporterVersion version,
TextureInformationRepository texInfoRepo)
{
var aggregator = new TextureValuesAggregator(value, advanceValue, texInfoRepo);
MaterialSerializerInstance.AddMaterialData(version, value, aggregator,
texture_and_index, distortionTexture_and_index, normalTexture_and_index, material_and_index);
return(aggregator.CurrentData);
}
public static byte[] GetBytes(Data.CommonValues value, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
var bytes = CommonValues.Create(value).GetBytes();
data.Add(bytes.Count().GetBytes());
data.Add(bytes);
if (value.LocationEffectType == Data.TranslationParentEffectType.NotBind_FollowParent ||
value.LocationEffectType == Data.TranslationParentEffectType.WhenCreating_FollowParent)
{
data.Add(value.SteeringBehaviorParam.MaxFollowSpeed.Max.GetBytes());
data.Add(value.SteeringBehaviorParam.MaxFollowSpeed.Min.GetBytes());
data.Add(value.SteeringBehaviorParam.SteeringSpeed.Max.GetBytes());
data.Add(value.SteeringBehaviorParam.SteeringSpeed.Min.GetBytes());
}
if (version >= ExporterVersion.Ver17Alpha1)
{
// Trigger's parameters
int triggerFlags =
((value.TriggerParam.ToStartGeneration.Value != Data.TriggerType.None) ? (1 << 0) : 0) |
((value.TriggerParam.ToStopGeneration.Value != Data.TriggerType.None) ? (1 << 1) : 0) |
((value.TriggerParam.ToRemove.Value != Data.TriggerType.None) ? (1 << 2) : 0);
data.Add(((byte)triggerFlags).GetBytes());
if (value.TriggerParam.ToStartGeneration.Value != Data.TriggerType.None)
{
data.Add(((ushort)value.TriggerParam.ToStartGeneration.GetValue()).GetBytes());
}
if (value.TriggerParam.ToStopGeneration.Value != Data.TriggerType.None)
{
data.Add(((ushort)value.TriggerParam.ToStopGeneration.GetValue()).GetBytes());
}
if (value.TriggerParam.ToRemove.Value != Data.TriggerType.None)
{
data.Add(((ushort)value.TriggerParam.ToRemove.GetValue()).GetBytes());
}
}
return(data.ToArray().ToArray());
}
public override int GetHashCode()
{
int hash = 1;
if (Language != global::Opencensus.Proto.Agent.Common.V1.LibraryInfo.Types.Language.Unspecified)
{
hash ^= Language.GetHashCode();
}
if (ExporterVersion.Length != 0)
{
hash ^= ExporterVersion.GetHashCode();
}
if (CoreLibraryVersion.Length != 0)
{
hash ^= CoreLibraryVersion.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public override int GetHashCode()
{
int hash = 1;
if (Language != 0)
{
hash ^= Language.GetHashCode();
}
if (ExporterVersion.Length != 0)
{
hash ^= ExporterVersion.GetHashCode();
}
if (CoreLibraryVersion.Length != 0)
{
hash ^= CoreLibraryVersion.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public static byte[] GetBytes(Data.RendererCommonValues value,
Data.AdvancedRenderCommonValues advanceValue,
SortedDictionary <string, int> texture_and_index,
SortedDictionary <string, int> normalTexture_and_index,
SortedDictionary <string, int> distortionTexture_and_index,
SortedDictionary <string, int> material_and_index,
ExporterVersion version,
System.Func <string, string> convertLoadingFilePath)
{
List <byte[]> data = new List <byte[]>();
var texInfoRepo = new TextureInformationRepository();
var texInfo = texInfoRepo.Texture;
data.Add(((int)value.Material.Value).GetBytes());
if (version >= ExporterVersion.Ver16Alpha1)
{
if (value.Material.Value == Data.RendererCommonValues.MaterialType.Default ||
value.Material.Value == Data.RendererCommonValues.MaterialType.Lighting)
{
data.Add(BitConverter.GetBytes(value.EmissiveScaling));
}
}
data.AddRange(GetTextureValues(value,
advanceValue,
texture_and_index,
normalTexture_and_index,
distortionTexture_and_index,
material_and_index,
version,
texInfoRepo,
convertLoadingFilePath));
data.Add(value.AlphaBlend);
data.Add(value.Filter);
data.Add(value.Wrap);
data.Add(value.Filter2);
data.Add(value.Wrap2);
if (version >= ExporterVersion.Ver16Alpha1)
{
data.Add(advanceValue.AlphaTextureParam.Filter);
data.Add(advanceValue.AlphaTextureParam.Wrap);
data.Add(advanceValue.UVDistortionTextureParam.Filter);
data.Add(advanceValue.UVDistortionTextureParam.Wrap);
data.Add(advanceValue.BlendTextureParams.BlendTextureParam.Filter);
data.Add(advanceValue.BlendTextureParams.BlendTextureParam.Wrap);
data.Add(advanceValue.BlendTextureParams.BlendAlphaTextureParam.Filter);
data.Add(advanceValue.BlendTextureParams.BlendAlphaTextureParam.Wrap);
data.Add(advanceValue.BlendTextureParams.BlendUVDistortionTextureParam.Filter);
data.Add(advanceValue.BlendTextureParams.BlendUVDistortionTextureParam.Wrap);
}
data.Add(value.ZTest.GetValue() ? 1.GetBytes() : 0.GetBytes());
data.Add(value.ZWrite.GetValue() ? 1.GetBytes() : 0.GetBytes());
data.Add(value.FadeInType);
if (value.FadeInType.Value == Data.RendererCommonValues.FadeInMethod.Use)
{
data.Add(value.FadeIn.Frame.GetBytes());
var easing = Utl.MathUtl.Easing((float)value.FadeIn.StartSpeed.Value, (float)value.FadeIn.EndSpeed.Value);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(value.FadeOutType);
if (value.FadeOutType.Value == Data.RendererCommonValues.FadeOutMethod.WithinLifetime ||
value.FadeOutType.Value == Data.RendererCommonValues.FadeOutMethod.AfterRemoved)
{
data.Add(value.FadeOut.Frame.GetBytes());
var easing = Utl.MathUtl.Easing((float)value.FadeOut.StartSpeed.Value, (float)value.FadeOut.EndSpeed.Value);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(new BasicUvSerializer(value, version).SerializeUv(texInfo));
if (version >= ExporterVersion.Ver16Alpha1)
{
AddUvBytes(advanceValue, data, texInfoRepo);
}
// Inheritance
data.Add(value.ColorInheritType.GetValueAsInt().GetBytes());
// Distortion
data.Add(value.DistortionIntensity.GetBytes());
// Custom data1 from 1.5
data.Add(value.CustomData1.CustomData);
if (value.CustomData1.CustomData.Value == Data.CustomDataType.Fixed2D)
{
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed.Y.Value));
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.Random2D)
{
var value_ = value.CustomData1.Random;
var bytes1 = value_.GetBytes(1.0f);
data.Add(bytes1);
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.Easing2D)
{
var easing = Utl.MathUtl.Easing((float)value.CustomData1.Easing.StartSpeed.Value, (float)value.CustomData1.Easing.EndSpeed.Value);
List <byte[]> _data = new List <byte[]>();
_data.Add(value.CustomData1.Easing.Start.GetBytes(1.0f));
_data.Add(value.CustomData1.Easing.End.GetBytes(1.0f));
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data);
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.FCurve2D)
{
var value_ = value.CustomData1.FCurve;
var bytes1 = value_.GetBytes();
data.Add(bytes1);
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.Fixed4D)
{
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.Y.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.Z.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.W.Value));
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.FCurveColor)
{
var bytes = value.CustomData1.FCurveColor.GetBytes();
data.Add(bytes);
}
// Custom data2 from 1.5
data.Add(value.CustomData2.CustomData);
if (value.CustomData2.CustomData.Value == Data.CustomDataType.Fixed2D)
{
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed.Y.Value));
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.Random2D)
{
var value_ = value.CustomData2.Random;
var bytes1 = value_.GetBytes(1.0f);
data.Add(bytes1);
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.Easing2D)
{
var easing = Utl.MathUtl.Easing((float)value.CustomData2.Easing.StartSpeed.Value, (float)value.CustomData2.Easing.EndSpeed.Value);
List <byte[]> _data = new List <byte[]>();
_data.Add(value.CustomData2.Easing.Start.GetBytes(1.0f));
_data.Add(value.CustomData2.Easing.End.GetBytes(1.0f));
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data);
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.FCurve2D)
{
var value_ = value.CustomData2.FCurve;
var bytes1 = value_.GetBytes();
data.Add(bytes1);
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.Fixed4D)
{
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.Y.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.Z.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.W.Value));
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.FCurveColor)
{
var bytes = value.CustomData2.FCurveColor.GetBytes();
data.Add(bytes);
}
if (version >= ExporterVersion.Ver16Alpha1)
{
if (version >= ExporterVersion.Ver16Alpha6)
{
if (advanceValue.AlphaCutoffParam.Enabled)
{
data.Add((1).GetBytes());
data.Add(AlphaCutoffValues.GetBytes(advanceValue.AlphaCutoffParam, version));
}
else
{
data.Add((0).GetBytes());
}
}
else
{
data.Add(AlphaCutoffValues.GetBytes(advanceValue.AlphaCutoffParam, version));
}
}
if (version >= ExporterVersion.Ver16Alpha3)
{
if (advanceValue.FalloffParam.Enabled)
{
data.Add((1).GetBytes());
data.Add(advanceValue.FalloffParam.ColorBlendType);
data.Add(advanceValue.FalloffParam.BeginColor);
data.Add(advanceValue.FalloffParam.EndColor);
data.Add(BitConverter.GetBytes(advanceValue.FalloffParam.Pow.Value));
}
else
{
data.Add((0).GetBytes());
}
}
if (advanceValue.SoftParticleParams.Enabled)
{
if (version >= ExporterVersion.Ver16Alpha4)
{
data.Add(advanceValue.SoftParticleParams.Distance.GetBytes());
}
if (version >= ExporterVersion.Ver16Alpha5)
{
data.Add(advanceValue.SoftParticleParams.DistanceNear.GetBytes());
data.Add(advanceValue.SoftParticleParams.DistanceNearOffset.GetBytes());
}
}
else
{
if (version >= ExporterVersion.Ver16Alpha4)
{
data.Add((0.0f).GetBytes());
}
if (version >= ExporterVersion.Ver16Alpha5)
{
data.Add((0.0f).GetBytes());
data.Add((0.0f).GetBytes());
}
}
return(data.ToArray().ToArray());
}
public static void ExportEasing(FloatEasingParamater easingValue, float magnification, List <byte[]> destination, ExporterVersion version, bool exportSize)
{
var refBuf1_1 = easingValue.Start.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = easingValue.Start.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = easingValue.End.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = easingValue.End.DynamicEquationMin.Index.GetBytes();
List <byte[]> _data = new List <byte[]>();
if (version >= ExporterVersion.Ver16Alpha1)
{
_data.Add(refBuf1_1);
_data.Add(refBuf1_2);
_data.Add(refBuf2_1);
_data.Add(refBuf2_2);
_data.Add(easingValue.Start.GetBytes(magnification));
_data.Add(easingValue.End.GetBytes(magnification));
}
else
{
_data.Add(easingValue.Start.GetBytes(magnification));
_data.Add(easingValue.End.GetBytes(magnification));
}
// middle
if (version >= ExporterVersion.Ver16Alpha1)
{
int isMiddleEnabled = easingValue.IsMiddleEnabled ? 1 : 0;
_data.Add(isMiddleEnabled.GetBytes());
if (easingValue.IsMiddleEnabled.Value)
{
var refBuf3_1 = easingValue.Middle.DynamicEquationMax.Index.GetBytes();
var refBuf3_2 = easingValue.Middle.DynamicEquationMin.Index.GetBytes();
_data.Add(refBuf3_1);
_data.Add(refBuf3_2);
_data.Add(easingValue.Middle.GetBytes(magnification));
}
}
var type = easingValue.Type.Value;
if (version >= ExporterVersion.Ver16Alpha1)
{
_data.Add(BitConverter.GetBytes((int)type));
if (type == EasingType.LeftRightSpeed)
{
var easing = Utl.MathUtl.Easing((float)easingValue.StartSpeed.Value, (float)easingValue.EndSpeed.Value);
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
}
}
else
{
var easing = Utl.MathUtl.Easing((float)easingValue.StartSpeed.Value, (float)easingValue.EndSpeed.Value);
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
}
// Channel
if (version >= ExporterVersion.Ver16Alpha1)
{
{
int channel = 0;
channel += (byte)0 << 0;
_data.Add(BitConverter.GetBytes(channel));
}
}
// Individual
if (version >= ExporterVersion.Ver16Alpha1)
{
int individualTypeEnabled = 0;
_data.Add(BitConverter.GetBytes(individualTypeEnabled));
}
var __data = _data.ToArray().ToArray();
if (exportSize)
{
destination.Add(__data.Count().GetBytes());
}
destination.Add(__data);
}
public static void ExportEasing(Vector3DEasingParamater easingValue, float magnification, List <byte[]> destination, ExporterVersion version)
{
var refBuf1_1 = easingValue.Start.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = easingValue.Start.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = easingValue.End.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = easingValue.End.DynamicEquationMin.Index.GetBytes();
List <byte[]> _data = new List <byte[]>();
_data.Add(refBuf1_1);
_data.Add(refBuf1_2);
_data.Add(refBuf2_1);
_data.Add(refBuf2_2);
_data.Add(easingValue.Start.GetBytes(magnification));
_data.Add(easingValue.End.GetBytes(magnification));
// middle
if (version >= ExporterVersion.Ver16Alpha1)
{
int isMiddleEnabled = easingValue.IsMiddleEnabled.Value ? 1 : 0;
_data.Add(isMiddleEnabled.GetBytes());
if (easingValue.IsMiddleEnabled.Value)
{
var refBuf3_1 = easingValue.Middle.DynamicEquationMax.Index.GetBytes();
var refBuf3_2 = easingValue.Middle.DynamicEquationMin.Index.GetBytes();
_data.Add(refBuf3_1);
_data.Add(refBuf3_2);
_data.Add(easingValue.Middle.GetBytes(magnification));
}
}
var type = easingValue.Type.Value;
if (version >= ExporterVersion.Ver16Alpha1)
{
_data.Add(BitConverter.GetBytes((int)type));
if (type == EasingType.LeftRightSpeed)
{
var easing = Utl.MathUtl.Easing((float)easingValue.StartSpeed.Value, (float)easingValue.EndSpeed.Value);
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
}
}
else
{
var easing = Utl.MathUtl.Easing((float)easingValue.StartSpeed.Value, (float)easingValue.EndSpeed.Value);
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
}
// Channel
if (version >= ExporterVersion.Ver16Alpha1)
{
if (easingValue.IsRandomGroupEnabled.Value)
{
Dictionary <int, int> id2ind = new Dictionary <int, int>();
var ids = new[] { easingValue.RandomGroupX.Value, easingValue.RandomGroupY.Value, easingValue.RandomGroupZ.Value };
foreach (var id in ids)
{
if (!id2ind.ContainsKey(id))
{
id2ind.Add(id, id2ind.Count);
}
}
int channel = 0;
channel += (byte)id2ind[easingValue.RandomGroupX.Value] << 0;
channel += (byte)id2ind[easingValue.RandomGroupY.Value] << 8;
channel += (byte)id2ind[easingValue.RandomGroupZ.Value] << 16;
_data.Add(BitConverter.GetBytes(channel));
}
else
{
int channel = 0;
channel += (byte)0 << 0;
channel += (byte)1 << 8;
channel += (byte)2 << 16;
_data.Add(BitConverter.GetBytes(channel));
}
}
// Individual
if (version >= ExporterVersion.Ver16Alpha1)
{
int individualTypeEnabled = easingValue.IsIndividualTypeEnabled.Value ? 1 : 0;
_data.Add(BitConverter.GetBytes(individualTypeEnabled));
if (easingValue.IsIndividualTypeEnabled.Value)
{
_data.Add(BitConverter.GetBytes((int)easingValue.TypeX.Value));
_data.Add(BitConverter.GetBytes((int)easingValue.TypeY.Value));
_data.Add(BitConverter.GetBytes((int)easingValue.TypeZ.Value));
}
}
var __data = _data.ToArray().ToArray();
destination.Add(__data.Count().GetBytes());
destination.Add(__data);
}
public static byte[] GetBytes(Data.RendererValues value, Dictionary <string, int> texture_and_index, Dictionary <string, int> normalTexture_and_index, Dictionary <string, int> model_and_index, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
if (value == null)
{
data.Add(((int)(Data.RendererValues.ParamaterType.None)).GetBytes());
}
else
{
data.Add(value.Type.GetValueAsInt().GetBytes());
}
if (value == null)
{
}
else if (value.Type.Value == Data.RendererValues.ParamaterType.None)
{
}
else if (value.Type.Value == Data.RendererValues.ParamaterType.Sprite)
{
var param = value.Sprite;
data.Add(param.RenderingOrder);
//data.Add(sprite_paramater.AlphaBlend);
data.Add(param.Billboard);
// 全体色
data.Add(param.ColorAll);
if (param.ColorAll.Value == Data.StandardColorType.Fixed)
{
var color_all = (byte[])param.ColorAll_Fixed;
data.Add(color_all);
}
else if (param.ColorAll.Value == Data.StandardColorType.Random)
{
var color_random = (byte[])param.ColorAll_Random;
data.Add(color_random);
}
else if (param.ColorAll.Value == Data.StandardColorType.Easing)
{
var easing = Utl.MathUtl.Easing((float)value.Sprite.ColorAll_Easing.StartSpeed.Value, (float)value.Sprite.ColorAll_Easing.EndSpeed.Value);
data.Add((byte[])value.Sprite.ColorAll_Easing.Start);
data.Add((byte[])value.Sprite.ColorAll_Easing.End);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
else if (param.ColorAll.Value == Data.StandardColorType.FCurve)
{
var bytes = param.ColorAll_FCurve.FCurve.GetBytes();
data.Add(bytes);
}
// 部分色
data.Add(param.Color);
if (param.Color.Value == Data.RendererValues.SpriteParamater.ColorType.Default)
{
}
else if (param.Color.Value == Data.RendererValues.SpriteParamater.ColorType.Fixed)
{
var color_ll = (byte[])param.Color_Fixed_LL;
var color_lr = (byte[])param.Color_Fixed_LR;
var color_ul = (byte[])param.Color_Fixed_UL;
var color_ur = (byte[])param.Color_Fixed_UR;
data.Add(color_ll);
data.Add(color_lr);
data.Add(color_ul);
data.Add(color_ur);
}
// 座標
//data.Add(sprite_paramater.Position);
data.Add(BitConverter.GetBytes((int)Data.RendererValues.SpriteParamater.PositionType.Fixed));
if (param.Position.Value == Data.RendererValues.SpriteParamater.PositionType.Default)
{
data.Add(BitConverter.GetBytes(-0.5f));
data.Add(BitConverter.GetBytes(-0.5f));
data.Add(BitConverter.GetBytes(+0.5f));
data.Add(BitConverter.GetBytes(-0.5f));
data.Add(BitConverter.GetBytes(-0.5f));
data.Add(BitConverter.GetBytes(+0.5f));
data.Add(BitConverter.GetBytes(+0.5f));
data.Add(BitConverter.GetBytes(+0.5f));
}
else if (param.Position.Value == Data.RendererValues.SpriteParamater.PositionType.Fixed)
{
var pos_ll = (byte[])param.Position_Fixed_LL.GetBytes();
var pos_lr = (byte[])param.Position_Fixed_LR.GetBytes();
var pos_ul = (byte[])param.Position_Fixed_UL.GetBytes();
var pos_ur = (byte[])param.Position_Fixed_UR.GetBytes();
data.Add(pos_ll);
data.Add(pos_lr);
data.Add(pos_ul);
data.Add(pos_ur);
}
// テクスチャ番号
/*
* if (sprite_paramater.ColorTexture.RelativePath != string.Empty)
* {
* data.Add(texture_and_index[sprite_paramater.ColorTexture.RelativePath].GetBytes());
* }
* else
* {
* data.Add((-1).GetBytes());
* }
*/
}
else if (value.Type.Value == Data.RendererValues.ParamaterType.Ribbon)
{
var ribbonParamater = value.Ribbon;
//data.Add(ribbonParamater.AlphaBlend);
// texture uv mode from 1.5
data.Add(TextureUVTypeParameter.GetBytes(value.TextureUVType));
if (ribbonParamater.ViewpointDependent)
{
data.Add((1).GetBytes());
}
else
{
data.Add((0).GetBytes());
}
// 全体色
data.Add(ribbonParamater.ColorAll);
if (ribbonParamater.ColorAll.Value == Data.RendererValues.RibbonParamater.ColorAllType.Fixed)
{
var color_all = (byte[])ribbonParamater.ColorAll_Fixed;
data.Add(color_all);
}
else if (ribbonParamater.ColorAll.Value == Data.RendererValues.RibbonParamater.ColorAllType.Random)
{
var color_random = (byte[])ribbonParamater.ColorAll_Random;
data.Add(color_random);
}
else if (ribbonParamater.ColorAll.Value == Data.RendererValues.RibbonParamater.ColorAllType.Easing)
{
var easing = Utl.MathUtl.Easing((float)ribbonParamater.ColorAll_Easing.StartSpeed.Value, (float)ribbonParamater.ColorAll_Easing.EndSpeed.Value);
data.Add((byte[])ribbonParamater.ColorAll_Easing.Start);
data.Add((byte[])ribbonParamater.ColorAll_Easing.End);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
// 部分色
data.Add(ribbonParamater.Color);
if (ribbonParamater.Color.Value == Data.RendererValues.RibbonParamater.ColorType.Default)
{
}
else if (ribbonParamater.Color.Value == Data.RendererValues.RibbonParamater.ColorType.Fixed)
{
var color_l = (byte[])ribbonParamater.Color_Fixed_L;
var color_r = (byte[])ribbonParamater.Color_Fixed_R;
data.Add(color_l);
data.Add(color_r);
}
// 座標
//data.Add(ribbonParamater.Position);
data.Add(BitConverter.GetBytes((int)Data.RendererValues.RibbonParamater.PositionType.Fixed));
if (ribbonParamater.Position.Value == Data.RendererValues.RibbonParamater.PositionType.Default)
{
data.Add(BitConverter.GetBytes(-0.5f));
data.Add(BitConverter.GetBytes(+0.5f));
}
else if (ribbonParamater.Position.Value == Data.RendererValues.RibbonParamater.PositionType.Fixed)
{
var pos_l = (byte[])ribbonParamater.Position_Fixed_L.GetBytes();
var pos_r = (byte[])ribbonParamater.Position_Fixed_R.GetBytes();
data.Add(pos_l);
data.Add(pos_r);
}
data.Add(BitConverter.GetBytes(ribbonParamater.SplineDivision.Value));
// テクスチャ番号
/*
* if (ribbonParamater.ColorTexture.RelativePath != string.Empty)
* {
* data.Add(texture_and_index[ribbonParamater.ColorTexture.RelativePath].GetBytes());
* }
* else
* {
* data.Add((-1).GetBytes());
* }
*/
}
else if (value.Type.Value == Data.RendererValues.ParamaterType.Ring)
{
var ringParamater = value.Ring;
data.Add(ringParamater.RenderingOrder);
//data.Add(ringParamater.AlphaBlend);
data.Add(ringParamater.Billboard);
// from 1.5
data.Add(RingShapeParameter.GetBytes(ringParamater.RingShape));
data.Add(ringParamater.VertexCount.Value.GetBytes());
// viewing angle (it will removed)
data.Add(ringParamater.ViewingAngle);
if (ringParamater.ViewingAngle.GetValue() == Data.RendererValues.RingParamater.ViewingAngleType.Fixed)
{
data.Add(ringParamater.ViewingAngle_Fixed.Value.GetBytes());
}
else if (ringParamater.ViewingAngle.GetValue() == Data.RendererValues.RingParamater.ViewingAngleType.Random)
{
data.Add(ringParamater.ViewingAngle_Random.Max.GetBytes());
data.Add(ringParamater.ViewingAngle_Random.Min.GetBytes());
}
else if (ringParamater.ViewingAngle.GetValue() == Data.RendererValues.RingParamater.ViewingAngleType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.ViewingAngle_Easing.StartSpeed.Value,
(float)ringParamater.ViewingAngle_Easing.EndSpeed.Value);
data.Add(ringParamater.ViewingAngle_Easing.Start.Max.GetBytes());
data.Add(ringParamater.ViewingAngle_Easing.Start.Min.GetBytes());
data.Add(ringParamater.ViewingAngle_Easing.End.Max.GetBytes());
data.Add(ringParamater.ViewingAngle_Easing.End.Min.GetBytes());
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(ringParamater.Outer);
if (ringParamater.Outer.GetValue() == Data.RendererValues.RingParamater.LocationType.Fixed)
{
data.Add((ringParamater.Outer_Fixed.Location.X.Value).GetBytes());
data.Add((ringParamater.Outer_Fixed.Location.Y.Value).GetBytes());
}
else if (ringParamater.Outer.GetValue() == Data.RendererValues.RingParamater.LocationType.PVA)
{
data.Add(ringParamater.Outer_PVA.Location.GetBytes());
data.Add(ringParamater.Outer_PVA.Velocity.GetBytes());
data.Add(ringParamater.Outer_PVA.Acceleration.GetBytes());
}
else if (ringParamater.Outer.GetValue() == Data.RendererValues.RingParamater.LocationType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.Outer_Easing.StartSpeed.Value,
(float)ringParamater.Outer_Easing.EndSpeed.Value);
data.Add((byte[])ringParamater.Outer_Easing.Start.GetBytes());
data.Add((byte[])ringParamater.Outer_Easing.End.GetBytes());
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(ringParamater.Inner);
if (ringParamater.Inner.GetValue() == Data.RendererValues.RingParamater.LocationType.Fixed)
{
data.Add((ringParamater.Inner_Fixed.Location.X.Value).GetBytes());
data.Add((ringParamater.Inner_Fixed.Location.Y.Value).GetBytes());
}
else if (ringParamater.Inner.GetValue() == Data.RendererValues.RingParamater.LocationType.PVA)
{
data.Add(ringParamater.Inner_PVA.Location.GetBytes());
data.Add(ringParamater.Inner_PVA.Velocity.GetBytes());
data.Add(ringParamater.Inner_PVA.Acceleration.GetBytes());
}
else if (ringParamater.Inner.GetValue() == Data.RendererValues.RingParamater.LocationType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.Inner_Easing.StartSpeed.Value,
(float)ringParamater.Inner_Easing.EndSpeed.Value);
data.Add((byte[])ringParamater.Inner_Easing.Start.GetBytes());
data.Add((byte[])ringParamater.Inner_Easing.End.GetBytes());
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(ringParamater.CenterRatio);
if (ringParamater.CenterRatio.GetValue() == Data.RendererValues.RingParamater.CenterRatioType.Fixed)
{
data.Add(ringParamater.CenterRatio_Fixed.Value.GetBytes());
}
else if (ringParamater.CenterRatio.GetValue() == Data.RendererValues.RingParamater.CenterRatioType.Random)
{
data.Add(ringParamater.CenterRatio_Random.Max.GetBytes());
data.Add(ringParamater.CenterRatio_Random.Min.GetBytes());
}
else if (ringParamater.CenterRatio.GetValue() == Data.RendererValues.RingParamater.CenterRatioType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.CenterRatio_Easing.StartSpeed.Value,
(float)ringParamater.CenterRatio_Easing.EndSpeed.Value);
data.Add(ringParamater.CenterRatio_Easing.Start.Max.GetBytes());
data.Add(ringParamater.CenterRatio_Easing.Start.Min.GetBytes());
data.Add(ringParamater.CenterRatio_Easing.End.Max.GetBytes());
data.Add(ringParamater.CenterRatio_Easing.End.Min.GetBytes());
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(ringParamater.OuterColor);
if (ringParamater.OuterColor.Value == Data.RendererValues.RingParamater.ColorType.Fixed)
{
data.Add((byte[])ringParamater.OuterColor_Fixed);
}
else if (ringParamater.OuterColor.Value == Data.RendererValues.RingParamater.ColorType.Random)
{
data.Add((byte[])ringParamater.OuterColor_Random);
}
else if (ringParamater.OuterColor.Value == Data.RendererValues.RingParamater.ColorType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.OuterColor_Easing.StartSpeed.Value,
(float)ringParamater.OuterColor_Easing.EndSpeed.Value);
data.Add((byte[])ringParamater.OuterColor_Easing.Start);
data.Add((byte[])ringParamater.OuterColor_Easing.End);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(ringParamater.CenterColor);
if (ringParamater.CenterColor.Value == Data.RendererValues.RingParamater.ColorType.Fixed)
{
data.Add((byte[])ringParamater.CenterColor_Fixed);
}
else if (ringParamater.CenterColor.Value == Data.RendererValues.RingParamater.ColorType.Random)
{
data.Add((byte[])ringParamater.CenterColor_Random);
}
else if (ringParamater.CenterColor.Value == Data.RendererValues.RingParamater.ColorType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.CenterColor_Easing.StartSpeed.Value,
(float)ringParamater.CenterColor_Easing.EndSpeed.Value);
data.Add((byte[])ringParamater.CenterColor_Easing.Start);
data.Add((byte[])ringParamater.CenterColor_Easing.End);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(ringParamater.InnerColor);
if (ringParamater.InnerColor.Value == Data.RendererValues.RingParamater.ColorType.Fixed)
{
data.Add((byte[])ringParamater.InnerColor_Fixed);
}
else if (ringParamater.InnerColor.Value == Data.RendererValues.RingParamater.ColorType.Random)
{
data.Add((byte[])ringParamater.InnerColor_Random);
}
else if (ringParamater.InnerColor.Value == Data.RendererValues.RingParamater.ColorType.Easing)
{
var easing = Utl.MathUtl.Easing(
(float)ringParamater.InnerColor_Easing.StartSpeed.Value,
(float)ringParamater.InnerColor_Easing.EndSpeed.Value);
data.Add((byte[])ringParamater.InnerColor_Easing.Start);
data.Add((byte[])ringParamater.InnerColor_Easing.End);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
// テクスチャ番号
/*
* if (ringParamater.ColorTexture.RelativePath != string.Empty)
* {
* data.Add(texture_and_index[ringParamater.ColorTexture.RelativePath].GetBytes());
* }
* else
* {
* data.Add((-1).GetBytes());
* }
*/
}
else if (value.Type.Value == Data.RendererValues.ParamaterType.Model)
{
var param = value.Model;
data.Add((1.0f).GetBytes());
if (param.Model.RelativePath != string.Empty)
{
var relative_path = param.Model.RelativePath;
if (string.IsNullOrEmpty(System.IO.Path.GetDirectoryName(relative_path)))
{
relative_path = System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkmodel";
}
else
{
relative_path = System.IO.Path.ChangeExtension(relative_path, ".efkmodel");
}
data.Add(model_and_index[relative_path].GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
data.Add(param.Billboard);
data.Add(((int)param.Culling.Value).GetBytes());
// 全体色
OutputStandardColor(data, param.Color, param.Color_Fixed, param.Color_Random, param.Color_Easing, param.Color_FCurve);
if (version >= ExporterVersion.Ver1600)
{
if (value.EnableFalloff)
{
data.Add((1).GetBytes());
data.Add(value.FalloffParam.ColorBlendType);
data.Add(value.FalloffParam.BeginColor);
data.Add(value.FalloffParam.EndColor);
data.Add(BitConverter.GetBytes(value.FalloffParam.Pow.Value));
}
else
{
data.Add((0).GetBytes());
}
}
}
else if (value.Type.Value == Data.RendererValues.ParamaterType.Track)
{
// texture uv mode from 1.5
data.Add(TextureUVTypeParameter.GetBytes(value.TextureUVType));
var param = value.Track;
data.Add(param.TrackSizeFor);
data.Add(BitConverter.GetBytes(param.TrackSizeFor_Fixed.Value));
data.Add(param.TrackSizeMiddle);
data.Add(BitConverter.GetBytes(param.TrackSizeMiddle_Fixed.Value));
data.Add(param.TrackSizeBack);
data.Add(BitConverter.GetBytes(param.TrackSizeBack_Fixed.Value));
data.Add(BitConverter.GetBytes(param.SplineDivision.Value));
OutputStandardColor(data, param.ColorLeft, param.ColorLeft_Fixed, param.ColorLeft_Random, param.ColorLeft_Easing, param.ColorLeft_FCurve);
OutputStandardColor(data, param.ColorLeftMiddle, param.ColorLeftMiddle_Fixed, param.ColorLeftMiddle_Random, param.ColorLeftMiddle_Easing, param.ColorLeftMiddle_FCurve);
OutputStandardColor(data, param.ColorCenter, param.ColorCenter_Fixed, param.ColorCenter_Random, param.ColorCenter_Easing, param.ColorCenter_FCurve);
OutputStandardColor(data, param.ColorCenterMiddle, param.ColorCenterMiddle_Fixed, param.ColorCenterMiddle_Random, param.ColorCenterMiddle_Easing, param.ColorCenterMiddle_FCurve);
OutputStandardColor(data, param.ColorRight, param.ColorRight_Fixed, param.ColorRight_Random, param.ColorRight_Easing, param.ColorRight_FCurve);
OutputStandardColor(data, param.ColorRightMiddle, param.ColorRightMiddle_Fixed, param.ColorRightMiddle_Random, param.ColorRightMiddle_Easing, param.ColorRightMiddle_FCurve);
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.ScaleValues value, Data.ParentEffectType parentEffectType, ExporterVersion version)
{
float magnification = 1.0f;
List <byte[]> data = new List <byte[]>();
data.Add(value.Type.GetValueAsInt().GetBytes());
if (value.Type.GetValue() == Data.ScaleValues.ParamaterType.Fixed)
{
var refBuf = value.Fixed.Scale.DynamicEquation.Index.GetBytes();
var mainBuf = Scaling_Fixed_Values.Create(value.Fixed, magnification).GetBytes();
data.Add((mainBuf.Count() + refBuf.Count()).GetBytes());
data.Add(refBuf);
data.Add(mainBuf);
}
else if (value.Type.GetValue() == Data.ScaleValues.ParamaterType.PVA)
{
var refBuf1_1 = value.PVA.Scale.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = value.PVA.Scale.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = value.PVA.Velocity.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = value.PVA.Velocity.DynamicEquationMin.Index.GetBytes();
var refBuf3_1 = value.PVA.Acceleration.DynamicEquationMax.Index.GetBytes();
var refBuf3_2 = value.PVA.Acceleration.DynamicEquationMin.Index.GetBytes();
var mainBuf = Scaling_PVA_Values.Create(value.PVA, magnification).GetBytes();
data.Add((mainBuf.Count() + refBuf1_1.Count() * 6).GetBytes());
data.Add(refBuf1_1);
data.Add(refBuf1_2);
data.Add(refBuf2_1);
data.Add(refBuf2_2);
data.Add(refBuf3_1);
data.Add(refBuf3_2);
data.Add(mainBuf);
}
else if (value.Type.GetValue() == Data.ScaleValues.ParamaterType.Easing)
{
Utils.ExportEasing(value.Easing, magnification, data, version);
}
else if (value.Type.GetValue() == Data.ScaleValues.ParamaterType.SinglePVA)
{
var bytes = Scaling_SinglePVA_Values.Create(value.SinglePVA, magnification).GetBytes();
data.Add(bytes.Count().GetBytes());
data.Add(bytes);
}
else if (value.Type.GetValue() == Data.ScaleValues.ParamaterType.SingleEasing)
{
var easing = Utl.MathUtl.Easing(
(float)value.SingleEasing.StartSpeed.Value,
(float)value.SingleEasing.EndSpeed.Value);
List <byte[]> _data = new List <byte[]>();
_data.Add(value.SingleEasing.Start.Max.GetBytes());
_data.Add(value.SingleEasing.Start.Min.GetBytes());
_data.Add(value.SingleEasing.End.Max.GetBytes());
_data.Add(value.SingleEasing.End.Min.GetBytes());
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data.Count().GetBytes());
data.Add(__data);
}
else if (value.Type.GetValue() == Data.ScaleValues.ParamaterType.FCurve)
{
var bytes = value.FCurve.FCurve.GetBytes();
data.Add(bytes.Count().GetBytes());
data.Add(bytes);
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.RendererValues value, SortedDictionary <string, int> texture_and_index, SortedDictionary <string, int> normalTexture_and_index, SortedDictionary <string, int> model_and_index, Dictionary <Data.ProceduralModelParameter, int> pmodel_and_index, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
// Fallback
if (version < ExporterVersion.Ver16Alpha2)
{
if (value != null && value.Type.Value == Data.RendererValues.ParamaterType.Model && value.Model.ModelReference.Value == Data.ModelReferenceType.ProceduralModel)
{
value = null;
}
}
if (value != null)
{
data.Add(value.Type.GetValueAsInt().GetBytes());
switch (value.Type.Value)
{
case Data.RendererValues.ParamaterType.None:
break;
case Data.RendererValues.ParamaterType.Sprite:
AddSpriteData(value, data);
break;
case Data.RendererValues.ParamaterType.Ribbon:
AddRibbonData(value, data);
break;
case Data.RendererValues.ParamaterType.Ring:
AddRingData(value, data, version);
break;
case Data.RendererValues.ParamaterType.Model:
AddModelData(value, model_and_index, pmodel_and_index, version, data);
break;
case Data.RendererValues.ParamaterType.Track:
AddTrackData(value, data);
break;
}
}
else
{
data.Add(((int)Data.RendererValues.ParamaterType.None).GetBytes());
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.LocationValues value, Data.ParentEffectType parentEffectType, Dictionary <string, int> curveAndIndex, ExporterVersion version)
{
//if (parentEffectType != Data.ParentEffectType.NotBind) magnification = 1.0f;
var type = value.Type.Value;
// Fall back
if (version < ExporterVersion.Ver1600)
{
if (type == Data.LocationValues.ParamaterType.NurbsCurve ||
type == Data.LocationValues.ParamaterType.ViewOffset)
{
type = Data.LocationValues.ParamaterType.Fixed;
}
}
List <byte[]> data = new List <byte[]>();
data.Add(((int)type).GetBytes());
if (type == Data.LocationValues.ParamaterType.Fixed)
{
var refBuf = value.Fixed.Location.DynamicEquation.Index.GetBytes();
var mainBuf = Translation_Fixed_Values.Create(value.Fixed, 1.0f).GetBytes();
data.Add((mainBuf.Count() + refBuf.Count()).GetBytes());
data.Add(refBuf);
data.Add(mainBuf);
}
else if (type == Data.LocationValues.ParamaterType.PVA)
{
var refBuf1_1 = value.PVA.Location.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = value.PVA.Location.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = value.PVA.Velocity.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = value.PVA.Velocity.DynamicEquationMin.Index.GetBytes();
var refBuf3_1 = value.PVA.Acceleration.DynamicEquationMax.Index.GetBytes();
var refBuf3_2 = value.PVA.Acceleration.DynamicEquationMin.Index.GetBytes();
var mainBuf = Translation_PVA_Values.Create(value.PVA, 1.0f).GetBytes();
data.Add((mainBuf.Count() + refBuf1_1.Count() * 6).GetBytes());
data.Add(refBuf1_1);
data.Add(refBuf1_2);
data.Add(refBuf2_1);
data.Add(refBuf2_2);
data.Add(refBuf3_1);
data.Add(refBuf3_2);
data.Add(mainBuf);
}
else if (type == Data.LocationValues.ParamaterType.Easing)
{
var easing = Utl.MathUtl.Easing((float)value.Easing.StartSpeed.Value, (float)value.Easing.EndSpeed.Value);
var refBuf1_1 = value.Easing.Start.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = value.Easing.Start.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = value.Easing.End.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = value.Easing.End.DynamicEquationMin.Index.GetBytes();
List <byte[]> _data = new List <byte[]>();
_data.Add(refBuf1_1);
_data.Add(refBuf1_2);
_data.Add(refBuf2_1);
_data.Add(refBuf2_2);
_data.Add(value.Easing.Start.GetBytes(1.0f));
_data.Add(value.Easing.End.GetBytes(1.0f));
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data.Count().GetBytes());
data.Add(__data);
}
else if (type == Data.LocationValues.ParamaterType.LocationFCurve)
{
var bytes1 = value.LocationFCurve.FCurve.GetBytes();
List <byte[]> _data = new List <byte[]>();
data.Add(bytes1.Count().GetBytes());
data.Add(bytes1);
}
else if (type == Data.LocationValues.ParamaterType.NurbsCurve)
{
if (value.NurbsCurve.FilePath.RelativePath != string.Empty)
{
// export index
var relative_path = value.NurbsCurve.FilePath.RelativePath;
data.Add(curveAndIndex[relative_path].GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
data.Add(BitConverter.GetBytes(value.NurbsCurve.Scale));
data.Add(BitConverter.GetBytes(value.NurbsCurve.MoveSpeed));
data.Add(value.NurbsCurve.LoopType.GetValueAsInt().GetBytes());
}
else if (type == Data.LocationValues.ParamaterType.ViewOffset)
{
data.Add(value.ViewOffset.Distance.Max.GetBytes());
data.Add(value.ViewOffset.Distance.Min.GetBytes());
}
return(data.ToArray().ToArray());
}
/// <summary>
/// Export effect data
/// </summary>
/// <returns></returns>
public byte[] Export(Data.NodeRoot rootNode, float magnification = 1.0f, ExporterVersion exporterVersion = ExporterVersion.Latest)
{
List <byte[]> data = new List <byte[]>();
// ヘッダ
data.Add(Encoding.UTF8.GetBytes("SKFE"));
// Version
data.Add(BitConverter.GetBytes((int)exporterVersion));
// reset texture names
UsedTextures = new HashSet <string>();
UsedNormalTextures = new HashSet <string>();
UsedDistortionTextures = new HashSet <string>();
Sounds = new HashSet <string>();
Models = new HashSet <string>();
Materials = new HashSet <string>();
Curves = new HashSet <string>();
Action <Data.NodeBase> get_textures = null;
get_textures = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node))
{
if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.Default)
{
var relative_path = _node.RendererCommonValues.ColorTexture.RelativePath;
if (relative_path != string.Empty)
{
if (!UsedTextures.Contains(relative_path))
{
UsedTextures.Add(relative_path);
}
}
if (exporterVersion >= ExporterVersion.Ver1600)
{
var alpha_relative_path = _node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.EnableAlphaTexture && alpha_relative_path != string.Empty)
{
if (!UsedTextures.Contains(alpha_relative_path))
{
UsedTextures.Add(alpha_relative_path);
}
}
var uvDistortion_relative_path = _node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.EnableUVDistortionTexture && uvDistortion_relative_path != string.Empty)
{
if (!UsedTextures.Contains(uvDistortion_relative_path))
{
UsedTextures.Add(uvDistortion_relative_path);
}
}
var blend_relative_path = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.EnableBlendTexture && blend_relative_path != string.Empty)
{
if (!UsedTextures.Contains(blend_relative_path))
{
UsedTextures.Add(blend_relative_path);
}
var blend_alpha_relative_path = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendAlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.BlendTextureParams.EnableBlendAlphaTexture &&
blend_alpha_relative_path != string.Empty)
{
if (!UsedTextures.Contains(blend_alpha_relative_path))
{
UsedTextures.Add(blend_alpha_relative_path);
}
}
var blend_uv_distortion_relative_path = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendUVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.BlendTextureParams.EnableBlendUVDistortionTexture &&
blend_uv_distortion_relative_path != string.Empty)
{
if (!UsedTextures.Contains(blend_uv_distortion_relative_path))
{
UsedTextures.Add(blend_uv_distortion_relative_path);
}
}
}
}
}
if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.BackDistortion)
{
var relative_path = _node.RendererCommonValues.ColorTexture.RelativePath;
if (relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(relative_path))
{
UsedDistortionTextures.Add(relative_path);
}
}
if (exporterVersion >= ExporterVersion.Ver1600)
{
var alpha_relative_path = _node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.EnableAlphaTexture && alpha_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(alpha_relative_path))
{
UsedDistortionTextures.Add(alpha_relative_path);
}
}
var uvDistortion_relative_path = _node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.EnableUVDistortionTexture && uvDistortion_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(uvDistortion_relative_path))
{
UsedDistortionTextures.Add(uvDistortion_relative_path);
}
}
var blend_relative_path = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.EnableBlendTexture && blend_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(blend_relative_path))
{
UsedDistortionTextures.Add(blend_relative_path);
}
var blend_alpha_relative_path = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendAlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.BlendTextureParams.EnableBlendAlphaTexture &&
blend_alpha_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(blend_alpha_relative_path))
{
UsedDistortionTextures.Add(blend_alpha_relative_path);
}
}
var blend_uv_distortion_relative_path = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendUVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.BlendTextureParams.EnableBlendUVDistortionTexture &&
blend_uv_distortion_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(blend_uv_distortion_relative_path))
{
UsedDistortionTextures.Add(blend_uv_distortion_relative_path);
}
}
}
}
}
if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.Lighting)
{
var path1 = _node.RendererCommonValues.ColorTexture.RelativePath;
if (path1 != string.Empty)
{
if (!UsedTextures.Contains(path1))
{
UsedTextures.Add(path1);
}
}
var path2 = _node.RendererCommonValues.NormalTexture.RelativePath;
if (path2 != string.Empty)
{
if (!UsedNormalTextures.Contains(path2))
{
UsedNormalTextures.Add(path2);
}
}
if (exporterVersion >= ExporterVersion.Ver1600)
{
// alpha texture
var path3 = _node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.EnableAlphaTexture && path3 != string.Empty)
{
if (!UsedTextures.Contains(path3))
{
UsedTextures.Add(path3);
}
}
// uv distortion texture
var path4 = _node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.EnableUVDistortionTexture && path4 != string.Empty)
{
if (!UsedTextures.Contains(path4))
{
UsedTextures.Add(path4);
}
}
// blend texture
var path5 = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.EnableBlendTexture && path5 != string.Empty)
{
if (!UsedTextures.Contains(path5))
{
UsedTextures.Add(path5);
}
var path6 = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendAlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.BlendTextureParams.EnableBlendAlphaTexture &&
path6 != string.Empty)
{
if (!UsedTextures.Contains(path6))
{
UsedTextures.Add(path6);
}
}
var path7 = _node.AdvancedRendererCommonValues2Values.BlendTextureParams.BlendUVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValues2Values.BlendTextureParams.EnableBlendUVDistortionTexture &&
path7 != string.Empty)
{
if (!UsedTextures.Contains(path7))
{
UsedTextures.Add(path7);
}
}
}
}
}
else if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.File)
{
var materialInfo = Core.ResourceCache.LoadMaterialInformation(_node.RendererCommonValues.MaterialFile.Path.AbsolutePath);
if (materialInfo == null)
{
materialInfo = new MaterialInformation();
}
var textures = _node.RendererCommonValues.MaterialFile.GetTextures(materialInfo).Where(_ => _.Item1 != null);
foreach (var texture in textures)
{
var relative_path = (texture.Item1.Value as Data.Value.PathForImage).RelativePath;
if (relative_path != string.Empty)
{
if (texture.Item2.Type == TextureType.Value)
{
if (!UsedNormalTextures.Contains(relative_path))
{
UsedNormalTextures.Add(relative_path);
}
}
else
{
if (!UsedTextures.Contains(relative_path))
{
UsedTextures.Add(relative_path);
}
}
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_textures(node.Children[i]);
}
};
get_textures(rootNode);
Dictionary <string, int> texture_and_index = new Dictionary <string, int>();
{
int index = 0;
foreach (var texture in UsedTextures.ToList().OrderBy(_ => _))
{
texture_and_index.Add(texture, index);
index++;
}
}
Dictionary <string, int> normalTexture_and_index = new Dictionary <string, int>();
{
int index = 0;
foreach (var texture in UsedNormalTextures.ToList().OrderBy(_ => _))
{
normalTexture_and_index.Add(texture, index);
index++;
}
}
Dictionary <string, int> distortionTexture_and_index = new Dictionary <string, int>();
{
int index = 0;
foreach (var texture in UsedDistortionTextures.ToList().OrderBy(_ => _))
{
distortionTexture_and_index.Add(texture, index);
index++;
}
}
Action <Data.NodeBase> get_waves = null;
get_waves = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node))
{
if (_node.SoundValues.Type.GetValue() == Data.SoundValues.ParamaterType.None)
{
}
else if (_node.SoundValues.Type.GetValue() == Data.SoundValues.ParamaterType.Use)
{
var relative_path = _node.SoundValues.Sound.Wave.RelativePath;
if (relative_path != string.Empty)
{
if (!Sounds.Contains(relative_path))
{
Sounds.Add(relative_path);
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_waves(node.Children[i]);
}
};
get_waves(rootNode);
Dictionary <string, int> wave_and_index = new Dictionary <string, int>();
{
int index = 0;
foreach (var wave in Sounds.ToList().OrderBy(_ => _))
{
wave_and_index.Add(wave, index);
index++;
}
}
Action <Data.NodeBase> get_models = null;
get_models = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node) && _node.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Model)
{
var relative_path = _node.DrawingValues.Model.Model.RelativePath;
if (!string.IsNullOrEmpty(relative_path))
{
if (string.IsNullOrEmpty(System.IO.Path.GetDirectoryName(relative_path)))
{
relative_path = System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkmodel";
}
else
{
relative_path = System.IO.Path.ChangeExtension(relative_path, ".efkmodel");
}
if (relative_path != string.Empty)
{
if (!Models.Contains(relative_path))
{
Models.Add(relative_path);
}
}
}
}
if (_node.GenerationLocationValues.Type.Value == Data.GenerationLocationValues.ParameterType.Model)
{
var relative_path = _node.GenerationLocationValues.Model.Model.RelativePath;
if (!string.IsNullOrEmpty(relative_path))
{
if (string.IsNullOrEmpty(System.IO.Path.GetDirectoryName(relative_path)))
{
relative_path = System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkmodel";
}
else
{
relative_path = System.IO.Path.ChangeExtension(relative_path, ".efkmodel");
}
if (relative_path != string.Empty)
{
if (!Models.Contains(relative_path))
{
Models.Add(relative_path);
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_models(node.Children[i]);
}
};
get_models(rootNode);
Dictionary <string, int> model_and_index = new Dictionary <string, int>();
{
int index = 0;
foreach (var model in Models.ToList().OrderBy(_ => _))
{
model_and_index.Add(model, index);
index++;
}
}
Action <Data.NodeBase> get_materials = null;
get_materials = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node) && _node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.File)
{
var relative_path = _node.RendererCommonValues.MaterialFile.Path.RelativePath;
if (relative_path != string.Empty)
{
if (!Materials.Contains(relative_path))
{
Materials.Add(relative_path);
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_materials(node.Children[i]);
}
};
get_materials(rootNode);
Dictionary <string, int> material_and_index = new Dictionary <string, int>();
{
int index = 0;
foreach (var wave in Materials.ToList().OrderBy(_ => _))
{
material_and_index.Add(wave, index);
index++;
}
}
Dictionary <string, int> curve_and_index = new Dictionary <string, int>();
Action <Data.NodeBase> get_curves = null;
get_curves = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (_node.LocationValues.Type == Data.LocationValues.ParamaterType.NurbsCurve)
{
var relative_path = _node.LocationValues.NurbsCurve.FilePath.RelativePath;
if (relative_path != string.Empty)
{
if (!Curves.Contains(relative_path))
{
if (relative_path != System.IO.Path.GetFileName(_node.LocationValues.NurbsCurve.FilePath.RelativePath))
{
relative_path = System.IO.Path.GetDirectoryName(relative_path) + "/" + System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkcurve";
}
else
{
relative_path = System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkcurve";
}
if (relative_path != string.Empty)
{
if (!Curves.Contains(relative_path))
{
Curves.Add(relative_path);
}
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_curves(node.Children[i]);
}
};
get_curves(Core.Root);
if (exporterVersion >= ExporterVersion.Ver1600)
{
int index = 0;
foreach (var curve in Curves.ToList().OrderBy(_ => _))
{
curve_and_index.Add(curve, index);
index++;
}
}
// get all nodes
var nodes = new List <Data.Node>();
Action <Data.NodeBase> get_nodes = null;
get_nodes = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
nodes.Add(_node);
}
var children = node.Children.Internal.Where(_ => IsRenderedNodeGroup(_)).ToList();
for (int i = 0; i < children.Count; i++)
{
get_nodes(children[i]);
}
};
get_nodes(rootNode);
var snode2ind = nodes.
Select((v, i) => Tuple35.Create(v, i)).
OrderBy(_ => _.Item1.DepthValues.DrawingPriority.Value * 255 + _.Item2).
Select((v, i) => Tuple35.Create(v.Item1, i)).ToList();
// ファイルにテクスチャ一覧出力
data.Add(BitConverter.GetBytes(texture_and_index.Count));
foreach (var texture in texture_and_index)
{
var path = Encoding.Unicode.GetBytes(texture.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
data.Add(BitConverter.GetBytes(normalTexture_and_index.Count));
foreach (var texture in normalTexture_and_index)
{
var path = Encoding.Unicode.GetBytes(texture.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
data.Add(BitConverter.GetBytes(distortionTexture_and_index.Count));
foreach (var texture in distortionTexture_and_index)
{
var path = Encoding.Unicode.GetBytes(texture.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// ファイルにウェーブ一覧出力
data.Add(BitConverter.GetBytes(wave_and_index.Count));
foreach (var wave in wave_and_index)
{
var path = Encoding.Unicode.GetBytes(wave.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// ファイルにモデル一覧出力
data.Add(BitConverter.GetBytes(model_and_index.Count));
foreach (var model in model_and_index)
{
var path = Encoding.Unicode.GetBytes(model.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// export materials to a file
data.Add(BitConverter.GetBytes(material_and_index.Count));
foreach (var material in material_and_index)
{
var path = Encoding.Unicode.GetBytes(material.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// export dynamic parameters
data.Add(BitConverter.GetBytes(Core.Dynamic.Inputs.Values.Count));
foreach (var value in Core.Dynamic.Inputs.Values)
{
float value_ = value.Input.Value;
data.Add(BitConverter.GetBytes(value_));
}
data.Add(BitConverter.GetBytes(Core.Dynamic.Equations.Values.Count));
if (exporterVersion >= ExporterVersion.Ver1600)
{
// export curves to a file
data.Add(BitConverter.GetBytes(curve_and_index.Count));
foreach (var curve in curve_and_index)
{
var path = Encoding.Unicode.GetBytes(curve.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
}
var compiler = new InternalScript.Compiler();
foreach (var value in Core.Dynamic.Equations.Values)
{
var cx = compiler.Compile(value.Code.Value);
var cs = new [] { cx };
foreach (var c in cs)
{
if (c.Bytecode != null)
{
data.Add(BitConverter.GetBytes((int)c.Bytecode.Length));
data.Add(c.Bytecode);
}
else
{
data.Add(BitConverter.GetBytes((int)0));
}
}
}
// Export the number of nodes
data.Add(BitConverter.GetBytes(snode2ind.Count));
var renderPriorityThreshold = snode2ind.Where(_ => _.Item1.DepthValues.DrawingPriority.Value < 0).Count();
data.Add(BitConverter.GetBytes(renderPriorityThreshold));
// Export magnification
data.Add(BitConverter.GetBytes(magnification));
// Export default seed
int randomSeed = Core.Global.RandomSeed.Value;
data.Add(BitConverter.GetBytes(randomSeed));
// カリングを出力
data.Add(BitConverter.GetBytes((int)Core.Culling.Type.Value));
if (Core.Culling.Type.Value == Data.EffectCullingValues.ParamaterType.Sphere)
{
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Radius));
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Location.X));
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Location.Y));
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Location.Z));
}
// ノード情報出力
Action <Data.NodeRoot> outout_rootnode = null;
Action <Data.Node> outout_node = null;
outout_rootnode = (n) =>
{
data.Add(((int)NodeType.Root).GetBytes());
var children = n.Children.Internal.Where(_ => IsRenderedNodeGroup(_)).ToList();
data.Add(children.Count.GetBytes());
for (int i = 0; i < children.Count; i++)
{
outout_node(children[i]);
}
};
outout_node = (n) =>
{
List <byte[]> node_data = new List <byte[]>();
var isRenderParamExported = n.IsRendered.GetValue();
for (int i = 0; i < n.Children.Count; i++)
{
var nc = n.Children[i];
var v = nc.RendererCommonValues.ColorInheritType.GetValue();
if (v == Data.ParentEffectType.Already || v == Data.ParentEffectType.WhenCreating)
{
isRenderParamExported = true;
break;
}
}
if (!isRenderParamExported)
{
data.Add(((int)NodeType.None).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.None)
{
data.Add(((int)NodeType.None).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Sprite)
{
data.Add(((int)NodeType.Sprite).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Ribbon)
{
data.Add(((int)NodeType.Ribbon).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Ring)
{
data.Add(((int)NodeType.Ring).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Model)
{
data.Add(((int)NodeType.Model).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Track)
{
data.Add(((int)NodeType.Track).GetBytes());
}
else
{
throw new Exception();
}
// Whether to draw the node.
if (n.IsRendered)
{
int v = 1;
node_data.Add(BitConverter.GetBytes(v));
}
else
{
int v = 0;
node_data.Add(BitConverter.GetBytes(v));
}
// render order
{
var s = snode2ind.FirstOrDefault(_ => _.Item1 == n);
if (s.Item1 != null)
{
node_data.Add(BitConverter.GetBytes(s.Item2));
}
else
{
node_data.Add(BitConverter.GetBytes(-1));
}
}
node_data.Add(CommonValues.GetBytes(n.CommonValues));
node_data.Add(LocationValues.GetBytes(n.LocationValues, n.CommonValues.ScaleEffectType, curve_and_index, exporterVersion));
node_data.Add(LocationAbsValues.GetBytes(n.LocationAbsValues, n.CommonValues.ScaleEffectType, exporterVersion));
node_data.Add(RotationValues.GetBytes(n.RotationValues, exporterVersion));
node_data.Add(ScaleValues.GetBytes(n.ScalingValues, n.CommonValues.ScaleEffectType, exporterVersion));
node_data.Add(GenerationLocationValues.GetBytes(n.GenerationLocationValues, n.CommonValues.ScaleEffectType, model_and_index));
// Export depth
node_data.Add(n.DepthValues.DepthOffset.Value.GetBytes());
node_data.Add(BitConverter.GetBytes(n.DepthValues.IsScaleChangedDependingOnDepthOffset.Value ? 1 : 0));
node_data.Add(BitConverter.GetBytes(n.DepthValues.IsDepthOffsetChangedDependingOnParticleScale.Value ? 1 : 0));
node_data.Add(((float)n.DepthValues.SuppressionOfScalingByDepth.Value).GetBytes());
if (n.DepthValues.DepthClipping.Infinite)
{
node_data.Add((float.MaxValue).GetBytes());
}
else
{
node_data.Add(((float)n.DepthValues.DepthClipping.Value.Value).GetBytes());
}
node_data.Add(((int)n.DepthValues.ZSort.Value).GetBytes());
node_data.Add(n.DepthValues.DrawingPriority.Value.GetBytes());
node_data.Add(n.DepthValues.SoftParticle.Value.GetBytes());
node_data.Add(RendererCommonValues.GetBytes(n.RendererCommonValues, n.AdvancedRendererCommonValuesValues, n.AdvancedRendererCommonValues2Values, texture_and_index, normalTexture_and_index, distortionTexture_and_index, material_and_index, exporterVersion));
if (isRenderParamExported)
{
node_data.Add(RendererValues.GetBytes(n.DrawingValues, texture_and_index, normalTexture_and_index, model_and_index, exporterVersion));
}
else
{
node_data.Add(RendererValues.GetBytes(null, texture_and_index, normalTexture_and_index, model_and_index, exporterVersion));
}
data.Add(node_data.ToArray().ToArray());
data.Add(SoundValues.GetBytes(n.SoundValues, wave_and_index));
var children = n.Children.Internal.Where(_ => IsRenderedNodeGroup(_)).ToList();
data.Add(children.Count.GetBytes());
for (int i = 0; i < children.Count; i++)
{
outout_node(children[i]);
}
};
outout_rootnode(rootNode);
return(data.ToArray().ToArray());
}
public static void OutputStandardColor(List <byte[]> data, StandardColor color, ExporterVersion version, ExporterVersion fcurveVersion, ExporterVersion gradientVersion)
{
OutputStandardColor(
data,
color.Type,
color.Fixed,
color.Random,
color.Easing,
version >= fcurveVersion ? color.FCurve : null,
version >= gradientVersion ? color.Gradient : null);
}
public static byte[] GetBytes(Data.RotationValues value, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
data.Add(value.Type.GetValueAsInt().GetBytes());
if (value.Type.GetValue() == Data.RotationValues.ParamaterType.Fixed)
{
var refBuf = value.Fixed.Rotation.DynamicEquation.Index.GetBytes();
var mainBuf = Rotation_Fixed_Values.Create(value.Fixed).GetBytes();
data.Add((mainBuf.Count() + refBuf.Count()).GetBytes());
data.Add(refBuf);
data.Add(mainBuf);
}
else if (value.Type.GetValue() == Data.RotationValues.ParamaterType.PVA)
{
var refBuf1_1 = value.PVA.Rotation.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = value.PVA.Rotation.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = value.PVA.Velocity.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = value.PVA.Velocity.DynamicEquationMin.Index.GetBytes();
var refBuf3_1 = value.PVA.Acceleration.DynamicEquationMax.Index.GetBytes();
var refBuf3_2 = value.PVA.Acceleration.DynamicEquationMin.Index.GetBytes();
List <byte[]> _data = new List <byte[]>();
_data.Add(value.PVA.Rotation.GetBytes((float)Math.PI / 180.0f));
_data.Add(value.PVA.Velocity.GetBytes((float)Math.PI / 180.0f));
_data.Add(value.PVA.Acceleration.GetBytes((float)Math.PI / 180.0f));
var mainBuf = _data.ToArray().ToArray();
data.Add((mainBuf.Count() + refBuf1_1.Count() * 6).GetBytes());
data.Add(refBuf1_1);
data.Add(refBuf1_2);
data.Add(refBuf2_1);
data.Add(refBuf2_2);
data.Add(refBuf3_1);
data.Add(refBuf3_2);
data.Add(mainBuf);
}
else if (value.Type.GetValue() == Data.RotationValues.ParamaterType.Easing)
{
Utils.ExportEasing(value.Easing, 1.0f, data, version);
}
else if (value.Type.GetValue() == Data.RotationValues.ParamaterType.AxisPVA)
{
List <byte[]> _data = new List <byte[]>();
_data.Add(value.AxisPVA.Axis.GetBytes());
_data.Add(BitConverter.GetBytes(value.AxisPVA.Rotation.Max * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisPVA.Rotation.Min * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisPVA.Velocity.Max * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisPVA.Velocity.Min * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisPVA.Acceleration.Max * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisPVA.Acceleration.Min * (float)Math.PI / 180.0f));
var __data = _data.ToArray().ToArray();
data.Add(__data.Count().GetBytes());
data.Add(__data);
}
else if (value.Type.GetValue() == Data.RotationValues.ParamaterType.AxisEasing)
{
var easing = Utl.MathUtl.Easing((float)value.AxisEasing.Easing.StartSpeed.Value, (float)value.AxisEasing.Easing.EndSpeed.Value);
List <byte[]> _data = new List <byte[]>();
_data.Add(value.AxisEasing.Axis.GetBytes());
_data.Add(BitConverter.GetBytes(value.AxisEasing.Easing.Start.Max * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisEasing.Easing.Start.Min * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisEasing.Easing.End.Max * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(value.AxisEasing.Easing.End.Min * (float)Math.PI / 180.0f));
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data.Count().GetBytes());
data.Add(__data);
}
else if (value.Type.GetValue() == Data.RotationValues.ParamaterType.RotationFCurve)
{
var bytes = value.RotationFCurve.FCurve.GetBytes(
(float)Math.PI / 180.0f);
List <byte[]> _data = new List <byte[]>();
data.Add(bytes.Count().GetBytes());
data.Add(bytes);
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.RendererValues value, SortedDictionary <string, int> texture_and_index, SortedDictionary <string, int> normalTexture_and_index, SortedDictionary <string, int> model_and_index, Dictionary <Data.ProceduralModelParameter, int> pmodel_and_index, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
// Fallback
if (version < ExporterVersion.Ver16Alpha2)
{
if (value != null && value.Type.Value == Data.RendererValues.ParamaterType.Model && value.Model.ModelReference.Value == Data.ModelReferenceType.ProceduralModel)
{
var param = value.Model;
data.Add(value.Type.GetValueAsInt().GetBytes());
data.Add(BitConverter.GetBytes(1.0f));
data.Add(BitConverter.GetBytes(-1));
data.Add(param.Billboard);
data.Add(((int)param.Culling.Value).GetBytes());
OutputStandardColor(data, param.Color, param.Color_Fixed, param.Color_Random, param.Color_Easing,
param.Color_FCurve);
return(data.ToArray().ToArray());
}
}
if (value != null)
{
data.Add(value.Type.GetValueAsInt().GetBytes());
switch (value.Type.Value)
{
case Data.RendererValues.ParamaterType.None:
break;
case Data.RendererValues.ParamaterType.Sprite:
AddSpriteData(value, data);
break;
case Data.RendererValues.ParamaterType.Ribbon:
AddRibbonData(value, data);
break;
case Data.RendererValues.ParamaterType.Ring:
AddRingData(value, data, version);
break;
case Data.RendererValues.ParamaterType.Model:
AddModelData(value, model_and_index, pmodel_and_index, version, data);
break;
case Data.RendererValues.ParamaterType.Track:
AddTrackData(value, data);
break;
}
}
else
{
data.Add(((int)Data.RendererValues.ParamaterType.None).GetBytes());
}
return(data.ToArray().ToArray());
}
/// <summary>
/// Export effect data
/// </summary>
/// <returns></returns>
public byte[] Export(Data.NodeRoot rootNode, float magnification = 1.0f, ExporterVersion exporterVersion = ExporterVersion.Latest)
{
List <byte[]> data = new List <byte[]>();
// ヘッダ
data.Add(Encoding.UTF8.GetBytes("SKFE"));
// Version
data.Add(BitConverter.GetBytes((int)exporterVersion));
// reset texture names
UsedTextures = new HashSet <string>();
UsedNormalTextures = new HashSet <string>();
UsedDistortionTextures = new HashSet <string>();
Sounds = new HashSet <string>();
Models = new HashSet <string>();
Materials = new HashSet <string>();
Curves = new HashSet <string>();
ProceduralModels = new List <ProceduralModelParameter>();
Action <Data.NodeBase> get_textures = null;
get_textures = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node))
{
if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.Default)
{
var relative_path = _node.RendererCommonValues.ColorTexture.RelativePath;
if (relative_path != string.Empty)
{
if (!UsedTextures.Contains(relative_path))
{
UsedTextures.Add(relative_path);
}
}
if (exporterVersion >= ExporterVersion.Ver16Alpha1)
{
var alpha_relative_path = _node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Enabled && alpha_relative_path != string.Empty)
{
if (!UsedTextures.Contains(alpha_relative_path))
{
UsedTextures.Add(alpha_relative_path);
}
}
var uvDistortion_relative_path = _node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Enabled && uvDistortion_relative_path != string.Empty)
{
if (!UsedTextures.Contains(uvDistortion_relative_path))
{
UsedTextures.Add(uvDistortion_relative_path);
}
}
var blend_relative_path = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.Enabled && blend_relative_path != string.Empty)
{
if (!UsedTextures.Contains(blend_relative_path))
{
UsedTextures.Add(blend_relative_path);
}
var blend_alpha_relative_path = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendAlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.EnableBlendAlphaTexture &&
blend_alpha_relative_path != string.Empty)
{
if (!UsedTextures.Contains(blend_alpha_relative_path))
{
UsedTextures.Add(blend_alpha_relative_path);
}
}
var blend_uv_distortion_relative_path = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendUVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.EnableBlendUVDistortionTexture &&
blend_uv_distortion_relative_path != string.Empty)
{
if (!UsedTextures.Contains(blend_uv_distortion_relative_path))
{
UsedTextures.Add(blend_uv_distortion_relative_path);
}
}
}
}
}
if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.BackDistortion)
{
var relative_path = _node.RendererCommonValues.ColorTexture.RelativePath;
if (relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(relative_path))
{
UsedDistortionTextures.Add(relative_path);
}
}
if (exporterVersion >= ExporterVersion.Ver16Alpha1)
{
var alpha_relative_path = _node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Enabled && alpha_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(alpha_relative_path))
{
UsedDistortionTextures.Add(alpha_relative_path);
}
}
var uvDistortion_relative_path = _node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Enabled && uvDistortion_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(uvDistortion_relative_path))
{
UsedDistortionTextures.Add(uvDistortion_relative_path);
}
}
var blend_relative_path = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.Enabled && blend_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(blend_relative_path))
{
UsedDistortionTextures.Add(blend_relative_path);
}
var blend_alpha_relative_path = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendAlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.EnableBlendAlphaTexture &&
blend_alpha_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(blend_alpha_relative_path))
{
UsedDistortionTextures.Add(blend_alpha_relative_path);
}
}
var blend_uv_distortion_relative_path = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendUVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.EnableBlendUVDistortionTexture &&
blend_uv_distortion_relative_path != string.Empty)
{
if (!UsedDistortionTextures.Contains(blend_uv_distortion_relative_path))
{
UsedDistortionTextures.Add(blend_uv_distortion_relative_path);
}
}
}
}
}
if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.Lighting)
{
var path1 = _node.RendererCommonValues.ColorTexture.RelativePath;
if (path1 != string.Empty)
{
if (!UsedTextures.Contains(path1))
{
UsedTextures.Add(path1);
}
}
var path2 = _node.RendererCommonValues.NormalTexture.RelativePath;
if (path2 != string.Empty)
{
if (!UsedNormalTextures.Contains(path2))
{
UsedNormalTextures.Add(path2);
}
}
if (exporterVersion >= ExporterVersion.Ver16Alpha1)
{
// alpha texture
var path3 = _node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.AlphaTextureParam.Enabled && path3 != string.Empty)
{
if (!UsedTextures.Contains(path3))
{
UsedTextures.Add(path3);
}
}
// uv distortion texture
var path4 = _node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.UVDistortionTextureParam.Enabled && path4 != string.Empty)
{
if (!UsedTextures.Contains(path4))
{
UsedTextures.Add(path4);
}
}
// blend texture
var path5 = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.Enabled && path5 != string.Empty)
{
if (!UsedTextures.Contains(path5))
{
UsedTextures.Add(path5);
}
var path6 = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendAlphaTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.EnableBlendAlphaTexture &&
path6 != string.Empty)
{
if (!UsedTextures.Contains(path6))
{
UsedTextures.Add(path6);
}
}
var path7 = _node.AdvancedRendererCommonValuesValues.BlendTextureParams.BlendUVDistortionTextureParam.Texture.RelativePath;
if (_node.AdvancedRendererCommonValuesValues.BlendTextureParams.EnableBlendUVDistortionTexture &&
path7 != string.Empty)
{
if (!UsedTextures.Contains(path7))
{
UsedTextures.Add(path7);
}
}
}
}
}
else if (_node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.File)
{
var materialInfo = Core.ResourceCache.LoadMaterialInformation(_node.RendererCommonValues.MaterialFile.Path.AbsolutePath);
if (materialInfo == null)
{
materialInfo = new MaterialInformation();
}
var textures = _node.RendererCommonValues.MaterialFile.GetTextures(materialInfo).Where(_ => _.Item1 != null);
foreach (var texture in textures)
{
var relative_path = (texture.Item1.Value as Data.Value.PathForImage).RelativePath;
if (relative_path != string.Empty)
{
if (texture.Item2.Type == TextureType.Value)
{
if (!UsedNormalTextures.Contains(relative_path))
{
UsedNormalTextures.Add(relative_path);
}
}
else
{
if (!UsedTextures.Contains(relative_path))
{
UsedTextures.Add(relative_path);
}
}
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_textures(node.Children[i]);
}
};
get_textures(rootNode);
var texture_and_index = new SortedDictionary <string, int>();
{
int index = 0;
foreach (var texture in UsedTextures.ToList().OrderBy(_ => _))
{
texture_and_index.Add(texture, index);
index++;
}
}
var normalTexture_and_index = new SortedDictionary <string, int>();
{
int index = 0;
foreach (var texture in UsedNormalTextures.ToList().OrderBy(_ => _))
{
normalTexture_and_index.Add(texture, index);
index++;
}
}
var distortionTexture_and_index = new SortedDictionary <string, int>();
{
int index = 0;
foreach (var texture in UsedDistortionTextures.ToList().OrderBy(_ => _))
{
distortionTexture_and_index.Add(texture, index);
index++;
}
}
Action <Data.NodeBase> get_waves = null;
get_waves = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node))
{
if (_node.SoundValues.Type.GetValue() == Data.SoundValues.ParamaterType.None)
{
}
else if (_node.SoundValues.Type.GetValue() == Data.SoundValues.ParamaterType.Use)
{
var relative_path = _node.SoundValues.Sound.Wave.RelativePath;
if (relative_path != string.Empty)
{
if (!Sounds.Contains(relative_path))
{
Sounds.Add(relative_path);
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_waves(node.Children[i]);
}
};
get_waves(rootNode);
var wave_and_index = new SortedDictionary <string, int>();
{
int index = 0;
foreach (var wave in Sounds.ToList().OrderBy(_ => _))
{
wave_and_index.Add(wave, index);
index++;
}
}
Action <Data.NodeBase> get_models = null;
get_models = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node) && _node.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Model)
{
var relative_path = _node.DrawingValues.Model.Model.RelativePath;
if (!string.IsNullOrEmpty(relative_path))
{
relative_path = Utils.GetModelPath(_node.DrawingValues.Model.Model);
if (relative_path != string.Empty)
{
if (!Models.Contains(relative_path))
{
Models.Add(relative_path);
}
}
}
}
if (_node.GenerationLocationValues.Type.Value == Data.GenerationLocationValues.ParameterType.Model)
{
var relative_path = _node.GenerationLocationValues.Model.Model.RelativePath;
if (!string.IsNullOrEmpty(relative_path))
{
relative_path = Utils.GetModelPath(_node.GenerationLocationValues.Model.Model);
if (relative_path != string.Empty)
{
if (!Models.Contains(relative_path))
{
Models.Add(relative_path);
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_models(node.Children[i]);
}
};
get_models(rootNode);
var model_and_index = new SortedDictionary <string, int>();
{
int index = 0;
foreach (var model in Models.ToList().OrderBy(_ => _))
{
model_and_index.Add(model, index);
index++;
}
}
Action <Data.NodeBase> get_materials = null;
get_materials = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node) && _node.RendererCommonValues.Material.Value == Data.RendererCommonValues.MaterialType.File)
{
var relative_path = _node.RendererCommonValues.MaterialFile.Path.RelativePath;
if (relative_path != string.Empty)
{
if (!Materials.Contains(relative_path))
{
Materials.Add(relative_path);
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_materials(node.Children[i]);
}
};
get_materials(rootNode);
var material_and_index = new SortedDictionary <string, int>();
{
int index = 0;
foreach (var wave in Materials.ToList().OrderBy(_ => _))
{
material_and_index.Add(wave, index);
index++;
}
}
var curve_and_index = new SortedDictionary <string, int>();
Action <Data.NodeBase> get_curves = null;
get_curves = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (_node.LocationValues.Type == Data.LocationValues.ParamaterType.NurbsCurve)
{
var relative_path = _node.LocationValues.NurbsCurve.FilePath.RelativePath;
if (!string.IsNullOrEmpty(relative_path))
{
if (string.IsNullOrEmpty(System.IO.Path.GetDirectoryName(relative_path)))
{
relative_path = System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkcurve";
}
else
{
relative_path = System.IO.Path.ChangeExtension(relative_path, ".efkcurve");
}
if (relative_path != string.Empty)
{
if (!Curves.Contains(relative_path))
{
Curves.Add(relative_path);
}
}
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_curves(node.Children[i]);
}
};
get_curves(Core.Root);
if (exporterVersion >= ExporterVersion.Ver16Alpha1)
{
int index = 0;
foreach (var curve in Curves.ToList().OrderBy(_ => _))
{
curve_and_index.Add(curve, index);
index++;
}
}
// Procedural meshes
Action <Data.NodeBase> get_procedural_models = null;
get_procedural_models = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
if (IsRenderedNode(_node) && _node.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Model && _node.DrawingValues.Model.ModelReference.Value == ModelReferenceType.ProceduralModel)
{
var param = _node.DrawingValues.Model.Reference.Value;
if (param != null && !ProceduralModels.Contains(param))
{
ProceduralModels.Add(param);
}
}
if (_node.GenerationLocationValues.Type.Value == Data.GenerationLocationValues.ParameterType.Model && _node.GenerationLocationValues.Model.ModelReference.Value == ModelReferenceType.ProceduralModel)
{
var param = _node.GenerationLocationValues.Model.Reference.Value;
if (param != null && !ProceduralModels.Contains(param))
{
ProceduralModels.Add(param);
}
}
}
for (int i = 0; i < node.Children.Count; i++)
{
get_procedural_models(node.Children[i]);
}
};
get_procedural_models(rootNode);
var procedural_mesh_and_index = new Dictionary <ProceduralModelParameter, int>();
{
int index = 0;
foreach (var mesh in ProceduralModels)
{
procedural_mesh_and_index.Add(mesh, index);
index++;
}
}
// get all nodes
var nodes = new List <Data.Node>();
Action <Data.NodeBase> get_nodes = null;
get_nodes = (node) =>
{
if (node is Data.Node)
{
var _node = node as Data.Node;
nodes.Add(_node);
}
var children = node.Children.Internal.Where(_ => IsRenderedNodeGroup(_)).ToList();
for (int i = 0; i < children.Count; i++)
{
get_nodes(children[i]);
}
};
get_nodes(rootNode);
var snode2ind = nodes.
Select((v, i) => Tuple35.Create(v, i)).
OrderBy(_ => _.Item1.DepthValues.DrawingPriority.Value * 255 + _.Item2).
Select((v, i) => Tuple35.Create(v.Item1, i)).ToList();
// ファイルにテクスチャ一覧出力
data.Add(BitConverter.GetBytes(texture_and_index.Count));
foreach (var texture in texture_and_index)
{
var path = Encoding.Unicode.GetBytes(texture.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
data.Add(BitConverter.GetBytes(normalTexture_and_index.Count));
foreach (var texture in normalTexture_and_index)
{
var path = Encoding.Unicode.GetBytes(texture.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
data.Add(BitConverter.GetBytes(distortionTexture_and_index.Count));
foreach (var texture in distortionTexture_and_index)
{
var path = Encoding.Unicode.GetBytes(texture.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// ファイルにウェーブ一覧出力
data.Add(BitConverter.GetBytes(wave_and_index.Count));
foreach (var wave in wave_and_index)
{
var path = Encoding.Unicode.GetBytes(wave.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// ファイルにモデル一覧出力
data.Add(BitConverter.GetBytes(model_and_index.Count));
foreach (var model in model_and_index)
{
var path = Encoding.Unicode.GetBytes(model.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// export materials to a file
data.Add(BitConverter.GetBytes(material_and_index.Count));
foreach (var material in material_and_index)
{
var path = Encoding.Unicode.GetBytes(material.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
if (exporterVersion >= ExporterVersion.Ver16Alpha1)
{
// export curves to a file
data.Add(BitConverter.GetBytes(curve_and_index.Count));
foreach (var curve in curve_and_index)
{
var path = Encoding.Unicode.GetBytes(curve.Key);
data.Add(((path.Count() + 2) / 2).GetBytes());
data.Add(path);
data.Add(new byte[] { 0, 0 });
}
// export procedural meshes
data.Add(BitConverter.GetBytes(ProceduralModels.Count));
foreach (var param in ProceduralModels)
{
var type = (int)param.Type.Value;
data.Add(type.GetBytes());
if (param.Type.Value == ProceduralModelType.Mesh)
{
data.Add(param.Mesh.AngleBeginEnd.X.Value.GetBytes());
data.Add(param.Mesh.AngleBeginEnd.Y.Value.GetBytes());
data.Add((byte[])param.Mesh.Divisions);
data.Add(param.Mesh.Rotate.Value.GetBytes());
}
else
{
data.Add(((int)param.Ribbon.CrossSection.Value).GetBytes());
data.Add(param.Ribbon.Rotate.Value.GetBytes());
data.Add(param.Ribbon.Vertices.Value.GetBytes());
data.Add((byte[])param.Ribbon.RibbonScales);
data.Add((byte[])param.Ribbon.RibbonAngles);
data.Add((byte[])param.Ribbon.RibbonNoises);
data.Add(param.Ribbon.Count.Value.GetBytes());
}
var primitiveType = (int)param.Shape.PrimitiveType.Value;
data.Add(primitiveType.GetBytes());
if (param.Shape.PrimitiveType.Value == ProceduralModelPrimitiveType.Sphere)
{
data.Add(param.Shape.Radius.Value.GetBytes());
data.Add(param.Shape.DepthMin.Value.GetBytes());
data.Add(param.Shape.DepthMax.Value.GetBytes());
}
else if (param.Shape.PrimitiveType.Value == ProceduralModelPrimitiveType.Cone)
{
data.Add(param.Shape.Radius.Value.GetBytes());
data.Add(param.Shape.Depth.Value.GetBytes());
}
else if (param.Shape.PrimitiveType.Value == ProceduralModelPrimitiveType.Cylinder)
{
data.Add(param.Shape.Radius.Value.GetBytes());
data.Add(param.Shape.Radius2.Value.GetBytes());
data.Add(param.Shape.Depth.Value.GetBytes());
}
else if (param.Shape.PrimitiveType.Value == ProceduralModelPrimitiveType.Spline4)
{
data.Add((byte[])param.Shape.Point1);
data.Add((byte[])param.Shape.Point2);
data.Add((byte[])param.Shape.Point3);
data.Add((byte[])param.Shape.Point4);
}
var axisType = (int)param.Shape.AxisType.Value;
data.Add(axisType.GetBytes());
data.Add((byte[])param.ShapeNoise.TiltNoiseFrequency);
data.Add((byte[])param.ShapeNoise.TiltNoiseOffset);
data.Add((byte[])param.ShapeNoise.TiltNoisePower);
data.Add((byte[])param.ShapeNoise.WaveNoiseFrequency);
data.Add((byte[])param.ShapeNoise.WaveNoiseOffset);
data.Add((byte[])param.ShapeNoise.WaveNoisePower);
data.Add((byte[])param.ShapeNoise.CurlNoiseFrequency);
data.Add((byte[])param.ShapeNoise.CurlNoiseOffset);
data.Add((byte[])param.ShapeNoise.CurlNoisePower);
data.Add((byte[])param.VertexColor.ColorUpperLeft);
data.Add((byte[])param.VertexColor.ColorUpperCenter);
data.Add((byte[])param.VertexColor.ColorUpperRight);
data.Add((byte[])param.VertexColor.ColorMiddleLeft);
data.Add((byte[])param.VertexColor.ColorMiddleCenter);
data.Add((byte[])param.VertexColor.ColorMiddleRight);
data.Add((byte[])param.VertexColor.ColorLowerLeft);
data.Add((byte[])param.VertexColor.ColorLowerCenter);
data.Add((byte[])param.VertexColor.ColorLowerRight);
data.Add((byte[])param.VertexColor.ColorCenterPosition);
data.Add((byte[])param.VertexColor.ColorCenterArea);
data.Add((byte[])param.VertexColorNoise.NoiseFrequency);
data.Add((byte[])param.VertexColorNoise.NoiseOffset);
data.Add((byte[])param.VertexColorNoise.NoisePower);
data.Add((byte[])param.UV.UVPosition);
data.Add((byte[])param.UV.UVSize);
}
}
// export dynamic parameters
data.Add(BitConverter.GetBytes(Core.Dynamic.Inputs.Values.Count));
foreach (var value in Core.Dynamic.Inputs.Values)
{
float value_ = value.Input.Value;
data.Add(BitConverter.GetBytes(value_));
}
data.Add(BitConverter.GetBytes(Core.Dynamic.Equations.Values.Count));
var compiler = new InternalScript.Compiler();
foreach (var value in Core.Dynamic.Equations.Values)
{
var cx = compiler.Compile(value.Code.Value);
var cs = new[] { cx };
foreach (var c in cs)
{
if (c.Bytecode != null)
{
data.Add(BitConverter.GetBytes((int)c.Bytecode.Length));
data.Add(c.Bytecode);
}
else
{
data.Add(BitConverter.GetBytes((int)0));
}
}
}
// Export the number of nodes
data.Add(BitConverter.GetBytes(snode2ind.Count));
var renderPriorityThreshold = snode2ind.Where(_ => _.Item1.DepthValues.DrawingPriority.Value < 0).Count();
data.Add(BitConverter.GetBytes(renderPriorityThreshold));
// Export magnification
data.Add(BitConverter.GetBytes(magnification));
// Export default seed
int randomSeed = Core.Global.RandomSeed.Value;
data.Add(BitConverter.GetBytes(randomSeed));
// カリングを出力
data.Add(BitConverter.GetBytes((int)Core.Culling.Type.Value));
if (Core.Culling.Type.Value == Data.EffectCullingValues.ParamaterType.Sphere)
{
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Radius));
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Location.X));
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Location.Y));
data.Add(BitConverter.GetBytes(Core.Culling.Sphere.Location.Z));
}
// ノード情報出力
Action <Data.NodeRoot> outout_rootnode = null;
Action <Data.Node> outout_node = null;
// Identifier to use when referring to a node from the editor.
int nextEditorNodeId = 1;
outout_rootnode = (n) =>
{
n.EditorNodeId = nextEditorNodeId;
nextEditorNodeId++;
data.Add(((int)NodeType.Root).GetBytes());
var children = n.Children.Internal.Where(_ => IsRenderedNodeGroup(_)).ToList();
data.Add(children.Count.GetBytes());
for (int i = 0; i < children.Count; i++)
{
outout_node(children[i]);
}
};
outout_node = (n) =>
{
n.EditorNodeId = nextEditorNodeId;
nextEditorNodeId++;
List <byte[]> node_data = new List <byte[]>();
var isRenderParamExported = n.IsRendered.GetValue();
for (int i = 0; i < n.Children.Count; i++)
{
var nc = n.Children[i];
var v = nc.RendererCommonValues.ColorInheritType.GetValue();
if (v == Data.ParentEffectType.Already || v == Data.ParentEffectType.WhenCreating)
{
isRenderParamExported = true;
break;
}
}
if (!isRenderParamExported)
{
data.Add(((int)NodeType.None).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.None)
{
data.Add(((int)NodeType.None).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Sprite)
{
data.Add(((int)NodeType.Sprite).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Ribbon)
{
data.Add(((int)NodeType.Ribbon).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Ring)
{
data.Add(((int)NodeType.Ring).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Model)
{
data.Add(((int)NodeType.Model).GetBytes());
}
else if (n.DrawingValues.Type.Value == Data.RendererValues.ParamaterType.Track)
{
data.Add(((int)NodeType.Track).GetBytes());
}
else
{
throw new Exception();
}
// Whether to draw the node.
if (n.IsRendered)
{
int v = 1;
node_data.Add(BitConverter.GetBytes(v));
}
else
{
int v = 0;
node_data.Add(BitConverter.GetBytes(v));
}
// render order
{
var s = snode2ind.FirstOrDefault(_ => _.Item1 == n);
if (s.Item1 != null)
{
node_data.Add(BitConverter.GetBytes(s.Item2));
}
else
{
node_data.Add(BitConverter.GetBytes(-1));
}
}
node_data.Add(CommonValues.GetBytes(n.CommonValues));
node_data.Add(LocationValues.GetBytes(n.LocationValues, n.CommonValues.ScaleEffectType, curve_and_index, exporterVersion));
node_data.Add(LocationAbsValues.GetBytes(n.LocationAbsValues, n.CommonValues.ScaleEffectType, exporterVersion));
node_data.Add(RotationValues.GetBytes(n.RotationValues, exporterVersion));
node_data.Add(ScaleValues.GetBytes(n.ScalingValues, n.CommonValues.ScaleEffectType, exporterVersion));
node_data.Add(GenerationLocationValues.GetBytes(n.GenerationLocationValues, n.CommonValues.ScaleEffectType, model_and_index, procedural_mesh_and_index, exporterVersion));
// Export depth
node_data.Add(n.DepthValues.DepthOffset.Value.GetBytes());
node_data.Add(BitConverter.GetBytes(n.DepthValues.IsScaleChangedDependingOnDepthOffset.Value ? 1 : 0));
node_data.Add(BitConverter.GetBytes(n.DepthValues.IsDepthOffsetChangedDependingOnParticleScale.Value ? 1 : 0));
node_data.Add(((float)n.DepthValues.SuppressionOfScalingByDepth.Value).GetBytes());
if (n.DepthValues.DepthClipping.Infinite)
{
node_data.Add((float.MaxValue).GetBytes());
}
else
{
node_data.Add(((float)n.DepthValues.DepthClipping.Value.Value).GetBytes());
}
node_data.Add(((int)n.DepthValues.ZSort.Value).GetBytes());
node_data.Add(n.DepthValues.DrawingPriority.Value.GetBytes());
float compatibility = 1.0f;
node_data.Add(compatibility.GetBytes());
#if DEBUG
{
var old = RendererCommonValues_Old.GetBytes(n.RendererCommonValues, n.AdvancedRendererCommonValuesValues, texture_and_index, normalTexture_and_index, distortionTexture_and_index, material_and_index, exporterVersion);
var @new = RendererCommonValues.GetBytes(n.RendererCommonValues, n.AdvancedRendererCommonValuesValues, texture_and_index, normalTexture_and_index, distortionTexture_and_index, material_and_index, exporterVersion);
if (!old.SequenceEqual(@new))
{
throw new Exception("RendererCommonValues.GetBytes returned unexpected data.");
}
node_data.Add(@new);
}
#else
node_data.Add(RendererCommonValues.GetBytes(n.RendererCommonValues, n.AdvancedRendererCommonValuesValues, texture_and_index, normalTexture_and_index, distortionTexture_and_index, material_and_index, exporterVersion));
#endif
if (isRenderParamExported)
{
node_data.Add(RendererValues.GetBytes(n.DrawingValues, texture_and_index, normalTexture_and_index, model_and_index, procedural_mesh_and_index, exporterVersion));
}
else
{
node_data.Add(RendererValues.GetBytes(null, texture_and_index, normalTexture_and_index, model_and_index, procedural_mesh_and_index, exporterVersion));
}
data.Add(node_data.ToArray().ToArray());
data.Add(SoundValues.GetBytes(n.SoundValues, wave_and_index));
var children = n.Children.Internal.Where(_ => IsRenderedNodeGroup(_)).ToList();
data.Add(children.Count.GetBytes());
for (int i = 0; i < children.Count; i++)
{
outout_node(children[i]);
}
};
outout_rootnode(rootNode);
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.GenerationLocationValues value, Data.ParentEffectType parentEffectType, SortedDictionary <string, int> model_and_index, Dictionary <Data.ProceduralModelParameter, int> pmodel_and_index, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
if (value.EffectsRotation)
{
data.Add((1).GetBytes());
}
else
{
data.Add((0).GetBytes());
}
var type = value.Type.GetValue();
// Fallback
if (version < ExporterVersion.Ver16Alpha1)
{
if (type == Data.GenerationLocationValues.ParameterType.Model && value.Model.ModelReference.Value == Data.ModelReferenceType.ProceduralModel)
{
type = Data.GenerationLocationValues.ParameterType.Point;
}
}
data.Add(((int)type).GetBytes());
if (type == Data.GenerationLocationValues.ParameterType.Point)
{
data.Add(value.Point.Location.GetBytes(1.0f));
}
else if (type == Data.GenerationLocationValues.ParameterType.Sphere)
{
data.Add((value.Sphere.Radius.Max).GetBytes());
data.Add((value.Sphere.Radius.Min).GetBytes());
data.Add((value.Sphere.RotationX.Max / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Sphere.RotationX.Min / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Sphere.RotationY.Max / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Sphere.RotationY.Min / 180.0f * (float)Math.PI).GetBytes());
}
if (type == Data.GenerationLocationValues.ParameterType.Model)
{
if (version >= ExporterVersion.Ver16Alpha3)
{
var refType = (int)value.Model.ModelReference.Value;
data.Add((refType).GetBytes());
}
if (value.Model.ModelReference.Value == Data.ModelReferenceType.File)
{
var relative_path = value.Model.Model.RelativePath;
if (!string.IsNullOrEmpty(relative_path))
{
relative_path = Utils.GetModelPath(value.Model.Model);
if (model_and_index.ContainsKey(relative_path))
{
data.Add(model_and_index[relative_path].GetBytes());
}
else
{
data.Add(((int)-1).GetBytes());
}
}
else
{
data.Add(((int)-1).GetBytes());
}
}
else if (value.Model.ModelReference.Value == Data.ModelReferenceType.ProceduralModel)
{
if (value.Model.Reference.Value != null)
{
var ind = pmodel_and_index[value.Model.Reference.Value];
data.Add(ind.GetBytes());
}
else
{
data.Add(((int)-1).GetBytes());
}
}
else
{
throw new Exception();
}
data.Add(((int)value.Model.Type.Value).GetBytes());
}
else if (type == Data.GenerationLocationValues.ParameterType.Circle)
{
data.Add((value.Circle.Division.Value).GetBytes());
data.Add((value.Circle.Radius.Max).GetBytes());
data.Add((value.Circle.Radius.Min).GetBytes());
data.Add((value.Circle.AngleStart.Max / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Circle.AngleStart.Min / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Circle.AngleEnd.Max / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Circle.AngleEnd.Min / 180.0f * (float)Math.PI).GetBytes());
data.Add(((int)value.Circle.Type.Value).GetBytes());
// Version 1.30(10)
data.Add(((int)value.Circle.AxisDirection.Value).GetBytes());
data.Add((value.Circle.AngleNoize.Max / 180.0f * (float)Math.PI).GetBytes());
data.Add((value.Circle.AngleNoize.Min / 180.0f * (float)Math.PI).GetBytes());
}
else if (type == Data.GenerationLocationValues.ParameterType.Line)
{
data.Add((value.Line.Division.Value).GetBytes());
data.Add(value.Line.PositionStart.GetBytes(1.0f));
data.Add(value.Line.PositionEnd.GetBytes(1.0f));
data.Add((value.Line.PositionNoize.Max).GetBytes());
data.Add((value.Line.PositionNoize.Min).GetBytes());
data.Add(((int)value.Line.Type.Value).GetBytes());
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.LocationAbsValues value, Data.ParentEffectType parentEffectType, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
// Force field
List <Data.LocalForceField> lffs = new List <Data.LocalForceField>
{
value.LocalForceField1,
value.LocalForceField2,
value.LocalForceField3,
value.LocalForceField4,
};
data.Add((lffs.Count).GetBytes());
foreach (var lff in lffs)
{
if (version >= ExporterVersion.Ver16Alpha1)
{
data.Add(lff.Type.GetValueAsInt().GetBytes());
var pi = (float)Math.PI;
data.Add(BitConverter.GetBytes(lff.Power));
data.Add(BitConverter.GetBytes(lff.Position.X));
data.Add(BitConverter.GetBytes(lff.Position.Y));
data.Add(BitConverter.GetBytes(lff.Position.Z));
data.Add(BitConverter.GetBytes(lff.Rotation.X / 180.0f * pi));
data.Add(BitConverter.GetBytes(lff.Rotation.Y / 180.0f * pi));
data.Add(BitConverter.GetBytes(lff.Rotation.Z / 180.0f * pi));
if (lff.Type.Value == Data.LocalForceFieldType.Force)
{
data.Add((lff.Force.Gravitation.GetValue() ? 1 : 0).GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Wind)
{
}
if (lff.Type.Value == Data.LocalForceFieldType.Vortex)
{
var ftype = lff.Vortex.VortexType.Value;
data.Add(((int)ftype).GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Turbulence)
{
var ftype = lff.Turbulence.TurbulenceType.Value;
data.Add(((int)ftype).GetBytes());
data.Add(lff.Turbulence.Seed.Value.GetBytes());
data.Add(lff.Turbulence.FieldScale.Value.GetBytes());
data.Add(lff.Turbulence.Octave.Value.GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Drag)
{
}
if (lff.Type.Value == Data.LocalForceFieldType.Gravity)
{
data.Add((byte[])lff.Gravity.Gravity);
}
if (lff.Type.Value == Data.LocalForceFieldType.AttractiveForce)
{
//data.Add(BitConverter.GetBytes(lff.AttractiveForce.Force.GetValue()));
data.Add(BitConverter.GetBytes(lff.AttractiveForce.Control.GetValue()));
data.Add(BitConverter.GetBytes(lff.AttractiveForce.MinRange.GetValue()));
data.Add(BitConverter.GetBytes(lff.AttractiveForce.MaxRange.GetValue()));
}
data.Add(lff.Falloff.Type.GetValueAsInt().GetBytes());
if (lff.Falloff.Type.Value != Data.ForceFieldFalloffType.None)
{
data.Add(lff.Falloff.Power.GetBytes());
data.Add(lff.Falloff.MaxDistance.GetBytes());
data.Add(lff.Falloff.MinDistance.GetBytes());
if (lff.Falloff.Type.Value == Data.ForceFieldFalloffType.Tube)
{
data.Add(lff.Falloff.Tube.RadiusPower.GetBytes());
data.Add(lff.Falloff.Tube.MaxRadius.GetBytes());
data.Add(lff.Falloff.Tube.MinRadius.GetBytes());
}
if (lff.Falloff.Type.Value == Data.ForceFieldFalloffType.Cone)
{
data.Add(lff.Falloff.Cone.AnglePower.GetBytes());
data.Add(lff.Falloff.Cone.MaxAngle.GetBytes(1.0f / 180.0f * pi));
data.Add(lff.Falloff.Cone.MinAngle.GetBytes(1.0f / 180.0f * pi));
}
}
}
else
{
// 1.5 or later
if (lff.Type.Value == Data.LocalForceFieldType.Turbulence)
{
data.Add(lff.Type.GetValueAsInt().GetBytes());
}
else
{
data.Add(((int)(Data.LocalForceFieldType.None)).GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Turbulence)
{
var strength = lff.Power.Value / 10.0f;
data.Add(lff.Turbulence.Seed.Value.GetBytes());
data.Add(lff.Turbulence.FieldScale.Value.GetBytes());
data.Add(strength.GetBytes());
data.Add(lff.Turbulence.Octave.Value.GetBytes());
}
}
}
// For compatibility
if (version < ExporterVersion.Ver16Alpha2)
{
var type = 0;
data.Add(((int)type).GetBytes());
data.Add(((int)0).GetBytes());
}
return(data.ToArray().ToArray());
}
public BasicUvSerializer(Data.RendererCommonValues value, ExporterVersion version)
: base(value.UV, value.UVFixed, value.UVAnimation.AnimationParams, value.UVScroll, value.UVFCurve)
{
_animationParameter = value.UVAnimation;
_version = version;
}
public static byte[] GetBytes(Data.LocationAbsValues value, Data.ParentEffectType parentEffectType, ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
// Force field
List <Data.LocalForceField> lffs = new List <Data.LocalForceField>
{
value.LocalForceField1,
value.LocalForceField2,
value.LocalForceField3,
};
data.Add((lffs.Count).GetBytes());
foreach (var lff in lffs)
{
if (version >= ExporterVersion.Ver1600)
{
data.Add(lff.Type.GetValueAsInt().GetBytes());
var pi = (float)Math.PI;
data.Add(BitConverter.GetBytes(lff.Power));
data.Add(BitConverter.GetBytes(lff.Position.X));
data.Add(BitConverter.GetBytes(lff.Position.Y));
data.Add(BitConverter.GetBytes(lff.Position.Z));
data.Add(BitConverter.GetBytes(lff.Rotation.X / 180.0f * pi));
data.Add(BitConverter.GetBytes(lff.Rotation.Y / 180.0f * pi));
data.Add(BitConverter.GetBytes(lff.Rotation.Z / 180.0f * pi));
if (lff.Type.Value == Data.LocalForceFieldType.Force)
{
data.Add((lff.Force.Gravitation.GetValue() ? 1 : 0).GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Wind)
{
}
if (lff.Type.Value == Data.LocalForceFieldType.Vortex)
{
}
if (lff.Type.Value == Data.LocalForceFieldType.Maginetic)
{
}
if (lff.Type.Value == Data.LocalForceFieldType.Turbulence)
{
data.Add(lff.Turbulence.Seed.Value.GetBytes());
data.Add(lff.Turbulence.FieldScale.Value.GetBytes());
data.Add(lff.Turbulence.Strength.Value.GetBytes());
data.Add(lff.Turbulence.Octave.Value.GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Drag)
{
}
data.Add(lff.Falloff.Type.GetValueAsInt().GetBytes());
if (lff.Falloff.Type.Value != Data.ForceFieldFalloffType.None)
{
data.Add(lff.Falloff.Power.GetBytes());
data.Add(lff.Falloff.MaxDistance.GetBytes());
data.Add(lff.Falloff.MinDistance.GetBytes());
if (lff.Falloff.Type.Value == Data.ForceFieldFalloffType.Tube)
{
data.Add(lff.Falloff.Tube.RadiusPower.GetBytes());
data.Add(lff.Falloff.Tube.MaxRadius.GetBytes());
data.Add(lff.Falloff.Tube.MinRadius.GetBytes());
}
if (lff.Falloff.Type.Value == Data.ForceFieldFalloffType.Cone)
{
data.Add(lff.Falloff.Cone.AnglePower.GetBytes());
data.Add(lff.Falloff.Cone.MaxAngle.GetBytes());
data.Add(lff.Falloff.Cone.MinAngle.GetBytes());
}
}
}
else
{
// 1.5 or later
if (lff.Type.Value == Data.LocalForceFieldType.Turbulence)
{
data.Add(lff.Type.GetValueAsInt().GetBytes());
}
else
{
data.Add(((int)(Data.LocalForceFieldType.None)).GetBytes());
}
if (lff.Type.Value == Data.LocalForceFieldType.Turbulence)
{
data.Add(lff.Turbulence.Seed.Value.GetBytes());
data.Add(lff.Turbulence.FieldScale.Value.GetBytes());
data.Add(lff.Turbulence.Strength.Value.GetBytes());
data.Add(lff.Turbulence.Octave.Value.GetBytes());
}
}
}
data.Add(value.Type.GetValueAsInt().GetBytes());
if (value.Type.GetValue() == Data.LocationAbsValues.ParamaterType.Gravity)
{
var bytes = TranslationAbs_Gravity_Values.Create(value.Gravity).GetBytes();
data.Add(bytes.Count().GetBytes());
data.Add(bytes);
}
else if (value.Type.GetValue() == Data.LocationAbsValues.ParamaterType.AttractiveForce)
{
var bytes = TranslationAbs_AttractiveForce_Values.Create(value.AttractiveForce).GetBytes();
data.Add(bytes.Count().GetBytes());
data.Add(bytes);
}
else if (value.Type.GetValue() == Data.LocationAbsValues.ParamaterType.None)
{
data.Add(((int)0).GetBytes());
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.RendererCommonValues value,
Data.AdvancedRenderCommonValues advanceValue,
Data.AdvancedRenderCommonValues2 advanceValue2,
SortedDictionary <string, int> texture_and_index,
SortedDictionary <string, int> normalTexture_and_index,
SortedDictionary <string, int> distortionTexture_and_index,
SortedDictionary <string, int> material_and_index,
ExporterVersion version)
{
List <byte[]> data = new List <byte[]>();
var texInfo = new TextureInformation();
var alphaTexInfo = new TextureInformation();
var uvDistortionTexInfo = new TextureInformation();
var blendTexInfo = new TextureInformation();
var blendAlphaTexInfo = new TextureInformation();
var blendUVDistortionTexInfo = new TextureInformation();
data.Add(((int)value.Material.Value).GetBytes());
if (version >= ExporterVersion.Ver16Alpha1)
{
if (value.Material.Value == Data.RendererCommonValues.MaterialType.Default ||
value.Material.Value == Data.RendererCommonValues.MaterialType.Lighting)
{
data.Add(BitConverter.GetBytes(value.EmissiveScaling));
}
}
Func <Data.Value.PathForImage, int, SortedDictionary <string, int>, int> getTexIDAndStoreSize = (Data.Value.PathForImage image, int number, SortedDictionary <string, int> texAndInd) =>
{
var tempTexInfo = new TextureInformation();
if (texAndInd.ContainsKey(image.RelativePath) && tempTexInfo.Load(image.AbsolutePath))
{
if (value.UVTextureReferenceTarget.Value != Data.UVTextureReferenceTargetType.None && number == (int)value.UVTextureReferenceTarget.Value)
{
texInfo.Load(image.AbsolutePath);
}
return(texAndInd[image.RelativePath]);
}
else
{
return(-1);
}
};
GetTexIDAndInfo getTexIDAndInfo = (Data.Value.PathForImage image, SortedDictionary <string, int> texAndInd, ref TextureInformation texInfoRef) =>
{
var tempTexInfo = new TextureInformation();
if (texAndInd.ContainsKey(image.RelativePath) && tempTexInfo.Load(image.AbsolutePath))
{
texInfoRef.Load(image.AbsolutePath);
return(texAndInd[image.RelativePath]);
}
return(-1);
};
if (value.Material.Value == Data.RendererCommonValues.MaterialType.Default)
{
// texture1
data.Add(getTexIDAndStoreSize(value.ColorTexture, 1, texture_and_index).GetBytes());
// texture2
data.Add((-1).GetBytes());
if (version >= ExporterVersion.Ver16Alpha1)
{
// alpha texture
if (advanceValue.EnableAlphaTexture)
{
data.Add(getTexIDAndInfo(advanceValue.AlphaTextureParam.Texture, texture_and_index, ref alphaTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// uv distortion texture
if (advanceValue.EnableUVDistortionTexture)
{
data.Add(getTexIDAndInfo(advanceValue.UVDistortionTextureParam.Texture, texture_and_index, ref uvDistortionTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// blend texture
if (advanceValue2.EnableBlendTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendTextureParam.Texture, texture_and_index, ref blendTexInfo).GetBytes());
// blend alpha texture
if (advanceValue2.BlendTextureParams.EnableBlendAlphaTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendAlphaTextureParam.Texture, texture_and_index, ref blendAlphaTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// blend uv distortion texture
if (advanceValue2.BlendTextureParams.EnableBlendUVDistortionTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.Texture, texture_and_index, ref blendUVDistortionTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
}
else
{
data.Add((-1).GetBytes());
data.Add((-1).GetBytes());
data.Add((-1).GetBytes());
}
}
}
else if (value.Material.Value == Data.RendererCommonValues.MaterialType.BackDistortion)
{
// texture1
data.Add(getTexIDAndStoreSize(value.ColorTexture, 1, distortionTexture_and_index).GetBytes());
// texture2
data.Add((-1).GetBytes());
if (version >= ExporterVersion.Ver16Alpha1)
{
// alpha texture
if (advanceValue.EnableAlphaTexture)
{
data.Add(getTexIDAndInfo(advanceValue.AlphaTextureParam.Texture, distortionTexture_and_index, ref alphaTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// uv distortion texture
if (advanceValue.EnableUVDistortionTexture)
{
data.Add(getTexIDAndInfo(advanceValue.UVDistortionTextureParam.Texture, distortionTexture_and_index, ref uvDistortionTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// blend texture
if (advanceValue2.EnableBlendTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendTextureParam.Texture, distortionTexture_and_index, ref blendTexInfo).GetBytes());
// blend alpha texture
if (advanceValue2.BlendTextureParams.EnableBlendAlphaTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendAlphaTextureParam.Texture, distortionTexture_and_index, ref blendAlphaTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// blend uv distortion texture
if (advanceValue2.BlendTextureParams.EnableBlendUVDistortionTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.Texture, distortionTexture_and_index, ref blendUVDistortionTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
}
else
{
data.Add((-1).GetBytes());
data.Add((-1).GetBytes());
data.Add((-1).GetBytes());
}
}
}
else if (value.Material.Value == Data.RendererCommonValues.MaterialType.Lighting)
{
// texture1
data.Add(getTexIDAndStoreSize(value.ColorTexture, 1, texture_and_index).GetBytes());
// texture2
data.Add(getTexIDAndStoreSize(value.NormalTexture, 2, normalTexture_and_index).GetBytes());
if (version >= ExporterVersion.Ver16Alpha1)
{
// alpha texture
if (advanceValue.EnableAlphaTexture)
{
data.Add(getTexIDAndInfo(advanceValue.AlphaTextureParam.Texture, texture_and_index, ref alphaTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// uv distortion texture
if (advanceValue.EnableUVDistortionTexture)
{
data.Add(getTexIDAndInfo(advanceValue.UVDistortionTextureParam.Texture, texture_and_index, ref uvDistortionTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// blend texture
if (advanceValue2.EnableBlendTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendTextureParam.Texture, texture_and_index, ref blendTexInfo).GetBytes());
// blend alpha texture
if (advanceValue2.BlendTextureParams.EnableBlendAlphaTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendAlphaTextureParam.Texture, texture_and_index, ref blendAlphaTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
// blend uv distortion texture
if (advanceValue2.BlendTextureParams.EnableBlendUVDistortionTexture)
{
data.Add(getTexIDAndInfo(advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.Texture, texture_and_index, ref blendUVDistortionTexInfo).GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
}
else
{
data.Add((-1).GetBytes());
data.Add((-1).GetBytes());
data.Add((-1).GetBytes());
}
}
}
else
{
var materialInfo = Core.ResourceCache.LoadMaterialInformation(value.MaterialFile.Path.AbsolutePath);
if (materialInfo == null)
{
materialInfo = new MaterialInformation();
}
var textures = value.MaterialFile.GetTextures(materialInfo).Where(_ => _.Item1 != null).ToArray();
var uniforms = value.MaterialFile.GetUniforms(materialInfo);
// maximum slot limitation
if (textures.Length > Constant.UserTextureSlotCount)
{
textures = textures.Take(Constant.UserTextureSlotCount).ToArray();
}
if (material_and_index.ContainsKey(value.MaterialFile.Path.RelativePath))
{
data.Add(material_and_index[value.MaterialFile.Path.RelativePath].GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
data.Add(textures.Length.GetBytes());
foreach (var texture in textures)
{
var texture_ = texture.Item1.Value as Data.Value.PathForImage;
if (texture.Item2.Type == TextureType.Value)
{
data.Add((1).GetBytes());
data.Add(getTexIDAndStoreSize(texture_, texture.Item2.Priority, normalTexture_and_index).GetBytes());
}
else
{
data.Add((0).GetBytes());
data.Add(getTexIDAndStoreSize(texture_, texture.Item2.Priority, texture_and_index).GetBytes());
}
}
data.Add(uniforms.Count.GetBytes());
foreach (var uniform in uniforms)
{
float[] floats = new float[4];
if (uniform.Item1 == null)
{
floats = uniform.Item2.DefaultValues.ToArray();
}
else if (uniform.Item1.Value is Data.Value.Float)
{
floats[0] = (uniform.Item1.Value as Data.Value.Float).Value;
}
else if (uniform.Item1.Value is Data.Value.Vector2D)
{
floats[0] = (uniform.Item1.Value as Data.Value.Vector2D).X.Value;
floats[1] = (uniform.Item1.Value as Data.Value.Vector2D).Y.Value;
}
else if (uniform.Item1.Value is Data.Value.Vector3D)
{
floats[0] = (uniform.Item1.Value as Data.Value.Vector3D).X.Value;
floats[1] = (uniform.Item1.Value as Data.Value.Vector3D).Y.Value;
floats[2] = (uniform.Item1.Value as Data.Value.Vector3D).Z.Value;
}
else if (uniform.Item1.Value is Data.Value.Vector4D)
{
floats[0] = (uniform.Item1.Value as Data.Value.Vector4D).X.Value;
floats[1] = (uniform.Item1.Value as Data.Value.Vector4D).Y.Value;
floats[2] = (uniform.Item1.Value as Data.Value.Vector4D).Z.Value;
floats[3] = (uniform.Item1.Value as Data.Value.Vector4D).W.Value;
}
data.Add(floats[0].GetBytes());
data.Add(floats[1].GetBytes());
data.Add(floats[2].GetBytes());
data.Add(floats[3].GetBytes());
}
}
data.Add(value.AlphaBlend);
data.Add(value.Filter);
data.Add(value.Wrap);
data.Add(value.Filter2);
data.Add(value.Wrap2);
if (version >= ExporterVersion.Ver16Alpha1)
{
data.Add(advanceValue.AlphaTextureParam.Filter);
data.Add(advanceValue.AlphaTextureParam.Wrap);
data.Add(advanceValue.UVDistortionTextureParam.Filter);
data.Add(advanceValue.UVDistortionTextureParam.Wrap);
data.Add(advanceValue2.BlendTextureParams.BlendTextureParam.Filter);
data.Add(advanceValue2.BlendTextureParams.BlendTextureParam.Wrap);
data.Add(advanceValue2.BlendTextureParams.BlendAlphaTextureParam.Filter);
data.Add(advanceValue2.BlendTextureParams.BlendAlphaTextureParam.Wrap);
data.Add(advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.Filter);
data.Add(advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.Wrap);
}
if (value.ZTest.GetValue())
{
data.Add((1).GetBytes());
}
else
{
data.Add((0).GetBytes());
}
if (value.ZWrite.GetValue())
{
data.Add((1).GetBytes());
}
else
{
data.Add((0).GetBytes());
}
data.Add(value.FadeInType);
if (value.FadeInType.Value == Data.RendererCommonValues.FadeType.Use)
{
data.Add(value.FadeIn.Frame.GetBytes());
var easing = Utl.MathUtl.Easing((float)value.FadeIn.StartSpeed.Value, (float)value.FadeIn.EndSpeed.Value);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
data.Add(value.FadeOutType);
if (value.FadeOutType.Value == Data.RendererCommonValues.FadeType.Use)
{
data.Add(value.FadeOut.Frame.GetBytes());
var easing = Utl.MathUtl.Easing((float)value.FadeOut.StartSpeed.Value, (float)value.FadeOut.EndSpeed.Value);
data.Add(BitConverter.GetBytes(easing[0]));
data.Add(BitConverter.GetBytes(easing[1]));
data.Add(BitConverter.GetBytes(easing[2]));
}
// sprcification change(1.5)
float width = 128.0f;
float height = 128.0f;
if (texInfo.Width > 0 && texInfo.Height > 0)
{
width = (float)texInfo.Width;
height = (float)texInfo.Height;
}
data.Add(value.UV);
if (value.UV.Value == Data.RendererCommonValues.UVType.Default)
{
}
else if (value.UV.Value == Data.RendererCommonValues.UVType.Fixed)
{
var value_ = value.UVFixed;
data.Add((value_.Start.X / width).GetBytes());
data.Add((value_.Start.Y / height).GetBytes());
data.Add((value_.Size.X / width).GetBytes());
data.Add((value_.Size.Y / height).GetBytes());
}
else if (value.UV.Value == Data.RendererCommonValues.UVType.Animation)
{
var value_ = value.UVAnimation;
data.Add((value_.AnimationParams.Start.X / width).GetBytes());
data.Add((value_.AnimationParams.Start.Y / height).GetBytes());
data.Add((value_.AnimationParams.Size.X / width).GetBytes());
data.Add((value_.AnimationParams.Size.Y / height).GetBytes());
if (value_.AnimationParams.FrameLength.Infinite)
{
var inf = int.MaxValue / 100;
data.Add(inf.GetBytes());
}
else
{
data.Add(value_.AnimationParams.FrameLength.Value.Value.GetBytes());
}
data.Add(value_.AnimationParams.FrameCountX.Value.GetBytes());
data.Add(value_.AnimationParams.FrameCountY.Value.GetBytes());
data.Add(value_.AnimationParams.LoopType);
data.Add(value_.AnimationParams.StartSheet.Max.GetBytes());
data.Add(value_.AnimationParams.StartSheet.Min.GetBytes());
data.Add(value_.FlipbookInterpolationType);
}
else if (value.UV.Value == Data.RendererCommonValues.UVType.Scroll)
{
var value_ = value.UVScroll;
data.Add((value_.Start.X.Max / width).GetBytes());
data.Add((value_.Start.Y.Max / height).GetBytes());
data.Add((value_.Start.X.Min / width).GetBytes());
data.Add((value_.Start.Y.Min / height).GetBytes());
data.Add((value_.Size.X.Max / width).GetBytes());
data.Add((value_.Size.Y.Max / height).GetBytes());
data.Add((value_.Size.X.Min / width).GetBytes());
data.Add((value_.Size.Y.Min / height).GetBytes());
data.Add((value_.Speed.X.Max / width).GetBytes());
data.Add((value_.Speed.Y.Max / height).GetBytes());
data.Add((value_.Speed.X.Min / width).GetBytes());
data.Add((value_.Speed.Y.Min / height).GetBytes());
}
else if (value.UV.Value == Data.RendererCommonValues.UVType.FCurve)
{
{
var value_ = value.UVFCurve.Start;
var bytes1 = value_.GetBytes(1.0f / width, 1.0f / height);
List <byte[]> _data = new List <byte[]>();
data.Add(bytes1);
}
{
var value_ = value.UVFCurve.Size;
var bytes1 = value_.GetBytes(1.0f / width, 1.0f / height);
List <byte[]> _data = new List <byte[]>();
data.Add(bytes1);
}
}
if (version >= ExporterVersion.Ver16Alpha1)
{
// alpha texture
data.Add(GetUVBytes
(
alphaTexInfo,
advanceValue.AlphaTextureParam.UV,
advanceValue.AlphaTextureParam.UVFixed,
advanceValue.AlphaTextureParam.UVAnimation,
advanceValue.AlphaTextureParam.UVScroll,
advanceValue.AlphaTextureParam.UVFCurve
));
// uv distortion texture
data.Add(GetUVBytes
(
uvDistortionTexInfo,
advanceValue.UVDistortionTextureParam.UV,
advanceValue.UVDistortionTextureParam.UVFixed,
advanceValue.UVDistortionTextureParam.UVAnimation,
advanceValue.UVDistortionTextureParam.UVScroll,
advanceValue.UVDistortionTextureParam.UVFCurve
));
// uv distortion intensity
data.Add((advanceValue.UVDistortionTextureParam.UVDistortionIntensity).GetBytes());
// blend texture
data.Add(GetUVBytes
(
blendTexInfo,
advanceValue2.BlendTextureParams.BlendTextureParam.UV,
advanceValue2.BlendTextureParams.BlendTextureParam.UVFixed,
advanceValue2.BlendTextureParams.BlendTextureParam.UVAnimation,
advanceValue2.BlendTextureParams.BlendTextureParam.UVScroll,
advanceValue2.BlendTextureParams.BlendTextureParam.UVFCurve
));
// blend texture blend type
if (advanceValue2.EnableBlendTexture && advanceValue2.BlendTextureParams.BlendTextureParam.Texture.RelativePath != string.Empty)
{
data.Add(advanceValue2.BlendTextureParams.BlendTextureParam.BlendType);
}
else
{
data.Add((-1).GetBytes());
}
// blend alpha texture
data.Add(GetUVBytes
(
blendAlphaTexInfo,
advanceValue2.BlendTextureParams.BlendAlphaTextureParam.UV,
advanceValue2.BlendTextureParams.BlendAlphaTextureParam.UVFixed,
advanceValue2.BlendTextureParams.BlendAlphaTextureParam.UVAnimation,
advanceValue2.BlendTextureParams.BlendAlphaTextureParam.UVScroll,
advanceValue2.BlendTextureParams.BlendAlphaTextureParam.UVFCurve
));
// blend uv distoriton texture
data.Add(GetUVBytes
(
blendUVDistortionTexInfo,
advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.UV,
advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.UVFixed,
advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.UVAnimation,
advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.UVScroll,
advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.UVFCurve
));
// blend uv distoriton intensity
data.Add((advanceValue2.BlendTextureParams.BlendUVDistortionTextureParam.UVDistortionIntensity).GetBytes());
}
// Inheritance
data.Add(value.ColorInheritType.GetValueAsInt().GetBytes());
// Distortion
data.Add(value.DistortionIntensity.GetBytes());
// Custom data1 from 1.5
data.Add(value.CustomData1.CustomData);
if (value.CustomData1.CustomData.Value == Data.CustomDataType.Fixed2D)
{
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed.Y.Value));
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.Random2D)
{
var value_ = value.CustomData1.Random;
var bytes1 = value_.GetBytes(1.0f);
data.Add(bytes1);
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.Easing2D)
{
var easing = Utl.MathUtl.Easing((float)value.CustomData1.Easing.StartSpeed.Value, (float)value.CustomData1.Easing.EndSpeed.Value);
List <byte[]> _data = new List <byte[]>();
_data.Add(value.CustomData1.Easing.Start.GetBytes(1.0f));
_data.Add(value.CustomData1.Easing.End.GetBytes(1.0f));
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data);
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.FCurve2D)
{
var value_ = value.CustomData1.FCurve;
var bytes1 = value_.GetBytes();
data.Add(bytes1);
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.Fixed4D)
{
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.Y.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.Z.Value));
data.Add(BitConverter.GetBytes(value.CustomData1.Fixed4.W.Value));
}
else if (value.CustomData1.CustomData.Value == Data.CustomDataType.FCurveColor)
{
var bytes = value.CustomData1.FCurveColor.GetBytes();
data.Add(bytes);
}
// Custom data2 from 1.5
data.Add(value.CustomData2.CustomData);
if (value.CustomData2.CustomData.Value == Data.CustomDataType.Fixed2D)
{
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed.Y.Value));
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.Random2D)
{
var value_ = value.CustomData2.Random;
var bytes1 = value_.GetBytes(1.0f);
data.Add(bytes1);
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.Easing2D)
{
var easing = Utl.MathUtl.Easing((float)value.CustomData2.Easing.StartSpeed.Value, (float)value.CustomData2.Easing.EndSpeed.Value);
List <byte[]> _data = new List <byte[]>();
_data.Add(value.CustomData2.Easing.Start.GetBytes(1.0f));
_data.Add(value.CustomData2.Easing.End.GetBytes(1.0f));
_data.Add(BitConverter.GetBytes(easing[0]));
_data.Add(BitConverter.GetBytes(easing[1]));
_data.Add(BitConverter.GetBytes(easing[2]));
var __data = _data.ToArray().ToArray();
data.Add(__data);
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.FCurve2D)
{
var value_ = value.CustomData2.FCurve;
var bytes1 = value_.GetBytes();
data.Add(bytes1);
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.Fixed4D)
{
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.X.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.Y.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.Z.Value));
data.Add(BitConverter.GetBytes(value.CustomData2.Fixed4.W.Value));
}
else if (value.CustomData2.CustomData.Value == Data.CustomDataType.FCurveColor)
{
var bytes = value.CustomData2.FCurveColor.GetBytes();
data.Add(bytes);
}
if (version >= ExporterVersion.Ver16Alpha1)
{
data.Add(AlphaCutoffValues.GetBytes(advanceValue.AlphaCutoffParam, version));
}
if (version >= ExporterVersion.Ver16Alpha3)
{
if (advanceValue.EnableFalloff)
{
data.Add((1).GetBytes());
data.Add(advanceValue.FalloffParam.ColorBlendType);
data.Add(advanceValue.FalloffParam.BeginColor);
data.Add(advanceValue.FalloffParam.EndColor);
data.Add(BitConverter.GetBytes(advanceValue.FalloffParam.Pow.Value));
}
else
{
data.Add((0).GetBytes());
}
}
if (version >= ExporterVersion.Ver16Alpha4)
{
data.Add(advanceValue.SoftParticleDistance.GetBytes());
}
if (version >= ExporterVersion.Ver16Alpha5)
{
data.Add(advanceValue.SoftParticleDistanceNear.GetBytes());
data.Add(advanceValue.SoftParticleDistanceNearOffset.GetBytes());
}
return(data.ToArray().ToArray());
}
public static byte[] GetBytes(Data.LocationValues value, Data.ParentEffectType parentEffectType, Dictionary <string, int> curveAndIndex, ExporterVersion version)
{
//if (parentEffectType != Data.ParentEffectType.NotBind) magnification = 1.0f;
var type = value.Type.Value;
// Fall back
if (version < ExporterVersion.Ver16Alpha1)
{
if (type == Data.LocationValues.ParamaterType.NurbsCurve ||
type == Data.LocationValues.ParamaterType.ViewOffset)
{
type = Data.LocationValues.ParamaterType.Fixed;
}
}
List <byte[]> data = new List <byte[]>();
data.Add(((int)type).GetBytes());
if (type == Data.LocationValues.ParamaterType.Fixed)
{
var refBuf = value.Fixed.Location.DynamicEquation.Index.GetBytes();
var mainBuf = Translation_Fixed_Values.Create(value.Fixed, 1.0f).GetBytes();
data.Add((mainBuf.Count() + refBuf.Count()).GetBytes());
data.Add(refBuf);
data.Add(mainBuf);
}
else if (type == Data.LocationValues.ParamaterType.PVA)
{
var refBuf1_1 = value.PVA.Location.DynamicEquationMax.Index.GetBytes();
var refBuf1_2 = value.PVA.Location.DynamicEquationMin.Index.GetBytes();
var refBuf2_1 = value.PVA.Velocity.DynamicEquationMax.Index.GetBytes();
var refBuf2_2 = value.PVA.Velocity.DynamicEquationMin.Index.GetBytes();
var refBuf3_1 = value.PVA.Acceleration.DynamicEquationMax.Index.GetBytes();
var refBuf3_2 = value.PVA.Acceleration.DynamicEquationMin.Index.GetBytes();
var mainBuf = Translation_PVA_Values.Create(value.PVA, 1.0f).GetBytes();
data.Add((mainBuf.Count() + refBuf1_1.Count() * 6).GetBytes());
data.Add(refBuf1_1);
data.Add(refBuf1_2);
data.Add(refBuf2_1);
data.Add(refBuf2_2);
data.Add(refBuf3_1);
data.Add(refBuf3_2);
data.Add(mainBuf);
}
else if (type == Data.LocationValues.ParamaterType.Easing)
{
Utils.ExportEasing(value.Easing, 1.0f, data, version);
}
else if (type == Data.LocationValues.ParamaterType.LocationFCurve)
{
var bytes1 = value.LocationFCurve.FCurve.GetBytes();
List <byte[]> _data = new List <byte[]>();
data.Add(bytes1.Count().GetBytes());
data.Add(bytes1);
}
else if (type == Data.LocationValues.ParamaterType.NurbsCurve)
{
if (value.NurbsCurve.FilePath.RelativePath != string.Empty)
{
// export index
var relative_path = value.NurbsCurve.FilePath.RelativePath;
if (relative_path != System.IO.Path.GetFileName(value.NurbsCurve.FilePath.RelativePath))
{
relative_path = System.IO.Path.GetDirectoryName(relative_path) + "/" + System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkcurve";
}
else
{
relative_path = System.IO.Path.GetFileNameWithoutExtension(relative_path) + ".efkcurve";
}
data.Add(curveAndIndex[relative_path].GetBytes());
}
else
{
data.Add((-1).GetBytes());
}
data.Add(BitConverter.GetBytes(value.NurbsCurve.Scale));
data.Add(BitConverter.GetBytes(value.NurbsCurve.MoveSpeed));
data.Add(value.NurbsCurve.LoopType.GetValueAsInt().GetBytes());
}
else if (type == Data.LocationValues.ParamaterType.ViewOffset)
{
data.Add(value.ViewOffset.Distance.Max.GetBytes());
data.Add(value.ViewOffset.Distance.Min.GetBytes());
}
return(data.ToArray().ToArray());
}
private static void AddRingData(Data.RendererValues value, List <byte[]> data, ExporterVersion version)
{
var ringParameter = value.Ring;
data.Add(ringParameter.RenderingOrder);
data.Add(ringParameter.Billboard);
// from 1.5
data.Add(RingShapeParameter.GetBytes(ringParameter.RingShape, version));
data.Add(ringParameter.VertexCount.Value.GetBytes());
AddViewingAngle();
AddLocation(ringParameter.Outer,
ringParameter.Outer_Fixed,
ringParameter.Outer_PVA,
ringParameter.Outer_Easing);
AddLocation(ringParameter.Inner,
ringParameter.Inner_Fixed,
ringParameter.Inner_PVA,
ringParameter.Inner_Easing);
AddCenterRatio();
AddColor(ringParameter.OuterColor,
ringParameter.OuterColor_Fixed,
ringParameter.OuterColor_Random,
ringParameter.OuterColor_Easing);
AddColor(ringParameter.CenterColor,
ringParameter.CenterColor_Fixed,
ringParameter.CenterColor_Random,
ringParameter.CenterColor_Easing);
AddColor(ringParameter.InnerColor,
ringParameter.InnerColor_Fixed,
ringParameter.InnerColor_Random,
ringParameter.InnerColor_Easing);
void AddViewingAngle()
{
// it will removed
data.Add(ringParameter.ViewingAngle);
if (ringParameter.ViewingAngle.GetValue() == Data.RendererValues.RingParamater.ViewingAngleType.Fixed)
{
data.Add(ringParameter.ViewingAngle_Fixed.Value.GetBytes());
}
else if (ringParameter.ViewingAngle.GetValue() == Data.RendererValues.RingParamater.ViewingAngleType.Random)
{
data.Add(ringParameter.ViewingAngle_Random.Max.GetBytes());
data.Add(ringParameter.ViewingAngle_Random.Min.GetBytes());
}
else if (ringParameter.ViewingAngle.GetValue() == Data.RendererValues.RingParamater.ViewingAngleType.Easing)
{
AddFloatEasing(data, ringParameter.ViewingAngle_Easing);
}
}
void AddLocation(Enum <Data.RendererValues.RingParamater.LocationType> locationType,
Data.RendererValues.RingParamater.FixedLocation @fixed,
Data.RendererValues.RingParamater.PVALocation pva,
Vector2DEasingParamater easingParam)
{
data.Add(locationType);
if (locationType.GetValue() == Data.RendererValues.RingParamater.LocationType.Fixed)
{
data.Add((@fixed.Location.X.Value).GetBytes());
data.Add((@fixed.Location.Y.Value).GetBytes());
}
else if (locationType.GetValue() == Data.RendererValues.RingParamater.LocationType.PVA)
{
data.Add(pva.Location.GetBytes());
data.Add(pva.Velocity.GetBytes());
data.Add(pva.Acceleration.GetBytes());
}
else if (locationType.GetValue() == Data.RendererValues.RingParamater.LocationType.Easing)
{
data.Add((byte[])easingParam.Start.GetBytes());
data.Add((byte[])easingParam.End.GetBytes());
AddEasing(data, easingParam.StartSpeed, easingParam.EndSpeed);
}
}
void AddCenterRatio()
{
data.Add(ringParameter.CenterRatio);
if (ringParameter.CenterRatio.GetValue() == Data.RendererValues.RingParamater.CenterRatioType.Fixed)
{
data.Add(ringParameter.CenterRatio_Fixed.Value.GetBytes());
}
else if (ringParameter.CenterRatio.GetValue() == Data.RendererValues.RingParamater.CenterRatioType.Random)
{
data.Add(ringParameter.CenterRatio_Random.Max.GetBytes());
data.Add(ringParameter.CenterRatio_Random.Min.GetBytes());
}
else if (ringParameter.CenterRatio.GetValue() == Data.RendererValues.RingParamater.CenterRatioType.Easing)
{
Utils.ExportEasing(ringParameter.CenterRatio_Easing, 1.0f, data, version, version >= ExporterVersion.Ver16Alpha9);
}
}
void AddColor(Enum <Data.RendererValues.RingParamater.ColorType> parameter,
Color @fixed,
ColorWithRandom random,
ColorEasingParamater easingParam)
{
data.Add(parameter);
if (parameter.Value == Data.RendererValues.RingParamater.ColorType.Fixed)
{
data.Add((byte[])@fixed);
}
else if (parameter.Value == Data.RendererValues.RingParamater.ColorType.Random)
{
data.Add((byte[])random);
}
else if (parameter.Value == Data.RendererValues.RingParamater.ColorType.Easing)
{
AddColorEasing(data, easingParam);
}
}
}
