public static void ConvertTiffToDDS(string tiffPath, bool overrideExisting = false)
{
string ddsPath = Path.ChangeExtension(tiffPath, ".dds");
if (overrideExisting || !StorageConfig.FileExists(ddsPath))
{
var bitmap = new Bitmap(tiffPath);
// Konvertierung
var target = SlimDx9TextureConvertible.CreateFile(
new SlimDx9TextureConvertible.SlimDx9TextureParameters()
{
AardvarkFormat = Patch.GetTextureFormatFromPixelFormat(bitmap.PixelFormat),
AardvarkUsage = AardvarkUsage.None,
FileName = ddsPath,
Pool = Pool.Scratch,
MipMapLevels = 0
});
var bitmapConvertible = new Convertible("BitmapMemory", bitmap);
bitmapConvertible.ConvertInto(target);
}
}
bool IConvertible.ToBoolean(IFormatProvider provider) => Convertible.ToBoolean(provider);
public HasParametersAndProperties([TypeConverter(typeof(ConvertibleConverter))] Convertible parameter)
{
Parameter = parameter;
}
public long ToInt64(IFormatProvider provider)
{
return(Convertible.ToInt64(provider));
}
public short ToInt16(IFormatProvider provider)
{
return(Convertible.ToInt16(provider));
}
public decimal ToDecimal(IFormatProvider provider)
{
return(Convertible.ToDecimal(provider));
}
public char ToChar(IFormatProvider provider)
{
return(Convertible.ToChar(provider));
}
public bool ToBoolean(IFormatProvider provider)
{
return(Convertible.ToBoolean(provider));
}
string IConvertible.ToString(IFormatProvider provider) => Convertible.ToString(provider);
float IConvertible.ToSingle(IFormatProvider provider) => Convertible.ToSingle(provider);
sbyte IConvertible.ToSByte(IFormatProvider provider) => Convertible.ToSByte(provider);
double IConvertible.ToDouble(IFormatProvider provider) => Convertible.ToDouble(provider);
decimal IConvertible.ToDecimal(IFormatProvider provider) => Convertible.ToDecimal(provider);
System.DateTime IConvertible.ToDateTime(IFormatProvider provider) => Convertible.ToDateTime(provider);
char IConvertible.ToChar(IFormatProvider provider) => Convertible.ToChar(provider);
public object ToType(Type conversionType, IFormatProvider provider)
{
return(Convertible.ToType(conversionType, provider));
}
public TypeCode GetTypeCode()
{
return(Convertible.GetTypeCode());
}
object IConvertible.ToType(Type conversionType, IFormatProvider provider) => Convertible.ToType(conversionType, provider);
public byte ToByte(IFormatProvider provider)
{
return(Convertible.ToByte(provider));
}
ushort IConvertible.ToUInt16(IFormatProvider provider) => Convertible.ToUInt16(provider);
public DateTime ToDateTime(IFormatProvider provider)
{
return(Convertible.ToDateTime(provider));
}
uint IConvertible.ToUInt32(IFormatProvider provider) => Convertible.ToUInt32(provider);
public double ToDouble(IFormatProvider provider)
{
return(Convertible.ToDouble(provider));
}
ulong IConvertible.ToUInt64(IFormatProvider provider) => Convertible.ToUInt64(provider);
public int ToInt32(IFormatProvider provider)
{
return(Convertible.ToInt32(provider));
}
public float ToSingle(IFormatProvider provider)
{
return(Convertible.ToSingle(provider));
}
public HasTypeConverterAttributes([TypeConverter(typeof(ConvertibleConverter))] Convertible parameter)
{
this.Property = parameter;
}
public string ToString(IFormatProvider provider)
{
return(Convertible.ToString(provider));
}
public ISg SetParameters(AbstractTraversal t)
{
if (!m_isInitialized)
{
var info = m_instance.PatchFileInfo;
var bb = m_instance.PositionsType == PositionsType.V3dPositions ?
info.LocalBoundingBox : info.LocalBoundingBox2d;
var patch = new StreamingJob(
() =>
{
//TaskCombinators.Delay(100);
//do importer logic here
var patchVg = m_instance.LoadingStrategy.Load(m_instance.PatchFileInfo, m_instance.PatchFilePath, m_instance.PositionsType,
true, true, true, m_instance.MaxTriangleSize);
if (patchVg == null)
{
return(EmptyLeaf.Singleton);
}
var lodColor = Patch.GetLodColor(m_instance.Level, m_instance.MaxLevel);
patchVg["LodColor"] = lodColor;
for (int i = 0; i < patchVg.Textures.Count; i++)
{
var key = patchVg.Textures.Keys.ToList()[i];
var source = patchVg.Textures[key].Convertible;
Convertible target = null;
if (t.Renderer is SlimDx9Renderer)
{
target = SlimDx9TextureConvertible.Create(
new SlimDx9TextureConvertible.SlimDx9TextureParameters()
{
//SlimDx9Format = SlimDX.Direct3D9.Format., // .Dxt5,
Pool = SlimDX.Direct3D9.Pool.Default
});
source.ConvertInto(target);
}
else
{
// nothing todo in slimdx10renderer (this just loads the texture on demand)
// fix this if you are fed up with framerate hick ups
target = source;
}
patchVg.Textures[key] = new Texture(target);
}
lock (asyncLock)
{
m_asyncTextures = patchVg.Textures;
}
return(patchVg.ToVertexGeometrySet());
},
bb, m_instance.MaxLevel - m_instance.Level, true);
patch.DestructSideEffects = DisposeSideEffects;
var placeHolder = Primitives.WireBox(bb, C4b.Red).ToVertexGeometrySet();
m_returnISg = new AsyncStreamingNode(patch, placeHolder)
{
DebugName = Path.GetFileName(m_instance.PatchFilePath),
};
var local2Global = m_instance.PatchFileInfo.GetLocal2Global(m_instance.PositionsType);
if (m_instance.InvertZ)
{
local2Global = M44d.Scale(1, 1, -1) * local2Global;
}
var global2Local = local2Global.Inverse;
m_returnISg = Rsg.Apply(Rsg.Attribute.PushTrafo3d(new Trafo3d(local2Global, global2Local)), m_returnISg);
m_isInitialized = true;
}
return(m_returnISg);
}
/// <summary>
/// Loads VertexGeometry from aara files. Beware: add Local2Global node for global space.
/// </summary>
/// <param name="positions">Raw positions, read from aara files for possible further processing.</param>
/// <param name="dataType">DataType of positions.</param>
/// <returns>Vertex Geometry in local OPC space.</returns>
public static VertexGeometry LoadPatch(PatchFileInfo info, string basePath, PositionsType posType, out Array positions, out Symbol dataType,
bool loadNormals = true, bool loadTexCoords = true, bool loadDiffTex = true, bool loadHueTex = true, float maxTriangleSize = float.PositiveInfinity, bool loadAsDoubles = false)
{
var vg = new VertexGeometry(GeometryMode.TriangleList);
positions = null;
// load metadata
var aara3dPos = AaraData.FromFile(
Path.Combine(basePath, posType == PositionsType.V3dPositions
? info.Positions : info.Positions2d));
dataType = aara3dPos.DataTypeAsSymbol;
var resolution = new V2i(aara3dPos.Size);
if (resolution.AnySmaller(2))
{
Report.Warn("ignoring patch {0} due to invalid gridresolution {1}", basePath, resolution);
return(null);
}
// load positions
positions = aara3dPos.LoadElements();
var positions3d = loadAsDoubles ? positions : AaraData.ConvertArrayToV3fs[aara3dPos.DataTypeAsSymbol](positions);
//var positionsV3 = loadAsDoubles ?
// (Array)AaraData.ConvertArrayToV3ds[aara3dPos.DataTypeAsSymbol](positions) :
// (Array);
vg.Positions = positions3d;
var p = AaraData.ConvertArrayToV3fs[aara3dPos.DataTypeAsSymbol](positions);
// calculate indices
var invalidPoints = OpcIndices.GetInvalidPositions(p);
// limit triangle size
if ((maxTriangleSize < float.PositiveInfinity) && (maxTriangleSize > 0.000001f))
{
vg.Indices = OpcIndices.ComputeIndexArray(resolution, invalidPoints.ToList(), p, maxTriangleSize);
}
else
{
vg.Indices = OpcIndices.ComputeIndexArray(resolution, invalidPoints.ToList());
}
// load normals
if (loadNormals)
{
var normalPath = Path.Combine(basePath, "Normals.aara");
if (StorageConfig.FileExists(normalPath))
{
var normals = AaraData.FromFile(normalPath);
var normals3d = AaraData.ConvertArrayToV3fs[normals.DataTypeAsSymbol](normals.LoadElements());
vg.Normals = normals3d;
}
}
// load coordinates
vg.Coordinates = new CoordinatesMap();
if (loadTexCoords)
{
var coordPath = Path.Combine(basePath, info.Coordinates.First());
var coordinates = AaraData.FromFile(coordPath).LoadElements() as V2f[];
vg.Coordinates[VertexGeometry.Property.DiffuseColorCoordinates] = coordinates;
}
// load textures
vg.Textures = new TexturesMap();
if (loadDiffTex)
{
var texFile = Path.ChangeExtension(info.Textures.First(), ".dds");
var texPath = Path.GetFullPath(Path.Combine(basePath, @"..\..\images", texFile));
if (StorageConfig.FileExists(texPath))
{
var img = Convertible.FromFile(texPath);
vg.Textures[VertexGeometry.Property.DiffuseColorTexture] =
new Aardvark.Rendering.Texture(img)
{
ForceImmediateUpload = false
};
}
}
if (loadHueTex)
{
vg.Textures[VertexGeometry.Property.LightMapTexture] =
new Aardvark.Rendering.Texture(Resources.HueColorMap.Convertible());
}
return(vg);
}
