/// <summary>Load resources here.</summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.Keyboard.KeyDown += KeyDown;
drawing = new QFontDrawing();
controlsDrawing = new QFontDrawing();
controlsTextOpts = new QFontRenderOptions()
{
Colour = Color.FromArgb(new Color4(0.8f, 0.1f, 0.1f, 1.0f).ToArgb()), DropShadowActive = true
};
heading2 = new QFont("woodenFont.qfont", new QFontConfiguration(addDropShadow: true), 1.0f);
heading2Options = new QFontRenderOptions()
{
Colour = Color.White, DropShadowActive = true
};
var builderConfig = new QFontBuilderConfiguration(addDropShadow: true);
builderConfig.ShadowConfig.blurRadius = 2; //reduce blur radius because font is very small
builderConfig.ShadowConfig.blurPasses = 1;
builderConfig.ShadowConfig.Type = ShadowType.Blurred;
builderConfig.TextGenerationRenderHint = TextGenerationRenderHint.ClearTypeGridFit; //best render hint for this font
builderConfig.Characters = CharacterSet.General | CharacterSet.Japanese | CharacterSet.Thai | CharacterSet.Cyrillic;
mainText = new QFont("Fonts/times.ttf", 14, builderConfig);
mainTextOptions = new QFontRenderOptions()
{
DropShadowActive = true, Colour = Color.White, WordSpacing = 0.5f
};
_benchmarkResults = new QFont("Fonts/times.ttf", 14, builderConfig);
heading1 = new QFont("Fonts/HappySans.ttf", 72, new QFontBuilderConfiguration(true));
controlsText = new QFont("Fonts/HappySans.ttf", 32, new QFontBuilderConfiguration(true));
codeText = new QFont("Fonts/Comfortaa-Regular.ttf", 12, new QFontBuilderConfiguration());
heading1Options = new QFontRenderOptions()
{
Colour = Color.FromArgb(new Color4(0.2f, 0.2f, 0.2f, 1.0f).ToArgb()), DropShadowActive = true
};
_processedText = QFontDrawingPrimitive.ProcessText(mainText, mainTextOptions, preProcessed, new SizeF(Width - 40, -1), QFontAlignment.Left);
codeTextOptions = new QFontRenderOptions()
{
Colour = Color.FromArgb(new Color4(0.0f, 0.0f, 0.4f, 1.0f).ToArgb())
};
monoSpaced = new QFont("Fonts/Anonymous.ttf", 10, new QFontBuilderConfiguration());
monoSpacedOptions = new QFontRenderOptions()
{
Colour = Color.FromArgb(new Color4(0.1f, 0.1f, 0.1f, 1.0f).ToArgb()), DropShadowActive = true
};
GL.ClearColor(Color4.CornflowerBlue);
}
public override void Load()
{
SceneManager.GameWindow.Cursor = MouseCursor.Empty;
_stage = new Stage(this.SceneManager);
_stage.ShaderProgram = _shaderProgram;
_loadingFontRenderOptions = new QFontRenderOptions();
_loadingFontRenderOptions.DropShadowActive = true;
_loadingFont = SceneManager.GameFontLibrary.GetFirstOrDefault(GameFontType.Heading);
_loadingFontDrawing = new QFontDrawing();
_loadingFontDrawing.ProjectionMatrix = SceneManager.ScreenCamera.ScreenProjectionMatrix;
_loadingText = QFontDrawingPrimitive.ProcessText(_loadingFont.Font, _loadingFontRenderOptions, "Loading", new SizeF(200, -1), QFontAlignment.Centre);
_loadingTextPosition = CalculateTextPosition(new Vector3((float)SceneManager.GameWindow.Width / 2, SceneManager.GameWindow.Height / 2, 0f), _loadingText);
_songText = QFontDrawingPrimitive.ProcessText(_loadingFont.Font, _loadingFontRenderOptions, _song.SongBase.Identifier, new SizeF(SceneManager.GameWindow.Width - 40, -1), QFontAlignment.Centre);
//Get difficulty options
DifficultyOptions dOptions;
switch ((DifficultyLevels)SceneManager.GameSettings["DifficultyLevel"])
{
case DifficultyLevels.Easy:
dOptions = DifficultyOptions.Easy;
break;
case DifficultyLevels.Medium:
dOptions = DifficultyOptions.Medium;
break;
case DifficultyLevels.Hard:
dOptions = DifficultyOptions.Hard;
break;
case DifficultyLevels.Ultra:
dOptions = DifficultyOptions.Ultra;
break;
case DifficultyLevels.Ninja:
dOptions = DifficultyOptions.Ninja;
break;
default:
//shouldn't happen
throw new Exception("Invalid difficulty level specified");
}
var progress = new Progress <string>(status =>
{
_loadingStatus = status;
});
_loadTask = Task.Factory.StartNew(() => _stage.LoadAsync(_song, _audioCorrection, _maxAudioVolume, progress, _centerPolygon, _player, dOptions, (DifficultyLevels)SceneManager.GameSettings["DifficultyLevel"]));
Loaded = true;
}
private void PrintComment(QFont font, string comment, QFontAlignment alignment, ref float yOffset, QFontRenderOptions opts)
{
yOffset += 20;
var pos = new Vector3(30f, Height - yOffset, 0f);
var dp = new QFontDrawingPrimitive(font, opts ?? new QFontRenderOptions());
dp.Print(comment, pos, new SizeF(Width - 60, -1), alignment);
yOffset += dp.Measure(comment, new SizeF(Width - 60, -1), alignment).Height;
_drawing.DrawingPrimitives.Add(dp);
}
private void PrintCommentWithLine(QFont font, string comment, QFontAlignment alignment, float xOffset, ref float yOffset, QFontRenderOptions opts)
{
yOffset += 20;
var dp = new QFontDrawingPrimitive(font, opts);
dp.Print(comment, new Vector3(xOffset, Height - yOffset, 0f), new SizeF(Width - 60, -1), alignment);
_drawing.DrawingPrimitives.Add(dp);
var bounds = font.Measure(comment, new SizeF(Width - 60, float.MaxValue), alignment);
yOffset += bounds.Height;
}
public static QFontDrawingPrimitive Create3DTextPrimitive(QFont font, Matrix4 transform, System.Drawing.Color textColor, float textScale)
{
var dp = new QFontDrawingPrimitive(font, new QFontRenderOptions()
{
Colour = textColor
});
var rotAdj = Matrix4.CreateRotationX(-((float)Math.PI / 2f));
dp.ModelViewMatrix = Matrix4.CreateScale(new Vector3(textScale)) * rotAdj * transform * TextViewMatrix;
UIRenderHelper.TextRenderer.DrawingPrimitives.Add(dp);
return(dp);
}
public static void DrawText(string text, QFont font, RectangleF bounds,
StringAlignment vAlign,
StringAlignment hAlign,
QFontRenderOptions options)
{
if (!Freetype6Loaded)
{
return;
}
var textSize = font.Measure(text, bounds.Size, QFontAlignment.Left);
textSize.Height += 2;
var textPos = Vector2.Zero;
switch (hAlign)
{
case StringAlignment.Near:
textPos.X = bounds.X;
break;
case StringAlignment.Far:
textPos.X = bounds.Right - textSize.Width;
break;
case StringAlignment.Center:
textPos.X = bounds.Left + ((bounds.Width - textSize.Width) / 2f);
break;
}
switch (vAlign)
{
case StringAlignment.Near:
textPos.Y = bounds.Y;
break;
case StringAlignment.Far:
textPos.Y = bounds.Y + bounds.Height - textSize.Height;
break;
case StringAlignment.Center:
textPos.Y = bounds.Y + ((bounds.Height - textSize.Height) / 2f);
break;
}
textPos.Y = ViewSize.Y - textPos.Y;
var dp = new QFontDrawingPrimitive(font, options);
dp.Print(text, new Vector3(textPos.X, textPos.Y, 0f), bounds.Size, QFontAlignment.Left);
TextRenderer.DrawingPrimitives.Add(dp);
}
private void PrintWithBounds(QFont font, string text, RectangleF bounds, QFontAlignment alignment, ref float yOffset)
{
var maxWidth = bounds.Width;
var height = font.Measure(text, new SizeF(maxWidth, -1), alignment).Height;
var dp = new QFontDrawingPrimitive(font);
dp.Print(text, new Vector3(bounds.X, Height - yOffset, 0), new SizeF(maxWidth, float.MaxValue), alignment);
_drawing.DrawingPrimitives.Add(dp);
yOffset += height;
}
public override void RenderText(Font font, Point position, TextContainer textContainer)
{
//Debug.Print(String.Format("RenderText {0}", font.FaceName));
// The DrawString(...) below will bind a new texture
// so make sure everything is rendered!
var tp = Translate(position);
//perform broad phase clipping
if (tp.Y > ClipRegion.Y + ClipRegion.Height || (tp.Y + font.RealSize * (textContainer.LineCount + 1) < ClipRegion.Y))
{
return;
}
//All text currently drawn in separate call, don't need to flush atm
Flush();
m_FontDrawing.DrawingPrimitives.Clear();
QFont sysQFont = font.RendererData as QFont;
if (sysQFont == null || Math.Abs(font.RealSize - font.Size * Scale) > 2)
{
FreeFont(font);
LoadFont(font);
sysQFont = font.RendererData as QFont;
}
// flip y coordinate for QuickFont
tp.Y = -tp.Y;
var key = new PrintedTextKey {
Color = this.DrawColor, Text = textContainer.Text, Font = font, Position = tp
};
if (!m_StringCache.Contains(key))
{
// not cached - create text renderer
Debug.Print(String.Format("RenderText: caching \"{0}\", {1}", textContainer.Text, font.FaceName));
Rectangle cRect;
cRect = m_ClipEnabled ? new Rectangle(ClipRegion.X, -ClipRegion.Y - ClipRegion.Height, ClipRegion.Width, ClipRegion.Height) : default(Rectangle);
m_StringCache[key] = new QFontDrawingPrimitive(sysQFont);
m_StringCache[key].Print(textContainer.Text, new Vector3(tp.X, tp.Y, 0), QFontAlignment.Left, this.DrawColor, cRect);
}
m_FontDrawing.DrawingPrimitives.Add(m_StringCache[key]);
DrawText();
}
public Text(string fileName)
: base(fileName)
{
//var file = Resources.GetFile(ImageRootPath + Name);
//Bitmap image = new Bitmap(file);
//TextureID = GL.GenTexture();
//GL.BindTexture(TextureTarget.Texture2D, TextureID);
//BitmapData data = image.LockBits(new System.Drawing.Rectangle(0, 0, image.Width, image.Height),
// ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
//GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0,
// OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0);
//image.UnlockBits(data);
//GL.TextureParameter((int)TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
//GL.TextureParameter((int)TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
//GL.TextureParameter((int)TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear);
//GL.TextureParameter((int)TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
//GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
var builderConfig = new QFontBuilderConfiguration(true)
{
ShadowConfig =
{
BlurRadius = 2,
BlurPasses = 1,
Type = ShadowType.Blurred
},
TextGenerationRenderHint = TextGenerationRenderHint.ClearTypeGridFit,
Characters = CharacterSet.General | CharacterSet.Japanese | CharacterSet.Thai | CharacterSet.Cyrillic
};
//reduce blur radius because font is very small
//best render hint for this font
drawing = new QFontDrawing();
mainText = new QFont(fontRootPath + fileName + ".ttf", 14, builderConfig);
mainTextOptions = new QFontRenderOptions {
DropShadowActive = true, Colour = Color.White, WordSpacing = 0.5f
};
processedText = QFontDrawingPrimitive.ProcessText(mainText, mainTextOptions, "Basldfgjwoietghwoifhewohfoiewuew", new SizeF(400 - 40, -1), QFontAlignment.Left);
}
public override Point MeasureText(Font font, string text)
{
QFont sysQFont = font.RendererData as QFont;
if (sysQFont == null || Math.Abs(font.RealSize - font.Size * Scale) > 2)
{
Debug.WriteLine("Refreshing font object");
FreeFont(font);
LoadFont(font);
sysQFont = font.RendererData as QFont;
}
var extra = sysQFont.MaxLineHeight - sysQFont.MaxGlyphHeight;
if (extra < 0)
{
extra = 0;
}
bool found = false;
QFontDrawingPrimitive qdp = null;
Point s = Point.Empty;
if (m_StringCache.Contains(text, font))
{
found = true;
//Debug.WriteLine("Measure Text Cache Hit");
qdp = m_StringCache.First(text, font);
s = new Point((int)Math.Ceiling(qdp.LastSize.Width), (int)Math.Ceiling(qdp.LastSize.Height + extra));
}
else
{
found = m_StringCache.GetMeasurement(text, font, out s);
}
if (found)
{
return(s);
}
SizeF size = sysQFont.Measure(text);
Debug.WriteLine("Measure Text Cache Miss");
////SizeF TabSize = m_Graphics.MeasureString("....", sysFont); //Spaces are not being picked up, let's just use .'s.
////m_StringFormat.SetTabStops(0f, new float[] { TabSize.Width });
s = new Point((int)Math.Ceiling(size.Width), (int)Math.Ceiling(size.Height + extra));
m_StringCache.AddMeasurement(text, font, s);
return(Point.Empty);
}
public static void DrawText(string text, QFont font, Color color, RectangleF bounds,
StringAlignment vAlign = StringAlignment.Near,
StringAlignment hAlign = StringAlignment.Near)
{
var textSize = font.Measure(text, bounds.Size, QFontAlignment.Left);
textSize.Height += 2;
var textPos = Vector2.Zero;
switch (hAlign)
{
case StringAlignment.Near:
textPos.X = bounds.X;
break;
case StringAlignment.Far:
textPos.X = bounds.Right - textSize.Width;
break;
case StringAlignment.Center:
textPos.X = bounds.Left + ((bounds.Width - textSize.Width) / 2f);
break;
}
switch (vAlign)
{
case StringAlignment.Near:
textPos.Y = bounds.Y;
break;
case StringAlignment.Far:
textPos.Y = bounds.Y + bounds.Height - textSize.Height;
break;
case StringAlignment.Center:
textPos.Y = bounds.Y + ((bounds.Height - textSize.Height) / 2f);
break;
}
textPos.Y = ViewSize.Y - textPos.Y;
var dp = new QFontDrawingPrimitive(font, new QFontRenderOptions()
{
Colour = color, LockToPixel = true
});
dp.Print(text, new Vector3(textPos.X, textPos.Y, 0f), bounds.Size, QFontAlignment.Left);
TextRenderer.DrawingPrimitives.Add(dp);
}
public override void Update(double time, bool focused = false)
{
// Update total elapsed time
_totalTime += time;
if (InputSystem.NewKeys.Contains(Key.Escape))
{
Exit();
}
_player.Update(time);
_centerPolygon.Update(time, false);
DoGUI();
// Update next if needed
if (_selectedItemChanged)
{
// Reset elapsed time
_totalTime = 0;
_menuFontDrawing.DrawingPrimitives.Clear();
_menuFDP = new QFontDrawingPrimitive(_menuFont.Font, _menuRenderOptions);
_menuFDP.Print(_selectedMenuItemText.ToUpper(), Vector3.Zero, QFontAlignment.Centre);
_menuFontDrawing.DrawingPrimitives.Add(_menuFDP);
_selectedItemChanged = false;
}
// Pulse text
var size = _menuFont.Font.Measure(_selectedMenuItemText.ToUpper());
var selectedSide = GetSelectedSide();
var newPos = new PolarVector(selectedSide * _centerPolygon.AngleBetweenSides + _centerPolygon.AngleBetweenSides * 0.5f, _player.Position.Radius + _player.Width + size.Height * 0.9);
var extraRotation = (selectedSide >= 0 && selectedSide < 3) ? (-Math.PI / 2.0) : (Math.PI / 2.0);
var extraOffset = (selectedSide >= 0 && selectedSide < 3) ? (0) : (-size.Height / 4);
newPos.Radius += extraOffset;
var cart = newPos.ToCartesianCoordinates();
var mvm = Matrix4.CreateTranslation(0, size.Height / 2, 0)
* Matrix4.CreateScale(0.90f + (float)Math.Pow(Math.Sin(_totalTime * 3), 2) * 0.10f)
* Matrix4.CreateRotationZ((float)(newPos.Azimuth + extraRotation))
* Matrix4.CreateTranslation(cart.X, cart.Y, 0);
_menuFDP.ModelViewMatrix = mvm;
}
private void PrintCommentWithLine(QFont font, string comment, QFontAlignment alignment, float xOffset, ref float yOffset, QFontRenderOptions opts)
{
yOffset += 20;
var dp = new QFontDrawingPrimitive(font, opts);
//if (doSpacing)
// dp.Options.CharacterSpacing = 0.05f;
dp.Print(comment, new Vector3(xOffset, Height - yOffset, 0f), new SizeF(Width - 60, -1), alignment);
drawing.DrawingPrimitives.Add(dp);
var bounds = font.Measure(comment, new SizeF(Width - 60, float.MaxValue), alignment);
//GL.Disable(EnableCap.Texture2D);
//GL.Begin(BeginMode.Lines);
//GL.Color4(1.0f, 0f, 0f, 1f); GL.Vertex2(0f, 0f);
//GL.Color4(1.0f, 0f, 0f, 1f); GL.Vertex2(0f, bounds.Height + 20f);
//GL.End();
yOffset += bounds.Height;
}
private void PrintWithBounds(QFont font, string text, RectangleF bounds, QFontAlignment alignment, ref float yOffset)
{
float maxWidth = bounds.Width;
float height = font.Measure(text, new SizeF(maxWidth, -1), alignment).Height;
//gl.begin(beginmode.lineloop);
//gl.vertex3(bounds.x, bounds.y, 0f);
//gl.vertex3(bounds.x + bounds.width, bounds.y, 0f);
//gl.vertex3(bounds.x + bounds.width, bounds.y + height, 0f);
//gl.vertex3(bounds.x, bounds.y + height, 0f);
//gl.end();
var dp = new QFontDrawingPrimitive(font);
dp.Print(text, new Vector3(bounds.X, Height - yOffset, 0), new SizeF(maxWidth, float.MaxValue), alignment);
drawing.DrawingPrimitives.Add(dp);
yOffset += height;
}
/// <summary>Load resources here.</summary>
/// <param name="e">Not used.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
_drawing = new QFontDrawing();
_controlsDrawing = new QFontDrawing();
_controlsTextOpts = new QFontRenderOptions {
Colour = Color.FromArgb(new Color4(0.8f, 0.1f, 0.1f, 1.0f).ToArgb()), DropShadowActive = true
};
_heading2 = new QFont("woodenFont.qfont", new QFontConfiguration(true));
_heading2Options = new QFontRenderOptions {
Colour = Color.White, DropShadowActive = true
};
var builderConfig = new QFontBuilderConfiguration(true)
{
ShadowConfig =
{
BlurRadius = 2,
BlurPasses = 1,
Type = ShadowType.Blurred
},
TextGenerationRenderHint = TextGenerationRenderHint.ClearTypeGridFit,
Characters = CharacterSet.General | CharacterSet.Japanese | CharacterSet.Thai | CharacterSet.Cyrillic
};
//reduce blur radius because font is very small
//best render hint for this font
_mainText = new QFont("Fonts/times.ttf", 14, builderConfig);
_mainTextOptions = new QFontRenderOptions {
DropShadowActive = true, Colour = Color.White, WordSpacing = 0.5f
};
_benchmarkResults = new QFont("Fonts/times.ttf", 14, builderConfig);
_heading1 = new QFont("Fonts/HappySans.ttf", 72, new QFontBuilderConfiguration(true));
_controlsText = new QFont("Fonts/HappySans.ttf", 32, new QFontBuilderConfiguration(true));
_codeText = new QFont("Fonts/Comfortaa-Regular.ttf", 12, new QFontBuilderConfiguration());
_heading1Options = new QFontRenderOptions {
Colour = Color.FromArgb(new Color4(0.2f, 0.2f, 0.2f, 1.0f).ToArgb()), DropShadowActive = true
};
_processedText = QFontDrawingPrimitive.ProcessText(_mainText, _mainTextOptions, _preProcessed, new SizeF(Width - 40, -1), QFontAlignment.Left);
_codeTextOptions = new QFontRenderOptions {
Colour = Color.FromArgb(new Color4(0.0f, 0.0f, 0.4f, 1.0f).ToArgb())
};
_monoSpaced = new QFont("Fonts/Anonymous.ttf", 10, new QFontBuilderConfiguration());
_monoSpacedOptions = new QFontRenderOptions {
Colour = Color.FromArgb(new Color4(0.1f, 0.1f, 0.1f, 1.0f).ToArgb()), DropShadowActive = true
};
// loop through some installed fonts and load them
var ifc = new InstalledFontCollection();
_installedFonts = new List <QFont>();
foreach (var fontFamily in ifc.Families)
{
// Don't load too many fonts
if (_installedFonts.Count > 15)
{
break;
}
_installedFonts.Add(new QFont(fontFamily.Name, 14, new QFontBuilderConfiguration()));
}
GL.ClearColor(Color4.CornflowerBlue);
}
public override void Resize(EventArgs e)
{
_loadingText = QFontDrawingPrimitive.ProcessText(_loadingFont.Font, _loadingFontRenderOptions, "Loading", new SizeF(1000, -1), QFontAlignment.Centre);
_loadingFontDrawing.ProjectionMatrix = SceneManager.ScreenCamera.ScreenProjectionMatrix;
_loadingTextPosition = CalculateTextPosition(new Vector3(SceneManager.ScreenCamera.PreferredWidth / 2, SceneManager.ScreenCamera.PreferredHeight / 2, 0f), _loadingText);
}
public override void Draw(double time)
{
_optionsDrawing.DrawingPrimitives.Clear();
float lineStep = Math.Max(_optionsFont.MaxLineHeight, _valueFont.MaxLineHeight);
float height = lineStep * _options.Count;
float currentY = height / 2.0f;
float unselectedValueScale = 0.8f;
foreach (var op in _options)
{
var settingColour = Color4.Black;
if (_options[_currentlySelectedOption] != op)
{
settingColour = Color.Black;
settingColour.A = 0.50f;
}
var dp = new QFontDrawingPrimitive(_optionsFont.Font, new QFontRenderOptions {
Colour = (Color)settingColour
});
dp.Print(op.FriendlyName + ":", Vector3.Zero, QFontAlignment.Centre);
dp.ModelViewMatrix = Matrix4.CreateTranslation(0, _optionsFont.MaxLineHeight * 0.5f, 0)
* Matrix4.CreateTranslation(-WindowWidth * 0.15f, currentY, 0);
_optionsDrawing.DrawingPrimitives.Add(dp);
dp = new QFontDrawingPrimitive(_valueFont.Font, new QFontRenderOptions {
Colour = (Color)settingColour
});
var valueSize = dp.Print(op.GetValue(), Vector3.Zero, QFontAlignment.Centre);
dp.ModelViewMatrix = Matrix4.CreateTranslation(0, _valueFont.MaxLineHeight * 0.5f, 0)
* Matrix4.CreateTranslation(WindowWidth * 0.15f, currentY, 0);
_optionsDrawing.DrawingPrimitives.Add(dp);
if (op.CanMoveForward())
{
dp = new QFontDrawingPrimitive(_valueFont.Font, new QFontRenderOptions {
Colour = (Color)settingColour
});
dp.Print(op.GetNextValue(), Vector3.Zero, QFontAlignment.Left);
dp.ModelViewMatrix = Matrix4.CreateScale(unselectedValueScale)
* Matrix4.CreateTranslation(WindowWidth * 0.15f + valueSize.Width * 1.25f, currentY + _valueFont.Font.MaxLineHeight * 0.5f * unselectedValueScale, 0);
_optionsDrawing.DrawingPrimitives.Add(dp);
}
if (op.CanMoveBackward())
{
dp = new QFontDrawingPrimitive(_valueFont.Font, new QFontRenderOptions {
Colour = (Color)settingColour
});
dp.Print(op.GetPrevValue(), Vector3.Zero, QFontAlignment.Right);
dp.ModelViewMatrix = Matrix4.CreateScale(unselectedValueScale)
* Matrix4.CreateTranslation(WindowWidth * 0.15f - valueSize.Width * 1.25f, currentY + _valueFont.Font.MaxLineHeight * 0.5f * unselectedValueScale, 0);
_optionsDrawing.DrawingPrimitives.Add(dp);
}
currentY -= lineStep;
}
_optionsDrawing.RefreshBuffers();
_optionsDrawing.Draw();
}
/// <summary>
/// Draw text to the screen
/// </summary>
/// <param name="text">Text to draw</param>
/// <param name="size">Font size</param>
/// <param name="x">X pos</param>
/// <param name="y">Y pos</param>
public static void Text(string text, int x, int y)
{
SizeF size = drawing.Print(font, text, new Vector3(x, y, 0), QFontAlignment.Left);
var dp = new QFontDrawingPrimitive(font);
}
public void Draw(double time)
{
_qfontDrawing.DrawingPrimitives.Clear();
var col = Color4.White;
if (_fileSystemEntries.Count > 0)
{
var s = _selectedFont.Font.Measure(_fileSystemEntries[_directoryBrowserEntryIndex].Name);
_parentManager.DrawTextLine(_fileSystemEntries[_directoryBrowserEntryIndex].Name, new Vector3(0, s.Height / 2.0f, 0), Color4.White, QFontAlignment.Centre, _selectedFont.Font);
float startY = _unselectedFont.MaxLineHeight * (_halfEntryDrawCount) + s.Height * 0.5f + _unselectedFont.MaxLineHeight * 0.5f;
for (int i = _directoryBrowserEntryIndex - (_halfEntryDrawCount); i < _directoryBrowserEntryIndex + _halfEntryDrawCount; i++)
{
if (i >= 0 && i < _fileSystemEntries.Count && i != _directoryBrowserEntryIndex)
{
_parentManager.DrawTextLine(_fileSystemEntries[i].Name, new Vector3(0, startY, 0), col, QFontAlignment.Centre, _unselectedFont.Font);
}
if (i == _directoryBrowserEntryIndex)
{
startY -= s.Height + _unselectedFont.MaxLineHeight * 1.5f;
}
if (i != _directoryBrowserEntryIndex)
{
startY -= _unselectedFont.MaxLineHeight;
}
}
}
// Draw file systems
var size = _parentManager.DrawTextLine(_currentFileSystem.FriendlyName, new Vector3(0, (_parentManager.Height / 2), 0), Color4.White, QFontAlignment.Centre, _selectedFont.Font);
int currentFSIndex = _fileSystemCollection.IndexOf(_currentFileSystem);
// Draw two file systems on either side
float unselectedFsScale = 0.9f;
col = Color4.White;
col.A = 1.0f;
var dp = new QFontDrawingPrimitive(_selectedFont.Font, new QFontRenderOptions {
Colour = (System.Drawing.Color)col
});
// Draw next fs on right
dp.Print(
_fileSystemCollection[(currentFSIndex + 1 + _fileSystemCollection.Count) % _fileSystemCollection.Count].FriendlyName,
Vector3.Zero,
QFontAlignment.Left);
dp.ModelViewMatrix = Matrix4.CreateTranslation(new Vector3(0, size.Height * 2.0f, 0))
* Matrix4.CreateScale(unselectedFsScale)
* Matrix4.CreateTranslation(new Vector3(size.Width * 0.75f, _parentManager.Height / 2 - size.Height * 2.0f, 0));
_qfontDrawing.DrawingPrimitives.Add(dp);
dp = new QFontDrawingPrimitive(_selectedFont.Font, new QFontRenderOptions {
Colour = (System.Drawing.Color)col
});
// Draw previous fs on left
dp.Print(
_fileSystemCollection[(currentFSIndex - 1 + _fileSystemCollection.Count) % _fileSystemCollection.Count].FriendlyName,
Vector3.Zero,
QFontAlignment.Right);
dp.ModelViewMatrix = Matrix4.CreateTranslation(new Vector3(0, size.Height * 2.0f, 0))
* Matrix4.CreateScale(unselectedFsScale)
* Matrix4.CreateTranslation(new Vector3(-size.Width * 0.75f, _parentManager.Height / 2 - size.Height * 2.0f, 0));
_qfontDrawing.DrawingPrimitives.Add(dp);
_qfontDrawing.RefreshBuffers();
_qfontDrawing.Draw();
var searchString = string.Format("Search: {0}", _searchString);
_parentManager.DrawTextLine(searchString, new Vector3(0, -(_parentManager.Height / 2) + _searchFont.MaxLineHeight, 0), Color4.White, QuickFont.QFontAlignment.Centre, _searchFont.Font);
}
/// <summary>
/// Called when it is time to render the next frame. Add your rendering code here.
/// </summary>
/// <param name="e">Contains timing information.</param>
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
drawing.ProjectionMatrix = _projectionMatrix;
frameCount++;
float yOffset = 0;
//mainText.Begin();
//GL.Begin(BeginMode.Quads);
//GL.Color3(1.0f, 1.0f, 1.0); GL.Vertex2(0, 0);
//GL.Color3(0.9f, 0.9f, 0.9f); GL.Vertex2(0, Height);
//GL.Color3(0.9f, 0.9f, 0.9f); GL.Vertex2(Width, Height);
//GL.Color3(0.9f, 0.9f, 0.9f); GL.Vertex2(Width, 0);
//GL.End();
//mainText.End();
if (currentDemoPage != _previousPage)
{
_previousPage = currentDemoPage;
// we have to rebuild the stuff
drawing.DrawingPrimitives.Clear();
switch (currentDemoPage)
{
case 0:
{
yOffset += drawing.Print(heading1, "ModernQuickFont",
new Vector3((float)Width / 2, Height, 0),
QFontAlignment.Centre, heading1Options).Height;
yOffset += drawing.Print(heading2, "Introduction #0",
new Vector3(20, Height - yOffset, 0),
QFontAlignment.Left, heading2Options)
.Height;
yOffset += drawing.Print(mainText, modernQuickFontIntro, new Vector3(30, Height - yOffset, 0),
new SizeF(Width - 60f, -1), QFontAlignment.Justify, new Rectangle(60, Height - 400, 200, 200)).Height;
PrintCode(modernIntroCode, ref yOffset);
break;
}
case 1:
{
yOffset += drawing.Print(heading1, "QuickFont",
new Vector3((float)Width / 2, Height, 0),
QFontAlignment.Centre, heading1Options).Height;
yOffset += drawing.Print(heading2, "Introduction",
new Vector3(20, Height - yOffset, 0),
QFontAlignment.Left, heading2Options)
.Height;
yOffset += 20f;
drawing.Print(mainText, introduction, new Vector3(30, Height - yOffset, 0),
new SizeF(Width - 60f, -1), QFontAlignment.Justify);
break;
}
case 2:
{
yOffset += drawing.Print(heading2, "Easy as ABC!",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
PrintComment(usingQuickFontIsSuperEasy, ref yOffset);
PrintCode(loadingAFont1, ref yOffset);
PrintComment(andPrintWithIt, ref yOffset);
PrintCode(printWithFont1, ref yOffset);
PrintComment(itIsAlsoEasyToMeasure, ref yOffset);
PrintCode(measureText1, ref yOffset);
PrintComment(oneOfTheFirstGotchas, ref yOffset);
PrintCode(loadingAFont2, ref yOffset);
break;
}
case 3:
{
yOffset += drawing.Print(heading2, "Alignment", new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
PrintCommentWithLine(whenPrintingText, QFontAlignment.Left, 20f, ref yOffset);
PrintCode(printWithFont2, ref yOffset);
PrintCommentWithLine(righAlignedText, QFontAlignment.Right, 20f, ref yOffset);
yOffset += 10f;
PrintCommentWithLine(centredTextAsYou, QFontAlignment.Centre, Width * 0.5f, ref yOffset);
break;
}
case 4:
{
// in this stage force redraw and recreation of VBO every time: just divert last page
_previousPage = -1;
yOffset += drawing.Print(heading2, "Bounds and Justify",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
yOffset += 20;
yOffset += drawing.Print(controlsText, "Press [Up], [Down] or [Enter]!",
new Vector3(Width * 0.5f, Height - yOffset, 0f),
QFontAlignment.Centre, controlsTextOpts).Height;
float boundShrink = (int)(350 * (1 - Math.Cos(boundsAnimationCnt * Math.PI * 2)));
yOffset += 15;
PrintWithBounds(mainText, ofCourseItsNot,
new RectangleF(30f + boundShrink * 0.5f, yOffset, Width - 60 - boundShrink,
350f), cycleAlignment, ref yOffset);
string printWithBounds = "myFont.Print(text, position, maxSize, QFontAlignment." +
cycleAlignment + ");";
yOffset += 15f;
PrintCode(printWithBounds, ref yOffset);
break;
}
case 5:
{
yOffset += drawing.Print(heading2, "Your own Texture Fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
PrintComment(anotherCoolFeature, ref yOffset);
PrintCode(textureFontCode1, ref yOffset);
PrintComment(thisWillHaveCreated, ref yOffset);
break;
}
case 6:
{
yOffset += drawing.Print(heading2, "Your own Texture Fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
PrintComment(ifYouDoIntend, ref yOffset);
PrintCode(textureFontCode2, ref yOffset);
PrintComment(actuallyTexturing, ref yOffset);
PrintCode(textureFontCode3, ref yOffset);
break;
}
case 7:
{
// in this stage force redraw and recreation of VBO every time: just divert last page
_previousPage = -1;
// store this primitive to remember
QFontDrawingPrimitive dp = new QFontDrawingPrimitive(heading2);
dp.Options.DropShadowActive = true;
dp.Options.DropShadowOffset = new Vector2(0.1f + 0.2f * (float)Math.Sin(cnt),
0.1f + 0.2f * (float)Math.Cos(cnt));
yOffset += dp.Print("Drop Shadows",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left).Height;
drawing.DrawingPrimitives.Add(dp);
PrintComment(asIhaveleant, ref yOffset);
PrintCode(dropShadowCode1, ref yOffset);
PrintComment(thisWorksFine, ref yOffset);
PrintCode(dropShadowCode2, ref yOffset);
PrintComment(onceAFont, ref yOffset);
//mainText.Options.DropShadowActive = false;
break;
}
case 8:
{
yOffset += drawing.Print(heading2, "Monospaced Fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
QFontRenderOptions monoSpaceCondensed = monoSpacedOptions.CreateClone();
monoSpaceCondensed.CharacterSpacing = 0.05f;
PrintComment(monoSpaced, hereIsSomeMono, QFontAlignment.Left, ref yOffset, monoSpaceCondensed);
PrintCode(monoCode1, ref yOffset);
PrintComment(monoSpaced, theDefaultMono, QFontAlignment.Left, ref yOffset, monoSpaceCondensed);
PrintCommentWithLine(monoSpaced, mono, QFontAlignment.Left, 20f, ref yOffset, monoSpaceCondensed);
yOffset += 2f;
PrintCommentWithLine(monoSpaced, mono, QFontAlignment.Right, 20f, ref yOffset, monoSpaceCondensed);
yOffset += 2f;
PrintCommentWithLine(monoSpaced, mono, QFontAlignment.Centre, Width * 0.5f, ref yOffset, monoSpaceCondensed);
yOffset += 2f;
PrintComment(monoSpaced,
"As usual, you can adjust character spacing with myPrimitive.Options.CharacterSpacing.",
QFontAlignment.Left, ref yOffset, monoSpaceCondensed);
break;
}
case 9:
{
// in this stage force redraw and recreation of VBO every time: just divert last page
_previousPage = -1;
yOffset += drawing.Print(heading2, "Preprocessed Text",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left).Height;
yOffset += 20f;
_stopwatch = Stopwatch.StartNew();
yOffset += drawing.Print(mainText, _processedText,
new Vector3(20, Height - yOffset, 0)).Height;
_stopwatch.Stop();
long preprocessed = _stopwatch.Elapsed.Ticks;
_stopwatch = Stopwatch.StartNew();
yOffset += drawing.Print(mainText, nonPreProcessed,
new Vector3(20, Height - yOffset, 0),
new SizeF(Width - 40f, -1), QFontAlignment.Left)
.Height;
_stopwatch.Stop();
long notpreprocessed = _stopwatch.Elapsed.Ticks;
if (frameCount > 60)
{
_benchResult = string.Format(("{0} {1}\nPreprocessed was {2} ticks faster"),
preprocessed,
notpreprocessed, notpreprocessed - preprocessed);
frameCount = 0;
}
drawing.Print(_benchmarkResults, _benchResult,
new Vector3(Width * 0.5f, Height - yOffset, 0),
QFontAlignment.Centre, Color.White);
break;
}
case 10:
{
yOffset += drawing.Print(heading2, "In Conclusion",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, heading2Options).Height;
PrintComment(thereAreActually, ref yOffset);
break;
}
}
drawing.RefreshBuffers();
}
// Create controlsDrawing every time.. would be also good to vary ProjectionMatrix with * Matrix4.CreateTranslation() !
// this would save buffer work for OpenGL
controlsDrawing.DrawingPrimitives.Clear();
controlsDrawing.ProjectionMatrix = _projectionMatrix;
if (currentDemoPage != lastPage)
{
Vector3 pos = new Vector3(Width - 10 - 16 * (float)(1 + Math.Sin(cnt * 4)),
controlsText.Measure("P").Height + 10f, 0f);
controlsDrawing.Print(controlsText, "Press [Right] ->", pos, QFontAlignment.Right, controlsTextOpts);
}
if (currentDemoPage != 0)
{
var pos = new Vector3(10 + 16 * (float)(1 + Math.Sin(cnt * 4)), controlsText.Measure("P").Height + 10f, 0f);
controlsDrawing.Print(controlsText, "<- Press [Left]", pos, QFontAlignment.Left, controlsTextOpts);
}
controlsDrawing.RefreshBuffers();
controlsDrawing.Draw();
drawing.Draw();
SwapBuffers();
}
/// <summary>
/// Called when it is time to render the next frame. Add your rendering code here.
/// </summary>
/// <param name="e">Contains timing information.</param>
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
_drawing.ProjectionMatrix = _projectionMatrix;
_frameCount++;
float yOffset = 0;
if (_currentDemoPage != _previousPage)
{
_previousPage = _currentDemoPage;
// we have to rebuild the stuff
_drawing.DrawingPrimitives.Clear();
switch (_currentDemoPage)
{
case 0:
{
yOffset += _drawing.Print(_heading1, "ModernQuickFont",
new Vector3((float)Width / 2, Height, 0),
QFontAlignment.Centre, _heading1Options).Height;
yOffset += _drawing.Print(_heading2, "Introduction #0",
new Vector3(20, Height - yOffset, 0),
QFontAlignment.Left, _heading2Options)
.Height;
yOffset += _drawing.Print(_mainText, _modernQuickFontIntro, new Vector3(30, Height - yOffset, 0),
new SizeF(Width - 60f, -1), QFontAlignment.Left).Height;
PrintCode(_modernIntroCode, ref yOffset);
break;
}
case 1:
{
yOffset += _drawing.Print(_heading1, "QuickFont",
new Vector3((float)Width / 2, Height, 0),
QFontAlignment.Centre, _heading1Options).Height;
yOffset += _drawing.Print(_heading2, "Introduction",
new Vector3(20, Height - yOffset, 0),
QFontAlignment.Left, _heading2Options)
.Height;
yOffset += 20f;
_drawing.Print(_mainText, _introduction, new Vector3(30, Height - yOffset, 0),
new SizeF(Width - 60f, -1), QFontAlignment.Justify);
break;
}
case 2:
{
yOffset += _drawing.Print(_heading2, "Easy as ABC!",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
PrintComment(_usingQuickFontIsSuperEasy, ref yOffset);
PrintCode(_loadingAFont1, ref yOffset);
PrintComment(_andPrintWithIt, ref yOffset);
PrintCode(_printWithFont1, ref yOffset);
PrintComment(_itIsAlsoEasyToMeasure, ref yOffset);
PrintCode(_measureText1, ref yOffset);
PrintComment(oneOfTheFirstGotchas, ref yOffset);
PrintCode(_loadingAFont2, ref yOffset);
break;
}
case 3:
{
yOffset += _drawing.Print(_heading2, "Alignment", new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
PrintCommentWithLine(_whenPrintingText, QFontAlignment.Left, 20f, ref yOffset);
PrintCode(_printWithFont2, ref yOffset);
PrintCommentWithLine(_righAlignedText, QFontAlignment.Right, 20f, ref yOffset);
yOffset += 10f;
PrintCommentWithLine(_centredTextAsYou, QFontAlignment.Centre, Width * 0.5f, ref yOffset);
break;
}
case 4:
{
// in this stage force redraw and recreation of VBO every time: just divert last page
_previousPage = -1;
yOffset += _drawing.Print(_heading2, "Bounds and Justify",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
yOffset += 20;
yOffset += _drawing.Print(_controlsText, "Press [Up], [Down] or [Enter]!",
new Vector3(Width * 0.5f, Height - yOffset, 0f),
QFontAlignment.Centre, _controlsTextOpts).Height;
float boundShrink = (int)(350 * (1 - Math.Cos(_boundsAnimationCnt * Math.PI * 2)));
yOffset += 15;
PrintWithBounds(_mainText, _ofCourseItsNot,
new RectangleF(30f + boundShrink * 0.5f, yOffset, Width - 60 - boundShrink,
350f), _cycleAlignment, ref yOffset);
string printWithBounds = "myFont.Print(text, position, maxSize, QFontAlignment." +
_cycleAlignment + ");";
yOffset += 15f;
PrintCode(printWithBounds, ref yOffset);
break;
}
case 5:
{
yOffset += _drawing.Print(_heading2, "Your own Texture Fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
PrintComment(_anotherCoolFeature, ref yOffset);
PrintCode(_textureFontCode1, ref yOffset);
PrintComment(_thisWillHaveCreated, ref yOffset);
break;
}
case 6:
{
yOffset += _drawing.Print(_heading2, "Your own Texture Fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
PrintComment(_ifYouDoIntend, ref yOffset);
PrintCode(_textureFontCode2, ref yOffset);
PrintComment(_actuallyTexturing, ref yOffset);
PrintCode(_textureFontCode3, ref yOffset);
break;
}
case 7:
{
// in this stage force redraw and recreation of VBO every time: just divert last page
_previousPage = -1;
// store this primitive to remember
QFontDrawingPrimitive dp = new QFontDrawingPrimitive(_heading2)
{
Options =
{
DropShadowActive = true,
DropShadowOffset = new Vector2(0.1f + 0.2f * (float)Math.Sin(_cnt),
0.1f + 0.2f * (float)Math.Cos(_cnt))
}
};
yOffset += dp.Print("Drop Shadows",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left).Height;
_drawing.DrawingPrimitives.Add(dp);
PrintComment(_asIhaveleant, ref yOffset);
PrintCode(_dropShadowCode1, ref yOffset);
PrintComment(_thisWorksFine, ref yOffset);
PrintCode(_dropShadowCode2, ref yOffset);
PrintComment(_onceAFont, ref yOffset);
//mainText.Options.DropShadowActive = false;
break;
}
case 8:
{
yOffset += _drawing.Print(_heading2, "Monospaced Fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
QFontRenderOptions monoSpaceCondensed = _monoSpacedOptions.CreateClone();
monoSpaceCondensed.CharacterSpacing = 0.05f;
PrintComment(_monoSpaced, _hereIsSomeMono, QFontAlignment.Left, ref yOffset, monoSpaceCondensed);
PrintCode(_monoCode1, ref yOffset);
PrintComment(_monoSpaced, _theDefaultMono, QFontAlignment.Left, ref yOffset, monoSpaceCondensed);
PrintCommentWithLine(_monoSpaced, _mono, QFontAlignment.Left, 20f, ref yOffset, monoSpaceCondensed);
yOffset += 2f;
PrintCommentWithLine(_monoSpaced, _mono, QFontAlignment.Right, 20f, ref yOffset, monoSpaceCondensed);
yOffset += 2f;
PrintCommentWithLine(_monoSpaced, _mono, QFontAlignment.Centre, Width * 0.5f, ref yOffset, monoSpaceCondensed);
yOffset += 2f;
PrintComment(_monoSpaced,
"As usual, you can adjust character spacing with myPrimitive.Options.CharacterSpacing.",
QFontAlignment.Left, ref yOffset, monoSpaceCondensed);
break;
}
case 9:
{
// in this stage force redraw and recreation of VBO every time: just divert last page
_previousPage = -1;
yOffset += _drawing.Print(_heading2, "Preprocessed Text",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left).Height;
yOffset += 20f;
_stopwatch = Stopwatch.StartNew();
yOffset += _drawing.Print(_mainText, _processedText,
new Vector3(20, Height - yOffset, 0)).Height;
_stopwatch.Stop();
long preprocessed = _stopwatch.Elapsed.Ticks;
_stopwatch = Stopwatch.StartNew();
yOffset += _drawing.Print(_mainText, _nonPreProcessed,
new Vector3(20, Height - yOffset, 0),
new SizeF(Width - 40f, -1), QFontAlignment.Left)
.Height;
_stopwatch.Stop();
long notpreprocessed = _stopwatch.Elapsed.Ticks;
if (_frameCount > 60)
{
_benchResult = string.Format(("{0} {1}\nPreprocessed was {2} ticks faster"),
preprocessed,
notpreprocessed, notpreprocessed - preprocessed);
_frameCount = 0;
}
_drawing.Print(_benchmarkResults, _benchResult,
new Vector3(Width * 0.5f, Height - yOffset, 0),
QFontAlignment.Centre, Color.White);
break;
}
case 10:
{
yOffset += _drawing.Print(_heading2, "In Conclusion",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height;
PrintComment(_thereAreActually, ref yOffset);
break;
}
case 11:
{
yOffset += _drawing.Print(_heading2, "Different installed fonts",
new Vector3(20f, Height - yOffset, 0f),
QFontAlignment.Left, _heading2Options).Height + 20;
foreach (var qFont in _installedFonts)
{
yOffset += _drawing.Print(qFont, "This text is printed with " + qFont.FontName,
new Vector3(20f, Height - yOffset, 0), QFontAlignment.Left, Color.White).Height + 10;
}
break;
}
}
_drawing.RefreshBuffers();
}
// Create controlsDrawing every time.. would be also good to vary ProjectionMatrix with * Matrix4.CreateTranslation() !
// this would save buffer work for OpenGL
_controlsDrawing.DrawingPrimitives.Clear();
_controlsDrawing.ProjectionMatrix = _projectionMatrix;
if (_currentDemoPage != _lastPage)
{
var dim = _controlsText.Measure("Press [Right] ->");
Vector3 pos = new Vector3(Width - dim.Width / 2 - 16 * (float)(1 + Math.Sin(_cnt * 4)),
_controlsText.Measure("P").Height + 10f, 0f);
var dp = new QFontDrawingPrimitive(_controlsText, _controlsTextOpts);
dp.ModelViewMatrix = Matrix4.CreateTranslation(0, dim.Height / 2, 0) * Matrix4.CreateRotationZ((float)MathHelper.DegreesToRadians(Math.Sin(_cnt * 4) * 15)) * Matrix4.CreateTranslation(pos);
_controlsDrawing.DrawingPrimitives.Add(dp);
dp.Print("Press [Right] ->", Vector3.Zero, QFontAlignment.Centre);
}
if (_currentDemoPage != 0)
{
var pos = new Vector3(10 + 16 * (float)(1 + Math.Sin(_cnt * 4)), _controlsText.Measure("P").Height + 10f, 0f);
_controlsDrawing.Print(_controlsText, "<- Press [Left]", pos, QFontAlignment.Left, _controlsTextOpts);
}
_controlsDrawing.RefreshBuffers();
_controlsDrawing.Draw();
_drawing.Draw();
SwapBuffers();
}
/// <summary>
/// Creates the image on an OpenGL 2D texture and returns it's OpenGL handle.
/// This function creates and destroys all the OpenGL objects it uses except the texture and framebuffer.
/// </summary>
/// <param name="singular">The singular form of the word</param>
/// <param name="plural">The plural form of the word</param>
/// <param name="imagePath">The path to the image showing the word to use</param>
/// <param name="fbo">The framebuffer object that was used to render to the returned texture, still with the texture attached in color0</param>
/// <param name="WIDTH">The width of the texture</param>
/// <param name="HEIGHT">The height of the texture</param>
static int MakeAllImage(String singular, String plural, String imagePath, out int fbo, out int WIDTH, out int HEIGHT)
{
#if LOG_DATA
DataLogger.Log("[ImageManager] MakeAllImage was called", LoggingMode.Message);
#endif
WIDTH = 800;
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusDstAlpha);
#if LOG_DATA
DataLogger.Log(String.Concat("[ImageManager] Loading bitmap from \"", imagePath, "\""), LoggingMode.Message);
#endif
Bitmap bitmap = new Bitmap(imagePath);
#region CalculateTextColor
#if LOG_DATA
DataLogger.Log("[ImageManager] Calculating text color", LoggingMode.Message);
#endif
//calculate whether to make the *noise text* black or white based on the colors on the image.
float diffX = bitmap.Width / (float)COLOR_CALCULATOR_SAMPLE_FREQ;
float diffY = bitmap.Height / (float)COLOR_CALCULATOR_SAMPLE_FREQ;
int grayscaleTotal = 0;
for (float x = (bitmap.Width - bitmap.Width / COLOR_CALCULATOR_SAMPLE_FREQ * COLOR_CALCULATOR_SAMPLE_FREQ) / 2f; x < bitmap.Width; x += diffX)
{
for (float y = (bitmap.Height - bitmap.Height / COLOR_CALCULATOR_SAMPLE_FREQ * COLOR_CALCULATOR_SAMPLE_FREQ) / 2f; y < bitmap.Height; y += diffY)
{
Color c = bitmap.GetPixel((int)x, (int)y);
grayscaleTotal += c.R;
grayscaleTotal += c.G;
grayscaleTotal += c.B;
}
}
bool isBlack = grayscaleTotal / (COLOR_CALCULATOR_SAMPLE_FREQ * COLOR_CALCULATOR_SAMPLE_FREQ * 3) > 127;
#if LOG_DATA
DataLogger.Log("[ImageManager] Text color: " + (isBlack ? "black" : "white"), LoggingMode.Message);
#endif
#endregion
#region LoadQFont
#if LOG_DATA
DataLogger.Log("[ImageManager] Loading QFont data", LoggingMode.Message);
#endif
QFontShadowConfiguration shadowConfig = new QFontShadowConfiguration()
{
Type = ShadowType.Expanded,
BlurRadius = 2,
};
QFontBuilderConfiguration qconfig = new QFontBuilderConfiguration(true)
{
SuperSampleLevels = 4,
TextGenerationRenderHint = TextGenerationRenderHint.AntiAlias,
};
QFont qfont = new QFont(new FreeTypeFont(FONT_LOCATION, 144, FontStyle.Regular), qconfig);
QFontDrawing qdraw = new QFontDrawing();
QFontRenderOptions opts = new QFontRenderOptions()
{
CharacterSpacing = 0.06f,
Colour = Color.Black,
};
ProcessedText text = QFontDrawingPrimitive.ProcessText(qfont, opts, plural + " be like", new SizeF(WIDTH - TEXT_BORDER_SPACE * 2, 99999f), QFontAlignment.Left);
SizeF topTextSize = qdraw.Print(qfont, text, new Vector3(0, 0, 0), opts);
qdraw.RefreshBuffers();
#endregion
int topHeight = 40 + (int)(topTextSize.Height + 0.5f);
HEIGHT = WIDTH * bitmap.Height / bitmap.Width + topHeight;
#if LOG_DATA
DataLogger.Log(String.Concat("[ImageManager] WIDTH=", WIDTH, " HEIGHT=", HEIGHT, " topHeight=", topHeight), LoggingMode.Message);
#endif
#region GenVBO
#if LOG_DATA
DataLogger.Log("[ImageManager] Generating VBO and VAO", LoggingMode.Message);
#endif
float[] vboData = new float[]
{
0, 0, 0, 0, 1,
0, 1, 0, 0, 0,
1, 0, 0, 1, 1,
1, 1, 0, 1, 0
};
int vbo = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GL.BufferData(BufferTarget.ArrayBuffer, vboData.Length * 4, vboData, BufferUsageHint.StaticDraw);
int vao = GL.GenVertexArray();
GL.BindVertexArray(vao);
GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 20, 0);
GL.EnableVertexAttribArray(0);
GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 20, 12);
GL.EnableVertexAttribArray(1);
#endregion
#region LoadTexture
#if LOG_DATA
DataLogger.Log("[ImageManager] Generating texture for image", LoggingMode.Message);
#endif
int tex = GL.GenTexture();
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, tex);
#if LOG_DATA
DataLogger.Log("[ImageManager] Loading texture pixels from bitmap", LoggingMode.Message);
#endif
BitmapData bits = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bitmap.Width, bitmap.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, bits.Scan0);
bitmap.UnlockBits(bits);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
#endregion
#region LoadShaderProgram
#if LOG_DATA
DataLogger.Log("[ImageManager] Creating shaders", LoggingMode.Message);
#endif
int vs = GL.CreateShader(ShaderType.VertexShader);
#if LOG_DATA
DataLogger.Log("[ImageManager] Loading vertex shader from " + VERTEX_SHADER_LOCATION, LoggingMode.Message);
#endif
GL.ShaderSource(vs, File.ReadAllText(VERTEX_SHADER_LOCATION));
GL.CompileShader(vs);
int tmp;
GL.GetShader(vs, ShaderParameter.CompileStatus, out tmp);
#if LOG_DATA
if (tmp != 1)
{
DataLogger.Log("[ImageManager] Vertex shader compilation failed", LoggingMode.Error);
}
DataLogger.Log("[ImageManager] Vertex Shader Info Log: ", LoggingMode.Message);
DataLogger.Log(GL.GetShaderInfoLog(vs), LoggingMode.RawData);
DataLogger.Log("[ImageManager] [END OF VERTEX SHADER INFO LOG]", LoggingMode.Message);
#endif
if (tmp != 1)
{
throw new Exception("Vertex Shader compilation failed. Process can't continue.");
}
int fs = GL.CreateShader(ShaderType.FragmentShader);
#if LOG_DATA
DataLogger.Log("[ImageManager] Loading fragment shader from " + FRAGMENT_SHADER_LOCATION, LoggingMode.Message);
#endif
GL.ShaderSource(fs, File.ReadAllText(FRAGMENT_SHADER_LOCATION));
GL.CompileShader(fs);
GL.GetShader(fs, ShaderParameter.CompileStatus, out tmp);
#if LOG_DATA
if (tmp != 1)
{
DataLogger.Log("[ImageManager] Fragment shader compilation failed", LoggingMode.Error);
}
DataLogger.Log("[ImageManager] Fragment Shader Info Log: ", LoggingMode.Message);
DataLogger.Log(GL.GetShaderInfoLog(fs), LoggingMode.RawData);
DataLogger.Log("[ImageManager] [END OF FRAGMENT SHADER INFO LOG]", LoggingMode.Message);
#endif
if (tmp != 1)
{
throw new Exception("Fragment Shader compilation failed. Process can't continue.");
}
#if LOG_DATA
DataLogger.Log("[ImageManager] Performing OpenGL program creation commands", LoggingMode.Message);
#endif
int program = GL.CreateProgram();
GL.AttachShader(program, vs);
GL.AttachShader(program, fs);
GL.BindAttribLocation(program, 0, "vPosition");
GL.BindAttribLocation(program, 1, "vTexCoords");
GL.LinkProgram(program);
GL.DetachShader(program, vs);
GL.DetachShader(program, fs);
GL.DeleteProgram(vs);
GL.DeleteProgram(fs);
int texUniformLoc = GL.GetUniformLocation(program, "tex");
int projUniformLoc = GL.GetUniformLocation(program, "Proj");
GL.UseProgram(program);
GL.GetProgram(program, GetProgramParameterName.LinkStatus, out tmp);
#if LOG_DATA
if (tmp != 1)
{
DataLogger.Log("[ImageManager] GL Program linking failed", LoggingMode.Error);
}
DataLogger.Log("[ImageManager] GL Program Info Log: ", LoggingMode.Message);
DataLogger.Log(GL.GetProgramInfoLog(program), LoggingMode.RawData);
DataLogger.Log("[ImageManager] [END OF GL PROGRAM INFO LOG]", LoggingMode.Message);
DataLogger.Log("[ImageManager] Just a friendly reminder that GL PROGRAM refers to a OpenGL Shader Program with attached shaders", LoggingMode.Message);
#endif
if (tmp != 1)
{
throw new Exception("Program linking failed. Process can't continue.");
}
#endregion
#region MakeResultTextureFramebuffer
#if LOG_DATA
DataLogger.Log("[ImageManager] Generating Framebuffer & Texture for rendering", LoggingMode.Message);
#endif
int resultTex = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, resultTex);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, WIDTH, HEIGHT, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
fbo = GL.GenFramebuffer();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, fbo);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, resultTex, 0);
if (GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer) != FramebufferErrorCode.FramebufferComplete)
{ //error
#if LOG_DATA
DataLogger.Log("[ImageManager] Framebuffer creation failed", LoggingMode.Error);
#endif
throw new Exception("Framebuffer creation failed. Process can't continue.");
}
#endregion
#region Drawing
#if LOG_DATA
DataLogger.Log("[ImageManager] Performing OpenGL draw commands", LoggingMode.Message);
#endif
GL.BindFramebuffer(FramebufferTarget.Framebuffer, fbo);
GL.ClearColor(1f, 1f, 1f, 1f);
GL.Clear(ClearBufferMask.ColorBufferBit);
GL.UseProgram(program);
Matrix4 mat = Matrix4.CreateOrthographicOffCenter(0, 1, 0, 1, -1, 1);
GL.UniformMatrix4(projUniformLoc, false, ref mat);
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, tex);
GL.Uniform1(texUniformLoc, 0);
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GL.BindVertexArray(vao);
GL.Viewport(0, 0, WIDTH, HEIGHT - topHeight);
GL.DrawArrays(PrimitiveType.TriangleStrip, 0, 4);
GL.Viewport(0, HEIGHT - topHeight, WIDTH, topHeight);
qdraw.ProjectionMatrix = Matrix4.CreateTranslation(TEXT_BORDER_SPACE, topTextSize.Height + TEXT_BORDER_SPACE, 0) * Matrix4.CreateOrthographicOffCenter(0, WIDTH, 0, topHeight, -1, 1);
qdraw.Draw();
GL.Viewport(0, 0, WIDTH, HEIGHT - topHeight);
opts.DropShadowActive = true;
opts.DropShadowColour = Color.White;
opts.DropShadowOffset = Vector2.Zero;//new Vector2(-0.12f, 0.12f);
text = QFontDrawingPrimitive.ProcessText(qfont, opts, String.Concat("*", singular, " noises*"), new SizeF(WIDTH - TEXT_BORDER_SPACE * 2, 99999f), QFontAlignment.Centre);
SizeF noiseTextSize = qdraw.Print(qfont, text, new Vector3(0, 0, 0), opts);
float textScale = Math.Min((WIDTH - TEXT_BORDER_SPACE * 4) / noiseTextSize.Width, (HEIGHT - TEXT_BORDER_SPACE * 4) / noiseTextSize.Height);
#if LOG_DATA
DataLogger.Log("[ImageManager] Updating QFont size (disposing and reloading)", LoggingMode.Message);
#endif
qfont.Dispose();
qconfig.ShadowConfig = shadowConfig;
qfont = new QFont(new FreeTypeFont(FONT_LOCATION, 144 * textScale, FontStyle.Regular), qconfig);
qdraw.DrawingPrimitives.Clear();
opts.Colour = isBlack ? Color.Black : Color.White;
opts.DropShadowColour = isBlack ? Color.White : Color.Black;
text = QFontDrawingPrimitive.ProcessText(qfont, opts, String.Concat("*", singular, " noises*"), new SizeF(WIDTH - TEXT_BORDER_SPACE * 2, 99999f), QFontAlignment.Centre);
qdraw.Print(qfont, text, new Vector3(0, 0, 0), opts);
qdraw.ProjectionMatrix = Matrix4.CreateTranslation(WIDTH / 2f, noiseTextSize.Height * textScale / 2f + (HEIGHT - topHeight) / 2f, 0f) * Matrix4.CreateOrthographicOffCenter(0, WIDTH, 0, HEIGHT - topHeight, -1, 1);
qdraw.RefreshBuffers();
qdraw.Draw();
#if LOG_DATA
DataLogger.Log("[ImageManager] Done drawing", LoggingMode.Success);
#endif
#endregion
#region Disposing
#if LOG_DATA
DataLogger.Log("[ImageManager] Disposing MakeAllImage resources", LoggingMode.Message);
#endif
bitmap.Dispose();
qfont.Dispose();
qdraw.Dispose();
GL.DeleteProgram(program);
GL.DeleteTexture(tex);
GL.DeleteBuffer(vbo);
GL.DeleteVertexArray(vao);
#endregion
#if LOG_DATA
DataLogger.Log("[ImageManager] MakeAllImage is done. Returning texture and framebuffer data", LoggingMode.Message);
#endif
return(resultTex);
}
