/// <inheritdoc/>
public override TextureAtlas ImportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryReader reader)
{
// Load the atlas' texture.
var texture = default(Texture2D);
var textureSizeInBytes = reader.ReadInt32();
var textureBytes = reader.ReadBytes(textureSizeInBytes);
using (var textureStream = new MemoryStream(textureBytes))
{
texture = manager.LoadFromStream <Texture2D>(textureStream, "png");
}
// Read the atlas' cells.
var cells = new Dictionary <String, Rectangle>();
var cellCount = reader.ReadInt32();
for (int i = 0; i < cellCount; i++)
{
var cellName = reader.ReadString();
var cellX = reader.ReadInt32();
var cellY = reader.ReadInt32();
var cellWidth = reader.ReadInt32();
var cellHeight = reader.ReadInt32();
cells[cellName] = new Rectangle(cellX, cellY, cellWidth, cellHeight);
}
// Create the atlas.
return(new TextureAtlas(texture, cells));
}
/// <inheritdoc/>
public override SpriteFont ImportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryReader reader)
{
var fileVersion = 0;
var characterRegionCount = reader.ReadInt32();
if (characterRegionCount == Int32.MaxValue)
{
fileVersion = reader.ReadInt32();
characterRegionCount = reader.ReadInt32();
}
var characterRegions = characterRegionCount > 0 ? new CharacterRegion[characterRegionCount] : null;
for (int i = 0; i < characterRegionCount; i++)
{
characterRegions[i] = new CharacterRegion(
reader.ReadChar(),
reader.ReadChar());
}
var faceRegular = ImportPreprocessedFace(manager, metadata, reader, characterRegions, fileVersion);
var faceBold = ImportPreprocessedFace(manager, metadata, reader, characterRegions, fileVersion);
var faceItalic = ImportPreprocessedFace(manager, metadata, reader, characterRegions, fileVersion);
var faceBoldItalic = ImportPreprocessedFace(manager, metadata, reader, characterRegions, fileVersion);
return(new SpriteFont(manager.Ultraviolet, faceRegular, faceBold, faceItalic, faceBoldItalic));
}
/// <inheritdoc/>
public override TextTableLayout Process(ContentManager manager, IContentProcessorMetadata metadata, JObject input)
{
var serializer = JsonSerializer.CreateDefault(UltravioletJsonSerializerSettings.Instance);
var layoutDesc = input.ToObject <TextTableLayoutDescription>(serializer);
return(new TextTableLayout(layoutDesc));
}
/// <summary>
/// Processes raw shader source into a new <see cref="ShaderSource"/> object.
/// </summary>
/// <param name="manager">The <see cref="ContentManager"/> that is loading the shader source.</param>
/// <param name="metadata">The content processor metadata for the shader source that is being loaded.</param>
/// <param name="source">The raw shader source to process.</param>
/// <returns>A <see cref="ShaderSource"/> object that represents the processed shader source.</returns>
public static ShaderSource ProcessRawSource(ContentManager manager, IContentProcessorMetadata metadata, String source)
{
var ssmd = new ShaderSourceMetadata();
return(ProcessInternal(ssmd, source, (line, output) =>
{
if (ProcessIncludeDirective(manager, metadata, line, output, ssmd))
{
return true;
}
if (ProcessIncludeResourceDirective(manager, metadata, line, output, ssmd))
{
return true;
}
if (ProcessIfVerDirective(manager, metadata, line, output, ssmd))
{
return true;
}
if (ProcessSamplerDirective(manager, metadata, line, output, ssmd))
{
return true;
}
if (ProcessParamDirective(manager, metadata, line, output, ssmd))
{
return true;
}
return false;
}));
}
/// <inheritdoc/>
public override SpriteFont Process(ContentManager manager, IContentProcessorMetadata metadata, SpriteFontDescription input)
{
var textures = (new[] { input.Faces?.Regular?.Texture, input.Faces?.Bold?.Texture, input.Faces?.Italic?.Texture, input.Faces?.BoldItalic?.Texture })
.Where(x => x != null).Distinct()
.Select(x => ResolveDependencyAssetPath(metadata, x))
.ToDictionary(x => x, x => manager.Import <SDL_Surface>(x));
try
{
var characterRegions = input.CharacterRegions?.Select(x => new CharacterRegion(x.Start, x.End)).ToList();
var faceRegular = ProcessFace(textures, manager, metadata, input.Faces?.Regular, "Regular", characterRegions);
var faceBold = ProcessFace(textures, manager, metadata, input.Faces?.Bold, "Bold", characterRegions);
var faceItalic = ProcessFace(textures, manager, metadata, input.Faces?.Italic, "Italic", characterRegions);
var faceBoldItalic = ProcessFace(textures, manager, metadata, input.Faces?.BoldItalic, "BoldItalic", characterRegions);
return(new SpriteFont(manager.Ultraviolet, faceRegular, faceBold, faceItalic, faceBoldItalic));
}
finally
{
foreach (var texture in textures)
{
texture.Value.Dispose();
}
}
}
/// <summary>
/// Processes a single file which has all of the layers of the surface within it.
/// </summary>
private Surface3D ProcessSingleFile(ContentManager manager, IContentProcessorMetadata metadata, PlatformNativeSurface input)
{
var mdat = metadata.As <SDL2Surface3DProcessorMetadata>();
var srgbEncoded = mdat.SrgbEncoded ?? manager.Ultraviolet.Properties.SrgbDefaultForSurface3D;
// Layers must be square. Validate our dimensions.
var layerHeight = input.Height;
var layerWidth = layerHeight;
var layerCount = input.Width / layerWidth;
if (input.Width % layerWidth != 0)
{
throw new InvalidDataException(SDL2Strings.SurfaceMustHaveSquareLayers);
}
// Create surfaces for each of our layers.
using (var mainSurface = Surface2D.Create(input))
{
mainSurface.SrgbEncoded = srgbEncoded;
var resultOpts = srgbEncoded ? SurfaceOptions.SrgbColor : SurfaceOptions.LinearColor;
var result = new SDL2Surface3D(manager.Ultraviolet, layerWidth, layerHeight, layerCount, mainSurface.BytesPerPixel, resultOpts);
for (int i = 0; i < layerCount; i++)
{
var layerSurface = mainSurface.CreateSurface(new Rectangle(i * layerWidth, 0, layerWidth, layerHeight));
result.SetLayer(i, layerSurface, true);
}
return(result);
}
}
/// <inheritdoc/>
public override CursorCollection Process(ContentManager manager, IContentProcessorMetadata metadata, JObject input)
{
var serializer = JsonSerializer.CreateDefault(UltravioletJsonSerializerSettings.Instance);
var desc = input.ToObject <CursorCollectionDescription>(serializer);
return(innerProcessor.Process(manager, metadata, desc));
}
/// <inheritdoc/>
public override void ExportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryWriter writer, PlatformNativeSurface input, Boolean delete)
{
var mdat = metadata.As <OpenGLTexture3DProcessorMetadata>();
var caps = manager.Ultraviolet.GetGraphics().Capabilities;
var srgbEncoded = (mdat.SrgbEncoded ?? manager.Ultraviolet.Properties.SrgbDefaultForTexture3D) && caps.SrgbEncodingEnabled;
using (var surface = manager.Process <PlatformNativeSurface, Surface3D>(input, metadata.AssetDensity))
{
var flipdir = caps.FlippedTextures ? SurfaceFlipDirection.Vertical : SurfaceFlipDirection.None;
for (int i = 0; i < surface.Depth; i++)
{
var layer = surface.GetLayer(i);
layer.SrgbEncoded = srgbEncoded;
layer.FlipAndProcessAlpha(flipdir, mdat.PremultiplyAlpha, mdat.Opaque ? null : (Color?)Color.Magenta);
}
writer.Write(Int32.MaxValue);
writer.Write(1u);
writer.Write(surface.Depth);
writer.Write(srgbEncoded);
for (int i = 0; i < surface.Depth; i++)
{
using (var memstream = new MemoryStream())
{
var layer = surface.GetLayer(i);
layer.SaveAsPng(memstream);
writer.Write((int)memstream.Length);
writer.Write(memstream.ToArray());
}
}
}
}
/// <inheritdoc/>
public override SpriteFont ImportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryReader reader)
{
var imgDataExtension = reader.ReadString();
var imgDataLength = reader.ReadInt32();
var imgData = reader.ReadBytes(imgDataLength);
Texture2D texture;
using (var stream = new MemoryStream(imgData))
texture = manager.LoadFromStream <Texture2D>(stream, imgDataExtension);
var glyphCount = reader.ReadInt32();
var glyphSubst = reader.ReadChar();
var glyphPositions = new Rectangle[glyphCount];
for (int i = 0; i < glyphCount; i++)
{
var glyphX = reader.ReadInt32();
var glyphY = reader.ReadInt32();
var glyphWidth = reader.ReadInt32();
var glyphHeight = reader.ReadInt32();
glyphPositions[i] = new Rectangle(glyphX, glyphY, glyphWidth, glyphHeight);
}
var fontFace = new SpriteFontFace(manager.Ultraviolet, texture, null, glyphPositions, glyphSubst, true);
var font = new SpriteFont(manager.Ultraviolet, fontFace);
return(font);
}
/// <summary>
/// Processes raw shader source into a new <see cref="ShaderSource"/> object.
/// </summary>
/// <param name="manager">The <see cref="ContentManager"/> that is loading the shader source.</param>
/// <param name="metadata">The content processor metadata for the shader source that is being loaded.</param>
/// <param name="source">The raw shader source to process.</param>
/// <returns>A <see cref="ShaderSource"/> object that represents the processed shader source.</returns>
public static ShaderSource ProcessRawSource(ContentManager manager, IContentProcessorMetadata metadata, String source)
{
var output = new StringBuilder();
var line = default(String);
using (var reader = new StringReader(source))
{
while ((line = reader.ReadLine()) != null)
{
if (ProcessIncludeDirective(manager, metadata, line, output))
{
continue;
}
if (ProcessIncludeResourceDirective(manager, metadata, line, output))
{
continue;
}
if (ProcessIfVerDirective(manager, metadata, line, output))
{
continue;
}
output.AppendLine(line);
}
}
return(new ShaderSource(output.ToString()));
}
/// <summary>
/// Processes the specified data structure into a game asset.
/// </summary>
/// <param name="manager">The content manager with which the asset is being processed.</param>
/// <param name="metadata">The asset's metadata.</param>
/// <param name="input">The input data structure to process.</param>
/// <returns>The game asset that was created.</returns>
public override Cursor Process(ContentManager manager, IContentProcessorMetadata metadata, SDL_Surface input)
{
using (var surface = new OpenGLSurface2D(manager.Ultraviolet, input.CreateCopy()))
{
return(new OpenGLCursor(manager.Ultraviolet, surface, 0, 0));
}
}
/// <inheritdoc/>
public override EffectImplementation Process(ContentManager manager, IContentProcessorMetadata metadata, String input)
{
var isFragShader = (metadata.Extension == ".frag");
var isVertShader = (metadata.Extension == ".vert");
if (!isFragShader && !isVertShader)
{
throw new InvalidDataException(OpenGLStrings.ImplicitEffectsMustLoadFromShaders.Format(metadata.AssetPath));
}
var vertShaderFilePath = isFragShader ? Path.ChangeExtension(metadata.AssetPath, "vert") : metadata.AssetPath;
var fragShaderFilePath = isFragShader ? metadata.AssetPath : Path.ChangeExtension(metadata.AssetPath, "frag");
metadata.AddAssetDependency(isFragShader ? vertShaderFilePath : fragShaderFilePath);
var vertShaderSource = ShaderSource.ProcessExterns(manager.Load <ShaderSource>(vertShaderFilePath), Externs);
var vertShader = new OpenGLVertexShader(manager.Ultraviolet, new[] { vertShaderSource });
var fragShaderSource = ShaderSource.ProcessExterns(manager.Load <ShaderSource>(fragShaderFilePath), Externs);
var fragShader = new OpenGLFragmentShader(manager.Ultraviolet, new[] { fragShaderSource });
var program = new OpenGLShaderProgram(manager.Ultraviolet, vertShader, fragShader, false);
var pass = new OpenGLEffectPass(manager.Ultraviolet, "Default", new[] { program });
var technique = new OpenGLEffectTechnique(manager.Ultraviolet, "Default", new[] { pass });
return(new OpenGLEffectImplementation(manager.Ultraviolet, new[] { technique }));
}
/// <inheritdoc/>
public override void ExportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryWriter writer, PlatformNativeSurface input, Boolean delete)
{
if (!metadata.IsFile)
{
throw new NotSupportedException();
}
var imgData = File.ReadAllBytes(metadata.AssetFilePath);
writer.Write(metadata.Extension);
writer.Write(imgData.Length);
writer.Write(imgData);
var glyphs = OpenGLSpriteFontHelper.IdentifyGlyphs(input);
writer.Write(glyphs.Count());
writer.Write('?');
foreach (var glyph in glyphs)
{
writer.Write(glyph.X);
writer.Write(glyph.Y);
writer.Write(glyph.Width);
writer.Write(glyph.Height);
}
}
/// <summary>
/// Processes the specified data structure into a game asset.
/// </summary>
/// <param name="manager">The content manager with which the asset is being processed.</param>
/// <param name="metadata">The asset's metadata.</param>
/// <param name="input">The input data structure to process.</param>
/// <returns>The game asset that was created.</returns>
public override Cursor Process(ContentManager manager, IContentProcessorMetadata metadata, PlatformNativeSurface input)
{
using (var surface = new SDL2Surface2D(manager.Ultraviolet, input.CreateCopy(), SurfaceOptions.SrgbColor))
{
return(new SDL2Cursor(manager.Ultraviolet, surface, 0, 0));
}
}
/// <inheritdoc/>
public override Texture3D ImportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryReader reader)
{
var caps = manager.Ultraviolet.GetGraphics().Capabilities;
var version = 0u;
var depth = reader.ReadInt32();
if (depth == Int32.MaxValue)
{
version = reader.ReadUInt32();
}
if (version > 0u)
{
depth = reader.ReadInt32();
}
var srgbEncoded = false;
if (version > 0u)
{
srgbEncoded = reader.ReadBoolean() && caps.SrgbEncodingEnabled;
}
var layerSurfaces = new List <SurfaceSource>();
var layerPointers = new List <IntPtr>();
try
{
for (int i = 0; i < depth; i++)
{
var length = reader.ReadInt32();
var bytes = reader.ReadBytes(length);
using (var stream = new MemoryStream(bytes))
{
var surfaceSource = SurfaceSource.Create(stream);
layerSurfaces.Add(surfaceSource);
layerPointers.Add(surfaceSource.Data);
}
}
var layerWidth = layerSurfaces[0].Width;
var layerHeight = layerSurfaces[0].Height;
var internalformat = OpenGLTextureUtil.GetInternalFormatFromBytesPerPixel(4, srgbEncoded);
var format = (layerSurfaces[0].DataFormat == SurfaceSourceDataFormat.RGBA) ? gl.GL_RGBA : gl.GL_BGRA;
return(new OpenGLTexture3D(manager.Ultraviolet, internalformat, layerWidth, layerHeight, format,
gl.GL_UNSIGNED_BYTE, layerPointers, true));
}
finally
{
foreach (var layerSurface in layerSurfaces)
{
layerSurface.Dispose();
}
}
}
/// <summary>
/// Imports a font face from the specified preprocessed asset stream.
/// </summary>
private static SpriteFontFace ImportPreprocessedFace(ContentManager manager,
IContentProcessorMetadata metadata, BinaryReader reader, IEnumerable <CharacterRegion> characterRegions)
{
var faceExists = reader.ReadBoolean();
if (!faceExists)
{
return(null);
}
var texturePath = reader.ReadString();
var texture = manager.Load <Texture2D>(texturePath);
var textureRegionSpecified = reader.ReadBoolean();
if (textureRegionSpecified)
{
reader.ReadInt32();
reader.ReadInt32();
reader.ReadInt32();
reader.ReadInt32();
}
var substitution = reader.ReadChar();
var glyphPositions = new List <Rectangle>();
var glyphCount = reader.ReadInt32();
for (int j = 0; j < glyphCount; j++)
{
var glyphX = reader.ReadInt32();
var glyphY = reader.ReadInt32();
var glyphWidth = reader.ReadInt32();
var glyphHeight = reader.ReadInt32();
glyphPositions.Add(new Rectangle(glyphX, glyphY, glyphWidth, glyphHeight));
}
var face = new SpriteFontFace(manager.Ultraviolet, texture, characterRegions, glyphPositions, substitution);
var kerning = new Dictionary <SpriteFontKerningPair, Int32>();
var kerningDefaultAdjustment = reader.ReadInt32();
var kerningCount = reader.ReadInt32();
for (int j = 0; j < kerningCount; j++)
{
var pairFirstChar = reader.ReadChar();
var pairSecondChar = reader.ReadChar();
var offset = reader.ReadInt32();
kerning[new SpriteFontKerningPair(pairFirstChar, pairSecondChar)] = offset;
}
face.Kerning.DefaultAdjustment = kerningDefaultAdjustment;
foreach (var kvp in kerning)
{
face.Kerning.Set(kvp.Key, kvp.Value);
}
return(face);
}
/// <inheritdoc/>
public override SpriteFont Process(ContentManager manager, IContentProcessorMetadata metadata, SDL_Surface input)
{
var positions = OpenGLSpriteFontHelper.IdentifyGlyphs(input);
var texture = manager.Process <SDL_Surface, Texture2D>(input);
var face = new SpriteFontFace(manager.Ultraviolet, texture, null, positions, true);
return(new SpriteFont(manager.Ultraviolet, face));
}
/// <summary>
/// Processes #ifver directives.
/// </summary>
private static Boolean ProcessIfVerDirective(ContentManager manager, IContentProcessorMetadata metadata, String line, StringBuilder output, ShaderSourceMetadata ssmd)
{
var ifVerMatch = regexIfVerDirective.Match(line);
if (ifVerMatch.Success)
{
var source = ifVerMatch.Groups["source"].Value;
var dirVersionIsGLES = !String.IsNullOrEmpty(ifVerMatch.Groups["gles"].Value);
var dirVersionMajor = Int32.Parse(ifVerMatch.Groups["version_maj"].Value);
var dirVersionMinor = Int32.Parse(ifVerMatch.Groups["version_min"].Value);
var dirVersion = new Version(dirVersionMajor, dirVersionMinor);
var dirSatisfied = false;
var uvVersionIsGLES = gl.IsGLES;
var uvVersionMajor = gl.MajorVersion;
var uvVersionMinor = gl.MinorVersion;
var uvVersion = new Version(uvVersionMajor, uvVersionMinor);
if (dirVersionIsGLES != uvVersionIsGLES)
{
return(true);
}
switch (ifVerMatch.Groups["op"].Value)
{
case "ifver":
dirSatisfied = (uvVersion == dirVersion);
break;
case "ifver_lt":
dirSatisfied = (uvVersion < dirVersion);
break;
case "ifver_lte":
dirSatisfied = (uvVersion <= dirVersion);
break;
case "ifver_gt":
dirSatisfied = (uvVersion > dirVersion);
break;
case "ifver_gte":
dirSatisfied = (uvVersion >= dirVersion);
break;
}
if (dirSatisfied)
{
var includedSource = ProcessRawSource(manager, metadata, source);
ssmd.Concat(includedSource.Metadata);
output.AppendLine(includedSource.Source);
}
return(true);
}
return(false);
}
/// <inheritdoc/>
public override void ExportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryWriter writer, XDocument input, Boolean delete)
{
writer.Write((Byte)255);
writer.Write((Byte)255);
writer.Write((Byte)255);
writer.Write((Byte)1);
var techniqueElements = input.Root.Elements("Technique");
if (!techniqueElements.Any())
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveTechniques);
}
writer.Write(techniqueElements.Count());
foreach (var techniqueElement in techniqueElements)
{
var techniqueName = (String)techniqueElement.Attribute("Name");
writer.Write(techniqueName);
var passElements = techniqueElement.Elements("Pass");
if (!passElements.Any())
{
throw new ContentLoadException(OpenGLStrings.EffectTechniqueMustHavePasses);
}
writer.Write(passElements.Count());
foreach (var passElement in passElements)
{
var passName = (String)passElement.Attribute("Name");
writer.Write(passName);
var vertexShader = (String)passElement.Element("VertexShader");
var vertexShaderES = (String)passElement.Element("VertexShaderES");
if (String.IsNullOrEmpty(vertexShader))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
writer.Write(vertexShader);
writer.Write(vertexShaderES);
var fragShader = (String)passElement.Element("VertexShader");
var fragShaderES = (String)passElement.Element("VertexShaderES");
if (String.IsNullOrEmpty(fragShader))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
writer.Write(fragShader);
writer.Write(fragShaderES);
}
}
}
/// <inheritdoc/>
public override EffectImplementation Process(ContentManager manager, IContentProcessorMetadata metadata, XDocument input)
{
var techniques = new List <OpenGLEffectTechnique>();
var techniqueElements = input.Root.Elements("Technique");
if (!techniqueElements.Any())
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveTechniques);
}
foreach (var techniqueElement in techniqueElements)
{
var techniqueName = (String)techniqueElement.Attribute("Name");
var techniquePasses = new List <OpenGLEffectPass>();
var passElements = techniqueElement.Elements("Pass");
if (!passElements.Any())
{
throw new ContentLoadException(OpenGLStrings.EffectTechniqueMustHavePasses);
}
foreach (var passElement in passElements)
{
var passName = (String)passElement.Attribute("Name");
var vertPath = GetShader(passElement, "VertexShader");
if (String.IsNullOrEmpty(vertPath))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
vertPath = ResolveDependencyAssetPath(metadata, vertPath);
metadata.AddAssetDependency(vertPath);
var fragPath = GetShader(passElement, "FragmentShader");
if (String.IsNullOrEmpty(fragPath))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
fragPath = ResolveDependencyAssetPath(metadata, fragPath);
metadata.AddAssetDependency(fragPath);
var vertShaderSource = ShaderSource.ProcessExterns(manager.Load <ShaderSource>(vertPath), Externs);
var vertShader = new OpenGLVertexShader(manager.Ultraviolet, new[] { vertShaderSource });
var fragShaderSource = ShaderSource.ProcessExterns(manager.Load <ShaderSource>(fragPath), Externs);
var fragShader = new OpenGLFragmentShader(manager.Ultraviolet, new[] { fragShaderSource });
var programs = new[] { new OpenGLShaderProgram(manager.Ultraviolet, vertShader, fragShader, false) };
techniquePasses.Add(new OpenGLEffectPass(manager.Ultraviolet, passName, programs));
}
techniques.Add(new OpenGLEffectTechnique(manager.Ultraviolet, techniqueName, techniquePasses));
}
return(new OpenGLEffectImplementation(manager.Ultraviolet, techniques));
}
/// <inheritdoc/>
public override FreeTypeFont Process(ContentManager manager, IContentProcessorMetadata metadata, FreeTypeFontInfo input)
{
var mdata = metadata.As <FreeTypeFontProcessorMetadata>();
var prepopGlyphRanges = new List <PrepopulatedGlyphRange>();
GetBestScreenDensityMatch(manager.Ultraviolet, metadata.AssetDensity, out var dpiX, out var dpiY);
GetPrepopulatedGlyphList(mdata.PrepopulatedGlyphs, prepopGlyphRanges);
var sizeInPoints = mdata.SizeInPoints;
var sizeInPixels = mdata.SizeInPixels;
if (sizeInPixels != 0 && sizeInPoints != 0)
{
throw new InvalidOperationException(FreeTypeStrings.CannotSpecifyPointAndPixelSize);
}
var iDpiX = (UInt32)dpiX;
var iDpiY = (UInt32)dpiY;
var pxSizeRegular = mdata.SizeInPixels;
var ftFaceRegular = LoadFontFace(input.FaceDataRegular, input.FaceDataRegularLength, sizeInPoints, ref pxSizeRegular, iDpiX, iDpiY, !mdata.UseClosestPixelSize);
var pxSizeBold = mdata.SizeInPixels;
var ftFaceBold = LoadFontFace(input.FaceDataBold, input.FaceDataBoldLength, sizeInPoints, ref pxSizeBold, iDpiX, iDpiY, !mdata.UseClosestPixelSize);
var pxSizeItalic = mdata.SizeInPixels;
var ftFaceItalic = LoadFontFace(input.FaceDataItalic, input.FaceDataItalicLength, sizeInPoints, ref pxSizeItalic, iDpiX, iDpiY, !mdata.UseClosestPixelSize);
var pxSizeBoldItalic = mdata.SizeInPixels;
var ftFaceBoldItalic = LoadFontFace(input.FaceDataBoldItalic, input.FaceDataBoldItalicLength, sizeInPoints, ref pxSizeBoldItalic, iDpiX, iDpiY, !mdata.UseClosestPixelSize);
var uvFaceRegular = (ftFaceRegular == IntPtr.Zero) ? null : new FreeTypeFontFace(manager.Ultraviolet, ftFaceRegular, mdata);
var uvFaceBold = (ftFaceBold == IntPtr.Zero) ? null : new FreeTypeFontFace(manager.Ultraviolet, ftFaceBold, mdata);
var uvFaceItalic = (ftFaceItalic == IntPtr.Zero) ? null : new FreeTypeFontFace(manager.Ultraviolet, ftFaceItalic, mdata);
var uvFaceBoldItalic = (ftFaceBoldItalic == IntPtr.Zero) ? null : new FreeTypeFontFace(manager.Ultraviolet, ftFaceBoldItalic, mdata);
if (uvFaceRegular != null)
{
PrepopulateGlyphs(uvFaceRegular, prepopGlyphRanges);
}
if (uvFaceBold != null)
{
PrepopulateGlyphs(uvFaceBold, prepopGlyphRanges);
}
if (uvFaceItalic != null)
{
PrepopulateGlyphs(uvFaceItalic, prepopGlyphRanges);
}
if (uvFaceBoldItalic != null)
{
PrepopulateGlyphs(uvFaceBoldItalic, prepopGlyphRanges);
}
return(new FreeTypeFont(manager.Ultraviolet, uvFaceRegular, uvFaceBold, uvFaceItalic, uvFaceBoldItalic));
}
/// <inheritdoc/>
public override SoundEffect Process(ContentManager manager, IContentProcessorMetadata metadata, FMODMediaDescription input)
{
if (!input.IsFilename)
{
throw new NotSupportedException();
}
return(new FMODSoundEffect(manager.Ultraviolet, (String)input.Data));
}
/// <inheritdoc/>
public override Texture2D Process(ContentManager manager, IContentProcessorMetadata metadata, SDL_Surface input)
{
var mdat = metadata.As <OpenGLTexture2DProcessorMetadata>();
using (var surface = new OpenGLSurface2D(manager.Ultraviolet, input))
{
return(surface.CreateTexture(mdat.PremultiplyAlpha));
}
}
/// <inheritdoc/>
public override UIPanelDefinition Process(ContentManager manager, IContentProcessorMetadata metadata, XDocument input)
{
var fss = FileSystemService.Create();
var defaultOpenTransitionDuration = input.Root.AttributeValueDouble("DefaultOpenTransitionDuration") ?? 0.0;
var defaultCloseTransitionDuration = input.Root.AttributeValueDouble("DefaultCloseTransitionDuration") ?? 0.0;
var styleSheetRoot = Path.GetDirectoryName(metadata.AssetPath);
var styleSheetElements = input.Root.Elements("StyleSheet");
var styleSheetAssets = styleSheetElements.Select(x => Path.Combine(styleSheetRoot, x.Value));
var styleSheetPaths = styleSheetAssets.Select(x => manager.ResolveAssetFilePath(x, metadata.AssetDensity, metadata.IsLoadedFromSolution));
var styleSheetSources = new List <String>();
foreach (var styleSheetPath in styleSheetPaths)
{
using (var stream = fss.OpenRead(styleSheetPath))
{
using (var reader = new StreamReader(stream))
{
var source = reader.ReadToEnd();
styleSheetSources.Add(source);
}
}
}
var directives = new List <UIPanelDirective>();
var xmlDirectives = input.Root.Elements("Directive");
foreach (var xmlDirective in xmlDirectives)
{
var directiveType = (String)xmlDirective.Attribute("Type");
if (String.IsNullOrEmpty(directiveType))
{
throw new InvalidDataException(UltravioletStrings.ViewDirectiveMustHaveType.Format(metadata.AssetFilePath));
}
directives.Add(new UIPanelDirective(directiveType, xmlDirective.Value));
}
foreach (var styleSheetAsset in styleSheetAssets)
{
metadata.AddAssetDependency(styleSheetAsset);
}
return(new UIPanelDefinition()
{
AssetFilePath = metadata.AssetFilePath,
DefaultOpenTransitionDuration = TimeSpan.FromMilliseconds(defaultOpenTransitionDuration),
DefaultCloseTransitionDuration = TimeSpan.FromMilliseconds(defaultCloseTransitionDuration),
RootElement = input.Root,
ViewElement = input.Root.Element("View"),
StyleSheetAssets = styleSheetAssets,
StyleSheetSources = styleSheetSources,
Directives = directives,
});
}
/// <inheritdoc/>
public override void ExportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryWriter writer, XDocument input, Boolean delete)
{
var desc = DeserializeDescription(input);
writer.Write((Byte)255);
writer.Write((Byte)255);
writer.Write((Byte)255);
writer.Write((Byte)2);
writer.Write(desc.Parameters.Count());
foreach (var parameter in desc.Parameters)
{
writer.Write(parameter);
}
if (!desc.Techniques?.Any() ?? false)
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveTechniques);
}
writer.Write(desc.Techniques.Count());
foreach (var technique in desc.Techniques)
{
writer.Write(technique.Name);
if (!technique.Passes?.Any() ?? false)
{
throw new ContentLoadException(OpenGLStrings.EffectTechniqueMustHavePasses);
}
writer.Write(technique.Passes.Count());
foreach (var pass in technique.Passes)
{
writer.Write(pass.Name);
if (String.IsNullOrEmpty(pass.Stages.VertexShader))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
writer.Write(pass.Stages.VertexShader);
writer.Write(pass.Stages.VertexShaderES);
if (String.IsNullOrEmpty(pass.Stages.FragmentShader))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
writer.Write(pass.Stages.FragmentShader);
writer.Write(pass.Stages.FragmentShaderES);
}
}
}
/// <inheritdoc/>
public override CursorCollection Process(ContentManager manager, IContentProcessorMetadata metadata, JObject input)
{
var serializer = new JsonSerializer();
serializer.Converters.Add(new UltravioletJsonConverter());
var desc = input.ToObject <CursorCollectionDescription>(serializer);
return(innerProcessor.Process(manager, metadata, desc));
}
/// <summary>
/// Creates the output texture for a texture atlas.
/// </summary>
private static Texture2D CreateOutputTexture(TextureAtlasDescription atlasDesc, IEnumerable <TextureAtlasImage> atlasImages,
ContentManager content, IContentProcessorMetadata metadata, Int32 width, Int32 height, Dictionary <String, Rectangle> images)
{
using (var output = CreateOutputSurface(atlasDesc, atlasImages, content, metadata, width, height, images))
{
var flipdir = content.Ultraviolet.GetGraphics().Capabilities.FlippedTextures ? SurfaceFlipDirection.Vertical : SurfaceFlipDirection.None;
output.FlipAndProcessAlpha(flipdir, true, Color.Magenta);
return(output.CreateTexture(unprocessed: true));
}
}
/// <summary>
/// Creates a texture atlas from the specified collection of images.
/// </summary>
private static TextureAtlas CreateTextureAtlas(TextureAtlasDescription atlasDesc, IEnumerable <TextureAtlasImage> atlasImages,
ContentManager content, IContentProcessorMetadata metadata, Int32 width, Int32 height, Dictionary <String, Rectangle> images)
{
var padding = atlasDesc.Metadata.Padding;
var texture = CreateOutputTexture(atlasDesc, atlasImages, content, metadata, width, height, images);
var atlas = new TextureAtlas(texture, images.ToDictionary(x => x.Key,
x => new Rectangle(x.Value.X, x.Value.Y, x.Value.Width - padding, x.Value.Height - padding)));
return(atlas);
}
/// <inheritdoc/>
public override TextTableLayout Process(ContentManager manager, IContentProcessorMetadata metadata, JObject input)
{
var serializer = new JsonSerializer();
serializer.Converters.Add(new UltravioletJsonConverter());
var layoutDesc = input.ToObject <TextTableLayoutDescription>(serializer);
return(new TextTableLayout(layoutDesc));
}
/// <inheritdoc/>
public override void ExportPreprocessed(ContentManager manager, IContentProcessorMetadata metadata, BinaryWriter writer, JObject input, Boolean delete)
{
var description = input.ToObject <EffectDescription>();
const Byte FileVersion = 0;
writer.Write(FileVersion);
writer.Write(description.Parameters?.Count() ?? 0);
foreach (var parameter in description.Parameters)
{
writer.Write(parameter);
}
if (!description.Techniques?.Any() ?? false)
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveTechniques);
}
writer.Write(description.Techniques.Count());
foreach (var technique in description.Techniques)
{
writer.Write(technique.Name);
if (!technique.Passes?.Any() ?? false)
{
throw new ContentLoadException(OpenGLStrings.EffectTechniqueMustHavePasses);
}
writer.Write(technique.Passes.Count());
foreach (var pass in technique.Passes)
{
writer.Write(pass.Name);
if (String.IsNullOrEmpty(pass.Stages.VertexShader))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
writer.Write(pass.Stages.VertexShader);
writer.Write(pass.Stages.VertexShaderES ?? String.Empty);
if (String.IsNullOrEmpty(pass.Stages.FragmentShader))
{
throw new ContentLoadException(OpenGLStrings.EffectMustHaveVertexAndFragmentShader);
}
writer.Write(pass.Stages.FragmentShader);
writer.Write(pass.Stages.FragmentShaderES ?? String.Empty);
}
}
}
