public void HighlightObject(GameObject obj, bool highlighted, Color hlColor)
{
if (obj == null)
{
throw new NullReferenceException();
}
bool alreadyHighlighted = highlightedObjects.ContainsKey(obj);
UnhighlightAll(obj);
// unhighlight all
if (highlighted && !alreadyHighlighted)
{
MaterialMap origMaterialMap = new MaterialMap();
MaterialMap highlightMaterialMap = new MaterialMap();
RenderingUtility.CloneMaterials(obj, origMaterialMap, highlightMaterialMap);
RenderingUtility.ChangeColor(obj, hlColor, true, true);
highlightedObjects.Add(obj, origMaterialMap);
}
if (!highlighted && highlightedObjects.ContainsKey(obj))
{
RenderingUtility.ReplaceMaterials(obj, highlightedObjects[obj]);
highlightedObjects[obj].Clear();
highlightedObjects.Remove(obj);
}
}
private void updateText()
{
var pos = selector.position;
text.text = "[" + pos.x + ", " + pos.y + ", " + pos.z + "]" + "\n"
+ map.blockType.getEnumValue(pos).NAME + " " + MaterialMap.get().material(map.blockType.getMaterial(pos)).name;
}
public MainWindow() : base(800, 600, false)
{
Version = "LancerEdit " + Platform.GetInformationalVersion <MainWindow>();
MaterialMap = new MaterialMap();
MaterialMap.AddRegex(new LibreLancer.Ini.StringKeyValue("^nomad.*$", "NomadMaterialNoBendy"));
MaterialMap.AddRegex(new LibreLancer.Ini.StringKeyValue("^n-texture.*$", "NomadMaterialNoBendy"));
FLLog.UIThread = this;
FLLog.AppendLine = (x, severity) =>
{
logText.AppendLine(x);
if (logText.Length > 16384)
{
logText.Remove(0, logText.Length - 16384);
}
logBuffer.SetText(logText.ToString());
if (severity == LogSeverity.Error)
{
errorTimer = 9;
Bell.Play();
}
};
Config = EditorConfiguration.Load();
logBuffer = new TextBuffer(32768);
recentFiles = new RecentFilesHandler(OpenFile);
}
public static void Init()
{
var map = new MaterialMap();
map.AddMap("EcEtOcOt", "DcDtOcOt");
map.AddMap("DcDtEcEt", "DcDtEt");
map.AddRegex("^nomad.*$", "NomadMaterialNoBendy");
map.AddRegex("^n-texture.*$", "NomadMaterialNoBendy");
map.AddRegex("^ui_.*", "HUDIconMaterial");
map.AddRegex("^exclusion_.*", "ExclusionZoneMaterial");
map.AddRegex("^c_glass$", "HighGlassMaterial");
map.AddRegex("^cv_glass$", "HighGlassMaterial");
map.AddRegex("^b_glass$", "HighGlassMaterial");
map.AddRegex("^k_glass$", "HighGlassMaterial");
map.AddRegex("^l_glass$", "HighGlassMaterial");
map.AddRegex("^r_glass$", "HighGlassMaterial");
map.AddRegex("^planet.*_glass$", "GFGlassMaterial");
map.AddRegex("^bw_glass$", "HighGlassMaterial");
map.AddRegex("^o_glass$", "HighGlassMaterial");
map.AddRegex("^anim_hud.*$", "HUDAnimMaterial");
map.AddRegex("^sea_anim.*$", "PlanetWaterMaterial");
map.AddRegex("^null$", " NullMaterial");
}
public DacomIni()
{
foreach (Section s in ParseFile("EXE\\dacom.ini", true))
{
switch (s.Name.ToLowerInvariant())
{
case "materialmap":
var map = new MaterialMap();
foreach (Entry e in s)
{
if (e.Name.ToLowerInvariant() != "name")
{
map.AddMap(e.Name, e [0].ToString());
}
else
{
map.AddRegex(e [0].ToKeyValue());
}
}
break;
default:
break;
}
}
}
//纹理测试
static private void createMaterial(Database db, Transaction myT)
{
DBDictionary dic =
(DBDictionary)myT.GetObject(db.MaterialDictionaryId, OpenMode.ForWrite, false);
ImageFileTexture imfttr = new ImageFileTexture();
imfttr.SourceFileName = @"D:\Geological Project\Geological Source\dbFiles\aaaaa.jpg";
double uScale = 1.0;
double vScale = 1.0;
double uOffset = 0;
double vOffset = 0;
double[] p = new double[] {
uScale, 0, 0, uScale *uOffset,
0, vScale, 0, vScale *vOffset,
0, 0, 1, 0,
0, 0, 0, 1
};
Matrix3d mx = new Matrix3d(p);
Mapper mapper = new Mapper(Projection.Planar, Tiling.Crop, Tiling.Crop,
AutoTransform.TransformObject, mx);
MaterialMap map = new MaterialMap(Source.File, imfttr, 1, mapper);
EntityColor eclr = new EntityColor(150, 150, 150);
MaterialColor mc = new MaterialColor(Method.Override, 1, eclr);
MaterialDiffuseComponent mdc = new MaterialDiffuseComponent(mc, map);
MaterialSpecularComponent mck = new MaterialSpecularComponent(mc, map, 0.5);
MaterialOpacityComponent moc = new MaterialOpacityComponent(1, map);
MaterialRefractionComponent mrfr = new MaterialRefractionComponent(2, map);
Material Mat = new Material();
Mat.Name = "My Material";
Mat.Description = "New Material";
Mat.Diffuse = mdc;
Mat.Specular = mck;
Mat.Refraction = mrfr;
Mat.Reflectivity = 1;
Mat.Reflection = map;
Mat.Opacity = moc;
Mat.Ambient = mc;
Mat.Bump = map;
Mat.SelfIllumination = 1;
// MaterialDiffuseComponent diffuseColor = new MaterialDiffuseComponent(color, map);
// material.Diffuse = diffuseColor;
// material.Mode = Mode.Realistic;
dic.SetAt(Mat.Name, Mat);
}
/// <summary>
/// Store a map of renderers and their materials into a dictionary
/// </summary>
/// <param name="targetObject">Game object to scan</param>
/// <param name="materialsBackup">Dictionary used to map renderers to their materials</param>
public static void BackupMaterials(GameObject targetObject, MaterialMap materialsBackup)
{
materialsBackup.Clear();
foreach (Renderer mr in targetObject.GetComponentsInChildren <Renderer>(true))
{
materialsBackup.Add(mr, mr.sharedMaterial);
}
}
private void createLayerGroup(string tag, int totalThickness, string type)
{
List <Material_> materials = MaterialMap.get().getByTag(tag);
int singleLayerThickness = totalThickness / materials.Count;
materials.ForEach(material => layers.Add(generateLayer(material.name, singleLayerThickness - 1, singleLayerThickness + 1)));
Debug.Log(type + " stone layers created, total: " + totalThickness + ", single: " + singleLayerThickness);
}
/// <summary>
///
/// </summary>
void InitMaps()
{
//APPEND NEW TYPES HERE
if (AnimationClips == null)
{
AnimationClips = new AnimationClipMap();
}
if (AnimatorControllers == null)
{
AnimatorControllers = new AnimatorControllerMap();
}
if (AudioClips == null)
{
AudioClips = new AudioClipMap();
}
if (Fonts == null)
{
Fonts = new FontMap();
}
if (GameObjects == null)
{
GameObjects = new GameObjectMap();
}
if (Materials == null)
{
Materials = new MaterialMap();
}
if (Meshes == null)
{
Meshes = new MeshMap();
}
if (PhysicMaterials == null)
{
PhysicMaterials = new PhysicMaterialMap();
}
if (PhysicsMaterial2Ds == null)
{
PhysicsMaterial2Ds = new PhysicsMaterial2DMap();
}
if (Shaders == null)
{
Shaders = new ShaderMap();
}
if (Sprites == null)
{
Sprites = new SpriteMap();
}
if (Texture2Ds == null)
{
Texture2Ds = new Texture2DMap();
}
if (Texture3Ds == null)
{
Texture3Ds = new Texture3DMap();
}
}
/// <summary>
/// Replace the materials of a game object using a previously stored map (see <see cref="BackupMaterials"/>)
/// </summary>
/// <param name="targetObject">Game object to scan</param>
/// <param name="materialsBackup">Dictionary that maps renderers to their materials</param>
/// <remarks>If the given dictionary does not match the renderers the behaviour is undefined.</remarks>
public static void ReplaceMaterials(GameObject targetObject, MaterialMap materialsBackup)
{
foreach (Renderer mr in targetObject.GetComponentsInChildren <Renderer>(true))
{
if (materialsBackup.ContainsKey(mr))
{
mr.sharedMaterial = materialsBackup[mr];
}
}
}
public void Initialize(MaterialMap matmap, long seed)
{
mMap = matmap;
this.Seed = seed;
Frequency = 0.03;
ContinentNoiseFrequency = Frequency / 2.0;
Lacunarity = 0.01;
Persistance = 0.01;
OctaveCount = 1;
Seed = seed;
TerrainNoise = new FastNoise();
ContinentNoise = new FastNoise();
CaveNoise = new Perlin();
GravelNoise = new Perlin();
TreeNoise = new Perlin();
TerrainNoise.Seed = (int)Seed;
ContinentNoise.Seed = (int)Seed + 2;
CaveNoise.Seed = (int)Seed + 3;
GravelNoise.Seed = (int)Seed + 4;
TreeNoise.Seed = (int)Seed + 4;
rand = new Random((int)Seed);
TerrainNoise.Frequency = Frequency;
TerrainNoise.NoiseQuality = NoiseQuality;
TerrainNoise.OctaveCount = OctaveCount;
TerrainNoise.Lacunarity = Lacunarity;
TerrainNoise.Persistence = Persistance;
ContinentNoise.Frequency = ContinentNoiseFrequency;
ContinentNoise.NoiseQuality = NoiseQuality;
ContinentNoise.OctaveCount = OctaveCount;
ContinentNoise.Lacunarity = Lacunarity;
ContinentNoise.Persistence = Persistance;
CaveNoise.Frequency = Frequency;
CaveNoise.NoiseQuality = NoiseQuality;
CaveNoise.OctaveCount = OctaveCount + 2;
CaveNoise.Lacunarity = Lacunarity;
CaveNoise.Persistence = Persistance;
GravelNoise.Frequency = Frequency;
GravelNoise.NoiseQuality = NoiseQuality;
GravelNoise.OctaveCount = OctaveCount;
GravelNoise.Lacunarity = Lacunarity;
GravelNoise.Persistence = Persistance;
TreeNoise.Frequency = Frequency + 2;
TreeNoise.NoiseQuality = NoiseQuality;
TreeNoise.OctaveCount = OctaveCount;
TreeNoise.Lacunarity = Lacunarity;
TreeNoise.Persistence = Persistance;
}
/// <summary>
/// Replace the materials in a game object with a copy of each one of them.
/// Both the original materials and the cloned materials are stored in the given dictionaries.
/// </summary>
/// <param name="targetObject">Game object to scan</param>
/// <param name="originalMaterials">Dictionary that maps renderers to their original materials</param>
/// <param name="newMaterials">Dictionary that maps renderers to their cloned materials</param>
/// <remarks>The given dictionaries are cleaned before they are filled.</remarks>
public static void CloneMaterials(GameObject targetObject, MaterialMap originalMaterials, MaterialMap newMaterials)
{
originalMaterials.Clear();
newMaterials.Clear();
foreach (Renderer mr in targetObject.GetComponentsInChildren <Renderer>(true))
{
originalMaterials.Add(mr, mr.sharedMaterial);
mr.sharedMaterial = Material.Instantiate(mr.sharedMaterial);
newMaterials.Add(mr, mr.sharedMaterial);
}
}
private static ObjectId AddMaterial(string nameWood)
{
//
Database db = Application.DocumentManager.MdiActiveDocument.Database;
TransactionManager tm = db.TransactionManager;
Transaction trans = tm.StartTransaction();
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
ObjectId materialId = ObjectId.Null;
try
{
DBDictionary materialDict;
ObjectId materialDictId = db.MaterialDictionaryId;
materialDict = trans.GetObject(materialDictId, OpenMode.ForWrite) as DBDictionary;
Material material = new Material();
material.Name = nameWood;
WoodTexture woodTexture = new WoodTexture();
MaterialColor matColor, woodColor1, woodColor2;
EntityColor entColor = new EntityColor(128, 0, 128);
matColor = new MaterialColor(Method.Override, 1.0, entColor);
EntityColor entColor2 = new EntityColor(128, 128, 0);
woodColor1 = new MaterialColor(Method.Override, 1.0, entColor2);
EntityColor entColor3 = new EntityColor(0, 128, 128);
woodColor2 = new MaterialColor(Method.Override, 1.0, entColor3);
woodTexture.Color1 = woodColor1;
woodTexture.Color2 = woodColor2;
MaterialMap materialMap = new MaterialMap(Source.Procedural, woodTexture, 0, null);
material.Diffuse = new MaterialDiffuseComponent(matColor, materialMap);
MaterialColor inheritColor = new MaterialColor(Method.Inherit, 1.0, entColor);
material.Ambient = matColor;
material.Specular = new MaterialSpecularComponent(matColor, new MaterialMap(), 0.5);
material.Mode = Mode.Realistic;
materialDict.SetAt(nameWood, material);
materialId = material.ObjectId;
trans.Commit();
}
catch (System.Exception e)
{
ed.WriteMessage(e.Message);
trans.Abort();
}
return(materialId);
}
void Awake () {
if (instance == null)
{
instance = this;
}
else
{
Debug.LogWarning("You should only have 1 MaterialMap per scene. Deleting duplicate.");
Destroy(gameObject);
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
MaterialMap.createInstance(modelBuilder);
ItemMaterialMap.createInstance(modelBuilder);
CategoriaMap.createInstance(modelBuilder);
ClassificacaoMap.createInstance(modelBuilder);
MaterialRelacionamento.createInstance(modelBuilder);
modelBuilder.HasDefaultSchema("dbo");
}
private void updateText()
{
if (cacheTarget == modelPosition)
{
return;
}
var pos = modelPosition;
if (!map.inMap(pos))
{
return;
}
text.text = "[" + pos.x + ", " + pos.y + ", " + pos.z + "]" + "\n"
+ map.blockType.getEnumValue(pos).NAME + " " + MaterialMap.get().material(map.blockType.getMaterial(pos)).name;
cacheTarget = modelPosition;
}
public MainWindow(bool useDX9) : base(800, 600, false, useDX9)
{
MaterialMap = new MaterialMap();
MaterialMap.AddRegex(new LibreLancer.Ini.StringKeyValue("^nomad.*$", "NomadMaterialNoBendy"));
MaterialMap.AddRegex(new LibreLancer.Ini.StringKeyValue("^n-texture.*$", "NomadMaterialNoBendy"));
FLLog.UIThread = this;
FLLog.AppendLine = (x) =>
{
logText.AppendLine(x);
if (logText.Length > 16384)
{
logText.Remove(0, logText.Length - 16384);
}
logBuffer.SetText(logText.ToString());
};
logBuffer = new TextBuffer(32768);
}
private static IEnumerator ImportRoutine(string dtuPath, string fbxPath)
{
Daz3DBridge.CurrentToolbarMode = Daz3DBridge.ToolbarMode.History;//force into history mode during import
Daz3DBridge.Progress = .03f;
yield return(new WaitForEndOfFrame());
_map = new MaterialMap(dtuPath);
while (!IrayShadersReady())
{
yield return(new WaitForEndOfFrame());
}
var dtu = new DTU();
var routine = ImportDTURoutine(dtuPath, (d => dtu = d), .8f);
while (routine.MoveNext())
{
yield return(new WaitForEndOfFrame());
}
//ImportDTU(dtuPath);
DazFigurePlatform platform = DiscoverFigurePlatform(dtu);
Daz3DBridge.Progress = .9f;
yield return(new WaitForEndOfFrame());
if (GenerateUnityPrefab)
{
GeneratePrefabFromFBX(fbxPath, platform);
}
Daz3DBridge.Progress = 1f;
yield return(new WaitForEndOfFrame());
_map = null;
Daz3DBridge.Progress = 0;
yield break;
}
public EcsEntity generateItem(string typeName, string materialName, Vector3Int position, EcsEntity entity)
{
ItemType type = ItemTypeMap.getItemType(typeName);
if (type == null)
{
Debug.LogError("Type " + typeName + " not found.");
}
Material_ material = MaterialMap.get().material(materialName);
entity.Replace(new ItemComponent {
material = material.id, type = typeName, materialString = material.name, volume = 1, weight = material.density * 1
});
entity.Replace(new PositionComponent {
position = position
});
entity.Replace(new NameComponent());
// entity.Replace(new ItemVisualComponent());
return(entity);
}
public void loadAll()
{
SpriteAtlas atlas = Resources.Load <SpriteAtlas>("tilesets/local_blocks/blockSpriteAtlas");
List <Material_> materials = MaterialMap.get().all;
foreach (Material_ material in materials)
{
if (material.tileset != null)
{
Sprite sprite = getSprite(atlas, material);
Dictionary <string, Tile> tileset = loader.slice(sprite);
tileset.Values.ToList().ForEach(tile => tile.color = material.color); // update tile colors
tilesets.Add(material.name, tileset);
}
}
Sprite selection = atlas.GetSprite("selection");
Dictionary <string, Tile> tileset2 = loader.slice(selection);
tilesets.Add("selection", tileset2);
flushNotFound();
}
public static void Test1()
{
Database database = HostApplicationServices.WorkingDatabase;
Document activeDoc = Application.DocumentManager.MdiActiveDocument;
Database db = activeDoc.Database;
Editor ed = activeDoc.Editor;
PromptEntityResult oRes = ed.GetEntity("Select Entity");
using (Transaction transaction = database.TransactionManager.StartTransaction())
{
Face oFace = transaction.GetObject(oRes.ObjectId, OpenMode.ForRead) as Face;
if (oFace != null)
{
string strMat = oFace.Material;
ObjectId nMat = oFace.MaterialId;
//Here change Entity MaterialId to ByBlock
DBDictionary matLib = transaction.GetObject(
db.MaterialDictionaryId,
OpenMode.ForRead
) as DBDictionary;
if (matLib.Contains("EngineTurned"))
{
ObjectId MaterialId = matLib.GetAt("EngineTurned");
Material mat = transaction.GetObject(MaterialId, OpenMode.ForRead) as Material;
}
Material material = transaction.GetObject(nMat, OpenMode.ForRead) as Material;
MaterialMap map = material.Diffuse.Map;
ImageFileTexture ift = map.Texture as ImageFileTexture;
ift.SourceFileName = "";
}
}
}
public void UnhighlightAll(GameObject excludedObj = null)
{
if (highlightedObjects.Count > 0)
{
MaterialMap origMaterialMap = null;
foreach (var item in highlightedObjects)
{
if (item.Key == excludedObj && excludedObj != null)
{
origMaterialMap = item.Value;
}
if (item.Key != excludedObj && item.Key != null && item.Value != null)
{
RenderingUtility.ReplaceMaterials(item.Key, item.Value);
}
}
highlightedObjects.Clear();
if (excludedObj != null && origMaterialMap != null)
{
highlightedObjects.Add(excludedObj, origMaterialMap);
}
}
}
protected void ParseMtlFile(string MtlPath)
{
var Lines = File.ReadAllLines(MtlPath);
ObjMeshMaterial NewMaterial = null;
foreach (var line in Lines)
{
var TrimmedLine = line.TrimStart(new char[] { ' ', '\t' });
if (TrimmedLine.StartsWith("newmtl"))
{
var Tokens = TrimmedLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (Tokens.Count() == 2)
{
NewMaterial = new ObjMeshMaterial();
NewMaterial.MaterialName = Tokens[1];
}
}
else if (TrimmedLine.StartsWith("map_Kd"))
{
var Tokens = TrimmedLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (Tokens.Count() == 2)
{
if (NewMaterial != null)
{
NewMaterial.DiffuseMap = Tokens[1];
}
}
}
else if (TrimmedLine.StartsWith("map_bump"))
{
var tokens = TrimmedLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.Count() == 2)
{
if (NewMaterial != null)
{
NewMaterial.NormalMap = tokens[1];
}
}
}
else if (TrimmedLine.StartsWith("map_Ka"))
{
var tokens = TrimmedLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.Count() == 2)
{
if (NewMaterial != null)
{
NewMaterial.SpecularMap = tokens[1];
}
}
}
else if (TrimmedLine.StartsWith("map_Ns"))
{
var tokens = TrimmedLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.Count() == 2)
{
if (NewMaterial != null)
{
NewMaterial.RoughnessMap = tokens[1];
}
}
}
else if (TrimmedLine.StartsWith("map_d"))
{
var tokens = TrimmedLine.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
if (tokens.Count() == 2)
{
if (NewMaterial != null)
{
NewMaterial.MaskMap = tokens[1];
}
}
}
else if (TrimmedLine.Length == 0 && NewMaterial != null)
{
MaterialMap.Add(NewMaterial.MaterialName, NewMaterial);
NewMaterial = null;
}
}
if (NewMaterial != null)
{
MaterialMap.Add(NewMaterial.MaterialName, NewMaterial);
NewMaterial = null;
}
}
protected virtual void Map(MaterialMap map, string token, StreamWriter writer)
{
writer.Write(token);
if (!map.IsHorizontalBlendingEnabled)
{
writer.Write(" -blenu {0}", OnOff.Off.ToString().ToLowerInvariant());
}
if (!map.IsVerticalBlendingEnabled)
{
writer.Write(" -blenv {0}", OnOff.Off.ToString().ToLowerInvariant());
}
if (map.BumpMultiplier != 0.0f)
{
writer.Write(" -bm ");
writer.Write(map.BumpMultiplier.ToString("F6", CultureInfo.InvariantCulture));
}
if (map.Boost != 0.0f)
{
writer.Write(" -boost ");
writer.Write(map.Boost.ToString("F6", CultureInfo.InvariantCulture));
}
if (map.IsColorCorrectionEnabled)
{
writer.Write(" -cc {0}", OnOff.On.ToString().ToLowerInvariant());
}
if (map.IsClampingEnabled)
{
writer.Write(" -clamp {0}", OnOff.On.ToString().ToLowerInvariant());
}
if (map.ScalarChannel != MapChannel.Luminance)
{
writer.Write(" -imfchan ");
switch (map.ScalarChannel)
{
case MapChannel.Red:
{
writer.Write(IMFChanToken.R.ToString().ToLowerInvariant());
break;
}
case MapChannel.Green:
{
writer.Write(IMFChanToken.G.ToString().ToLowerInvariant());
break;
}
case MapChannel.Blue:
{
writer.Write(IMFChanToken.B.ToString().ToLowerInvariant());
break;
}
case MapChannel.Matte:
{
writer.Write(IMFChanToken.M.ToString().ToLowerInvariant());
break;
}
case MapChannel.Depth:
{
writer.Write(IMFChanToken.Z.ToString().ToLowerInvariant());
break;
}
default:
{
writer.Write(IMFChanToken.L.ToString().ToLowerInvariant());
break;
}
}
}
if (map.ModifierBase != 0.0f || map.ModifierGain != 1.0f)
{
writer.Write(" -mm {0} {1}", map.ModifierBase.ToString("F6", CultureInfo.InvariantCulture), map.ModifierGain.ToString("F6", CultureInfo.InvariantCulture));
}
if (map.Offset.X != 0.0f || map.Offset.Y != 0.0f || map.Offset.Z != 0.0f)
{
writer.Write(" -o {0} {1} {2}", map.Offset.X.ToString("F6", CultureInfo.InvariantCulture), map.Offset.Y.ToString("F6", CultureInfo.InvariantCulture), map.Offset.Z.ToString("F6", CultureInfo.InvariantCulture));
}
if (map.Scale.X != 1.0f || map.Scale.Y != 1.0f || map.Scale.Z != 1.0f)
{
writer.Write(" -s {0} {1} {2}", map.Scale.X.ToString("F6", CultureInfo.InvariantCulture), map.Scale.Y.ToString("F6", CultureInfo.InvariantCulture), map.Scale.Z.ToString("F6", CultureInfo.InvariantCulture));
}
if (map.Turbulence.X != 0.0f || map.Turbulence.Y != 0.0f || map.Turbulence.Z != 0.0f)
{
writer.Write(" -t {0} {1} {2}", map.Turbulence.X.ToString("F6", CultureInfo.InvariantCulture), map.Turbulence.Y.ToString("F6", CultureInfo.InvariantCulture), map.Turbulence.Z.ToString("F6", CultureInfo.InvariantCulture));
}
if (map.TextureResolution != 0)
{
writer.Write(" -texres {0}", map.TextureResolution);
}
writer.WriteLine(" {0}", map.FileName);
}
public void setRaw(int x, int y, int z, int value, string material) => setRaw(x, y, z, value, MaterialMap.get().id(material));
private string selectMaterial(int x, int y, int z)
{
return(MaterialMap.get().material(map.blockType.material[x, y, z]).name);
}
public MainWindow() : base(800, 600, false, false)
{
MaterialMap = new MaterialMap();
MaterialMap.AddRegex(new LibreLancer.Ini.StringKeyValue("^nomad.*$", "NomadMaterialNoBendy"));
MaterialMap.AddRegex(new LibreLancer.Ini.StringKeyValue("^n-texture.*$", "NomadMaterialNoBendy"));
}
