/// <summary>
/// On scene load.
/// </summary>
protected override void Load()
{
// set assets root and load config
if (IsFirstScene)
{
Assets.AssetsRoot = "../../../../TestAssets";
Game.LoadConfig("config.ini");
}
// load assets
_cursor = Assets.LoadImage("gfx/cursor.png", ImageFilterMode.Nearest);
_treeImage = Assets.LoadImage("gfx/tree.png", ImageFilterMode.Nearest);
_dirtImage = Assets.LoadImage("gfx/dirt.png", ImageFilterMode.Nearest);
_font = Assets.LoadFont("gfx/OpenSans-Regular.ttf", 22, false);
_fontBig = Assets.LoadFont("gfx/OpenSans-Regular.ttf", 42, false);
// get window size
_windowSize = Gfx.WindowSize;
// create empty texture to draw on
_targetTexture = Assets.CreateEmptyImage(_windowSize);
// create trees
for (var i = 0; i < 55; ++i)
{
CreateTestSprite();
}
// sort trees by y position so it will look like there's depth
_sprites.Sort((Sprite a, Sprite b) => (int)(a.Position.Y - b.Position.Y));
}
public void Draw()
{
if (!IsVisible)
{
return;
}
DX.DrawBox(X - 1, Y - 1, X + Width + 1, Y + Height + 1, WindowBaseColor, DX.TRUE);
DX.DrawBox(X - 1, Y - 1, X + Width + 1, Y + Height + 1, WindowFrameColor, DX.FALSE);
ReloadButton.Draw();
CloseButton.Draw();
if (!IsHaveInfo)
{
FontAsset.Draw(TextFont, "Please Reload",
X + Width / 2 - FontAsset.GetDrawTextWidth(TextFont, "Please Reload") / 2,
Y + 60, TextColor
);
}
else if (IsReloading)
{
FontAsset.Draw(TextFont, "Loading...",
X + Width / 2 - FontAsset.GetDrawTextWidth(TextFont, "Loading...") / 2,
Y + 60, TextColor
);
}
else
{
foreach (var button in MatchesListButtons)
{
button.Draw();
button.DrawText();
}
}
}
internal static void InitializeFontAssetResourceChangeCallBacks()
{
FontAsset.RegisterResourceForUpdate += TextEditorResourceManager.RegisterResourceForUpdate;
FontAsset.RegisterResourceForReimport += TextEditorResourceManager.RegisterResourceForReimport;
FontAsset.OnFontAssetTextureChanged += TextEditorResourceManager.AddTextureToAsset;
FontAsset.SetAtlasTextureIsReadable += FontEngineEditorUtilities.SetAtlasTextureIsReadable;
FontAsset.GetSourceFontRef += TextEditorResourceManager.GetSourceFontRef;
FontAsset.SetSourceFontGUID += TextEditorResourceManager.SetSourceFontGUID;
// Callback to handle clearing dynamic font asset data when closing the Editor
EditorApplication.quitting += () =>
{
// Find all font assets in the project
string searchPattern = "t:FontAsset";
string[] fontAssetGUIDs = AssetDatabase.FindAssets(searchPattern);
for (int i = 0; i < fontAssetGUIDs.Length; i++)
{
string fontAssetPath = AssetDatabase.GUIDToAssetPath(fontAssetGUIDs[i]);
FontAsset fontAsset = AssetDatabase.LoadAssetAtPath <FontAsset>(fontAssetPath);
if (fontAsset != null && (fontAsset.atlasPopulationMode == AtlasPopulationMode.Dynamic || fontAsset.atlasPopulationMode == AtlasPopulationMode.DynamicOS) && fontAsset.clearDynamicDataOnBuild && fontAsset.atlasTexture.width != 0)
{
fontAsset.ClearFontAssetDataInternal();
}
}
};
}
public void RenderText(IRenderContext context, IEffect effect, IEffectParameterSet effectParameterSet, Matrix matrix,
string text, FontAsset font, HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment verticalAlignment = VerticalAlignment.Top, Color? textColor = null, bool renderShadow = true,
Color? shadowColor = null)
{
throw new NotSupportedException();
}
public void OnPreprocessBuild(BuildReport report)
{
// Find all font assets in the project
string searchPattern = "t:FontAsset";
string[] fontAssetGUIDs = AssetDatabase.FindAssets(searchPattern);
for (int i = 0; i < fontAssetGUIDs.Length; i++)
{
string assetPath = AssetDatabase.GUIDToAssetPath(fontAssetGUIDs[i]);
// Exclude assets not located in the project.
if (!assetPath.StartsWith("Assets/", System.StringComparison.OrdinalIgnoreCase))
{
continue;
}
FontAsset fontAsset = AssetDatabase.LoadAssetAtPath <FontAsset>(assetPath);
if (fontAsset != null && (fontAsset.atlasPopulationMode == AtlasPopulationMode.Dynamic || fontAsset.atlasPopulationMode == AtlasPopulationMode.DynamicOS) && fontAsset.clearDynamicDataOnBuild && fontAsset.atlasTexture.width != 0)
{
fontAsset.ClearFontAssetDataInternal();
}
}
}
static void ExtractAtlas(MenuCommand command)
{
FontAsset font = command.context as FontAsset;
string fontPath = AssetDatabase.GetAssetPath(font);
string texPath = Path.GetDirectoryName(fontPath) + "/" + Path.GetFileNameWithoutExtension(fontPath) + " Atlas.png";
// Create a Serialized Object of the texture to allow us to make it readable.
SerializedObject texprop = new SerializedObject(font.material.GetTexture(TextShaderUtilities.ID_MainTex));
texprop.FindProperty("m_IsReadable").boolValue = true;
texprop.ApplyModifiedProperties();
// Create a copy of the texture.
Texture2D tex = Instantiate(font.material.GetTexture(TextShaderUtilities.ID_MainTex)) as Texture2D;
// Set the texture to not readable again.
texprop.FindProperty("m_IsReadable").boolValue = false;
texprop.ApplyModifiedProperties();
Debug.Log(texPath);
// Saving File for Debug
var pngData = tex.EncodeToPNG();
File.WriteAllBytes(texPath, pngData);
AssetDatabase.Refresh();
DestroyImmediate(tex);
}
public static int AddMaterialReference(Material material, FontAsset fontAsset, MaterialReference[] materialReferences, Dictionary <int, int> materialReferenceIndexLookup)
{
int instanceID = material.GetInstanceID();
int count;
bool flag = materialReferenceIndexLookup.TryGetValue(instanceID, out count);
int result;
if (flag)
{
result = count;
}
else
{
count = materialReferenceIndexLookup.Count;
materialReferenceIndexLookup[instanceID] = count;
materialReferences[count].index = count;
materialReferences[count].fontAsset = fontAsset;
materialReferences[count].spriteAsset = null;
materialReferences[count].material = material;
materialReferences[count].isDefaultMaterial = (instanceID == fontAsset.material.GetInstanceID());
materialReferences[count].referenceCount = 0;
result = count;
}
return(result);
}
/// <summary>
/// Loads a font asset.
/// </summary>
/// <param name="path">Font track path.</param>
/// <param name="fontSize">Font native size to load.</param>
/// <param name="useCache">Should we use cache for this asset to make future loadings faster?</param>
/// <param name="useAssetsRoot">If true, path will be relative to 'AssetsRoot'. If false, will be relative to working directory.</param>
/// <returns>Loaded font asset.</returns>
public FontAsset LoadFont(string path, int fontSize, bool useCache = true, bool useAssetsRoot = true)
{
var ret = new FontAsset(_BonEngineBind.BON_Assets_LoadFont(ToAssetsPath(path, true, useAssetsRoot), fontSize, useCache));
ret.Path = path;
return(ret);
}
/// <summary>
/// Get the estimated bounding box of a text rendering.
/// </summary>
/// <param name="font">Font to use.</param>
/// <param name="text">Text to draw.</param>
/// <param name="position">Text position.</param>
/// <param name="fontSize">Font size.</param>
/// <param name="maxWidth">Max line width.</param>
/// <param name="origin">Text origin.</param>
/// <param name="rotation">Text rotation.</param>
/// <returns>Estimated text drawing bounding box.</returns>
public RectangleI GetTextBoundingBox(FontAsset font, string text, PointF position, int fontSize, int maxWidth, PointF origin, float rotation)
{
RectangleI ret = new RectangleI();
_BonEngineBind.BON_Gfx_GetTextBoundingBox(font._handle, text, position.X, position.Y, fontSize, maxWidth, origin.X, origin.Y, rotation, ref ret.X, ref ret.Y, ref ret.Width, ref ret.Height);
return(ret);
}
public DetectorEntity(WebcamEntity webcamEntity, IAssetManager assetManager, I2DRenderUtilities renderUtilities)
{
_webcamEntity = webcamEntity;
_assetManager = assetManager;
_renderUtilities = renderUtilities;
_defaultFont = _assetManager.Get <FontAsset>("font.Default");
_colorsToDetect = new List <ColorToDetect>
{
new ColorToDetect {
Color = new Color(1f, 0f, 0f), Name = "Red"
},
new ColorToDetect {
Color = new Color(0f, 1f, 0f), Name = "Green"
},
new ColorToDetect {
Color = new Color(0f, 0f, 1f), Name = "Blue"
},
new ColorToDetect {
Color = new Color(1f, 1f, 0f), Name = "Yellow"
}
};
_currentIndex = 0;
_currentColor = _colorsToDetect[_currentIndex];
GlobalSensitivity = 1 / 10000000f * 25f;
_thread = new Thread(ProcessorThread);
_thread.IsBackground = true;
_thread.Start();
}
private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
bool textureImported = false;
foreach (var asset in importedAssets)
{
// Return if imported asset path is outside of the project.
if (asset.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) == false)
continue;
Type assetType = AssetDatabase.GetMainAssetTypeAtPath(asset);
if (assetType == typeof(FontAsset))
{
FontAsset fontAsset = AssetDatabase.LoadAssetAtPath(asset, typeof(FontAsset)) as FontAsset;
// Only refresh font asset definition if font asset was previously initialized.
if (fontAsset != null && fontAsset.m_CharacterLookupDictionary != null)
TextEditorResourceManager.RegisterFontAssetForDefinitionRefresh(fontAsset);
continue;
}
if (assetType == typeof(Texture2D))
textureImported = true;
}
// If textures were imported, issue callback to any potential text objects that might require updating.
if (textureImported)
TextEventManager.ON_SPRITE_ASSET_PROPERTY_CHANGED(true, null);
}
public IAsset Load(string name, IRawAsset data)
{
if (data.IsCompiled)
{
return(new FontAsset(this.m_AssetContentManager, name, null, 0, false, 0, data.GetProperty <PlatformData>("PlatformData")));
}
PlatformData platformData = null;
if (data.GetProperty <PlatformData>("PlatformData") != null)
{
platformData = new PlatformData
{
Platform = data.GetProperty <PlatformData>("PlatformData").Platform,
Data = ByteReader.ReadAsByteArray(data.GetProperty <PlatformData>("PlatformData").Data)
};
}
var effect = new FontAsset(
this.m_AssetContentManager,
name,
data.GetProperty <string>("FontName"),
data.GetProperty <int>("FontSize"),
data.GetProperty <bool>("UseKerning"),
data.GetProperty <int>("Spacing"),
platformData);
return(effect);
}
protected override void RenderContent(RenderComposer composer)
{
ImGui.InputInt("Font Size", ref _size);
if (ImGui.Button("Select Font"))
{
var explorer = new FileExplorer <FontAsset>(f => { _font = f; });
Parent.AddWindow(explorer);
}
if (_font == null)
{
return;
}
ImGui.Text($"Font: {_font.Font.FullName}");
ImGui.Text($"Asset Name: {_font.Name}");
if (ImGui.Checkbox("Emotion Renderer", ref _emotionRenderer))
{
FontAsset.GlyphRasterizer = _emotionRenderer ? GlyphRasterizer.Emotion : GlyphRasterizer.StbTrueType;
}
ImGui.InputTextMultiline("Test Text", ref _testText, 200, new Vector2(200, 100));
composer.RenderString(new Vector3(0, 100, 0), Color.Black, _testText, _font.GetAtlas(_size));
}
public MyGameWorld(
I2DRenderUtilities renderUtilities,
IAssetManagerProvider assetManagerProvider,
IEntityFactory entityFactory)
{
this.Entities = new List<IEntity>();
_renderUtilities = renderUtilities;
_assetManager = assetManagerProvider.GetAssetManager();
_defaultFont = this._assetManager.Get<FontAsset>("font.Default");
// You can also save the entity factory in a field and use it, e.g. in the Update
// loop or anywhere else in your game.
var entityA = entityFactory.CreateExampleEntity("EntityA");
entityA.X = 100;
entityA.Y = 50;
var entityB = entityFactory.CreateExampleEntity("EntityB");
entityB.X = 120;
entityB.Y = 100;
// Don't forget to add your entities to the world!
this.Entities.Add(entityA);
this.Entities.Add(entityB);
// This pulls in the texture asset via the asset manager. Note that
// the folder seperator from "texture/Player" has been translated
// into a single dot.
_playerTexture = _assetManager.Get<TextureAsset>("texture.Player");
}
/// <summary>
/// Function to add a new material reference and returning its index in the material reference array.
/// </summary>
/// <param name="material"></param>
/// <param name="fontAsset"></param>
/// <param name="materialReferences"></param>
/// <param name="materialReferenceIndexLookup"></param>
/// <returns></returns>
public static int AddMaterialReference(Material material, FontAsset fontAsset, ref MaterialReference[] materialReferences, Dictionary <int, int> materialReferenceIndexLookup)
{
int materialId = material.GetInstanceID();
int index;
if (materialReferenceIndexLookup.TryGetValue(materialId, out index))
{
return(index);
}
index = materialReferenceIndexLookup.Count;
// Add new reference index
materialReferenceIndexLookup[materialId] = index;
if (index >= materialReferences.Length)
{
Array.Resize(ref materialReferences, Mathf.NextPowerOfTwo(index + 1));
}
materialReferences[index].index = index;
materialReferences[index].fontAsset = fontAsset;
materialReferences[index].spriteAsset = null;
materialReferences[index].material = material;
materialReferences[index].isDefaultMaterial = materialId == fontAsset.material.GetInstanceID();
materialReferences[index].referenceCount = 0;
return(index);
}
/// <summary>
///
/// </summary>
internal static void RebuildFontAssetCache()
{
// Iterate over loaded font assets to update affected font assets
foreach (var pair in s_FontAssetReferences)
{
FontAssetRef fontAssetRef = pair.Value;
FontAsset fontAsset = fontAssetRef.fontAsset;
if (fontAsset == null)
{
// Remove font asset from our lookup dictionaries
s_FontAssetNameReferenceLookup.Remove(fontAssetRef.nameHashCode);
s_FontAssetFamilyNameAndStyleReferenceLookup.Remove(fontAssetRef.familyNameAndStyleHashCode);
// Add font asset to our removal list
s_FontAssetRemovalList.Add(pair.Key);
continue;
}
fontAsset.InitializeCharacterLookupDictionary();
fontAsset.AddSynthesizedCharactersAndFaceMetrics();
}
// Remove font assets in our removal list from our font asset references
for (int i = 0; i < s_FontAssetRemovalList.Count; i++)
{
s_FontAssetReferences.Remove(s_FontAssetRemovalList[i]);
}
s_FontAssetRemovalList.Clear();
TextEventManager.ON_FONT_PROPERTY_CHANGED(true, null);
}
/// <summary>
/// Load scene
/// </summary>
protected override void Load()
{
// set assets root
Assets.AssetsRoot = "../../../../TestAssets";
// load config
Game.LoadConfig("config.ini");
// load assets
_cursor = Assets.LoadImage("gfx/cursor.png", ImageFilterMode.Nearest);
_fontBig = Assets.LoadFont("gfx/OpenSans-Regular.ttf", 46, false);
_font = Assets.LoadFont("gfx/OpenSans-Regular.ttf", 28, false);
// add demos
AddDemo("Input & Spritesheet", new Demos.InputAndSpritesheetScene());
AddDemo("Music & Sound Effects", new Demos.MusicAndSoundScene());
AddDemo("Drawing Texts", new Demos.TextScene());
AddDemo("Fullscreen Mode", new Demos.FullscreenScene());
AddDemo("Windowed Fullscreen", new Demos.WindowedFullscreenScene());
AddDemo("Rendering Viewport", new Demos.ViewportScene());
AddDemo("Performance Test", new Demos.PerformanceTestScene());
AddDemo("Render To Texture", new Demos.RenderToTextureScene());
AddDemo("Basic Lights", new Demos.BasicLightsScene());
AddDemo("Custom Managers", new Demos.CustomManagerScene());
AddDemo("Drawing Shapes", new Demos.DrawingShapesScene());
AddDemo("UI System", new Demos.UIScene());
}
/// <summary>
/// 文字列のみ描画する関数(透明度設定なし)
/// </summary>
private void DrawTextWithoutMODESETTING()
{
if (FontHandle >= 0)
{
FontAsset.Draw(FontHandle, Text, TextPosX, TextPosY, TextColor);
}
}
/// <summary>
/// テキストのみ描画する
/// </summary>
public void DrawText()
{
if (FontHandle >= 0)
{
FontAsset.Draw(FontHandle, Text, TextPosX, TextPosY, TextColor);
}
}
/// <summary>
/// Create a FontDefinition from <see cref="FontAsset"/>.
/// </summary>
/// <param name="f">The SDF font to use to display text.</param>
/// <returns>A new FontDefinition object.</returns>
public static FontDefinition FromSDFFont(FontAsset f)
{
return(new FontDefinition()
{
m_FontAsset = f
});
}
List <FontAsset> loadFonts()
{
var fonts = new List <FontAsset>();
if (!Directory.Exists(metadataPath + "Fonts"))
{
Directory.CreateDirectory(metadataPath + "Fonts");
}
foreach (var filename in Directory.EnumerateFiles(metadataPath + "Fonts"))
{
var metadata = File.ReadAllLines(filename);
var font = new FontAsset();
font.Name = System.IO.Path.GetFileNameWithoutExtension(filename);
font.Description = metadata[0].Split('=')[1].Trim();
font.LastUpdated = parseLastUpdatedDate(metadata[1].Split('=')[1].Trim(), "font", font.Name);
font.FontName = metadata[2].Split('=')[1].Trim();
font.ImportedFilename = metadata[3].Split('=')[1].Trim();
fonts.Add(font);
}
return(fonts);
}
public MyGameWorld(
I2DRenderUtilities renderUtilities,
IAssetManagerProvider assetManagerProvider,
IEntityFactory entityFactory)
{
this.Entities = new List <IEntity>();
_renderUtilities = renderUtilities;
_assetManager = assetManagerProvider.GetAssetManager();
_defaultFont = this._assetManager.Get <FontAsset>("font.Default");
// You can also save the entity factory in a field and use it, e.g. in the Update
// loop or anywhere else in your game.
var entityA = entityFactory.CreateExampleEntity("EntityA");
entityA.X = 100;
entityA.Y = 50;
var entityB = entityFactory.CreateExampleEntity("EntityB");
entityB.X = 120;
entityB.Y = 100;
// Don't forget to add your entities to the world!
this.Entities.Add(entityA);
this.Entities.Add(entityB);
// This pulls in the texture asset via the asset manager. Note that
// the folder seperator from "texture/Player" has been translated
// into a single dot.
_playerTexture = _assetManager.Get <TextureAsset>("texture.Player");
}
public DefaultCaptureService(
I2DRenderUtilities twoDRenderUtilities,
IAssetManagerProvider assetManagerProvider)
{
this.m_2DRenderUtilities = twoDRenderUtilities;
this.m_DefaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
}
internal static Material[] FindMaterialReferences(FontAsset fontAsset)
{
List <Material> refs = new List <Material>();
Material mat = fontAsset.material;
refs.Add(mat);
// Get materials matching the search pattern.
string searchPattern = "t:Material" + " " + fontAsset.name.Split(new char[] { ' ' })[0];
string[] materialAssetGUIDs = AssetDatabase.FindAssets(searchPattern);
for (int i = 0; i < materialAssetGUIDs.Length; i++)
{
string materialPath = AssetDatabase.GUIDToAssetPath(materialAssetGUIDs[i]);
Material targetMaterial = AssetDatabase.LoadAssetAtPath <Material>(materialPath);
if (targetMaterial.HasProperty(TextShaderUtilities.ID_MainTex) && targetMaterial.GetTexture(TextShaderUtilities.ID_MainTex) != null && mat.GetTexture(TextShaderUtilities.ID_MainTex) != null && targetMaterial.GetTexture(TextShaderUtilities.ID_MainTex).GetInstanceID() == mat.GetTexture(TextShaderUtilities.ID_MainTex).GetInstanceID())
{
if (!refs.Contains(targetMaterial))
{
refs.Add(targetMaterial);
}
}
else
{
// TODO: Find a more efficient method to unload resources.
//Resources.UnloadAsset(targetMaterial.GetTexture(ShaderUtilities.ID_MainTex));
}
}
return(refs.ToArray());
}
// load the scene
protected override void Load()
{
// load fonts
_font = Assets.LoadFont("gfx/OpenSans-Regular.ttf", 22, false);
_fontBig = Assets.LoadFont("gfx/OpenSans-Regular.ttf", 42, false);
// set level and starting positions
_ballPosition.Set(400, 500);
_ballSpeed.Set(-1f, -0.75f);
// init player
var windowSize = Gfx.WindowSize;
_player = new RectangleF(windowSize.X / 2 - 60, windowSize.Y - 50, 120, 15);
// init level
for (int i = 0; i < windowSize.X / BlockSize.X; ++i)
{
for (int j = 0; j < 10; ++j)
{
_blocks.Add(new Block()
{
Rectangle = new RectangleI(i * BlockSize.X, j * BlockSize.Y, BlockSize.X, BlockSize.Y),
Color = new Color(1f - (j / 10f), 0f, (j / 10f) - 1f, 1f)
});
}
}
// create empty texture for trail effects
_trailEffectTexture = Assets.CreateEmptyImage(windowSize);
}
public void RenderText(IRenderContext context, Vector2 position, string text, FontAsset font,
HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment verticalAlignment = VerticalAlignment.Top, Color? textColor = null, bool renderShadow = true,
Color? shadowColor = null)
{
throw new NotSupportedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="TextBuffer"/> class.
/// </summary>
/// <param name="font">The font to use.</param>
/// <param name="size">The font size (may be slightly different to the size of <paramref name="font"/>).</param>
public TextBuffer(FontAsset font, float size)
{
SetFont(font, size);
_kerning = true;
_lastTimeUsed = DateTime.MinValue;
_lastTextSize = new SizeF();
ResetScrollPosition();
}
public FontAssetRef(int nameHashCode, int familyNameHashCode, int styleNameHashCode, FontAsset fontAsset)
{
this.nameHashCode = nameHashCode;
this.familyNameHashCode = familyNameHashCode;
this.styleNameHashCode = styleNameHashCode;
this.familyNameAndStyleHashCode = (long)styleNameHashCode << 32 | (uint)familyNameHashCode;
this.fontAsset = fontAsset;
}
public StatusBar(
I2DRenderUtilities twodRenderUtilities,
IAssetManagerProvider assetManagerProvider)
{
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_AssetManager = assetManagerProvider.GetAssetManager();
this.m_DefaultFont = this.m_AssetManager.Get<FontAsset>("font.Default");
}
/// <summary>
/// Draw text on screen.
/// </summary>
/// <param name="font">Font to use.</param>
/// <param name="text">Text to draw.</param>
/// <param name="position">Text position.</param>
public void DrawText(FontAsset font, string text, PointF position)
{
if (!font.HaveHandle)
{
throw new Exception("Tried to render a font without handle!");
}
_BonEngineBind.BON_Gfx_DrawText(font._handle, text, position.X, position.Y, 1f, 1f, 1f, 1f, 0, 0, (int)BlendModes.AlphaBlend, 0, 0, 0);
}
/// <summary>
/// Draw text on screen.
/// </summary>
/// <param name="font">Font to use.</param>
/// <param name="text">Text to draw.</param>
/// <param name="position">Text position.</param>
/// <param name="color">Text color.</param>
/// <param name="fontSize">Font size.</param>
/// <param name="maxWidth">Max line width.</param>
/// <param name="blend">Blend mode.</param>
/// <param name="origin">Text origin.</param>
/// <param name="rotation">Text rotation.</param>
public void DrawText(FontAsset font, string text, PointF position, Color color, int fontSize, int maxWidth, BlendModes blend, PointF origin, float rotation)
{
if (!font.HaveHandle)
{
throw new Exception("Tried to render a font without handle!");
}
_BonEngineBind.BON_Gfx_DrawText(font._handle, text, position.X, position.Y, color.R, color.G, color.B, color.A, fontSize, maxWidth, (int)blend, origin.X, origin.Y, rotation);
}
/// <summary>
/// Draw text on screen.
/// </summary>
/// <param name="font">Font to use.</param>
/// <param name="text">Text to draw.</param>
/// <param name="position">Text position.</param>
/// <param name="color">Text color.</param>
/// <param name="outlineColor">Text outline color.</param>
/// <param name="outlineWidth">Text outline width.</param>
/// <param name="fontSize">Font size.</param>
/// <param name="maxWidth">Max line width.</param>
/// <param name="blend">Blend mode.</param>
public void DrawText(FontAsset font, string text, PointF position, Color color, Color outlineColor, int outlineWidth = 1, int fontSize = 0, int maxWidth = 0, BlendModes blend = BlendModes.AlphaBlend)
{
if (!font.HaveHandle)
{
throw new Exception("Tried to render a font without handle!");
}
_BonEngineBind.BON_Gfx_DrawTextWithOutline(font._handle, text, position.X, position.Y, color.R, color.G, color.B, color.A, fontSize, maxWidth, (int)blend, 0, 0, 0, outlineWidth, outlineColor.R, outlineColor.G, outlineColor.B, outlineColor.A);
}
void DisposeFont()
{
if (_font != null)
{
_font.Deallocated -= DisposeBuffer;
}
_font = null;
}
public PhysicsMetricsProfilerVisualiser(
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities renderUtilities,
IPhysicsEngine physicsEngine)
{
_renderUtilities = renderUtilities;
_physicsEngine = physicsEngine;
_defaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
}
public FontAssetRef(int nameHashCode, int familyNameHashCode, int styleNameHashCode, FontAsset fontAsset)
{
// Use familyNameHashCode for font assets created at runtime as these asset do not typically have a names.
this.nameHashCode = nameHashCode != 0 ? nameHashCode : familyNameHashCode;
this.familyNameHashCode = familyNameHashCode;
this.styleNameHashCode = styleNameHashCode;
this.familyNameAndStyleHashCode = (long)styleNameHashCode << 32 | (uint)familyNameHashCode;
this.fontAsset = fontAsset;
}
static void RegenerateFontAsset(MenuCommand command)
{
FontAsset fontAsset = command.context as FontAsset;
if (fontAsset != null)
{
FontAssetCreatorWindow.ShowFontAtlasCreatorWindow(fontAsset);
}
}
public GeneratedWorld(
I2DRenderUtilities twoDRenderUtilities,
IAssetManagerProvider assetManagerProvider)
{
this.Entities = new List<IEntity>();
this.m_2DRenderUtilities = twoDRenderUtilities;
this.m_AssetManager = assetManagerProvider.GetAssetManager();
this.m_DefaultFont = this.m_AssetManager.Get<FontAsset>("font.Default");
}
public KernelMetricsProfilerVisualiser(
IKernel kernel,
IHierarchy hierachy,
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities renderUtilities)
{
_kernel = kernel;
_hierachy = hierachy;
_renderUtilities = renderUtilities;
_defaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
}
public NetworkTrafficProfilerVisualiser(
IAssetManagerProvider assetManagerProvider,
INetworkEngine networkEngine,
I2DRenderUtilities renderUtilities)
{
_defaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
_networkEngine = networkEngine;
_renderUtilities = renderUtilities;
_sentSampler = new NetworkSampler(_renderUtilities, _defaultFont, "SENT");
_receivedSampler = new NetworkSampler(_renderUtilities, _defaultFont, "RECV");
}
public TychaiaProfilerEntity(
TychaiaProfiler profiler,
I2DRenderUtilities twodRenderUtilities,
IAssetManagerProvider assetManagerProvider,
IPersistentStorage persistentStorage)
{
this.Profiler = profiler;
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_DefaultFontAsset = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
this.m_ProfilingInformation = new List<FrameProfileInfo>();
this.m_PersistentStorage = persistentStorage;
this.m_TychaiaProfilerEntityUtil = new TychaiaProfilerEntityUtil();
}
public GraphicsMetricsProfilerVisualiser(
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities renderUtilities,
IRenderCache renderCache,
IRenderAutoCache renderAutoCache,
IRenderBatcher renderBatcher)
{
_renderUtilities = renderUtilities;
_renderCache = renderCache;
_renderAutoCache = renderAutoCache;
_renderBatcher = renderBatcher;
_defaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
}
public LobbyWorld(
IKernel kernel,
I2DRenderUtilities twodRenderUtilities,
IAssetManagerProvider assetManagerProvider,
bool join,
IPAddress address)
{
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_DefaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
this.Entities = new List<IEntity>();
this.m_NetworkAPI = new DefaultNetworkAPI(join, address);
kernel.Bind<INetworkAPI>().ToMethod(x => this.m_NetworkAPI);
}
public OperationCostProfilerVisualiser(
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities renderUtilities,
IMemoryProfiler memoryProfiler)
{
_defaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
_renderUtilities = renderUtilities;
_memoryProfiler = memoryProfiler;
_averageOverTimePeriod = new Dictionary<string, double>();
_historyOverTimePeriod = new Dictionary<string, List<double>>();
_lastFrameToHaveData = new Dictionary<string, int>();
_maximumOverTimePeriod = new Dictionary<string, double>();
MicrosecondLimit = 14000;
FramesToAnalyse = 240;
}
public ShipEditorWorld(
IFactory factory,
I2DRenderUtilities twoDRenderUtilities,
IAssetManagerProvider assetManagerProvider,
IShipTool[] shipTools)
{
this.Entities = new List<IEntity>();
this.m_2DRenderUtilities = twoDRenderUtilities;
this.m_AssetManager = assetManagerProvider.GetAssetManager();
this.m_ShipTools = shipTools;
this.m_DefaultFont = this.m_AssetManager.Get<FontAsset>("font.Default");
this.m_Ship = factory.CreateShip();
this.m_ShipEditorEntity = factory.CreateShipEditorEntity(this.m_Ship);
this.Entities.Add(this.m_ShipEditorEntity);
}
public Vector2 MeasureText(IRenderContext context, string text, FontAsset font)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (string.IsNullOrWhiteSpace(text))
{
return new Vector2(0, 0);
}
if (font == null)
{
throw new ArgumentNullException(nameof(font));
}
return font.Font.MeasureString(_stringSanitizer.SanitizeCharacters(font.Font, text));
}
public GCMetricsProfilerVisualiser(
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities renderUtilities)
{
_renderUtilities = renderUtilities;
_defaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
#if PLATFORM_WINDOWS || PLATFORM_MACOS || PLATFORM_LINUX
string instanceName;
if (TryGetInstanceName(Process.GetCurrentProcess(), out instanceName))
{
_gen0PerformanceCounter = new PerformanceCounter(".NET CLR Memory", "# Gen 0 Collections",
instanceName, true);
_gen1PerformanceCounter = new PerformanceCounter(".NET CLR Memory", "# Gen 1 Collections",
instanceName, true);
_gen2PerformanceCounter = new PerformanceCounter(".NET CLR Memory", "# Gen 2 Collections",
instanceName, true);
}
#endif
}
public MainMenuWorld(IAssetManagerProvider assetManagerProvider, I2DRenderUtilities twodRenderUtilities)
{
this.m_2DRenderUtilities = twodRenderUtilities;
var assetManager = assetManagerProvider.GetAssetManager();
this.m_RussianLargeFont = assetManager.Get<FontAsset>("font.RussianLarge");
this.m_RussianMediumFont = assetManager.Get<FontAsset>("font.RussianMedium");
this.Entities = new IEntity[0];
this.Actions = new Dictionary<string, Action<IGameContext>>
{
{ "-Hyperplayer", this.DoHyperplayer },
{ "-Multiplayer", this.DoMultiplayer },
{ "-Singleplayer", this.DoSingleplayer },
{ "Ship editor", this.DoShipEditor },
{ "Quit", this.DoQuit }
};
}
public MenuWorld(
I2DRenderUtilities twodRenderUtilities,
IAssetManagerProvider assetManagerProvider,
IBackgroundCubeEntityFactory backgroundCubeEntityFactory,
ISkin skin)
{
this.m_2DRenderUtilities = twodRenderUtilities;
this.AssetManager = assetManagerProvider.GetAssetManager();
this.m_BackgroundCubeEntityFactory = backgroundCubeEntityFactory;
this.m_TitleFont = this.AssetManager.Get<FontAsset>("font.Title");
this.m_PlayerModel = this.AssetManager.Get<ModelAsset>("model.Character");
this.m_PlayerModelTexture = this.AssetManager.Get<TextureAsset>("model.CharacterTex");
this.Entities = new List<IEntity>();
this.m_CanvasEntity = new CanvasEntity(skin) { Canvas = new Canvas() };
this.m_CanvasEntity.Canvas.SetChild(this.m_TitleMenu = new TitleMenu());
// Don't add the canvas to the entities list; that way we can explicitly
// order it's depth.
}
public IntermissionWorld(
IKernel kernel,
INetworkAPI networkAPI,
I2DRenderUtilities twodRenderUtilities,
IAssetManagerProvider assetManagerProvider,
int level)
{
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_MessageFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Message");
this.m_NetworkAPI = networkAPI;
this.Entities = new List<IEntity>();
this.m_Ticks = 0;
this.m_ApproachingLevel = level;
this.m_NetworkAPI.ClearAllListeners();
this.m_NoNextLevel =
(assetManagerProvider.GetAssetManager().TryGet<LevelAsset>("level." + level + "a") == null);
}
public ShipEditorEntity(
IAssetManagerProvider assetManagerProvider,
I2DRenderUtilities twoRenderUtilities,
I3DRenderUtilities threeRenderUtilities,
IGridRenderer gridRenderer,
ICollision collision,
Ship ship)
{
this.m_DefaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
this.m_2DRenderUtilities = twoRenderUtilities;
this.m_3DRenderUtilities = threeRenderUtilities;
this.m_GridRenderer = gridRenderer;
this.m_Collision = collision;
this.m_Ship = ship;
this.m_PreviewRotation = 0;
this.HorizontalRange = 30;
this.VerticalRange = 30;
this.VerticalSelection = 3;
this.UpdateShipVisibilityCull();
}
public DetectorEntity(WebcamEntity webcamEntity, IAssetManager assetManager, I2DRenderUtilities renderUtilities)
{
_webcamEntity = webcamEntity;
_assetManager = assetManager;
_renderUtilities = renderUtilities;
_defaultFont = _assetManager.Get<FontAsset>("font.Default");
_colorsToDetect = new List<ColorToDetect>
{
new ColorToDetect {Color = new Color(1f, 0f, 0f), Name = "Red"},
new ColorToDetect {Color = new Color(0f, 1f, 0f), Name = "Green"},
new ColorToDetect {Color = new Color(0f, 0f, 1f), Name = "Blue"},
new ColorToDetect {Color = new Color(1f, 1f, 0f), Name = "Yellow"}
};
_currentIndex = 0;
_currentColor = _colorsToDetect[_currentIndex];
GlobalSensitivity = 1/10000000f*25f;
_thread = new Thread(ProcessorThread);
_thread.IsBackground = true;
_thread.Start();
}
public PROJECT_SAFE_NAMEWorld(
INode worldNode,
IHierarchy hierarchy,
I2DRenderUtilities twoDRenderUtilities,
IAssetManagerProvider assetManagerProvider,
IEntityFactory entityFactory)
{
this.Entities = new List<IEntity>();
_renderUtilities = twoDRenderUtilities;
_assetManager = assetManagerProvider.GetAssetManager();
_defaultFont = this._assetManager.Get<FontAsset>("font.Default");
// You can also save the entity factory in a field and use it, e.g. in the Update
// loop or anywhere else in your game.
var entityA = entityFactory.CreateExampleEntity("EntityA");
entityA.Transform.LocalPosition = new Vector3(100, 50, 0);
var entityB = entityFactory.CreateExampleEntity("EntityB");
entityB.Transform.LocalPosition = new Vector3(120, 100, 0);
// Don't forget to add your entities to the world!
hierarchy.MoveNode(worldNode, hierarchy.Lookup(entityA));
hierarchy.MoveNode(worldNode, hierarchy.Lookup(entityB));
}
public BoardAnalyzerEntity(
DetectorEntity detectorEntity,
TextBox pointThresholdTextBox,
TextBox minNumberOfPointsTextBox,
TextBox maxNumberOfPointsTextBox,
I2DRenderUtilities renderUtilities,
IAssetManager assetManager)
{
_detectorEntity = detectorEntity;
_pointThresholdTextBox = pointThresholdTextBox;
_minNumberOfPointsTextBox = minNumberOfPointsTextBox;
_maxNumberOfPointsTextBox = maxNumberOfPointsTextBox;
_renderUtilities = renderUtilities;
_pointThresholdTextBox.Text = _pointThreshold.ToString();
_minNumberOfPointsTextBox.Text = _minNumberOfPoints.ToString();
_maxNumberOfPointsTextBox.Text = _maxNumberOfPoints.ToString();
_defaultFont = assetManager.Get<FontAsset>("font.Default");
_thread = new Thread(Run);
_thread.IsBackground = true;
_thread.Start();
}
public ConnectWorld(
IKernel kernel,
I2DRenderUtilities twodRenderUtilities,
IAssetManagerProvider assetManagerProvider,
IBackgroundCubeEntityFactory backgroundCubeEntityFactory,
ISkin skin,
IProfiler profiler,
IPersistentStorage persistentStorage,
bool startServer,
IPAddress address,
int port)
: base(twodRenderUtilities, assetManagerProvider, backgroundCubeEntityFactory, skin)
{
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_PersistentStorage = persistentStorage;
this.m_DefaultFont = assetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
this.m_Address = address;
this.m_Port = port;
TychaiaClient client = null;
byte[] initial = null;
Action cleanup = () =>
{
kernel.Unbind<INetworkAPI>();
kernel.Unbind<IClientNetworkAPI>();
if (client != null)
{
client.Close();
}
this.TerminateExistingProcess();
};
if (startServer)
{
this.m_Actions = new Action[]
{
() => this.m_Message = "Closing old process...", () => this.TerminateExistingProcess(),
() => this.m_Message = "Starting server...", () => this.StartServer(),
() => this.m_Message = "Creating client...", () => client = new TychaiaClient(port + 2, port + 3),
() => client.AttachProfiler(profiler),
() => this.m_Message = "Connecting to server...",
() => client.Connect(new DualIPEndPoint(address, port, port + 1)),
() => this.m_Message = "Binding node to kernel...",
() => kernel.Bind<INetworkAPI>().ToMethod(x => client),
() => kernel.Bind<IClientNetworkAPI>().ToMethod(x => client), () => this.m_Message = "Joining game...",
() => this.m_UniqueClientIdentifier = this.JoinGame(client), () => this.m_Message = "Retrieving initial game state...",
() => initial = client.LoadInitialState(), () => this.m_Message = "Starting client...",
() => this.m_PerformFinalAction = true
};
}
else
{
this.m_Actions = new Action[]
{
() => this.m_Message = "Creating client...", () => client = new TychaiaClient(port + 2, port + 3),
() => client.AttachProfiler(profiler),
() => this.m_Message = "Connecting to server...",
() => client.Connect(new DualIPEndPoint(address, port, port + 1)),
() => this.m_Message = "Binding node to kernel...",
() => kernel.Bind<INetworkAPI>().ToMethod(x => client),
() => kernel.Bind<IClientNetworkAPI>().ToMethod(x => client),
() => this.m_Message = "Joining game...",
() => this.m_UniqueClientIdentifier = this.JoinGame(client), () => this.m_Message = "Retrieving initial game state...",
() => initial = client.LoadInitialState(), () => this.m_Message = "Starting client...",
() => this.m_PerformFinalAction = true
};
}
this.m_FinalAction =
() =>
this.TargetWorld =
this.GameContext.CreateWorld<IWorldFactory>(x => x.CreateTychaiaGameWorld(this.m_UniqueClientIdentifier, cleanup));
var thread = new Thread(this.Run) { IsBackground = true };
thread.Start();
AppDomain.CurrentDomain.ProcessExit += (sender, e) =>
{
if (this.m_Process != null)
{
try
{
this.m_Process.Kill();
this.m_Process = null;
}
catch (InvalidOperationException)
{
}
}
};
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
if (this.m_Process != null)
{
try
{
this.m_Process.Kill();
this.m_Process = null;
}
catch (InvalidOperationException)
{
}
}
};
}
public void RenderText(
IRenderContext context,
Vector2 position,
string text,
FontAsset font,
HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment verticalAlignment = VerticalAlignment.Top,
Color? textColor = null,
bool renderShadow = true,
Color? shadowColor = null)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (string.IsNullOrWhiteSpace(text))
{
return;
}
if (font == null)
{
throw new ArgumentNullException(nameof(font));
}
if (textColor == null)
{
textColor = Color.White;
}
if (shadowColor == null)
{
shadowColor = Color.Black;
}
if (font.Font == null)
{
throw new AssetNotCompiledException(font.Name);
}
// Sanitize the text.
text = _stringSanitizer.SanitizeCharacters(font.Font, text);
// Determine position to draw.
var size = font.Font.MeasureString(text);
float xx = 0, yy = 0;
switch (horizontalAlignment)
{
case HorizontalAlignment.Left:
xx = position.X;
break;
case HorizontalAlignment.Center:
xx = position.X - (size.X / 2);
break;
case HorizontalAlignment.Right:
xx = position.X - size.X;
break;
}
switch (verticalAlignment)
{
case VerticalAlignment.Top:
yy = position.Y;
break;
case VerticalAlignment.Center:
yy = position.Y - (size.Y / 2);
break;
case VerticalAlignment.Bottom:
yy = position.Y - size.Y;
break;
}
// Normalize location to prevent blurring artifacts.
xx = (int)xx;
yy = (int)yy;
// Draw shadow if required.
if (renderShadow)
{
context.SpriteBatch.DrawString(font.Font, text, new Vector2(xx + 1, yy + 1), shadowColor.Value);
}
// Render the main text.
context.SpriteBatch.DrawString(font.Font, text, new Vector2(xx, yy), textColor.Value);
}
/// <summary>
/// The render text.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="matrix">
/// The matrix.
/// </param>
/// <param name="text">
/// The text.
/// </param>
/// <param name="font">
/// The font.
/// </param>
/// <param name="horizontalAlignment">
/// The horizontal alignment.
/// </param>
/// <param name="verticalAlignment">
/// The vertical alignment.
/// </param>
/// <param name="textColor">
/// The text color.
/// </param>
/// <param name="renderShadow">
/// The render shadow.
/// </param>
/// <param name="shadowColor">
/// The shadow color.
/// </param>
/// <exception cref="InvalidOperationException">
/// </exception>
public void RenderText(
IRenderContext context,
Matrix matrix,
string text,
FontAsset font,
HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
VerticalAlignment verticalAlignment = VerticalAlignment.Top,
Color? textColor = null,
bool renderShadow = true,
Color? shadowColor = null)
{
if (!context.Is3DContext)
{
throw new InvalidOperationException("Can't use 3D rendering utilities in 2D context.");
}
var targets = context.GraphicsDevice.GetRenderTargets();
var size = this.MeasureText(context, text, font);
var temporary = new RenderTarget2D(
context.GraphicsDevice,
(int)size.X,
(int)size.Y,
false,
SurfaceFormat.Color,
DepthFormat.None,
0,
RenderTargetUsage.DiscardContents);
context.GraphicsDevice.SetRenderTarget(temporary);
context.GraphicsDevice.Clear(Color.Transparent);
using (var spriteBatch = new SpriteBatch(context.GraphicsDevice))
{
this.m_2DRenderUtilities.RenderText(
context,
new Vector2(0, 0),
text,
font,
HorizontalAlignment.Left,
VerticalAlignment.Top,
textColor,
renderShadow,
shadowColor);
spriteBatch.End();
}
var texture = (Texture2D)temporary;
context.GraphicsDevice.SetRenderTarget(null);
context.GraphicsDevice.BlendState = BlendState.Opaque;
context.GraphicsDevice.DepthStencilState = DepthStencilState.Default;
context.GraphicsDevice.SamplerStates[0] = SamplerState.LinearWrap;
context.GraphicsDevice.RasterizerState = RasterizerState.CullNone;
this.RenderTexture(context, matrix, texture, Color.White, flipHorizontally: false, flipVertically: false);
}
/// <summary>
/// The measure text.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="text">
/// The text.
/// </param>
/// <param name="font">
/// The font.
/// </param>
/// <returns>
/// The <see cref="Vector2"/>.
/// </returns>
public Vector2 MeasureText(IRenderContext context, string text, FontAsset font)
{
return this.m_2DRenderUtilities.MeasureText(context, text, font);
}
void DisposeFont()
{
if (_font != null)
_font.Deallocated -= DisposeBuffer;
_font = null;
}
public TychaiaGameWorld(
IAssetManagerProvider assetManagerProvider,
I3DRenderUtilities threedRenderUtilities,
IFilteredFeatures filteredFeatures,
IChunkOctreeFactory chunkOctreeFactory,
IIsometricCameraFactory isometricCameraFactory,
IChunkSizePolicy chunkSizePolicy,
IChunkManagerEntityFactory chunkManagerEntityFactory,
IProfiler profiler,
IConsole console,
ILevelAPI levelAPI /* temporary */,
IGameUIFactory gameUIFactory,
I2DRenderUtilities twodRenderUtilities,
IClientNetworkAPI networkAPI,
IEntityFactory entityFactory,
IChunkConverter chunkConverter,
IChunkCompressor chunkCompressor,
IChunkGenerator chunkGenerator,
ITerrainSurfaceCalculator terrainSurfaceCalculator,
int uniqueClientIdentifier,
Action cleanup,
IViewportMode viewportMode)
{
this.m_3DRenderUtilities = threedRenderUtilities;
this.m_FilteredFeatures = filteredFeatures;
this.m_ChunkSizePolicy = chunkSizePolicy;
this.m_Profiler = profiler;
this.m_Console = console;
this.m_2DRenderUtilities = twodRenderUtilities;
this.m_NetworkAPI = networkAPI;
this.m_EntityFactory = entityFactory;
this.m_ChunkConverter = chunkConverter;
this.m_ChunkCompressor = chunkCompressor;
this.m_ChunkGenerator = chunkGenerator;
this.m_TerrainSurfaceCalculator = terrainSurfaceCalculator;
this.m_UniqueClientIdentifier = uniqueClientIdentifier;
this.m_AssetManagerProvider = assetManagerProvider;
this.m_Cleanup = cleanup;
this.Level = levelAPI.NewLevel("test");
this.m_ViewportMode = viewportMode;
this.m_DefaultFontAsset = this.m_AssetManagerProvider.GetAssetManager().Get<FontAsset>("font.Default");
this.ChunkOctree = chunkOctreeFactory.CreateChunkOctree<ClientChunk>();
var chunk = new ClientChunk(0, 0, 0);
this.IsometricCamera = isometricCameraFactory.CreateIsometricCamera(this.ChunkOctree, chunk);
this.m_ChunkManagerEntity = chunkManagerEntityFactory.CreateChunkManagerEntity(this);
this.m_InventoryUIEntity = gameUIFactory.CreateInventoryUIEntity();
this.Entities = new List<IEntity> { this.m_ChunkManagerEntity, this.m_InventoryUIEntity };
// TODO: Move this somewhere better.
this.m_NetworkAPI.ListenForMessage(
"player update",
(client, data) =>
{
var playerState = InMemorySerializer.Deserialize<PlayerServerEntity.PlayerServerState>(data);
// Lookup the player entity for this unique client ID if we have one.
var player =
this.Entities.OfType<PlayerEntity>()
.FirstOrDefault(x => x.RuntimeData.UniqueClientIdentifier == playerState.UniqueClientID);
if (player == null)
{
// Need to create a new player entity.
player =
this.m_EntityFactory.CreatePlayerEntity(
new Player { UniqueClientIdentifier = playerState.UniqueClientID });
this.Entities.Add(player);
}
player.X = playerState.X;
player.Y = playerState.Y;
player.Z = playerState.Z;
});
// TODO: Move this somewhere better.
this.m_NetworkAPI.ListenForMessage(
"player leave",
(client, data) =>
{
var playerState = InMemorySerializer.Deserialize<PlayerServerEntity.PlayerServerState>(data);
// Lookup the player entity for this unique client ID if we have one.
var player =
this.Entities.OfType<PlayerEntity>()
.FirstOrDefault(x => x.RuntimeData.UniqueClientIdentifier == playerState.UniqueClientID);
// If we have a player entity, remove it from the world.
if (player != null)
{
this.Entities.Remove(player);
}
});
// TODO: Move this somewhere better.
this.m_NetworkAPI.ListenForMessage(
"chunk available",
(client, data) =>
{
var dataChunk = this.m_ChunkCompressor.Decompress(data);
var clientChunk = this.ChunkOctree.Get(dataChunk.X, dataChunk.Y, dataChunk.Z);
if (clientChunk == null)
{
clientChunk = new ClientChunk(dataChunk.X, dataChunk.Y, dataChunk.Z);
this.ChunkOctree.Set(clientChunk);
}
else if (clientChunk.Generated)
{
// TODO: We already have this chunk. The server shouldn't announce it to
// us because we've already had it sent before, but at the moment the server
// doesn't track this. We just ignore it for now (so we don't recompute
// graphics data).
Console.WriteLine("Chunk is marked as generated, will not reload from server");
return;
}
this.m_ChunkConverter.FromChunk(dataChunk, clientChunk);
this.m_ChunkGenerator.Generate(clientChunk);
});
}
public Vector2 MeasureText(IRenderContext context, string text, FontAsset font)
{
return _twoDimensionalRenderUtilities.MeasureText(context, text, font);
}
