public override bool Convert(ConvertOperation convert)
{
bool finishConvertOp = false;
List<Pixmap> availData = convert.Perform<Pixmap>().ToList();
// Generate objects
foreach (Pixmap baseRes in availData)
{
if (convert.IsObjectHandled(baseRes)) continue;
// Find target Resource matching the source - or create one.
Texture targetRes = this.FindMatch(baseRes);
if (targetRes == null && convert.AllowedOperations.HasFlag(ConvertOperation.Operation.CreateRes))
{
string texPath = PathHelper.GetFreePath(baseRes.FullName, Resource.GetFileExtByType<Texture>());
targetRes = new Texture(baseRes);
targetRes.Save(texPath);
}
if (targetRes == null) continue;
convert.AddResult(targetRes);
finishConvertOp = true;
convert.MarkObjectHandled(baseRes);
}
return finishConvertOp;
}
private Material FindMatch(Texture baseRes)
{
if (baseRes == null)
{
return null;
}
else if (baseRes.IsDefaultContent)
{
var defaultContent = ContentProvider.GetDefaultContent<Resource>();
return defaultContent.Res().OfType<Material>().FirstOrDefault(r => r.MainTexture == baseRes);
}
else
{
// First try a direct approach
string fileExt = Resource.GetFileExtByType<Material>();
string targetPath = baseRes.FullName + fileExt;
Material match = ContentProvider.RequestContent<Material>(targetPath).Res;
if (match != null) return match;
// If that fails, search for other matches
string targetName = baseRes.Name + fileExt;
string[] resFilePaths = Resource.GetResourceFiles().ToArray();
var resNameMatch = resFilePaths.Where(p => Path.GetFileName(p) == targetName);
var resQuery = resNameMatch.Concat(resFilePaths).Distinct();
foreach (string resFile in resQuery)
{
if (!resFile.EndsWith(fileExt)) continue;
match = ContentProvider.RequestContent<Material>(resFile).Res;
if (match != null && match.MainTexture == baseRes) return match;
}
// Give up.
return null;
}
}
private static void Bake()
{
var renderTexture = new Texture(2048, 2048, filterMin: TextureMinFilter.Linear);
var renderTarget = new RenderTarget(AAQuality.Off, new[] {new ContentRef<Texture>(renderTexture)});
var scenes = ContentProvider.GetAvailableContent(typeof (Scene))
.Where(s => Path.GetDirectoryName(s.Path) == "Data\\Scenes")
.Select(s => (Scene) s.Res);
foreach (var scene in scenes)
{
TileSystemSceneCruncher.CrunchScene(scene, renderTarget, renderTexture);
}
renderTexture.Dispose();
renderTarget.Dispose();
}
public static bool CompressTexture(Texture texture)
{
try
{
byte[] bytes = Squish.CompressImage(texture.BasePixmap.Res.ProcessedLayer.GetPixelDataByteRgba(), texture.PixelWidth, texture.PixelHeight, SquishFlags.Dxt5);
var layer = texture.BasePixmap.Res.ProcessedLayer;
layer.SetPixelDataDxtCompressed(bytes);
DualityEditorApp.NotifyObjPropChanged(null, new ObjectSelection(texture.BasePixmap.Res));
DualityEditorApp.NotifyObjPropChanged(null, new ObjectSelection(texture));
return true;
}
catch (Exception e)
{
Log.Editor.WriteError("Something went wrong while DXT compressing {0}: {1}", texture.Name, e.Message);
return false;
}
}
/// <summary>
/// Sets up the appropriate OpenGL rendering state for this DrawTechnique.
/// </summary>
/// <param name="lastTechnique">The last DrawTechnique that has been set up. This parameter is optional, but
/// specifying it will increase performance by reducing redundant state changes.</param>
/// <param name="textures">A set of <see cref="Duality.Resources.Texture">Textures</see> to use.</param>
/// <param name="uniforms">A set of <see cref="Duality.Resources.ShaderVarInfo">uniform values</see> to apply.</param>
public void SetupForRendering(IDrawDevice device, BatchInfo material, DrawTechnique lastTechnique)
{
// Prepare Rendering
if (this.NeedsPreparation)
{
// Clone the material, if not done yet due to vertex preprocessing
if (!this.NeedsPreprocess)
{
material = new BatchInfo(material);
}
this.PrepareRendering(device, material);
}
// Setup BlendType
if (lastTechnique == null || this.blendType != lastTechnique.blendType)
{
this.SetupBlendType(this.blendType, device.DepthWrite);
}
// Bind Shader
ContentRef <ShaderProgram> selShader = this.SelectShader();
if (lastTechnique == null || selShader.Res != lastTechnique.shader.Res)
{
ShaderProgram.Bind(selShader);
}
// Setup shader data
if (selShader.IsAvailable)
{
ShaderVarInfo[] varInfo = selShader.Res.VarInfo;
// Setup sampler bindings automatically
int curSamplerIndex = 0;
if (material.Textures != null)
{
for (int i = 0; i < varInfo.Length; i++)
{
if (varInfo[i].glVarLoc == -1)
{
continue;
}
if (varInfo[i].type != ShaderVarType.Sampler2D)
{
continue;
}
// Bind Texture
ContentRef <Texture> texRef = material.GetTexture(varInfo[i].name);
Texture.Bind(texRef, curSamplerIndex);
GL.Uniform1(varInfo[i].glVarLoc, curSamplerIndex);
curSamplerIndex++;
}
}
Texture.ResetBinding(curSamplerIndex);
// Transfer uniform data from material to actual shader
if (material.Uniforms != null)
{
for (int i = 0; i < varInfo.Length; i++)
{
if (varInfo[i].glVarLoc == -1)
{
continue;
}
float[] data = material.GetUniform(varInfo[i].name);
if (data == null)
{
continue;
}
varInfo[i].SetupUniform(data);
}
}
}
// Setup fixed function data
else
{
// Fixed function texture binding
if (material.Textures != null)
{
int samplerIndex = 0;
foreach (var pair in material.Textures)
{
Texture.Bind(pair.Value, samplerIndex);
samplerIndex++;
}
Texture.ResetBinding(samplerIndex);
}
else
{
Texture.ResetBinding();
}
}
}
private void GenerateTexture()
{
if (this.texture != null) this.texture.Dispose();
if (this.pixelData == null)
return;
this.texture = new Texture(this.pixelData,
TextureSizeMode.Enlarge,
this.IsPixelGridAligned ? TextureMagFilter.Nearest : TextureMagFilter.Linear,
this.IsPixelGridAligned ? TextureMinFilter.Nearest : TextureMinFilter.LinearMipmapLinear);
}
private void SetupPickingRT(Point2 size)
{
if (this.pickingTex == null ||
this.pickingTex.PixelWidth != size.X ||
this.pickingTex.PixelHeight != size.Y)
{
if (this.pickingTex != null) this.pickingTex.Dispose();
if (this.pickingRT != null) this.pickingRT.Dispose();
this.pickingTex = new Texture(
size.X, size.Y, TextureSizeMode.Default,
TextureMagFilter.Nearest, TextureMinFilter.Nearest);
this.pickingRT = new RenderTarget(AAQuality.Off, this.pickingTex);
}
}
private static bool IsMatch(Texture source, Material target)
{
return target.MainTexture == source;
}
[TestFixtureSetUp] public void FixtureSetup()
{
this.texCoordUV = new Texture(new Pixmap(TestRes.TexCoordUV));
}
/// <summary>
/// Compiles a <see cref="Tileset"/> using its specified source data, in order to
/// generate optimized target data for rendering and collision detection.
/// </summary>
public TilesetCompilerOutput Compile(TilesetCompilerInput input)
{
TilesetCompilerOutput output = input.ExistingOutput;
output.TileData = output.TileData ?? new RawList<TileInfo>(input.TileInput.Count);
output.RenderData = output.RenderData ?? new List<Texture>();
output.AutoTileData = output.AutoTileData ?? new List<TilesetAutoTileInfo>();
// Clear existing data, but keep the sufficiently big data structures
output.TileData.Clear();
output.RenderData.Clear();
output.AutoTileData.Clear();
// Determine how many source tiles we have
int sourceTileCount = int.MaxValue;
for (int renderInputIndex = 0; renderInputIndex < input.RenderConfig.Count; renderInputIndex++)
{
TilesetRenderInput renderInput = input.RenderConfig[renderInputIndex] ?? DefaultRenderInput;
PixelData sourceLayerData = (renderInput.SourceData.Res ?? Pixmap.Checkerboard.Res).MainLayer;
LayerGeometry layerGeometry = this.CalculateLayerGeometry(renderInput, sourceLayerData);
sourceTileCount = Math.Min(sourceTileCount, layerGeometry.SourceTileCount);
}
if (input.RenderConfig.Count == 0) sourceTileCount = 0;
// Transform AutoTile data
for (int autoTileIndex = 0; autoTileIndex < input.AutoTileConfig.Count; autoTileIndex++)
{
TilesetAutoTileInput autoTileInput = input.AutoTileConfig[autoTileIndex];
TilesetAutoTileInfo autoTileInfo = this.TransformAutoTileData(
autoTileIndex,
autoTileInput,
output.TileData,
sourceTileCount);
output.AutoTileData.Add(autoTileInfo);
}
// Initialize all tiles to being visually empty. They will be subtractively updated
// during output pixel data generation in the next step.
{
int tileDataCount = output.TileData.Count;
TileInfo[] tileData = output.TileData.Data;
for (int i = 0; i < tileDataCount; i++)
{
tileData[i].IsVisuallyEmpty = true;
}
}
// Generate output pixel data
for (int renderInputIndex = 0; renderInputIndex < input.RenderConfig.Count; renderInputIndex++)
{
TilesetRenderInput renderInput = input.RenderConfig[renderInputIndex] ?? DefaultRenderInput;
PixelData sourceLayerData = (renderInput.SourceData.Res ?? Pixmap.Checkerboard.Res).MainLayer;
// Determine overal geometry values for this layer, such as tile bounds and texture sizes
LayerGeometry layerGeometry = this.CalculateLayerGeometry(renderInput, sourceLayerData);
// Generate pixel data and atlas values for this layer's texture
LayerPixelData targetLayerData = this.GenerateLayerPixelData(
renderInput,
sourceLayerData,
layerGeometry,
output.TileData);
// Create the texture to be used for this rendering input
using (Pixmap targetPixmap = new Pixmap(targetLayerData.PixelData))
{
targetPixmap.Atlas = targetLayerData.Atlas;
Texture targetTexture = new Texture(
targetPixmap, TextureSizeMode.Enlarge,
renderInput.TargetMagFilter, renderInput.TargetMinFilter,
TextureWrapMode.Clamp, TextureWrapMode.Clamp,
renderInput.TargetFormat);
output.RenderData.Add(targetTexture);
}
}
// Generate additional per-tile data
this.TransformTileData(input.TileInput, output.TileData, output.RenderData);
// Apply global tileset stats
output.TileCount = sourceTileCount;
return output;
}
/// <summary>
/// Resets the OpenGL rendering state after finishing DrawTechnique-Setups. Only call this when there are no more
/// DrawTechniques to follow directly.
/// </summary>
public void FinishRendering()
{
this.SetupBlendType(BlendMode.Reset);
ShaderProgram.Bind(ContentRef <ShaderProgram> .Null);
Texture.ResetBinding();
}
private static void DrawTileHighlights(Canvas canvas, ICmpTilemapRenderer renderer, Point2 origin, IReadOnlyGrid<bool> highlight, ColorRgba fillTint, ColorRgba outlineTint, TileHighlightMode mode, List<Vector2[]> outlineCache = null)
{
if (highlight.Width == 0 || highlight.Height == 0) return;
// Generate strippled line texture if not available yet
if (strippledLineTex == null)
{
PixelData pixels = new PixelData(8, 1);
for (int i = 0; i < pixels.Width / 2; i++)
pixels[i, 0] = ColorRgba.White;
for (int i = pixels.Width / 2; i < pixels.Width; i++)
pixels[i, 0] = ColorRgba.TransparentWhite;
using (Pixmap pixmap = new Pixmap(pixels))
{
strippledLineTex = new Texture(pixmap,
TextureSizeMode.Default,
TextureMagFilter.Nearest,
TextureMinFilter.Nearest,
TextureWrapMode.Repeat,
TextureWrapMode.Repeat,
TexturePixelFormat.Rgba);
}
}
BatchInfo defaultMaterial = new BatchInfo(DrawTechnique.Alpha, canvas.State.Material.MainColor);
BatchInfo strippleMaterial = new BatchInfo(DrawTechnique.Alpha, canvas.State.Material.MainColor, strippledLineTex);
bool uncertain = (mode & TileHighlightMode.Uncertain) != 0;
bool selection = (mode & TileHighlightMode.Selection) != 0;
Component component = renderer as Component;
Transform transform = component.GameObj.Transform;
Tilemap tilemap = renderer.ActiveTilemap;
Tileset tileset = tilemap != null ? tilemap.Tileset.Res : null;
Vector2 tileSize = tileset != null ? tileset.TileSize : Tileset.DefaultTileSize;
Rect localRect = renderer.LocalTilemapRect;
// Determine the object's local coordinate system (rotated, scaled) in world space
Vector2 worldAxisX = Vector2.UnitX;
Vector2 worldAxisY = Vector2.UnitY;
MathF.TransformCoord(ref worldAxisX.X, ref worldAxisX.Y, transform.Angle, transform.Scale);
MathF.TransformCoord(ref worldAxisY.X, ref worldAxisY.Y, transform.Angle, transform.Scale);
Vector2 localOriginPos = tileSize * origin;
Vector2 worldOriginPos = localOriginPos.X * worldAxisX + localOriginPos.Y * worldAxisY;
canvas.PushState();
{
// Configure the canvas so our shapes are properly rotated and scaled
canvas.State.TransformHandle = -localRect.TopLeft;
canvas.State.TransformAngle = transform.Angle;
canvas.State.TransformScale = new Vector2(transform.Scale);
// Fill all highlighted tiles that are currently visible
{
canvas.State.SetMaterial(defaultMaterial);
canvas.State.ColorTint = fillTint * ColorRgba.White.WithAlpha(selection ? 0.2f : 0.375f);
// Determine tile visibility
Vector2 worldTilemapOriginPos = localRect.TopLeft;
MathF.TransformCoord(ref worldTilemapOriginPos.X, ref worldTilemapOriginPos.Y, transform.Angle, transform.Scale);
TilemapCulling.TileInput cullingIn = new TilemapCulling.TileInput
{
// Remember: All these transform values are in world space
TilemapPos = transform.Pos + new Vector3(worldTilemapOriginPos) + new Vector3(worldOriginPos),
TilemapScale = transform.Scale,
TilemapAngle = transform.Angle,
TileCount = new Point2(highlight.Width, highlight.Height),
TileSize = tileSize
};
TilemapCulling.TileOutput cullingOut = TilemapCulling.GetVisibleTileRect(canvas.DrawDevice, cullingIn);
int renderedTileCount = cullingOut.VisibleTileCount.X * cullingOut.VisibleTileCount.Y;
// Draw all visible highlighted tiles
{
Point2 tileGridPos = cullingOut.VisibleTileStart;
Vector2 renderStartPos = worldOriginPos + tileGridPos.X * tileSize.X * worldAxisX + tileGridPos.Y * tileSize.Y * worldAxisY;;
Vector2 renderPos = renderStartPos;
Vector2 tileXStep = worldAxisX * tileSize.X;
Vector2 tileYStep = worldAxisY * tileSize.Y;
int lineMergeCount = 0;
int totalRects = 0;
for (int tileIndex = 0; tileIndex < renderedTileCount; tileIndex++)
{
bool current = highlight[tileGridPos.X, tileGridPos.Y];
if (current)
{
// Try to merge consecutive rects in the same line to reduce drawcalls / CPU load
bool hasNext = (tileGridPos.X + 1 < highlight.Width) && ((tileGridPos.X + 1 - cullingOut.VisibleTileStart.X) < cullingOut.VisibleTileCount.X);
bool next = hasNext ? highlight[tileGridPos.X + 1, tileGridPos.Y] : false;
if (next)
{
lineMergeCount++;
}
else
{
totalRects++;
canvas.FillRect(
transform.Pos.X + renderPos.X - lineMergeCount * tileXStep.X,
transform.Pos.Y + renderPos.Y - lineMergeCount * tileXStep.Y,
transform.Pos.Z,
tileSize.X * (1 + lineMergeCount),
tileSize.Y);
lineMergeCount = 0;
}
}
tileGridPos.X++;
renderPos += tileXStep;
if ((tileGridPos.X - cullingOut.VisibleTileStart.X) >= cullingOut.VisibleTileCount.X)
{
tileGridPos.X = cullingOut.VisibleTileStart.X;
tileGridPos.Y++;
renderPos = renderStartPos;
renderPos += tileYStep * (tileGridPos.Y - cullingOut.VisibleTileStart.Y);
}
}
}
}
// Draw highlight area outlines, unless flagged as uncertain
if (!uncertain)
{
// Determine the outlines of individual highlighted tile patches
if (outlineCache == null) outlineCache = new List<Vector2[]>();
if (outlineCache.Count == 0)
{
GetTileAreaOutlines(highlight, tileSize, ref outlineCache);
}
// Draw outlines around all highlighted tile patches
canvas.State.SetMaterial(selection ? strippleMaterial : defaultMaterial);
canvas.State.ColorTint = outlineTint;
foreach (Vector2[] outline in outlineCache)
{
// For strippled-line display, determine total length of outline
if (selection)
{
float totalLength = 0.0f;
for (int i = 1; i < outline.Length; i++)
{
totalLength += (outline[i - 1] - outline[i]).Length;
}
canvas.State.TextureCoordinateRect = new Rect(totalLength / strippledLineTex.PixelWidth, 1.0f);
}
// Draw the outline
canvas.DrawPolygon(
outline,
transform.Pos.X + worldOriginPos.X,
transform.Pos.Y + worldOriginPos.Y,
transform.Pos.Z);
}
}
// If this is an uncertain highlight, i.e. not actually reflecting the represented action,
// draw a gizmo to indicate this for the user.
if (uncertain)
{
Vector2 highlightSize = new Vector2(highlight.Width * tileSize.X, highlight.Height * tileSize.Y);
Vector2 highlightCenter = highlightSize * 0.5f;
Vector3 circlePos = transform.Pos + new Vector3(worldOriginPos + worldAxisX * highlightCenter + worldAxisY * highlightCenter);
float circleRadius = MathF.Min(tileSize.X, tileSize.Y) * 0.2f;
canvas.State.SetMaterial(defaultMaterial);
canvas.State.ColorTint = outlineTint;
canvas.FillCircle(
circlePos.X,
circlePos.Y,
circlePos.Z,
circleRadius);
}
}
canvas.PopState();
}
private void ActionTextureCreateMaterial(Texture tex)
{
Material.CreateFromTexture(tex);
}
public VideoPlayer()
{
// Initialize OpenAL members.
audioSourceIndex = -1;
// Initialize public members.
IsDisposed = false;
IsLooped = false;
IsMuted = false;
State = MediaState.Stopped;
Volume = 1.0f;
// Initialize private members.
timer = new Stopwatch();
audioStarted = false;
// Initialize this here to prevent null GetTexture returns.
videoTexture = new Texture();
// Game.Instance.GraphicsDevice,
// 1280,
// 720
// );
#if VIDEOPLAYER_OPENGL
// Initialize the OpenGL bits.
GL_initialize();
#endif
}
public override void PerformGetValue()
{
base.PerformGetValue();
Texture lastValue = this.value;
Texture[] values = this.GetValue().Cast<Texture>().ToArray();
this.value = values.NotNull().FirstOrDefault() as Texture;
this.ResetPreviewImage();
if (this.value != lastValue)
this.Invalidate();
else
this.Invalidate(this.rectHeader);
}
public void FixtureSetup()
{
this.texCoordUV = new Texture(new Pixmap(BitmapToPixelData(TestRes.TexCoordUV)));
}
public void Play(OgvComponent video)
{
checkDisposed();
// We need to assign this regardless of what happens next.
Video = video;
// FIXME: This is a part of the Duration hack!
Video.Duration = TimeSpan.MaxValue;
// Check the player state before attempting anything.
if (State != MediaState.Stopped)
{
return;
}
// In rare cases, the thread might still be going. Wait until it's done.
if (audioDecoderThread != null && audioDecoderThread.IsAlive)
{
Stop();
}
// Create new Thread instances in case we use this player multiple times.
audioDecoderThread = new Thread(new ThreadStart(this.DecodeAudio));
// Update the player state now, for the thread we're about to make.
State = MediaState.Playing;
// Start the video if it hasn't been yet.
if (Video.IsDisposed)
{
video.Initialize();
}
// Grab the first bit of audio. We're trying to start the decoding ASAP.
if (TheoraPlay.THEORAPLAY_hasAudioStream(Video.TheoraDecoder) != 0)
{
audioDecoderThread.Start();
}
else
{
audioStarted = true; // Welp.
}
// Grab the first bit of video, set up the texture.
if (TheoraPlay.THEORAPLAY_hasVideoStream(Video.TheoraDecoder) != 0)
{
currentVideo = TheoraPlay.getVideoFrame(Video.VideoStream);
previousFrame = Video.VideoStream;
do
{
// The decoder miiight not be ready yet.
Video.VideoStream = TheoraPlay.THEORAPLAY_getVideo(Video.TheoraDecoder);
} while (Video.VideoStream == IntPtr.Zero);
nextVideo = TheoraPlay.getVideoFrame(Video.VideoStream);
Texture overlap = videoTexture;
videoTexture = new Texture(
// Game.Instance.GraphicsDevice,
// (int)currentVideo.width,
// (int)currentVideo.height,
// false,
// SurfaceFormat.Color
);
overlap.Dispose();
#if VIDEOPLAYER_OPENGL
GL_setupTargets(
(int)currentVideo.width,
(int)currentVideo.height
);
#endif
}
// Initialize the thread!
Log.Editor.Write("Starting Theora player...");
while (!audioStarted) ;
timer.Start();
if (audioSourceIndex != -1)
{
AL.SourcePlay(audioSourceIndex);
}
Log.Editor.Write(" Done starting Theora player!");
}
private static bool IsMatch(Pixmap source, Texture target)
{
return target.BasePixmap == source;
}
private void GenerateResources()
{
if (this.mat != null || this.texture != null || this.pixelData != null)
this.ReleaseResources();
int cols;
int rows;
cols = rows = (int)Math.Ceiling(Math.Sqrt(SupportedChars.Length));
Pixmap.Layer pixelLayer = new Pixmap.Layer(MathF.RoundToInt(cols * this.internalFont.Size), MathF.RoundToInt(rows * (this.internalFont.Height + 1)));
Pixmap.Layer glyphTemp;
Pixmap.Layer glyphTempTypo;
Bitmap bm;
Bitmap measureBm = new Bitmap(1, 1);
Rect[] atlas = new Rect[SupportedChars.Length];
using (Graphics measureGraphics = Graphics.FromImage(measureBm))
{
Brush fntBrush = new SolidBrush(Color.Black);
StringFormat formatDef = StringFormat.GenericDefault;
formatDef.LineAlignment = StringAlignment.Near;
formatDef.FormatFlags = 0;
StringFormat formatTypo = StringFormat.GenericTypographic;
formatTypo.LineAlignment = StringAlignment.Near;
int x = 0;
int y = 0;
for (int i = 0; i < SupportedChars.Length; ++i)
{
string str = SupportedChars[i].ToString(CultureInfo.InvariantCulture);
bool isSpace = str == " ";
SizeF charSize = measureGraphics.MeasureString(str, this.internalFont, pixelLayer.Width, formatDef);
// Render a single glyph
bm = new Bitmap((int)Math.Ceiling(Math.Max(1, charSize.Width)), this.internalFont.Height + 1);
using (Graphics glyphGraphics = Graphics.FromImage(bm))
{
glyphGraphics.Clear(Color.Transparent);
glyphGraphics.TextRenderingHint = (System.Drawing.Text.TextRenderingHint)this.hint;
glyphGraphics.DrawString(str, this.internalFont, fntBrush, new RectangleF(0, 0, bm.Width, bm.Height), formatDef);
}
glyphTemp = new Pixmap.Layer(bm);
if (!isSpace)
{
Rectangle glyphTempBounds = glyphTemp.OpaqueBounds();
glyphTemp.SubImage(glyphTempBounds.X, 0, glyphTempBounds.Width, glyphTemp.Height);
if (BodyAscentRef.Contains(SupportedChars[i]))
this.bodyAscent += glyphTempBounds.Height;
// Render a single glyph in typographic mode
bm = new Bitmap((int)Math.Ceiling(Math.Max(1, charSize.Width)), this.internalFont.Height + 1);
using (Graphics glyphGraphics = Graphics.FromImage(bm))
{
glyphGraphics.Clear(Color.Transparent);
glyphGraphics.TextRenderingHint = (System.Drawing.Text.TextRenderingHint)this.hint;
glyphGraphics.DrawString(str, this.internalFont, fntBrush, new RectangleF(0, 0, bm.Width, bm.Height), formatTypo);
}
glyphTempTypo = new Pixmap.Layer(bm);
glyphTempTypo.Crop(true, false);
}
else
glyphTempTypo = glyphTemp;
// Update xy values if it doesn't fit anymore
if (x + glyphTemp.Width + 2 > pixelLayer.Width)
{
x = 0;
y += (this.internalFont.Height + 1) + 2;
}
// Memorize atlas coordinates & glyph data
this.maxGlyphWidth = Math.Max(this.maxGlyphWidth, glyphTemp.Width);
this.glyphs[i].width = glyphTemp.Width;
this.glyphs[i].height = glyphTemp.Height;
this.glyphs[i].offsetX = glyphTemp.Width - glyphTempTypo.Width;
if (isSpace)
{
this.glyphs[i].width /= 2;
this.glyphs[i].offsetX /= 2;
}
atlas[i].X = x;
atlas[i].Y = y;
atlas[i].W = glyphTemp.Width;
atlas[i].H = (this.internalFont.Height + 1);
// Draw it onto the font surface
glyphTemp.DrawOnto(pixelLayer, BlendMode.Solid, x, y);
x += glyphTemp.Width + 2;
}
}
// Adjust colors based on alpha value
//for (int i = 0; i < pixelLayer.Data.Length; i++)
System.Threading.Tasks.Parallel.For(0, pixelLayer.Data.Length, i =>
{
float factor = pixelLayer.Data[i].A / 255.0f;
float invFactor = 1.0f - factor;
pixelLayer.Data[i].R = (byte)Math.Min(255.0f, Math.Max(0.0f, this.bgColor.R * invFactor + this.color.R * factor));
pixelLayer.Data[i].G = (byte)Math.Min(255.0f, Math.Max(0.0f, this.bgColor.G * invFactor + this.color.G * factor));
pixelLayer.Data[i].B = (byte)Math.Min(255.0f, Math.Max(0.0f, this.bgColor.B * invFactor + this.color.B * factor));
pixelLayer.Data[i].A = (byte)Math.Min(255.0f, Math.Max(0.0f, this.bgColor.A * invFactor + this.color.A * factor));
});
this.height = this.internalFont.Height;
this.ascent = (int)Math.Round(this.internalFont.FontFamily.GetCellAscent(this.internalFont.Style) * this.internalFont.Size / this.internalFont.FontFamily.GetEmHeight(this.internalFont.Style));
this.bodyAscent /= BodyAscentRef.Length;
this.descent = (int)Math.Round(this.internalFont.FontFamily.GetCellDescent(this.internalFont.Style) * this.internalFont.GetHeight() / this.internalFont.FontFamily.GetLineSpacing(this.internalFont.Style));
this.baseLine = (int)Math.Round(this.internalFont.FontFamily.GetCellAscent(this.internalFont.Style) * this.internalFont.GetHeight() / this.internalFont.FontFamily.GetLineSpacing(this.internalFont.Style));
bool useNearest = this.hint == RenderHint.Monochrome || !this.filtering;
this.pixelData = new Pixmap(pixelLayer);
this.pixelData.Atlas = new List<Rect>(atlas);
this.texture = new Texture(this.pixelData,
Texture.SizeMode.Enlarge,
useNearest ? OpenTK.Graphics.OpenGL.TextureMagFilter.Nearest : OpenTK.Graphics.OpenGL.TextureMagFilter.Linear,
useNearest ? OpenTK.Graphics.OpenGL.TextureMinFilter.Nearest : OpenTK.Graphics.OpenGL.TextureMinFilter.LinearMipmapLinear);
this.mat = new Material(this.hint == RenderHint.Monochrome ? DrawTechnique.Mask : DrawTechnique.Alpha, ColorRgba.White, this.texture);
}
protected void GetAnimData(Texture mainTex, DrawTechnique tech, bool smoothShaderInput, out Rect uvRect, out Rect uvRectNext)
{
this.UpdateVisibleFrames();
if (mainTex != null)
{
mainTex.LookupAtlas(this.curAnimFrame, out uvRect);
if (smoothShaderInput)
mainTex.LookupAtlas(this.nextAnimFrame, out uvRectNext);
else
uvRectNext = uvRect;
}
else if (mainTex != null)
uvRect = uvRectNext = new Rect(mainTex.UVRatio.X, mainTex.UVRatio.Y);
else
uvRect = uvRectNext = new Rect(1.0f, 1.0f);
}
internal void Initialize()
{
Stop();
_fmodTheoraStream = new FmodTheoraStream();
_fmodTheoraStream.Initialize();
_theoraVideo = new TheoraVideo();
#if __ANDROID__
_fileName = ExtractVideoFromAPK(_fileName);
#endif
_theoraVideo.InitializeVideo(_fileName);
_textureOne = new Texture(_theoraVideo.Width, _theoraVideo.Height, filterMin: TextureMinFilter.Linear);
_textureTwo = new Texture(_theoraVideo.Width / 2, _theoraVideo.Height / 2, filterMin: TextureMinFilter.Linear);
_textureThree = new Texture(_theoraVideo.Width / 2, _theoraVideo.Height / 2, filterMin: TextureMinFilter.Linear);
}
private Pixmap.Layer RenderToTexture(int width, int height, Action<Canvas> renderMethod)
{
Pixmap.Layer pixelData;
using (Texture texture = new Texture(width, height, Texture.SizeMode.NonPowerOfTwo))
using (RenderTarget renderTarget = new RenderTarget(AAQuality.Off, texture))
using (DrawDevice device = new DrawDevice())
{
device.Perspective = PerspectiveMode.Flat;
device.VisibilityMask = VisibilityFlag.AllGroups | VisibilityFlag.ScreenOverlay;
device.RenderMode = RenderMatrix.OrthoScreen;
device.Target = renderTarget;
device.ViewportRect = new Rect(renderTarget.Width, renderTarget.Height);
device.BeginRendering(ClearFlag.All, ColorRgba.TransparentBlack, 1.0f);
{
Canvas canvas = new Canvas(device);
renderMethod(canvas);
}
device.EndRendering();
RenderTarget.Bind(RenderTarget.None);
pixelData = texture.RetrievePixelData();
}
return pixelData;
}
private void ReleaseResources()
{
if (this.material != null) this.material.Dispose();
if (this.texture != null) this.texture.Dispose();
if (this.pixelData != null) this.pixelData.Dispose();
this.material = null;
this.texture = null;
this.pixelData = null;
this.glyphsDirty = true;
}
[TestFixtureTearDown] public void FixtureTearDown()
{
this.texCoordUV.Dispose();
this.texCoordUV = null;
}
private void GenerateTexMat()
{
if (this.material != null) this.material.Dispose();
if (this.texture != null) this.texture.Dispose();
if (this.pixelData == null)
return;
this.texture = new Texture(this.pixelData,
TextureSizeMode.Enlarge,
this.IsPixelGridAligned ? TextureMagFilter.Nearest : TextureMagFilter.Linear,
this.IsPixelGridAligned ? TextureMinFilter.Nearest : TextureMinFilter.LinearMipmapLinear);
// Select DrawTechnique to use
ContentRef<DrawTechnique> technique;
if (this.renderMode == RenderMode.MonochromeBitmap)
technique = DrawTechnique.Mask;
else if (this.renderMode == RenderMode.GrayscaleBitmap)
technique = DrawTechnique.Alpha;
else if (this.renderMode == RenderMode.SmoothBitmap)
technique = DrawTechnique.Alpha;
else
technique = DrawTechnique.SharpAlpha;
// Create and configure internal BatchInfo
BatchInfo matInfo = new BatchInfo(technique, ColorRgba.White, this.texture);
if (technique == DrawTechnique.SharpAlpha)
{
matInfo.SetUniform("smoothness", this.size * 4.0f);
}
this.material = new Material(matInfo);
}
private static void CompressTexture(Texture texture)
{
if (EditorUtility.CompressTexture(texture) == false)
texture.Compressed = false;
}
private void GenerateResources()
{
if (this.mat != null || this.texture != null || this.pixelData != null)
this.ReleaseResources();
TextRenderingHint textRenderingHint;
if (this.renderMode == RenderMode.MonochromeBitmap)
textRenderingHint = TextRenderingHint.SingleBitPerPixelGridFit;
else
textRenderingHint = TextRenderingHint.AntiAliasGridFit;
int cols;
int rows;
cols = rows = (int)Math.Ceiling(Math.Sqrt(SupportedChars.Length));
Pixmap.Layer pixelLayer = new Pixmap.Layer(MathF.RoundToInt(cols * this.internalFont.Size * 1.2f), MathF.RoundToInt(rows * this.internalFont.Height * 1.2f));
Pixmap.Layer glyphTemp;
Pixmap.Layer glyphTempTypo;
Bitmap bm;
Bitmap measureBm = new Bitmap(1, 1);
Rect[] atlas = new Rect[SupportedChars.Length];
using (Graphics measureGraphics = Graphics.FromImage(measureBm))
{
Brush fntBrush = new SolidBrush(Color.Black);
StringFormat formatDef = StringFormat.GenericDefault;
formatDef.LineAlignment = StringAlignment.Near;
formatDef.FormatFlags = 0;
StringFormat formatTypo = StringFormat.GenericTypographic;
formatTypo.LineAlignment = StringAlignment.Near;
int x = 1;
int y = 1;
for (int i = 0; i < SupportedChars.Length; ++i)
{
string str = SupportedChars[i].ToString(CultureInfo.InvariantCulture);
bool isSpace = str == " ";
SizeF charSize = measureGraphics.MeasureString(str, this.internalFont, pixelLayer.Width, formatDef);
// Rasterize a single glyph for rendering
bm = new Bitmap((int)Math.Ceiling(Math.Max(1, charSize.Width)), this.internalFont.Height + 1);
using (Graphics glyphGraphics = Graphics.FromImage(bm))
{
glyphGraphics.Clear(Color.Transparent);
glyphGraphics.TextRenderingHint = textRenderingHint;
glyphGraphics.DrawString(str, this.internalFont, fntBrush, new RectangleF(0, 0, bm.Width, bm.Height), formatDef);
}
glyphTemp = new Pixmap.Layer(bm);
// Rasterize a single glyph in typographic mode for metric analysis
if (!isSpace)
{
Rectangle glyphTempBounds = glyphTemp.OpaqueBounds();
glyphTemp.SubImage(glyphTempBounds.X, 0, glyphTempBounds.Width, glyphTemp.Height);
if (BodyAscentRef.Contains(SupportedChars[i]))
this.bodyAscent += glyphTempBounds.Height;
bm = new Bitmap((int)Math.Ceiling(Math.Max(1, charSize.Width)), this.internalFont.Height + 1);
using (Graphics glyphGraphics = Graphics.FromImage(bm))
{
glyphGraphics.Clear(Color.Transparent);
glyphGraphics.TextRenderingHint = textRenderingHint;
glyphGraphics.DrawString(str, this.internalFont, fntBrush, new RectangleF(0, 0, bm.Width, bm.Height), formatTypo);
}
glyphTempTypo = new Pixmap.Layer(bm);
glyphTempTypo.Crop(true, false);
}
else
{
glyphTempTypo = glyphTemp;
}
// Update xy values if it doesn't fit anymore
if (x + glyphTemp.Width + 2 > pixelLayer.Width)
{
x = 1;
y += this.internalFont.Height + MathF.Clamp((int)MathF.Ceiling(this.internalFont.Height * 0.1875f), 3, 10);
}
// Memorize atlas coordinates & glyph data
this.maxGlyphWidth = Math.Max(this.maxGlyphWidth, glyphTemp.Width);
this.glyphs[i].width = glyphTemp.Width;
this.glyphs[i].height = glyphTemp.Height;
this.glyphs[i].offsetX = glyphTemp.Width - glyphTempTypo.Width;
if (isSpace)
{
this.glyphs[i].width /= 2;
this.glyphs[i].offsetX /= 2;
}
atlas[i].X = x;
atlas[i].Y = y;
atlas[i].W = glyphTemp.Width;
atlas[i].H = (this.internalFont.Height + 1);
// Draw it onto the font surface
glyphTemp.DrawOnto(pixelLayer, BlendMode.Solid, x, y);
x += glyphTemp.Width + MathF.Clamp((int)MathF.Ceiling(this.internalFont.Height * 0.125f), 2, 10);
}
}
// White out texture except alpha channel.
for (int i = 0; i < pixelLayer.Data.Length; i++)
{
pixelLayer.Data[i].R = 255;
pixelLayer.Data[i].G = 255;
pixelLayer.Data[i].B = 255;
}
// Determine Font properties
this.height = this.internalFont.Height;
this.ascent = (int)Math.Round(this.internalFont.FontFamily.GetCellAscent(this.internalFont.Style) * this.internalFont.Size / this.internalFont.FontFamily.GetEmHeight(this.internalFont.Style));
this.bodyAscent /= BodyAscentRef.Length;
this.descent = (int)Math.Round(this.internalFont.FontFamily.GetCellDescent(this.internalFont.Style) * this.internalFont.GetHeight() / this.internalFont.FontFamily.GetLineSpacing(this.internalFont.Style));
this.baseLine = (int)Math.Round(this.internalFont.FontFamily.GetCellAscent(this.internalFont.Style) * this.internalFont.GetHeight() / this.internalFont.FontFamily.GetLineSpacing(this.internalFont.Style));
// Create internal Pixmap and Texture Resources
this.pixelData = new Pixmap(pixelLayer);
this.pixelData.Atlas = new List<Rect>(atlas);
this.texture = new Texture(this.pixelData,
Texture.SizeMode.Enlarge,
this.IsPixelGridAligned ? TextureMagFilter.Nearest : TextureMagFilter.Linear,
this.IsPixelGridAligned ? TextureMinFilter.Nearest : TextureMinFilter.LinearMipmapLinear);
// Select DrawTechnique to use
ContentRef<DrawTechnique> technique;
if (this.renderMode == RenderMode.MonochromeBitmap)
technique = DrawTechnique.Mask;
else if (this.renderMode == RenderMode.GrayscaleBitmap)
technique = DrawTechnique.Alpha;
else if (this.renderMode == RenderMode.SmoothBitmap)
technique = DrawTechnique.Alpha;
else
technique = DrawTechnique.SharpAlpha;
// Create and configure internal BatchInfo
BatchInfo matInfo = new BatchInfo(technique, ColorRgba.White, this.texture);
if (technique == DrawTechnique.SharpAlpha)
{
matInfo.SetUniform("smoothness", this.size * 3.0f);
}
this.mat = new Material(matInfo);
}
private void SetupPickingRT()
{
Vector2 refSize = DualityApp.TargetResolution;
if (this.pickingTex == null ||
this.pickingTex.PixelWidth != MathF.RoundToInt(refSize.X) ||
this.pickingTex.PixelHeight != MathF.RoundToInt(refSize.Y))
{
if (this.pickingTex != null) this.pickingTex.Dispose();
if (this.pickingRT != null) this.pickingRT.Dispose();
this.pickingTex = new Texture(
MathF.RoundToInt(refSize.X), MathF.RoundToInt(refSize.Y), Texture.SizeMode.Default,
TextureMagFilter.Nearest, TextureMinFilter.Nearest);
this.pickingRT = new RenderTarget(AAQuality.Off, this.pickingTex);
}
}
private void ReleaseResources()
{
if (this.mat != null) this.mat.Dispose();
if (this.texture != null) this.texture.Dispose();
if (this.pixelData != null) this.pixelData.Dispose();
this.mat = null;
this.texture = null;
this.pixelData = null;
this.needsReload = true;
}
/// <summary>
/// Creates a new Texture Resource based on the specified Pixmap, saves it and returns a reference to it.
/// </summary>
/// <param name="pixmap"></param>
/// <returns></returns>
public static ContentRef<Texture> CreateFromPixmap(ContentRef<Pixmap> pixmap)
{
string texPath = PathHelper.GetFreePath(pixmap.FullName, FileExt);
Texture tex = new Texture(pixmap);
tex.Save(texPath);
return tex;
}
private void CreateInternalTexture()
{
this.texture = new Texture(this.pixelData,
Texture.SizeMode.Enlarge,
this.IsPixelGridAligned ? TextureMagFilter.Nearest : TextureMagFilter.Linear,
this.IsPixelGridAligned ? TextureMinFilter.Nearest : TextureMinFilter.LinearMipmapLinear,
keepPixmapDataResident: DualityApp.ExecContext == DualityApp.ExecutionContext.Editor || this.Characters == CharacterSet.Dynamic);
}