public SolarData(ConfigNode node)
{
name = node.GetStringValue("name");
modelName = node.GetStringValue("modelName", name);
def = SSTUModelData.getModelDefinition(modelName);
ConfigNode solarNode = def.configNode.GetNode("SOLARDATA");
//loaded from SOLARDATA from model def
animationName = solarNode.GetStringValue("animationName");
pivotNames = solarNode.GetStringValue("pivotNames");
secPivotNames = solarNode.GetStringValue("secPivotNames");
sunNames = solarNode.GetStringValue("sunNames");
panelsEnabled = solarNode.GetBoolValue("enabled");
sunAxis = solarNode.GetStringValue("sunAxis", SSTUSolarPanelDeployable.Axis.ZPlus.ToString());
//loaded from SOLARDATA with option of per-model override (energy, tech-unlock-upgrade-name)
upgradeName = node.GetStringValue("upgrade", solarNode.GetStringValue("upgrade"));
energy = node.GetFloatValue("energy", solarNode.GetFloatValue("energy"));//allow local override of energy
ConfigNode[] posNodes = node.GetNodes("POSITION");
int len = posNodes.Length;
positions = new SolarPosition[len];
for (int i = 0; i < len; i++)
{
positions[i] = new SolarPosition(posNodes[i]);
}
}
//called from the ModuleManagerPostLoad() callback for KSPShaderTools
public void KSPShaderToolsPostLoad()
{
MonoBehaviour.print("Reloading config databases (fuel types, model data, etc...)");
FuelTypes.INSTANCE.loadConfigData();
VolumeContainerLoader.loadConfigData(); //needs to be loaded after fuel types
SSTUDatabase.loadConfigData(); //loads heat-shield types
SSTUModelData.loadConfigData();
}
public void ModuleManagerPostLoad()
{
MonoBehaviour.print("Reloading config databases (fuel types, model data, etc...)");
FuelTypes.INSTANCE.loadConfigData();
VolumeContainerLoader.loadConfigData();//needs to be loaded after fuel types
SSTUModelData.loadConfigData();
SSTUDatabase.loadConfigData();
}
private void initialize()
{
if (initialized)
{
return;
}
initialized = true;
recolorHandler = new RecoloringHandler(Fields[nameof(customColorData)]);
ConfigNode node = SSTUConfigNodeUtils.parseConfigNode(configNodeData);
string[] names = node.GetStringValues("textureSet");
string[] titles = SSTUUtils.getNames(TexturesUnlimitedLoader.getTextureSets(names), m => m.title);
TextureSet currentTextureSetData = TexturesUnlimitedLoader.getTextureSet(currentTextureSet);
if (currentTextureSetData == null)
{
currentTextureSet = names[0];
currentTextureSetData = TexturesUnlimitedLoader.getTextureSet(currentTextureSet);
initializedColors = false;
}
if (!initializedColors)
{
initializedColors = true;
recolorHandler.setColorData(currentTextureSetData.maskColors);
}
this.updateUIChooseOptionControl(nameof(currentTextureSet), names, titles, true, currentTextureSet);
Fields[nameof(currentTextureSet)].guiActiveEditor = names.Length > 1;
fuelType = VolumeContainerLoader.getPreset(fuelPreset);
Transform modelBase = part.transform.FindRecursive("model");
//Set up the engine models container
ConfigNode[] modelNodes = node.GetNodes("MODEL");
engineModelRoot = modelBase.FindOrCreate(engineModelRootName);
ModelDefinitionLayoutOptions[] models = SSTUModelData.getModelDefinitions(modelNodes);
engineModels = new ModelModule <SSTUInterstageDecoupler>(part, this, engineModelRoot, ModelOrientation.CENTRAL, nameof(currentEngineModel), nameof(currentEngineLayout), nameof(currentEngineTextureSet), nameof(customEngineColorData), null, null, null, null);
engineModels.getSymmetryModule = m => m.engineModels;
engineModels.getValidOptions = () => models;
engineModels.getLayoutPositionScalar = () => currentBottomDiameter * 0.5f;
//engineModels.getLayoutScaleScalar = () => currentEngineScale;
engineModels.setupModelList(models);
engineModels.setupModel();
engineModels.updateSelections();
updateEnginePositionAndScale();
//set up the fairing container
minHeight = engineModels.moduleHeight;
Transform fairingContainerRoot = modelBase.FindOrCreate(baseTransformName);
fairingBase = new FairingContainer(fairingContainerRoot.gameObject, cylinderSides, numberOfPanels, wallThickness);
updateEditorFields();
buildFairing();
updateEnginePositionAndScale();
updateFairingTextureSet(false);
updateNodePositions(false);
updatePartMass();
}
public ModelData(ConfigNode node)
{
name = node.GetStringValue("name");
modelDefinition = SSTUModelData.getModelDefinition(name);
if (modelDefinition == null)
{
MonoBehaviour.print("ERROR: Could not locate model data for name: " + name);
}
volume = node.GetFloatValue("volume", modelDefinition.volume);
minVerticalScale = node.GetFloatValue("minVerticalScale", 1f);
maxVerticalScale = node.GetFloatValue("maxVerticalScale", 1f);
}
public ModelData(String name)
{
this.name = name;
modelDefinition = SSTUModelData.getModelDefinition(name);
if (modelDefinition == null)
{
MonoBehaviour.print("ERROR: Could not locate model definition data for name: " + name);
}
currentDiameter = modelDefinition.diameter;
currentHeight = modelDefinition.height;
volume = modelDefinition.volume;
mass = modelDefinition.mass;
cost = modelDefinition.cost;
}
/// <summary>
/// Create a group of model definition layout sets. Loads the model definitions + their supported layout configurations.
/// </summary>
/// <param name="nodes"></param>
/// <returns></returns>
public static ModelDefinitionLayoutOptions[] getModelDefinitions(ConfigNode[] nodes)
{
int len = nodes.Length;
List <ModelDefinitionLayoutOptions> options = new List <ModelDefinitionLayoutOptions>();
List <ModelLayoutData> layoutDataList = new List <ModelLayoutData>();
ModelDefinition def;
string[] groupedNames;
string[] groupedLayouts;
int len2;
for (int i = 0; i < len; i++)
{
//because configNode.ToString() reverses the order of values, and model def layouts are always loaded from string-cached config nodes
//we need to reverse the order of the model and layout names during parsing
groupedNames = nodes[i].GetStringValues("model");
groupedLayouts = nodes[i].GetStringValues("layout", new string[] { "default" });
len2 = groupedNames.Length;
for (int k = 0; k < len2; k++)
{
def = SSTUModelData.getModelDefinition(groupedNames[k]);
layoutDataList.AddRange(ModelLayout.findLayouts(groupedLayouts));
if (nodes[i].HasValue("position") || nodes[i].HasValue("rotation") || nodes[i].HasValue("scale"))
{
Vector3 pos = nodes[i].GetVector3("position", Vector3.zero);
Vector3 scale = nodes[i].GetVector3("scale", Vector3.one);
Vector3 rot = nodes[i].GetVector3("rotation", Vector3.zero);
ModelPositionData mpd = new ModelPositionData(pos, scale, rot);
ModelLayoutData custom = new ModelLayoutData("default", new ModelPositionData[] { mpd });
if (layoutDataList.Exists(m => m.name == "default"))
{
ModelLayoutData del = layoutDataList.Find(m => m.name == "default");
layoutDataList.Remove(del);
}
layoutDataList.Add(custom);
}
if (def == null)
{
error("Model definition was null for name: " + groupedNames[k] + ". Skipping definition during loading of part");
}
else
{
options.Add(new ModelDefinitionLayoutOptions(def, layoutDataList.ToArray()));
}
layoutDataList.Clear();
}
}
return(options.ToArray());
}
private void initialize()
{
if (initialized)
{
return;
}
initialized = true;
double hsp = 1;
double dens = 1;
PartResourceDefinition resource = PartResourceLibrary.Instance.GetDefinition(resourceName);
hsp = resource.specificHeatCapacity;
dens = resource.density;
fluxPerResourceUnit = hsp * ablationEfficiency * dens;
baseSkinIntMult = part.skinInternalConductionMult;
baseCondMult = part.heatConductivity;
ConfigNode node = SSTUConfigNodeUtils.parseConfigNode(configNodeData);
Transform mhsRoot = part.transform.FindRecursive("model").FindOrCreate("SSTU-MHS-Root");
ConfigNode[] modelNodes = node.GetNodes("MODELS");
ModelDefinitionLayoutOptions[] models = SSTUModelData.getModelDefinitions(modelNodes);
model = new ModelModule <SSTUModularHeatShield>(part, this, mhsRoot, ModelOrientation.CENTRAL, nameof(currentShieldModel), null, nameof(currentShieldTexture), nameof(modelPersistentData), null, null, null, null);
model.getSymmetryModule = (m) => m.model;
model.setupModelList(models);
model.setupModel();
model.setScaleForDiameter(currentDiameter);
model.setPosition(0);
model.updateModelMeshes();
model.updateSelections();
model.volumeScalar = resourceScalePower;
model.massScalar = resourceScalePower;
if (standAlonePart)
{
updateDragCube();
updateAttachNodes(false);
}
SSTUModInterop.updateResourceVolume(part);
ConfigNode[] typeNodes = node.GetNodes("SHIELDTYPE");
shieldTypeData = HeatShieldTypeData.load(typeNodes);
currentShieldTypeData = Array.Find(shieldTypeData, m => m.baseType.name == currentShieldType);
updateModuleStats();
updatePartCost();
SSTUModInterop.onPartGeometryUpdate(part, false);
SSTUModInterop.updateResourceVolume(part);
SSTUStockInterop.fireEditorUpdate();//update for mass/cost/etc.
}
private void init()
{
if (initialized)
{
return;
}
initialized = true;
standoffRotatedRoot = part.transform.FindRecursive("SSTUModularRCSStructureRoot");
if (standoffRotatedRoot == null)
{
standoffRotatedRoot = new GameObject("SSTUModularRCSStructureRoot").transform;
standoffRotatedRoot.NestToParent(part.transform.FindRecursive("model"));
standoffRotatedRoot.Rotate(90, -90, 0);
}
modelRotatedRoot = part.transform.FindRecursive("SSTUModularRCSBlockRoot");
if (modelRotatedRoot == null)
{
modelRotatedRoot = new GameObject("SSTUModularRCSBlockRoot").transform;
modelRotatedRoot.NestToParent(part.transform.FindRecursive("model"));
modelRotatedRoot.Rotate(0, 0, 0);
}
ConfigNode node = SSTUConfigNodeUtils.parseConfigNode(configNodeData);
ModelDefinitionLayoutOptions[] blocks = SSTUModelData.getModelDefinitions(node.GetNodes("MODEL"));
ModelDefinitionLayoutOptions[] structs = SSTUModelData.getModelDefinitions(node.GetNodes("STRUCTURE"));
modelTransform = modelRotatedRoot.FindOrCreate("ModularRCSModel");
rcsBlockModule = new ModelModule <SSTUModularRCS>(part, this, modelTransform, ModelOrientation.CENTRAL, nameof(currentModel), nameof(currentLayout), nameof(currentTexture), nameof(modelPersistentData), null, null, null, null);
rcsBlockModule.name = "RCSBlock";
rcsBlockModule.getSymmetryModule = m => m.rcsBlockModule;
rcsBlockModule.setupModelList(blocks);
rcsBlockModule.getValidOptions = () => blocks;
rcsBlockModule.setupModel();
rcsBlockModule.updateSelections();
standoffTransform = standoffRotatedRoot.FindOrCreate("ModularRCSStandoff");
standoffModule = new ModelModule <SSTUModularRCS>(part, this, standoffTransform, ModelOrientation.TOP, nameof(currentStructure), nameof(currentLayout), nameof(currentStructureTexture), nameof(structurePersistentData), null, null, null, null);
standoffModule.name = "Standoff";
standoffModule.getSymmetryModule = m => m.standoffModule;
standoffModule.setupModelList(structs);
standoffModule.getValidOptions = () => structs;
standoffModule.setupModel();
standoffModule.updateSelections();
updateModelScale();
updateMassAndCost();
rcsBlockModule.renameRCSThrustTransforms(rcsThrustTransformName);
updateAttachNodes(false);
}
private void initialize()
{
if (!moduleIsEnabled)
{
//TODO -- UI disabling
return;
}
if (initialized)
{
return;
}
initialized = true;
AnimationData animData = null;
ModelSolarData msd = null;
ConfigNode node = SSTUConfigNodeUtils.parseConfigNode(configNodeData);
if (node.HasValue("modelDefinition"))
{
ModelDefinition def = SSTUModelData.getModelDefinition(node.GetStringValue("modelDefinition"));
if (def == null)
{
MonoBehaviour.print("Could not locate model definition: " + node.GetStringValue("modelDefinition") + " for solar data");
}
else
{
animData = def.animationData;
msd = def.solarModuleData;
}
}
//allow local override of animation data
if (node.HasNode("ANIMATIONDATA"))
{
animData = new AnimationData(node.GetNode("ANIMATIONDATA"));
}
if (node.HasNode("SOLARDATA"))
{
msd = new ModelSolarData(node.GetNode("SOLARDATA"));
}
animationModule = new AnimationModule(part, this, nameof(persistentState), null, nameof(extendEvent), nameof(retractEvent));
animationModule.getSymmetryModule = m => ((SSTUSolarPanelDeployable)m).animationModule;
animationModule.setupAnimations(animData, part.transform.FindRecursive("model"), animationLayer);
solarModule = new SolarModule(part, this, animationModule, Fields[nameof(solarPersistentData)], Fields[nameof(guiStatus)]);
solarModule.getSymmetryModule = m => ((SSTUSolarPanelDeployable)m).solarModule;
solarModule.setupSolarPanelData(new ModelSolarData[] { msd }, new Transform[] { part.transform.FindRecursive("model") });
nominalSolarOutput = solarModule.standardPotentialOutput;
}
public ModelData(ConfigNode node)
{
name = node.GetStringValue("name");
modelDefinition = SSTUModelData.getModelDefinition(name);
if (modelDefinition == null)
{
MonoBehaviour.print("ERROR: Could not locate model data for name: " + name);
}
currentDiameter = modelDefinition.diameter;
currentHeight = modelDefinition.height;
volume = node.GetFloatValue("volume", modelDefinition.volume);
mass = node.GetFloatValue("mass", modelDefinition.mass);
cost = node.GetFloatValue("cost", modelDefinition.cost);
minVerticalScale = node.GetFloatValue("minVerticalScale", 1f);
maxVerticalScale = node.GetFloatValue("maxVerticalScale", 1f);
baseScale = node.GetFloatValue("scale", baseScale);
}
public ModelSwitchData(ConfigNode node, Part owner, ModelSwitchGroup group)
{
name = node.GetStringValue("name");
modelName = node.GetStringValue("modelName", name);
groupName = node.GetStringValue("group", groupName);
containerIndex = node.GetIntValue("containerIndex", 0);
localPosition = node.GetVector3("localPosition", Vector3.zero);
localRotation = node.GetVector3("localRotation", Vector3.zero);
scale = node.GetFloatValue("scale", scale);
nodes = ModelNodeData.load(node.GetStringValues("node"));
suppressNode = nodes.Length > 0;
modelDefinition = SSTUModelData.getModelDefinition(modelName);
if (modelDefinition == null)
{
throw new NullReferenceException("Could not locate model data for name: " + modelName + " :: " + name);
}
this.part = owner;
this.group = group;
this.group.add(this);
}
public void ModuleManagerPostLoad()
{
MonoBehaviour.print("Creating Part Config cache.");
partConfigNodes.Clear();
ConfigNode[] partNodes = GameDatabase.Instance.GetConfigNodes("PART");
String name;
foreach (ConfigNode node in partNodes)
{
name = node.GetStringValue("name");
name = name.Replace('_', '.');
if (partConfigNodes.ContainsKey(name))
{
continue;
}
partConfigNodes.Add(name, node);
}
MonoBehaviour.print("Reloading config databases (fuel types, model data, etc...)");
FuelTypes.INSTANCE.loadConfigData();
VolumeContainerLoader.loadConfigData();//needs to be loaded after fuel types
SSTUModelData.loadConfigData();
SSTUDatabase.loadConfigData();
}
public SSTUEngineLayout(ConfigNode node)
{
name = node.GetStringValue("name");
mountSizeMult = node.GetFloatValue("mountSizeMult", mountSizeMult);
defaultUpperStageMount = node.GetStringValue("defaultUpperStageMount", defaultUpperStageMount);
defaultLowerStageMount = node.GetStringValue("defaultLowerStageMount", defaultLowerStageMount);
ConfigNode[] posNodes = node.GetNodes("POSITION");
int len = posNodes.Length;
for (int i = 0; i < len; i++)
{
positions.Add(new SSTUEnginePosition(posNodes[i]));
}
ConfigNode[] mountNodes = node.GetNodes("MOUNT");
len = mountNodes.Length;
List <SSTUEngineLayoutMountOption> mountOptionsList = new List <SSTUEngineLayoutMountOption>();
string mountName;
ModelDefinition md;
for (int i = 0; i < len; i++)
{
mountName = mountNodes[i].GetStringValue("name");
md = SSTUModelData.getModelDefinition(mountName);
if (md != null)
{
mountOptionsList.Add(new SSTUEngineLayoutMountOption(mountNodes[i]));
}
else
{
MonoBehaviour.print("ERROR: Could not locate mount model data for name: " + mountName + " -- please check your configs for errors.");
}
}
mountOptions = mountOptionsList.ToArray();
}
private void initialize()
{
if (initialized)
{
return;
}
initialized = true;
ConfigNode node = SSTUConfigNodeUtils.parseConfigNode(configNodeData);
ModelDefinitionLayoutOptions[] defs = SSTUModelData.getModelDefinitions(node.GetNodes("MODEL"));
Transform root = part.transform.FindRecursive("model").FindOrCreate(rootTransformName);
models = new ModelModule <SSTUModelSwitch>(part, this, root, ModelOrientation.TOP, nameof(currentModel), null, nameof(currentTexture), nameof(modelPersistentData), nameof(animationPersistentData), nameof(animationMaxDeploy), nameof(enableAnimationEvent), nameof(disableAnimationEvent));
models.name = "ModelSwitch";
models.getSymmetryModule = m => m.models;
models.getValidOptions = () => defs;
models.setupModelList(defs);
models.setupModel();
models.setScale(currentScale);
models.updateModelMeshes();
models.updateSelections();
updateMassAndCost();
updateAttachNodes(false);
}
